home *** CD-ROM | disk | FTP | other *** search
/ Tools / WinSN5.0Ver.iso / NETSCAP.50 / WIN1998.ZIP / ns / cmd / winfe / compfrm.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1998-04-08  |  56.1 KB  |  1,843 lines
  1. /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
  2.  *
  3.  * The contents of this file are subject to the Netscape Public License
  4.  * Version 1.0 (the "NPL"); you may not use this file except in
  5.  * compliance with the NPL.  You may obtain a copy of the NPL at
  6.  * http://www.mozilla.org/NPL/
  7.  *
  8.  * Software distributed under the NPL is distributed on an "AS IS" basis,
  9.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
  10.  * for the specific language governing rights and limitations under the
  11.  * NPL.
  12.  *
  13.  * The Initial Developer of this code under the NPL is Netscape
  14.  * Communications Corporation.  Portions created by Netscape are
  15.  * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
  16.  * Reserved.
  17.  */
  18.  
  19. /* COMPFRM.CPP - Compose Window Frame.  This module contains code for the
  20.  * compose window frame class.  Handles all menu and tool commands.
  21.  *
  22.  */
  23.  
  24. #include "stdafx.h"
  25. #include "edt.h"
  26. #include "compbar.h"
  27. #include "compfrm.h"
  28. #include "prefapi.h"
  29. #include "intl_csi.h"
  30.  
  31. extern "C" {
  32. #include "xpgetstr.h"
  33. extern int MK_MSG_SAVE_AS;
  34. extern int MK_MSG_CANT_OPEN;
  35. extern int MK_MSG_MISSING_SUBJECT;
  36. };
  37.  
  38. #ifdef XP_WIN32
  39. #include "postal.h"
  40. #endif
  41.  
  42. #define COMPOSE_WINDOW_WIDTH    73 // default to 73 characters wide
  43.  
  44. /////////////////////////////////////////////////////////////////////////////
  45. // CComposeFrame
  46.  
  47. // This is for mail that is sent immediately
  48. static UINT ComposeCodes[] = {
  49.    IDM_SENDNOW,
  50.    IDM_QUOTEORIGINAL,
  51.    IDM_ADDRESSPICKER,
  52.    ID_CHECK_SPELLING,
  53.    IDM_SAVEASDRAFT,
  54.    ID_SECURITY,
  55.    ID_NAVIGATE_INTERRUPT
  56.     };
  57.  
  58. static BOOL bSendDeferred = FALSE;
  59.  
  60. BEGIN_MESSAGE_MAP(CComposeFrame, CGenericFrame)
  61.    ON_WM_CREATE()
  62.    ON_WM_CLOSE()
  63.    ON_WM_SETFOCUS()
  64.    ON_MESSAGE(WM_SETMESSAGESTRING, OnSetMessageString)
  65.    ON_MESSAGE(NSBUTTONMENUOPEN, OnButtonMenuOpen)
  66.    ON_MESSAGE(WM_TOOLCONTROLLER,OnToolController)
  67.    ON_COMMAND(ID_CHECK_SPELLING, OnCheckSpelling)
  68.    ON_COMMAND(IDM_PASTEASQUOTE, OnPasteQuote)
  69.    ON_UPDATE_COMMAND_UI(IDM_PASTEASQUOTE, OnUpdatePasteQuote)
  70.    ON_COMMAND(ID_EDIT_SELECTALLMESSAGES, OnSelectAll)
  71.    ON_UPDATE_COMMAND_UI(ID_EDIT_SELECTALLMESSAGES,OnUpdateSelectAll)
  72.    ON_COMMAND(IDM_SEND, OnSend)
  73.    ON_UPDATE_COMMAND_UI(IDM_SEND, OnUpdateSend)
  74.    ON_COMMAND(IDM_SENDNOW, OnSendNow)
  75.    ON_UPDATE_COMMAND_UI(IDM_SENDNOW, OnUpdateSendNow)
  76.    ON_COMMAND(IDM_SENDLATER, OnSendLater)
  77.    ON_UPDATE_COMMAND_UI(IDM_SENDLATER,OnUpdateSendLater)
  78.    ON_COMMAND(IDM_QUOTEORIGINAL, OnQuoteOriginal)
  79.    ON_UPDATE_COMMAND_UI(IDM_QUOTEORIGINAL,OnUpdateButtonGeneral)
  80.    ON_COMMAND(IDM_SAVEAS, OnSaveAs)
  81.    ON_UPDATE_COMMAND_UI(IDM_SAVEAS, OnUpdateButtonGeneral)
  82.    ON_COMMAND(IDM_SAVEASDRAFT, OnSaveDraft)
  83.    ON_UPDATE_COMMAND_UI(IDM_SAVEASDRAFT, OnUpdateSaveDraft)
  84.    ON_COMMAND(IDM_SAVEASTEMPLATE, OnSaveTemplate)
  85.    ON_UPDATE_COMMAND_UI(IDM_SAVEASTEMPLATE, OnUpdateSaveTemplate)
  86.    ON_COMMAND(IDM_CONVERT,OnConvert)
  87.    ON_UPDATE_COMMAND_UI(IDM_CONVERT, OnUpdateConvert)
  88.    ON_COMMAND(IDM_ATTACHFILE,OnAttachFile)
  89.    ON_COMMAND(ID_SECURITY,OnSecurity)
  90.    ON_UPDATE_COMMAND_UI(ID_SECURITY,OnUpdateSecurity)
  91.    
  92.    ON_COMMAND(ID_DONEGOINGOFFLINE, OnDoneGoingOffline)
  93.  
  94.    ON_WM_DESTROY()
  95.    ON_BN_CLICKED(IDM_ATTACHFILE, OnAttachFile)
  96.    ON_BN_CLICKED(IDM_ATTACHWEBPAGE, OnAttachUrl)
  97.    ON_COMMAND(IDM_ADDRESSPICKER,OnSelectAddresses)
  98.    ON_COMMAND(ID_MAIL_WRAPLONGLINES,OnWrapLongLines)
  99.    ON_UPDATE_COMMAND_UI(ID_MAIL_WRAPLONGLINES,OnUpdateWrapLongLines)    
  100.    ON_COMMAND(IDM_ATTACHMYCARD,OnAttachMyCard)
  101.    ON_UPDATE_COMMAND_UI(IDM_ATTACHMYCARD,OnUpdateAttachMyCard)
  102.    ON_COMMAND(ID_FILE_NEWMESSAGE, OnNew)
  103.    ON_COMMAND(IDM_ADDRESSES,OnViewAddresses)
  104.    ON_COMMAND(IDM_ATTACHMENTS,OnViewAttachments)
  105.    ON_COMMAND(IDM_OPTIONS,OnViewOptions)
  106.    ON_COMMAND(IDC_ADDRESSTAB,OnAddressTab)
  107.    ON_COMMAND(IDC_ATTACHTAB,OnAttachTab)
  108.    ON_COMMAND(IDC_OPTIONSTAB,OnOptionsTab)
  109.    ON_COMMAND(IDC_COLLAPSE,OnCollapse)
  110.    ON_UPDATE_COMMAND_UI(ID_CHECK_SPELLING, OnUpdateButtonGeneral)
  111.    ON_UPDATE_COMMAND_UI(IDM_ADDRESSES,OnUpdateViewAddresses)
  112.    ON_UPDATE_COMMAND_UI(IDM_ATTACHMENTS,OnUpdateViewAttachments)
  113.    ON_UPDATE_COMMAND_UI(IDM_OPTIONS,OnUpdateViewOptions)
  114.    ON_REGISTERED_MESSAGE(WM_FINDREPLACE, OnFindReplace)
  115.    // general button enabler, these should be enabled as long as the
  116.    // compose window is visible
  117.    ON_UPDATE_COMMAND_UI(ID_VIEW_ADDRESSES, OnUpdateButtonGeneral)
  118.    ON_UPDATE_COMMAND_UI(IDC_ADDRESS,OnUpdateButtonGeneral)
  119.    ON_UPDATE_COMMAND_UI(IDC_DIRECTORY,OnUpdateButtonGeneral)
  120.    ON_UPDATE_COMMAND_UI(IDM_ATTACHFILE,OnUpdateButtonGeneral) 
  121.    ON_UPDATE_COMMAND_UI(IDM_ATTACHWEBPAGE,OnUpdateButtonGeneral)
  122.    ON_UPDATE_COMMAND_UI(IDM_ADDRESSPICKER,OnUpdateButtonGeneral) 
  123.  
  124.    ON_COMMAND(IDM_MESSAGEBODYONLY,OnToggleAddressArea)
  125.    ON_UPDATE_COMMAND_UI(IDM_MESSAGEBODYONLY,OnUpdateToggleAddressArea)
  126.    ON_COMMAND(IDM_OPT_MESSAGEBAR_TOGGLE, OnToggleMessageToolbar)
  127.    ON_UPDATE_COMMAND_UI(IDM_OPT_MESSAGEBAR_TOGGLE, OnUpdateToggleMessageToolbar)
  128.  
  129.     // Security Stuff 
  130.        ON_UPDATE_COMMAND_UI(IDS_SECURITY_STATUS, OnUpdateSecureStatus)
  131.     ON_UPDATE_COMMAND_UI(IDS_SIGNED_STATUS, OnUpdateSecureStatus)
  132.  
  133.  
  134. END_MESSAGE_MAP()
  135.  
  136. #ifndef _AFXDLL
  137. #undef new
  138. #endif
  139. IMPLEMENT_DYNCREATE(CComposeFrame,CGenericFrame)
  140. #ifndef _AFXDLL
  141. #define new DEBUG_NEW
  142. #endif
  143.  
  144. #ifdef XP_WIN32
  145. char *ToolBarProfileName = "MailComposeToolBar";
  146. #endif
  147.  
  148. // Constructor for CCompFrame.  Creates the toolbar controller object.
  149. // This object is used by the Gold editor to display/control the
  150. // HTML toolbar commands.  Initialize local variables, set the deferred
  151. // flag to the last known state
  152.  
  153. CComposeFrame::CComposeFrame()
  154. {
  155.     PREF_GetBoolPref("network.online", &bSendDeferred);
  156.    bSendDeferred = !bSendDeferred;
  157.     m_bUseHtml = FALSE;
  158.     m_pToolBarController = NULL;
  159.    m_pComposeBar = NULL;                               // dialog bar
  160.     m_pComposePane = NULL;                              // message pane (for backend)
  161.    m_pFocus = NULL;                                    // current field with focus
  162.    m_bInitialized = FALSE;
  163.     m_pInitialText = NULL;
  164.    m_bWrapLongLines = TRUE;
  165.    m_cxChar = 0;
  166.    m_quoteSel = -1;                // no quoting selection yet
  167.  
  168.    m_bMAPISendMode = MAPI_IGNORE;   // rhp - For MAPI UI-less send/save operations
  169. }
  170.  
  171. // The menu gets cleaned up on window destruction but we need
  172. // to delete our accelerator table ourselves
  173.  
  174. CComposeFrame::~CComposeFrame()
  175. {
  176.     // free the accelerator table
  177.     if(m_hAccelTable != NULL)   {
  178.         ::FreeResource((HGLOBAL)m_hAccelTable);
  179.         m_hAccelTable = NULL;
  180.     }
  181.     if (m_pToolBarController)
  182.         delete m_pToolBarController;
  183.     // free up the dialog bar (address & attachment controls)
  184.     if (m_pComposeBar)
  185.         delete m_pComposeBar;
  186. }
  187.  
  188.  
  189. // GetAddressWidget() returns the current address control widget.
  190.  
  191. LPADDRESSCONTROL CComposeFrame::GetAddressWidgetInterface() 
  192. {
  193.     ASSERT(m_pComposeBar);
  194.     return m_pComposeBar->GetAddressWidgetInterface();
  195. }    
  196.  
  197. // AppendAddress() adds a header/value to the current address block.  It 
  198. // accepts a MSG_HEADER_SET value which is translated to the appropriate 
  199. // corresponding string and appended to the end of the address list with 
  200. // the supplied value.
  201. // Returns TRUE on success, FALSE otherwise.
  202.  
  203. BOOL CComposeFrame::AppendAddress(
  204.     MSG_HEADER_SET header,  // header to add
  205.     const char * value      // header value (or NULL for empty)
  206.     )
  207. {
  208.     // check for a valid widget 
  209.     if (::IsWindow(m_pComposeBar->m_hWnd))
  210.     {
  211.         // get a pointer to the addressing block widget
  212.         LPADDRESSCONTROL pIAddress = GetAddressWidgetInterface();
  213.         if (pIAddress)
  214.         {
  215.             CListBox * pListBox = pIAddress->GetListBox();        
  216.             // check to make sure we got a valid list and the list
  217.             // has a valid window
  218.             if (::IsWindow(pListBox->m_hWnd))
  219.             {
  220.                 const char * szType = MSG_HeaderMaskToString(header);
  221.                 if (!szType)
  222.                     return FALSE;
  223.                 // add the entry to the list
  224.                 pIAddress->AppendEntry(TRUE, szType,value ? value : "", 0, 0);
  225.             }
  226.         }
  227.     }
  228.     return TRUE;
  229. }
  230.  
  231. // destroy message compose pane
  232. void CComposeFrame::OnDestroy()
  233. {
  234.     MSG_DestroyPane(m_pComposePane);
  235.     m_pComposePane = NULL;
  236.     CGenericFrame::OnDestroy();
  237. }
  238.  
  239. int CComposeFrame::CreateHtmlToolbars()
  240. {
  241.    // Create the HTML edit toolbars.  There are currently two separate
  242.    // toolbars.. one for formats and another for character operations.
  243.    m_pToolBarController = new CEditToolBarController(this);
  244.    ASSERT(m_pToolBarController);
  245.    if (!m_pToolBarController->CreateEditBars(GetMainContext()->GetContext(), DISPLAY_CHARACTER_TOOLBAR))
  246.       return -1;      // fail to create
  247.    return 0;
  248. }
  249.  
  250. void CComposeFrame::DestroyHtmlToolbars()
  251. {
  252.    XP_Bool prefBool;
  253.    PREF_GetBoolPref("editor.show_character_toolbar",&prefBool);
  254.    if ( prefBool ) 
  255.    {
  256.       CWnd * pWnd = m_pToolBarController->GetCharacterBar();
  257.       if (pWnd && ::IsWindow(pWnd->m_hWnd))
  258.          pWnd->DestroyWindow();
  259.    }
  260. }
  261.  
  262. void CComposeFrame::ShowHtmlToolbars()
  263. {
  264.    // display the appropriate toolbars for HTML editing based on 
  265.    // configuration.
  266.    XP_Bool prefBool;
  267.    PREF_GetBoolPref("editor.show_character_toolbar",&prefBool);
  268.    if ( prefBool ) 
  269.       m_pToolBarController->GetCharacterBar()->ShowWindow(SW_SHOW);
  270. }
  271.  
  272. void CComposeFrame::SetMsgPane(MSG_Pane * pPane) 
  273. { 
  274.     m_pComposePane = pPane; 
  275. }
  276.  
  277. void CComposeFrame::CreatePlainTextEditor()
  278. {
  279.    CWnd *pView = GetDescendantWindow(AFX_IDW_PANE_FIRST, TRUE);
  280.    ASSERT(pView);
  281.  
  282.    // create the editor parent.  This is a window whose sole purpose is to
  283.    // resize the edit control... this will go away when the Gold editor
  284.    // is fully integrated.
  285.  
  286.    CRect rect(0,0,0,0);   
  287.    if (::IsWindow(pView->m_hWnd) && pView->IsWindowVisible())
  288.       pView->GetClientRect(rect);
  289.    
  290.    m_EditorParent.Create ( 
  291.       NULL, NULL, WS_VISIBLE | WS_CHILD,  rect, pView, 0 );        
  292.  
  293.    SetEditorParent((CWnd*)&m_EditorParent);
  294.  
  295.    // create the editor which is currently a standard windows edit 
  296.    // control.  This will be replaced by the Gold editor.
  297.  
  298.    if (rect.Width())
  299.       rect.left = EDIT_MARGIN_OFFSET;
  300.  
  301.    m_Editor.Create ( 
  302.       WS_VSCROLL | ES_MULTILINE | WS_CHILD | WS_VISIBLE | ES_AUTOVSCROLL | ES_WANTRETURN | ES_NOHIDESEL,
  303.       rect, 
  304.       &m_EditorParent, IDC_COMPOSEEDITOR);
  305.       
  306.    m_Editor.SetComposeFrame(this);
  307.    m_Editor.SetTabStops();
  308.  
  309.    m_cxChar = m_Editor.GetCharWidth();
  310.  
  311.    #ifdef XP_WIN16
  312.    m_Editor.SendMessage(EM_LIMITTEXT,0,0);
  313.    #endif
  314. }
  315.  
  316. // Perform initial setup for the compose window.
  317.  
  318. // status bar format
  319. static const UINT BASED_CODE indicators[] =
  320. {
  321.     IDS_SECURITY_STATUS,
  322.     IDS_SIGNED_STATUS,
  323.     IDS_TRANSFER_STATUS,    
  324.     ID_SEPARATOR,
  325.     IDS_TASKBAR
  326. };
  327.  
  328. int CComposeFrame::OnCreate( LPCREATESTRUCT lpCreateStruct )
  329. {
  330.    int retval = CGenericFrame::OnCreate ( lpCreateStruct );
  331.  
  332.     //I'm hardcoding string since I don't want it translated.
  333.     m_pChrome->CreateCustomizableToolbar("Compose_Message", 3, TRUE);
  334.     CButtonToolbarWindow *pWindow;
  335.     BOOL bOpen, bShowing;
  336.  
  337.     int32 nPos;
  338.  
  339.     m_pChrome->LoadToolbarConfiguration(ID_COMPOSE_MESSAGE_TOOLBAR, CString("Message_Toolbar"),nPos, bOpen, bShowing);
  340.  
  341.     // Set up toolbar
  342.     LPNSTOOLBAR pIToolBar = NULL;
  343.     m_pChrome->QueryInterface(IID_INSToolBar,(LPVOID*)&pIToolBar);
  344.     if ( pIToolBar ) 
  345.    {
  346.         pIToolBar->Create( this );
  347.         pIToolBar->SetButtons( ComposeCodes, sizeof(ComposeCodes) / sizeof(UINT) );
  348.         pIToolBar->SetSizes( CSize( 23+7, 21+6), CSize( 23, 21 ) );
  349.        // this is currently loading one bitmap.. this needs to be fixed to add
  350.        // the deferred bitmaps as well.
  351.         pIToolBar->LoadBitmap(MAKEINTRESOURCE(IDB_COMPOSETOOLBAR));
  352.         pIToolBar->SetToolbarStyle( theApp.m_pToolbarStyle );
  353.         pWindow = new CButtonToolbarWindow(CWnd::FromHandlePermanent(pIToolBar->GetHWnd()), theApp.m_pToolbarStyle, 43, 27, eLARGE_HTAB);
  354.         m_pChrome->GetCustomizableToolbar()->AddNewWindow(ID_COMPOSE_MESSAGE_TOOLBAR, pWindow,nPos, 50, 37, 0, CString(szLoadString(ID_COMPOSE_MESSAGE_TOOLBAR)),theApp.m_pToolbarStyle, bOpen, FALSE);
  355.         m_pChrome->ShowToolbar(ID_COMPOSE_MESSAGE_TOOLBAR, bShowing);
  356.         m_pChrome->GetCustomizableToolbar()->SetBottomBorder(TRUE);
  357.         CWnd *pToolWnd = CWnd::FromHandlePermanent( pIToolBar->GetHWnd() );
  358.         if ( pToolWnd ) {
  359.             CStationaryToolbarButton * pStationaryToolbarButton = new CStationaryToolbarButton;
  360.             pStationaryToolbarButton->Create(pToolWnd, theApp.m_pToolbarStyle, CSize(50, 40), CSize(30, 27), 
  361.                szLoadString(IDS_TOOLATTACH),
  362.                szLoadString(IDS_TOOLATTACHFILES),
  363.                szLoadString(IDS_TOOLATTACHALL),
  364.                     IDB_ATTACHBUTTON, 0, CSize(23, 21), TRUE, IDM_ATTACHFILE, 10, TB_HAS_IMMEDIATE_MENU);
  365.             pIToolBar->AddButton( pStationaryToolbarButton, 3 );
  366.         }
  367.  
  368.       if (bSendDeferred)
  369.       {
  370.            pIToolBar->RemoveButton(0);
  371.               CCommandToolbarButton *pCommandButton = new CCommandToolbarButton;
  372.               CString statusStr, toolTipStr, textStr;
  373.            WFE_ParseButtonString(IDM_SENDLATER, statusStr, toolTipStr, textStr);
  374.            DWORD dwButtonStyle = 0;
  375.            pCommandButton->Create(pToolWnd, theApp.m_pToolbarStyle, CSize(44, 37), CSize(25, 25),
  376.                         (const char*) textStr,(const char*) toolTipStr, (const char*) statusStr,
  377.                         IDB_COMPOSETOOLBAR, 7, CSize(23,21), IDM_SENDLATER, -1, dwButtonStyle);
  378.            pIToolBar->AddButton(pCommandButton, 0);
  379.            CCommandToolbar *pToolBar = (CCommandToolbar *) CWnd::FromHandlePermanent( pIToolBar->GetHWnd() );
  380.            pToolBar->ReplaceButtonBitmapIndex(IDM_SENDNOW,7);
  381.       }
  382.  
  383.         m_pChrome->Release();
  384.     }
  385.  
  386.    // create the address/attachment widget dialog bar
  387.    m_pComposeBar = new CComposeBar;
  388.    ASSERT(m_pComposeBar);
  389.    m_pComposeBar->Create ( this, (UINT) IDD_COMPOSEBAR, 
  390.                            (UINT) WS_CLIPCHILDREN|CBRS_TOP, 
  391.                            (UINT) IDD_COMPOSEBAR );
  392.  
  393.    if (m_bUseHtml)
  394.    {
  395.       if (CreateHtmlToolbars() == -1)
  396.          return -1;
  397.         
  398.       RecalcLayout();        
  399.       // Check if format toolbar needs more room and 
  400.       // increase window width to fit it, but observe 600 pixel maximum width
  401.       int iWidth = min(600, m_pToolBarController->GetCharacterBar()->GetToolbarWidth()
  402.                        + GetSystemMetrics(SM_CXFRAME) + 8); // Kludge - 8 more needed to work right!
  403.  
  404.       if( iWidth > lpCreateStruct->cx ){
  405.          SetWindowPos(NULL, 0, 0, iWidth,
  406.                       lpCreateStruct->cy, SWP_NOMOVE|SWP_NOZORDER|SWP_NOACTIVATE);
  407.       }
  408.    }
  409.    else
  410.    {
  411.       CreatePlainTextEditor();
  412.    }
  413.  
  414.    // create a unique title for the composition window    
  415.    CString cs;
  416.    cs = szLoadString(IDS_COMPOSITION);
  417.    GetChrome()->SetWindowTitle(cs);
  418.  
  419.     // Instead of using ANSI_VAR_FONT for i18n
  420.     SetCSID(INTL_DefaultWinCharSetID(0));
  421.  
  422.    // create the status bar
  423.     m_barStatus.Create( this );
  424.     m_barStatus.SetIndicators(indicators, sizeof(indicators)/sizeof(UINT));
  425.  
  426.     LPNSSTATUSBAR pIStatusBar = NULL;
  427.     m_pChrome->QueryInterface( IID_INSStatusBar, (LPVOID *) &pIStatusBar );
  428.     if ( pIStatusBar ) {
  429.         pIStatusBar->Attach( &m_barStatus );
  430.         pIStatusBar->Release();
  431.     }
  432.  
  433.    if (m_bUseHtml)
  434.       ShowHtmlToolbars();
  435.  
  436.     // Attach the submenus shared by Composer, Message Composer, and right-button popups
  437.     HMENU hMenu = ::GetMenu(m_hWnd);
  438.     if( hMenu )
  439.     {
  440.         HMENU hTableMenu = ::GetSubMenu(hMenu, ED_MENU_TABLE);
  441.         if( hTableMenu )
  442.         {
  443.             ::ModifyMenu( hTableMenu, ID_SELECT_TABLE, MF_BYCOMMAND | MF_POPUP | MF_STRING,
  444.                           (UINT)::LoadMenu(AfxGetResourceHandle(), MAKEINTRESOURCE(IDM_COMPOSER_TABLE_SELECTMENU)),
  445.                           szLoadString(IDS_SUBMENU_SELECT_TABLE) );
  446.             ::ModifyMenu( hTableMenu, ID_INSERT_TABLE, MF_BYCOMMAND | MF_POPUP | MF_STRING,
  447.                           (UINT)::LoadMenu(AfxGetResourceHandle(), MAKEINTRESOURCE(IDM_COMPOSER_TABLE_INSERTMENU)),
  448.                           szLoadString(IDS_SUBMENU_INSERT_TABLE) );
  449.             ::ModifyMenu( hTableMenu, ID_DELETE_TABLE, MF_BYCOMMAND | MF_POPUP | MF_STRING,
  450.                           (UINT)::LoadMenu(AfxGetResourceHandle(), MAKEINTRESOURCE(IDM_COMPOSER_TABLE_DELETEMENU)),
  451.                           szLoadString(IDS_SUBMENU_DELETE_TABLE) );
  452.         }
  453.     }
  454.    return retval;
  455. }
  456.  
  457. // OnCreateClient() sets up the context information and create the
  458. // contained CView derived class.
  459.  
  460. BOOL CComposeFrame::OnCreateClient(LPCREATESTRUCT lpcs, CCreateContext *pContext)
  461. {
  462.      BOOL bRetval = CGenericFrame::OnCreateClient(lpcs, pContext);
  463.  
  464.     // Get the current view
  465.     CWnd *pView = GetDescendantWindow(AFX_IDW_PANE_FIRST, TRUE);
  466.     ASSERT(pView);
  467.      CWinCX * pWinCX = new CWinCX(
  468.        (CGenericDoc*)pContext->m_pCurrentDoc, this, (CGenericView *)pView );
  469.  
  470.      //      This is the main and active context.
  471.      SetMainContext(pWinCX);
  472.      SetActiveContext(pWinCX);
  473.     RECT rect;
  474.     GetClientRect(&rect);
  475.     pWinCX->Initialize(FALSE, &rect);
  476.     pWinCX->GetContext()->fancyFTP = TRUE;
  477.     pWinCX->GetContext()->fancyNews = TRUE;
  478.     pWinCX->GetContext()->intrupt = FALSE;
  479.     if (m_bUseHtml)
  480.           pWinCX->GetContext()->is_editor = TRUE;
  481.  
  482.     pWinCX->GetContext()->reSize = FALSE;
  483.     return bRetval;
  484. }
  485.  
  486. // PreCreateWindow() sets the initial compose window size based on
  487. // values that were saved in the registry during OnClose().  The width
  488. // is currently hard-coded to open up to 73 (COMPOSE_WINDOW_WIDTH)
  489. // characters wide.
  490.  
  491. BOOL CComposeFrame::PreCreateWindow ( CREATESTRUCT &cs )
  492. {
  493.     cs.style |= WS_CLIPCHILDREN;
  494.  
  495.     BOOL rv = CGenericFrame::PreCreateWindow ( cs );
  496.  
  497.     int16 iLeft,iRight,iTop,iBottom;
  498.     PREF_GetRectPref("mail.compose_window_rect", &iLeft, &iTop, &iRight, &iBottom);
  499.     // Restore X,Y and height, but recalculate width
  500.     if ( iLeft != -1) 
  501.     {
  502.         cs.x = iLeft;
  503.         cs.y = iTop;
  504.         cs.cy = iBottom-iTop;
  505.         if (m_bUseHtml)
  506.         {
  507.             cs.cx = iRight - iLeft;
  508.             return rv;
  509.         }
  510.     } 
  511.  
  512.     CWnd *pCwnd = AfxGetMainWnd();
  513.     ASSERT(pCwnd);
  514.     
  515.     // get the current character width from the font size, first
  516.     // we have to create the font.
  517.     CClientDC dc(pCwnd);
  518.     HFONT font;
  519.     CFont *pOldFont;
  520.     LOGFONT lf;
  521.     XP_MEMSET(&lf,0,sizeof(LOGFONT));
  522.     TEXTMETRIC tm;
  523.  
  524.     lf.lfPitchAndFamily = FF_MODERN | FIXED_PITCH;
  525.     strcpy(lf.lfFaceName, IntlGetUIFixFaceName(0));
  526.     lf.lfHeight = -MulDiv(9,dc.GetDeviceCaps(LOGPIXELSY), 72);
  527.     lf.lfQuality = PROOF_QUALITY;    
  528.     font = theApp.CreateAppFont( lf );
  529.  
  530.     pOldFont = dc.SelectObject(CFont::FromHandle(font));
  531.     dc.GetTextMetrics(&tm);
  532.     dc.SelectObject(pOldFont);
  533.  
  534.     cs.cx = (GetSystemMetrics(SM_CXFRAME)*2) + 
  535.         (tm.tmAveCharWidth*(COMPOSE_WINDOW_WIDTH+(m_bUseHtml?2:0)));
  536.     cs.cx += GetSystemMetrics(SM_CXVSCROLL);
  537.     cs.cx += EDIT_MARGIN_OFFSET;
  538.     
  539.     // use 2/3 of the screen as the standard default height
  540.     cs.cy = (GetSystemMetrics(SM_CYSCREEN)/3)*2;
  541.     theApp.ReleaseAppFont(font);
  542.     return rv;
  543. }
  544.  
  545. void CComposeFrame::DisplayHeaders ( MSG_HEADER_SET headers )
  546. {
  547.    ASSERT(m_pComposeBar);
  548.    m_pComposeBar->DisplayHeaders ( headers );
  549.     m_pComposeBar->UpdateFixedSize ( );
  550.    RecalcLayout ( );
  551. #ifdef XP_WIN16
  552.     m_pComposeBar->Invalidate();
  553. #endif
  554.    m_SavedHeaders = headers;
  555. }
  556.  
  557. LONG CComposeFrame::OnToolController(UINT,LONG)
  558. {
  559.     if (m_bUseHtml)
  560.     return (LONG)m_pToolBarController;
  561.     return 0;
  562. }
  563.  
  564. void CComposeFrame::SetModified(BOOL bValue)
  565. {
  566.     if (m_bUseHtml)
  567.         EDT_SetDirtyFlag(GetMainContext()->GetContext(), bValue);
  568.     else
  569.         m_EditorParent.SetModified(bValue);
  570. }
  571.  
  572. void CComposeFrame::OnSetFocus(CWnd * pOldWnd) 
  573. {
  574.     CGenericFrame::OnSetFocus(pOldWnd);
  575.     if (GetFocusField())
  576.         GetFocusField()->SetFocus();
  577. }
  578.  
  579. BOOL CComposeFrame::CanCloseFrame(void)
  580. {
  581.     BOOL bModified = FALSE;
  582.     if (m_bUseHtml){
  583.         bModified = EDT_DirtyFlag(GetMainContext()->GetContext());
  584.         MWContext *pMWContext;
  585.         if( GetMainContext() == NULL ||
  586.             (pMWContext = GetMainContext()->GetContext()) == NULL )
  587.             return(FALSE);
  588.  
  589.         // Ignore close if in the process of doing something
  590.         if( pMWContext->edit_saving_url ||
  591.             pMWContext->waitingMode ||
  592.             EDT_IsBlocked(pMWContext)  )
  593.             return(FALSE);
  594.     } else
  595.         bModified = m_EditorParent.m_bModified;
  596.  
  597.     if (bModified) 
  598.     {
  599.         CString csText, csTitle;
  600.         csText.LoadString(IDS_MESSAGENOTSENT);
  601.         csTitle.LoadString(IDS_MESSAGECOMPOSITION);
  602.         if(MessageBox( csText, csTitle, MB_YESNO | MB_ICONEXCLAMATION)==IDNO)
  603.              return(FALSE);
  604.     }
  605.     return(TRUE);
  606.     
  607. }
  608.  
  609. void CComposeFrame::OnClose ( void )
  610. {
  611.     // See if the document will allow closing.
  612.     
  613.      if (!CanCloseFrame())
  614.         return;
  615.     
  616.     m_pComposeBar->Cleanup();
  617.     
  618.     if (m_bUseHtml){
  619.         MWContext *pMWContext;
  620.         if( GetMainContext() == NULL ||
  621.             (pMWContext = GetMainContext()->GetContext()) == NULL )
  622.             return;
  623.  
  624.         // Stop any active plugin
  625.         if (!CheckAndCloseEditorPlugin(pMWContext)) 
  626.             return;
  627.         EDT_DestroyEditBuffer(pMWContext);
  628.     }
  629.  
  630.     // Save the window position... as long as it is not iconified or
  631.     // maximized... 
  632.    if ( !IsIconic() && !IsZoomed() )
  633.    {
  634.       CRect rect;
  635.        GetWindowRect ( &rect );
  636.        PREF_SetRectPref("mail.compose_window_rect", 
  637.          (int16)rect.left, (int16)rect.top, (int16)rect.right, (int16)rect.bottom);
  638.     }
  639.         
  640.    CWinCX * pWinCX = (CWinCX*)GetMainContext();
  641.    if ( pWinCX )
  642.    {
  643.        // close the context and stuff
  644.        CGenericView * pView = pWinCX->GetView();
  645.        if ( pView ) 
  646.           pView->FrameClosing ( );
  647.    }
  648.   
  649.     m_pChrome->SaveToolbarConfiguration(ID_COMPOSE_MESSAGE_TOOLBAR, CString("Message_Toolbar"));
  650. #ifdef XP_WIN32
  651.     // Save toolbar state
  652.    CFrameWnd::SaveBarState(ToolBarProfileName);
  653. #endif
  654.    CGenericFrame::OnClose();
  655. }
  656.  
  657. // Used by the template to set the context type.
  658.  
  659. void CComposeFrame::SetType(MWContextType type)
  660. {
  661.     MWContext * xpContext = GetMainContext()->GetContext();
  662.     ASSERT(xpContext);
  663.     xpContext->type = type;
  664. }
  665.  
  666. #ifdef XP_WIN32
  667. int16 CComposeFrame::GetTitleWinCSID()    // jliu - used by genframe.cpp
  668. {
  669.     return INTL_DocToWinCharSetID( m_iCSID );
  670. }
  671. #endif
  672.  
  673. void CComposeFrame::SetCSID(int16 iCSID)
  674. {
  675.    if(iCSID != m_iCSID)
  676.    {    
  677.     m_iCSID = iCSID;
  678.     m_pComposeBar->SetCSID(iCSID);
  679.     if (m_cfTextFont) {
  680.         theApp.ReleaseAppFont(m_cfTextFont);
  681.     }
  682.  
  683.     CClientDC dc(this);
  684.     LOGFONT lf;                 
  685.     XP_MEMSET(&lf,0,sizeof(LOGFONT));
  686.     lf.lfPitchAndFamily = FF_MODERN | FIXED_PITCH;
  687.     strcpy(lf.lfFaceName, IntlGetUIFixFaceName(m_iCSID));
  688.     lf.lfCharSet = IntlGetLfCharset(m_iCSID); 
  689.     lf.lfHeight = -MulDiv(9,dc.GetDeviceCaps(LOGPIXELSY), 72);
  690.     lf.lfQuality = PROOF_QUALITY;    
  691.     m_cfTextFont = theApp.CreateAppFont( lf );
  692.     TEXTMETRIC tm;
  693.     CFont * pOld = dc.SelectObject(CFont::FromHandle(m_cfTextFont));
  694.     dc.GetTextMetrics(&tm);
  695.     dc.SelectObject(pOld);
  696.     m_cxChar = tm.tmAveCharWidth;
  697.  
  698.     if (!m_bUseHtml)
  699.         ::SendMessage(m_Editor.GetSafeHwnd(), WM_SETFONT, (WPARAM)m_cfTextFont, FALSE);
  700.     else
  701.         EDT_SetEncoding(GetMainContext()->GetContext(), m_iCSID);
  702.  
  703. #ifdef XP_WIN32
  704.     // jliu added the following to support CJK caption print
  705.     SendMessage( WM_SETTINGCHANGE );
  706. #endif
  707.  
  708.     RecalcLayout();
  709.    }
  710. }
  711.  
  712. // OnUpdateThis() enables/disables UI menus/tools based on the state
  713. // which the backend is reporting.  If the menu is a check-item, that
  714. // will be reflected into the appropriate item as well.
  715.  
  716. void CComposeFrame::OnUpdateThis ( CCmdUI* pCmdUI, MSG_CommandType tMenuType )
  717. {
  718.    if (!m_pComposePane || !pCmdUI)
  719.       return;
  720.  
  721.     if (GetMsgPane() && MSG_DeliveryInProgress(GetMsgPane())) 
  722.    {
  723.       pCmdUI->Enable(FALSE);
  724.       return;
  725.    }
  726.  
  727.    XP_Bool bSelectable = FALSE;                    // is this a selectable command?
  728.    XP_Bool bPlural = FALSE;                        // indicates whether to append "s" (which we never do)
  729.    MSG_COMMAND_CHECK_STATE sState = MSG_Unchecked; // checked or unchecked 
  730.  
  731.     // call the backend requesting various state information
  732.     MSG_CommandStatus( 
  733.     m_pComposePane, // message pane
  734.         tMenuType,      // MSG_CommandType value
  735.         NULL,           
  736.     0,
  737.         &bSelectable,   // enable/disable
  738.         &sState,        // checked/unchecked
  739.         NULL,
  740.         &bPlural);      // plural command?
  741.  
  742.     pCmdUI->Enable(bSelectable);                // enable or disable item
  743.     pCmdUI->SetCheck(sState == MSG_Checked);    // set the check state
  744.  
  745. }
  746.  
  747. void CComposeFrame::MessageCommand(MSG_CommandType msgCmd)
  748. {
  749.     ASSERT(m_pComposePane);
  750.     MSG_Command(m_pComposePane, msgCmd, NULL, 0);
  751. }
  752.  
  753. void CComposeFrame::OnWrapLongLines ( )
  754. {
  755.    if (!m_bUseHtml)
  756.    {
  757.       int bHasFocus = 0;
  758.       m_bWrapLongLines ^= 1;
  759.       CRect rect;
  760.       CString cs;
  761.  
  762.       if (GetFocus() == (CWnd *)&m_Editor)
  763.           bHasFocus = 1;
  764.  
  765.       m_Editor.GetWindowRect(rect);
  766.       m_EditorParent.ScreenToClient(rect);
  767.       m_Editor.GetWindowText(cs);
  768.       CFont *pFont = m_Editor.GetFont();
  769.  
  770.       m_Editor.DestroyWindow();
  771.       m_Editor.Create ( 
  772.           WS_VSCROLL | ES_MULTILINE | WS_CHILD | WS_VISIBLE | 
  773.               ES_AUTOVSCROLL | ES_WANTRETURN | (m_bWrapLongLines ? 0 : ES_AUTOHSCROLL|WS_HSCROLL),
  774.           rect, &m_EditorParent, IDC_COMPOSEEDITOR);
  775.       
  776.       m_Editor.SetFont(pFont);
  777.       m_Editor.SetWindowText(cs);
  778.  
  779.       if (bHasFocus)
  780.           m_Editor.SetFocus();
  781.    } 
  782. }
  783.  
  784. void CComposeFrame::OnUpdateWrapLongLines ( CCmdUI * pCmdUI )
  785. {
  786.    OnUpdateButtonGeneral(pCmdUI);
  787.    pCmdUI->SetCheck(m_bWrapLongLines == 1);
  788. }
  789.  
  790. void CComposeFrame::OnNew ( )
  791. {
  792.     MSG_Command(GetMsgPane(), MSG_MailNew, NULL, 0);
  793. }
  794.  
  795. void CComposeFrame::OnSelectAll()
  796. {
  797.     if (m_bUseHtml)
  798.         EDT_SelectAll(GetMainContext()->GetContext());
  799.     else
  800.     {
  801.         m_Editor.SetSel(0,-1);
  802.         m_Editor.SetFocus();
  803.     }
  804. }
  805.  
  806. void CComposeFrame::OnUpdateSelectAll(CCmdUI *pCmdUI)
  807. {
  808.     pCmdUI->Enable(TRUE);
  809. }
  810.  
  811. void CComposeFrame::OnUpdatePasteQuote(CCmdUI *pCmdUI)
  812. {
  813.     pCmdUI->Enable(
  814.         IsClipboardFormatAvailable(CF_TEXT)
  815. #ifdef XP_WIN32
  816.             || IsClipboardFormatAvailable(CF_UNICODETEXT)
  817. #endif
  818.     );
  819. }
  820.  
  821. void CComposeFrame::OnPasteQuote( )
  822. {       
  823.     char *lpszText;
  824.     HANDLE hszText;
  825.     char *lpszQuotedText = NULL;
  826.     OpenClipboard();
  827.  
  828. #ifdef XP_WIN32    // ftang
  829.     BOOL bDoneByUnicode = FALSE;
  830.     // Try to use CF_UNICODETEXT first
  831.     if ((CS_USER_DEFINED_ENCODING != (m_iCSID & ~CS_AUTO)) && 
  832.         IsClipboardFormatAvailable(CF_UNICODETEXT) &&
  833.         (hszText = (HANDLE) GetClipboardData(CF_UNICODETEXT)) )
  834.     {
  835.         char* lpszConvertedText = NULL;
  836.         lpszText = (char *) GlobalLock(hszText);
  837.  
  838.         // Now, let's convert the Unicode text into the datacsid encoding
  839.         int ucs2len = CASTINT(INTL_UnicodeLen((INTL_Unicode*)lpszText));
  840.         int    mbbufneeded = CASTINT(INTL_UnicodeToStrLen((m_iCSID & ~CS_AUTO), 
  841.                                                         (INTL_Unicode*)lpszText, 
  842.                                                         ucs2len));
  843.         if(NULL != (lpszConvertedText = (char*)XP_ALLOC(mbbufneeded + 1)))
  844.         {
  845.             INTL_UnicodeToStr(m_iCSID, (INTL_Unicode*)lpszText, ucs2len, 
  846.                                         (unsigned char*) lpszConvertedText, mbbufneeded + 1);
  847.             
  848.             if (m_bUseHtml) {
  849.                 MSG_PastePlaintextQuotation(GetMsgPane(), lpszConvertedText);
  850.             } else {
  851.                 lpszQuotedText = MSG_ConvertToQuotation(lpszConvertedText);
  852.                 FE_InsertMessageCompositionText(GetMainContext()->GetContext(),
  853.                                                 lpszQuotedText, FALSE);
  854.             }
  855.             XP_FREEIF(lpszConvertedText);
  856.  
  857.             bDoneByUnicode = TRUE;
  858.         }
  859.         GlobalUnlock(hszText);
  860.     }
  861.     
  862.     if(bDoneByUnicode)
  863.     {
  864.         // Already done. Do nothing
  865.     }
  866.     else // not done by unicode try CF_TEXT now
  867. #endif
  868.     if (hszText = (HANDLE) GetClipboardData(CF_TEXT)) 
  869.     {
  870.         lpszText = (char *) GlobalLock(hszText);
  871.         if (m_bUseHtml) {
  872.             MSG_PastePlaintextQuotation(GetMsgPane(), lpszText);
  873.         } else {
  874.             lpszQuotedText = MSG_ConvertToQuotation(lpszText);
  875.             FE_InsertMessageCompositionText(GetMainContext()->GetContext(),
  876.                                             lpszQuotedText, FALSE);
  877.         }
  878.         GlobalUnlock(hszText);
  879.     }
  880.     if (lpszQuotedText) XP_FREE(lpszQuotedText);
  881.     CloseClipboard();
  882. }
  883.  
  884. // UpdateToolbar() changes the command IDs as well as the assigned bitmap
  885. // to reflect the current state.. deferred send or immediate delivery.
  886. void CComposeFrame::UpdateToolBar(void)
  887. {
  888.     ApiToolBar(pIToolBar,m_pChrome);
  889.  
  890.     if ( pIToolBar ) 
  891.     {
  892.         pIToolBar->SetButtons(ComposeCodes, sizeof(ComposeCodes) / sizeof(UINT));
  893.         // this is currently loading one bitmap.. this needs to be fixed to add
  894.         // the deferred bitmaps as well.
  895.         pIToolBar->LoadBitmap(MAKEINTRESOURCE(IDB_COMPOSETOOLBAR));
  896.     }
  897. }
  898.  
  899. void CComposeFrame::OnDoneGoingOffline()
  900. {
  901.     BOOL bGlobalDeferred = FALSE;
  902.     PREF_GetBoolPref("network.online", &bGlobalDeferred);
  903.     bSendDeferred = !bGlobalDeferred;
  904.       LPNSTOOLBAR pIToolBar;
  905.     m_pChrome->QueryInterface( IID_INSToolBar, (LPVOID *) &pIToolBar );
  906.  
  907.     if ( pIToolBar ) 
  908.     {
  909.         CString statusStr, toolTipStr, textStr;
  910.         if (bSendDeferred)
  911.         {
  912.             WFE_ParseButtonString(IDM_SENDLATER, statusStr, toolTipStr, textStr);
  913.             CCommandToolbar *pToolBar = (CCommandToolbar *) CWnd::FromHandlePermanent( pIToolBar->GetHWnd() );
  914.             if ( pToolBar)
  915.             {
  916.                 CToolbarButton *pBarButton = pToolBar->GetNthButton(0);
  917.                 if (pBarButton)
  918.                 {
  919.                      pToolBar->ReplaceButtonBitmapIndex(IDM_SENDNOW, 7);
  920.                     pBarButton->SetToolTipText(toolTipStr);
  921.                     pBarButton->SetStatusText(statusStr);
  922.                     pBarButton->SetText(textStr);
  923.                     pBarButton->SetButtonCommand(IDM_SENDLATER);
  924.                 }
  925.                 pIToolBar->Release();
  926.             }
  927.         }
  928.         else
  929.         {
  930.             WFE_ParseButtonString(IDM_SENDNOW, statusStr, toolTipStr, textStr);
  931.             CCommandToolbar *pToolBar = (CCommandToolbar *) CWnd::FromHandlePermanent( pIToolBar->GetHWnd() );
  932.             if (pToolBar)
  933.             {
  934.                 CToolbarButton *pBarButton = pToolBar->GetNthButton(0);
  935.                  pToolBar->ReplaceButtonBitmapIndex(IDM_SENDLATER, 0);
  936.                 if (pBarButton)
  937.                 {
  938.                     pBarButton->SetToolTipText(toolTipStr);
  939.                     pBarButton->SetStatusText(statusStr);
  940.                     pBarButton->SetText(textStr);
  941.                     pBarButton->SetButtonCommand(IDM_SENDNOW);
  942.                 }
  943.                 pIToolBar->Release();
  944.             }
  945.         }
  946.     }
  947. }
  948.  
  949. void CComposeFrame::OnUpdateButtonGeneral(CCmdUI *pCmdUI)    
  950. { 
  951.     OnUpdateThis(pCmdUI, MSG_SendMessage );
  952. }
  953.  
  954. void CComposeFrame::OnUpdateSend(CCmdUI *pCmdUI)
  955. {
  956.     OnUpdateThis(pCmdUI, bSendDeferred ? MSG_SendMessageLater : MSG_SendMessage);
  957.     pCmdUI->SetText(bSendDeferred ? szLoadString(IDS_DEFAULTSENDNOW) : szLoadString(IDS_DEFAULTSENDLATER));
  958. }
  959.  
  960. void CComposeFrame::OnUpdateSendNow(CCmdUI *pCmdUI)
  961. {
  962.  
  963.     OnUpdateThis(pCmdUI, MSG_SendMessage);
  964.     pCmdUI->SetText(bSendDeferred ? szLoadString(IDS_SENDNOW) : szLoadString(IDS_DEFAULTSENDNOW));
  965. }
  966.  
  967. void CComposeFrame::OnUpdateSendLater(CCmdUI *pCmdUI)
  968. {
  969.  
  970.     OnUpdateThis(pCmdUI, MSG_SendMessageLater);
  971.     pCmdUI->SetText(bSendDeferred ? szLoadString(IDS_DEFAULTSENDLATER) : szLoadString(IDS_SENDLATER));
  972. }
  973.  
  974. // This function is send to the backend for a callback when quoting
  975. // text. Currently, it simply calls the pre-existing insert code.
  976. int WFE_InsertMessage(void *closure, const char * data)
  977. {
  978.    if (data) {
  979.       FE_InsertMessageCompositionText((MWContext*)closure,data,FALSE);
  980.    }
  981.    else {
  982.        MSG_Pane *pPane = MSG_FindPane((MWContext *)closure, MSG_COMPOSITIONPANE);
  983.        if (pPane) {
  984.             CComposeFrame * pCompose = (CComposeFrame *) MSG_GetFEData(pPane);
  985.             if (pCompose->GetQuoteSel() != -1) {
  986.                 if (! pCompose->UseHtml()) {
  987.                     int32 eReplyOnTop = 0;
  988.                     int start = ((int) pCompose->GetQuoteSel()), end = start;
  989.                     int tmpStart = 0;
  990.  
  991.                     if (PREF_NOERROR ==
  992.                             PREF_GetIntPref("mailnews.reply_on_top", &eReplyOnTop)) {
  993.                         switch(eReplyOnTop) {
  994.                         case 1:
  995.                         default:
  996.                             pCompose->GetEditor()->SetSel(start, end);
  997.                             break;
  998.                         case 2:
  999.                             pCompose->GetEditor()->GetSel(tmpStart, end);
  1000.                             pCompose->GetEditor()->SetSel(start, end);
  1001.                             break;
  1002.                         case 3:
  1003.                             pCompose->GetEditor()->GetSel(tmpStart, end);
  1004.                             pCompose->GetEditor()->SetSel(end, start);
  1005.                             break;
  1006.                         }
  1007.                     }
  1008.                 }
  1009.                 pCompose->SetQuoteSel(-1);
  1010.             }
  1011.        }
  1012.    }
  1013.    return 0;
  1014. }
  1015.  
  1016. void CComposeFrame::OnQuoteOriginal( void )
  1017. {
  1018.     SetQuoteSelection();
  1019.     MSG_QuoteMessage(GetMsgPane(),WFE_InsertMessage,(void*)GetMainContext()->GetContext());
  1020. }
  1021.  
  1022. void CComposeFrame::OnAddressTab(void)
  1023. {
  1024.     m_pComposeBar->OnAddressTab();
  1025. }
  1026.  
  1027. void CComposeFrame::OnAttachTab(void)
  1028. {
  1029.     m_pComposeBar->OnAttachTab();
  1030. }
  1031.  
  1032. void CComposeFrame::OnOptionsTab(void)
  1033. {
  1034.     m_pComposeBar->OnOptionsTab();
  1035. }
  1036.  
  1037. void CComposeFrame::OnCollapse(void)
  1038. {
  1039.     m_pComposeBar->OnCollapse();
  1040. }
  1041.  
  1042. // OnSaveAs().. This should probably have better backend support.  This function
  1043. // gets the current message body text and saves it to a user specified location.
  1044.  
  1045. void CComposeFrame::OnSaveAs(void)
  1046. {
  1047.     // Call the file-picker to get a filename/location.
  1048.     char * pPath = wfe_GetSaveFileName(m_hWnd, XP_GetString(MK_MSG_SAVE_AS), szLoadString(IDS_DEFAULTSAVEAS), 0);
  1049.     
  1050.     // if a valid path was specified, continue with save
  1051.     if (pPath && strlen(pPath)) 
  1052.     {
  1053.         uint32 ulBodySize;
  1054.         char *pBody;
  1055.     
  1056.     // open the file for writing
  1057.         FILE *pFile = fopen(pPath, "w");
  1058.     
  1059.     // if the file was opened successfully, continue with save
  1060.         if (pFile)
  1061.     {
  1062.             FE_GetMessageBody(m_pComposePane, &pBody, &ulBodySize, NULL);
  1063.             if (!fwrite(pBody, sizeof(char), CASTSIZE_T(ulBodySize), pFile)) 
  1064.         {
  1065.         // couldn't write file
  1066.                 char szOpenError[512];
  1067.                 sprintf(szOpenError, szLoadString(IDS_CANTWRITETOFILE), pPath);
  1068.                 FE_Alert(GetMainContext()->GetContext(), szOpenError);
  1069.             }
  1070.             if (UseHtml())
  1071.                 XP_HUGE_FREE(pBody);
  1072.             else
  1073.                 XP_FREE(pBody); 
  1074.             fclose(pFile);
  1075.         } 
  1076.     else 
  1077.     {
  1078.         // can't open file
  1079.             char szOpenError[512];
  1080.             sprintf(szOpenError, szLoadString(IDS_CANTWRITETOFILE), pPath);
  1081.             FE_Alert(GetMainContext()->GetContext(), szOpenError);
  1082.         }
  1083.         XP_FREE(pPath);
  1084.     }
  1085. }
  1086.  
  1087.  
  1088. void CComposeFrame::OnCheckSpelling()
  1089. {
  1090.    CWnd * pWnd = GetEditorWnd();
  1091.    if (pWnd)
  1092.       pWnd->SendMessage(WM_COMMAND,ID_CHECK_SPELLING);
  1093. }
  1094.  
  1095. // OnSaveAsDraft() sends based on the current delivery state.
  1096.  
  1097. void CComposeFrame::OnSaveDraft ( void )
  1098.  
  1099. {
  1100.     ASSERT(m_pComposeBar);
  1101.     m_pComposeBar->UpdateHeaderInfo ( );
  1102.  
  1103.     // first we must get the text from the front end and then
  1104.     // tell the backend what text to send.
  1105.  
  1106.     uint32 ulBodySize;
  1107.     char *pBody;
  1108.  
  1109.     FE_GetMessageBody(GetMsgPane(), &pBody, &ulBodySize, NULL);
  1110.     
  1111.     // if we could get text, tell the backend
  1112.     if (ulBodySize) 
  1113.     MSG_SetCompBody(GetMsgPane(),pBody);
  1114.  
  1115.     // start the meteors tumbling    
  1116.     GetChrome()->StartAnimation();
  1117.  
  1118.     MWContext *context;
  1119.     context = GetMainContext()->GetContext();
  1120.  
  1121.     // Pass current csid to backend, so it can do right conversion for 
  1122.     // 8bit header.    
  1123.     INTL_SetCSIDocCSID(LO_GetDocumentCharacterSetInfo(context), m_iCSID);
  1124.  
  1125.     MSG_Command(GetMsgPane(), MSG_SaveDraft, 0, 0);
  1126.     
  1127.     GetChrome()->StopAnimation();
  1128.  
  1129.     if (!m_bUseHtml)
  1130.         m_EditorParent.m_bModified = FALSE;
  1131. }
  1132.  
  1133.  
  1134.  
  1135. void CComposeFrame::OnUpdateSaveDraft(CCmdUI *pCmdUI)
  1136. {
  1137.  
  1138.     // Change the string based on the deferred sending status
  1139.  
  1140.     OnUpdateThis(pCmdUI, MSG_SaveDraft );
  1141.  
  1142. }
  1143.  
  1144.  
  1145. void CComposeFrame::OnSaveTemplate ( void )
  1146.  
  1147. {
  1148.     ASSERT(m_pComposeBar);
  1149.     m_pComposeBar->UpdateHeaderInfo ( );
  1150.  
  1151.     // first we must get the text from the front end and then
  1152.     // tell the backend what text to send.
  1153.  
  1154.     uint32 ulBodySize;
  1155.     char *pBody;
  1156.  
  1157.     FE_GetMessageBody(GetMsgPane(), &pBody, &ulBodySize, NULL);
  1158.     
  1159.     // if we could get text, tell the backend
  1160.     if (ulBodySize) 
  1161.     MSG_SetCompBody(GetMsgPane(),pBody);
  1162.  
  1163.     // start the meteors tumbling    
  1164.     GetChrome()->StartAnimation();
  1165.  
  1166.     MWContext *context;
  1167.     context = GetMainContext()->GetContext();
  1168.  
  1169.     // Pass current csid to backend, so it can do right conversion for 
  1170.     // 8bit header.    
  1171.     INTL_SetCSIDocCSID(LO_GetDocumentCharacterSetInfo(context), m_iCSID);
  1172.  
  1173.     MSG_Command(GetMsgPane(), MSG_SaveTemplate, 0, 0);
  1174.     
  1175.     GetChrome()->StopAnimation();
  1176.  
  1177.     if (!m_bUseHtml)
  1178.         m_EditorParent.m_bModified = FALSE;
  1179. }
  1180.  
  1181. void CComposeFrame::OnUpdateSaveTemplate(CCmdUI *pCmdUI)
  1182. {
  1183.  
  1184.     // Change the string based on the deferred sending status
  1185.  
  1186.     OnUpdateThis(pCmdUI, MSG_SaveTemplate );
  1187.  
  1188. }
  1189.  
  1190.  
  1191. LRESULT CComposeFrame::OnButtonMenuOpen(WPARAM wParam, LPARAM lParam)
  1192. {
  1193.     HMENU hMenu = (HMENU) lParam;
  1194.     UINT nCommand = (UINT) LOWORD(wParam);
  1195.     if (nCommand == IDM_ATTACHFILE){
  1196.         ::AppendMenu(hMenu,MF_STRING|MF_ENABLED, IDM_ATTACHFILE, szLoadString(IDS_TOOLATTACHFILE));
  1197.         ::AppendMenu(hMenu,MF_STRING|MF_ENABLED, IDM_ATTACHWEBPAGE, szLoadString(IDS_ATTACHWEBPAGE));
  1198.         ::AppendMenu(hMenu,MF_SEPARATOR, 0, NULL);
  1199.         ::AppendMenu(hMenu,MF_STRING|MF_ENABLED, IDM_ATTACHMYCARD, szLoadString(IDS_ATTACHMYCARD));
  1200.         return 1;
  1201.     } else if (GetMainWinContext()){
  1202.         // Route other messages to Edit View, which handles messages common to all Composer frames
  1203.         return ::SendMessage( GetMainWinContext()->GetPane(), NSBUTTONMENUOPEN, wParam, lParam);
  1204.     }
  1205.     return 0;
  1206. }
  1207.  
  1208. // DoSend() sends based on the current delivery state.
  1209. void CComposeFrame::DoSend ( BOOL bNow )
  1210. {
  1211.     ASSERT(m_pComposeBar);
  1212.     LPADDRESSCONTROL pIAddress = GetAddressWidgetInterface();
  1213.     if (pIAddress)
  1214.     {
  1215.         CListBox * pListBox = pIAddress->GetListBox();
  1216.         if (::IsWindow(pListBox->m_hWnd))
  1217.             pListBox->SendMessage(WM_NOTIFYSELECTIONCHANGE);
  1218.     }
  1219.     MSG_ClearComposeHeaders(GetMsgPane());
  1220.     m_pComposeBar->UpdateHeaderInfo ( );
  1221.  
  1222.     // first we must get the text from the front end and then
  1223.     // tell the backend what text to send.
  1224.     uint32 ulBodySize;
  1225.     char *pBody = NULL;
  1226.     FE_GetMessageBody(GetMsgPane(), &pBody, &ulBodySize, NULL);
  1227.     
  1228. #ifndef _WIN32
  1229.     if (ulBodySize > 32767) {
  1230.         MessageBox(szLoadString(IDS_MSGTOBIG), szLoadString(IDS_TITLE_ERROR), MB_ICONSTOP|MB_OK);
  1231.         return;
  1232.     }
  1233. #endif
  1234.     // if we could get text, tell the backend
  1235.     if (pBody) 
  1236.         MSG_SetCompBody(GetMsgPane(),pBody);
  1237.  
  1238.     int errcode = 0;
  1239.     MWContext * context = GetMainContext()->GetContext();
  1240.     while ((errcode = MSG_SanityCheck(GetMsgPane(),errcode))!=0)
  1241.     {
  1242.         GetChrome()->StopAnimation();
  1243.         if (errcode == MK_MSG_MISSING_SUBJECT)
  1244.         {
  1245.             char * ptr = PromptMessageSubject();
  1246.             if (ptr != NULL)
  1247.             {
  1248.                 MSG_SetCompHeader(GetMsgPane(),MSG_SUBJECT_HEADER_MASK,ptr);
  1249.                 XP_FREE(ptr);
  1250.             }
  1251.             else
  1252.                 return;
  1253.         }
  1254.         else if (!FE_Confirm(context,XP_GetString(errcode)))
  1255.             return;
  1256.     }
  1257.     
  1258.     // Pass current csid to backend, so it can do right conversion for 
  1259.     // 8bit header.  
  1260.     INTL_SetCSIWinCSID(LO_GetDocumentCharacterSetInfo(context), m_iCSID);
  1261.    
  1262.     MSG_Command(GetMsgPane(), bNow ? MSG_SendMessage : MSG_SendMessageLater, 0, 0);
  1263.  
  1264.     if (GetMsgPane() && MSG_DeliveryInProgress(GetMsgPane())) {
  1265.         // start the meteors tumbling    
  1266.         GetChrome()->StartAnimation();
  1267.         LPNSSTATUSBAR pIStatusBar = NULL;
  1268.         GetChrome()->QueryInterface( IID_INSStatusBar, (LPVOID *) &pIStatusBar );
  1269.         if ( pIStatusBar ) {
  1270.             pIStatusBar->ModalStatus( TRUE, 0, szLoadString(IDS_SENDINGMESSAGE));
  1271.             pIStatusBar->Release();
  1272.         }
  1273.     }
  1274.   // rhp - this condition is for MAPI UI-less send operations...
  1275.   else
  1276.   {
  1277.     if (!IsWindowVisible())       // First, check if the window is not already visible
  1278.       ShowWindow(SW_SHOW);        // and if not, get it on the screen for the user to deal with...    
  1279.   }
  1280.   // rhp 
  1281. }
  1282.  
  1283. void CComposeFrame::OnAttachMyCard()
  1284. {
  1285.     ASSERT(m_pComposeBar);
  1286.     m_pComposeBar->SetAttachMyCard(!m_pComposeBar->GetAttachMyCard());
  1287. }
  1288.  
  1289. void CComposeFrame::OnUpdateAttachMyCard(CCmdUI * pCmdUI)
  1290. {
  1291.     pCmdUI->Enable(TRUE);
  1292.     pCmdUI->SetCheck(m_pComposeBar->GetAttachMyCard());
  1293. }
  1294.  
  1295. void CComposeFrame::OnAttachFile()
  1296. {
  1297.     ASSERT(m_pComposeBar);
  1298.     m_pComposeBar->OnAttachTab();
  1299.     m_pComposeBar->UpdateWindow();
  1300.     m_pComposeBar->AttachFile();
  1301. }
  1302.  
  1303. void CComposeFrame::OnAttachUrl()
  1304. {
  1305.     ASSERT(m_pComposeBar);
  1306.     m_pComposeBar->OnAttachTab();
  1307.     m_pComposeBar->UpdateWindow();
  1308.     m_pComposeBar->AttachUrl();
  1309. }
  1310.  
  1311. void CComposeFrame::ConvertToPlainText()
  1312. {
  1313.    if (MessageBox(szLoadString(IDS_CONVERTWARN), szLoadString(IDS_CONVERTTITLE), 
  1314.       MB_ICONEXCLAMATION | MB_YESNO) == IDYES)
  1315.    {
  1316.  
  1317.       MWContext *pMWContext;
  1318.       if( GetMainContext() == NULL ||
  1319.          (pMWContext = GetMainContext()->GetContext()) == NULL )
  1320.              return;
  1321.         // Stop any active plugin
  1322.       if (!CheckAndCloseEditorPlugin(pMWContext)) 
  1323.          return;
  1324.       EDT_DestroyEditBuffer(pMWContext);
  1325.       pMWContext->is_editor = FALSE;
  1326.       m_pChrome->SetMenu(IDR_COMPOSEPLAIN);
  1327.       DestroyHtmlToolbars();
  1328.       RecalcLayout();
  1329.       CreatePlainTextEditor();
  1330.       ::SendMessage(m_Editor.GetSafeHwnd(), WM_SETFONT, (WPARAM)m_cfTextFont, FALSE);
  1331.       m_bUseHtml = FALSE;
  1332.    }
  1333. }
  1334.  
  1335. void CComposeFrame::ConvertToHtml()
  1336. {
  1337.    m_pChrome->SetMenu(IDR_COMPOSEFRAME);
  1338.    CreateHtmlToolbars();
  1339.    ShowHtmlToolbars();
  1340.    RecalcLayout();
  1341.    SetEditorParent(NULL);
  1342.    m_Editor.DestroyWindow();
  1343.    m_EditorParent.DestroyWindow();
  1344.    m_bUseHtml = TRUE;
  1345.  
  1346.    if (GetMainContext() != NULL)
  1347.    {
  1348.       CWinCX * pWinCX = GetMainContext()->IsFrameContext() ? 
  1349.          VOID2CX(GetMainContext(),CWinCX) : NULL;
  1350.       if (pWinCX != NULL)
  1351.       {
  1352.          MWContext * pContext = pWinCX->GetContext();
  1353.          if (!pContext->is_editor)
  1354.          {
  1355.             pContext->is_editor = TRUE;
  1356.             URL_Struct * pUrl = NET_CreateURLStruct(EDT_NEW_DOC_URL,NET_DONT_RELOAD);
  1357.             if (pUrl != NULL)
  1358.             {
  1359.                pWinCX->GetUrl(pUrl, FO_CACHE_AND_PRESENT);
  1360.                pWinCX->GetContext()->bIsComposeWindow = TRUE;
  1361.             }
  1362.          }  
  1363.       }
  1364.    }
  1365. }
  1366.  
  1367. void CComposeFrame::OnConvert()
  1368. {
  1369.    if (m_bUseHtml)   
  1370.       ConvertToPlainText();
  1371.    else
  1372.       ConvertToHtml();   
  1373. }
  1374.  
  1375. void CComposeFrame::OnUpdateConvert(CCmdUI * pCmdUI)
  1376. {
  1377.    pCmdUI->Enable(FALSE);   // wait for it
  1378. }
  1379.  
  1380. void CComposeFrame::OnSend()
  1381. {
  1382.     DoSend(!bSendDeferred);
  1383. }
  1384.  
  1385. void CComposeFrame::OnSendNow()
  1386. {
  1387.    DoSend(TRUE );
  1388. }
  1389.  
  1390. void CComposeFrame::OnSendLater()
  1391. {
  1392.    DoSend(FALSE);
  1393. }
  1394.  
  1395. void CComposeFrame::MakeComposeBarVisible()
  1396. {
  1397.     if (!GetComposeBar()->IsVisible())
  1398.         GetComposeBar()->OnToggleShow();
  1399.     else if (GetComposeBar()->IsCollapsed())
  1400.     {
  1401.         GetComposeBar()->OnCollapse();
  1402.         CCustToolbar * pToolbar = GetChrome()->GetCustomizableToolbar();
  1403.         if( pToolbar ) 
  1404.             pToolbar->RemoveExternalTab(1);
  1405.            RecalcLayout();
  1406.     }
  1407. }
  1408.  
  1409. void CComposeFrame::OnViewAddresses()
  1410. {
  1411.     MakeComposeBarVisible();
  1412.     GetComposeBar()->SendMessage(WM_COMMAND,IDC_ADDRESSTAB);
  1413. }
  1414.  
  1415. void CComposeFrame::OnViewAttachments()
  1416. {
  1417.     MakeComposeBarVisible();
  1418.     m_pComposeBar->m_pSubjectEdit->SetFocus();
  1419.     UpdateWindow();
  1420.     GetComposeBar()->SendMessage(WM_COMMAND,IDC_ATTACHTAB);
  1421. }
  1422.  
  1423. void CComposeFrame::OnViewOptions()
  1424. {
  1425.     MakeComposeBarVisible();
  1426.     m_pComposeBar->m_pSubjectEdit->SetFocus();
  1427.     UpdateWindow();
  1428.     GetComposeBar()->PostMessage(WM_COMMAND,IDC_OPTIONSTAB);
  1429. }
  1430.  
  1431. void CComposeFrame::OnUpdateViewAddresses(CCmdUI * pCmdUI)
  1432. {
  1433.     pCmdUI->SetRadio(GetComposeBar()->GetTab() == IDX_COMPOSEADDRESS);
  1434.     pCmdUI->Enable(TRUE);
  1435. }
  1436.  
  1437. void CComposeFrame::OnUpdateViewAttachments(CCmdUI * pCmdUI)
  1438. {
  1439.     pCmdUI->SetRadio(GetComposeBar()->GetTab() == IDX_COMPOSEATTACH);
  1440.     pCmdUI->Enable(TRUE);
  1441. }
  1442.  
  1443. void CComposeFrame::OnUpdateViewOptions(CCmdUI * pCmdUI)
  1444. {
  1445.     pCmdUI->SetRadio(GetComposeBar()->GetTab() == IDX_COMPOSEOPTIONS);
  1446.     pCmdUI->Enable(TRUE);
  1447. }
  1448.  
  1449. // OnSetInitialFocus - Invoked after the frame window, toolbar and view are created.
  1450. // It sets the initial keyboard focus.
  1451.  
  1452. LONG CComposeFrame::OnSetInitialFocus(WPARAM wParam, LPARAM lParam)
  1453. {
  1454.     return 0;
  1455. }
  1456.  
  1457. void CComposeFrame::SetInitialText( const char *pText )
  1458. {
  1459.     if (m_pInitialText)
  1460.         XP_FREE (m_pInitialText);
  1461.  
  1462.     m_pInitialText = NULL;
  1463.  
  1464.     if (pText)
  1465.         m_pInitialText = XP_STRDUP(pText);
  1466. }
  1467.  
  1468. BOOL CComposeFrame::BccOnly(void)
  1469. {
  1470.     LPADDRESSCONTROL pIAddress = GetAddressWidgetInterface();
  1471.     CListBox * pListBox = pIAddress->GetListBox();
  1472.     int count = pListBox->GetCount();
  1473.     int total = 0;
  1474.     for (int i=0; i<count; i++)
  1475.     {
  1476.         char * szName, * szType;
  1477.         if(pIAddress->GetEntry(i,&szType, &szName))
  1478.             if(strcmp(szType,szLoadString(IDS_ADDRESSBCC)))
  1479.                 total++;
  1480.     }
  1481.     return !total;
  1482. }
  1483.  
  1484. void CComposeFrame::InsertInitialText(void)
  1485. {
  1486.     const char *pBody = MSG_GetCompBody(GetMsgPane());
  1487.  
  1488.     LPADDRESSCONTROL pIAddress = GetAddressWidgetInterface();
  1489.     if (pIAddress)
  1490.     {
  1491.         CListBox * pListBox = pIAddress->GetListBox();
  1492.         if (::IsWindow(pListBox->m_hWnd))
  1493.             pListBox->ResetContent();
  1494.     }
  1495.  
  1496.     if (m_pInitialText && strlen(m_pInitialText))
  1497.     {
  1498.         EDT_ReadFromBuffer(GetMainContext()->GetContext(),
  1499.                         m_pInitialText);
  1500.         XP_FREEIF(m_pInitialText);
  1501.     }
  1502.     else if (pBody && strlen(pBody))
  1503.     {
  1504.         FE_InsertMessageCompositionText( GetMainContext()->GetContext(), pBody, TRUE);
  1505.         FE_InsertMessageCompositionText( GetMainContext()->GetContext(), "\n", TRUE);
  1506.         MSG_SetCompBody(GetMsgPane(), "");
  1507.     }
  1508.  
  1509.     CompleteComposeInitialization();
  1510.     if (m_bUseHtml)
  1511.         EDT_SetDirtyFlag(GetMainContext()->GetContext(), FALSE);
  1512.  
  1513.     if (MSG_ShouldAutoQuote(GetMsgPane()))
  1514.     {
  1515.         SetQuoteSelection();
  1516.         MSG_QuoteMessage(GetMsgPane(),WFE_InsertMessage,(void*)GetMainContext()->GetContext());
  1517.     }
  1518. }
  1519.  
  1520. void CComposeFrame::CompleteComposeInitialization(void)
  1521. {
  1522.     MSG_HeaderEntry * entry;
  1523.     int nCount;
  1524.     nCount = MSG_RetrieveStandardHeaders(GetMsgPane(),&entry);
  1525.     LPADDRESSCONTROL pIAddress = m_pComposeBar->GetAddressWidgetInterface();
  1526.     CListBox * pListBox = pIAddress->GetListBox();
  1527.     if (nCount > 0) 
  1528.     {
  1529.         int i;
  1530.         pListBox->LockWindowUpdate();
  1531.         for (i=0; i<nCount; i++)
  1532.         {
  1533.             pIAddress->AppendEntry(FALSE,
  1534.                 MSG_HeaderMaskToString(entry[i].header_type),
  1535.                 entry[i].header_value,
  1536.                 0, 0);
  1537.             XP_FREE(entry[i].header_value);
  1538.         }
  1539.         pIAddress->AppendEntry();
  1540.         ::LockWindowUpdate(NULL);
  1541.     }
  1542.  
  1543.     if (entry)
  1544.         XP_FREE(entry);
  1545.  
  1546.     const char * subject = MSG_GetCompHeader(GetMsgPane(),MSG_SUBJECT_HEADER_MASK);
  1547.  
  1548.     if (!nCount)
  1549.         pIAddress->AppendEntry(NULL);
  1550.  
  1551.     // in case of the existance hidden headers, get new count
  1552.     nCount = pListBox->GetCount();
  1553.  
  1554.     if (subject && strlen(subject))
  1555.     {
  1556.         m_pComposeBar->m_pSubjectEdit->SetWindowText(subject);
  1557.         GetChrome()->SetDocumentTitle(subject);
  1558.     }
  1559.  
  1560.     if (nCount<=1 || BccOnly())  
  1561.     {
  1562.         if (BccOnly())
  1563.         {
  1564.             pIAddress->DeleteEntry(pListBox->GetCount()-1);
  1565.             pIAddress->AppendEntry(TRUE, szLoadString(IDS_ADDRESSTO),"",0,0);
  1566.         }
  1567.         pListBox->UpdateWindow();
  1568.         pListBox->SetFocus();
  1569.         SetFocusField(pListBox);
  1570.     }
  1571.     else if (subject && strlen(subject))
  1572.     {
  1573.         if (!UseHtml())
  1574.         {
  1575.             GetEditor()->SetFocus();
  1576.             SetFocusField(GetEditor());
  1577.         }
  1578.     }
  1579.     else
  1580.     {
  1581.         m_pComposeBar->m_pSubjectEdit->SetSel(-1,0);
  1582.         m_pComposeBar->m_pSubjectEdit->SetFocus();
  1583.         SetFocusField(m_pComposeBar->m_pSubjectEdit);
  1584.     }
  1585.  
  1586.    // Set the message priority based on the fileds
  1587.     const char * priorityString = MSG_GetCompHeader(GetMsgPane(), MSG_PRIORITY_HEADER_MASK);
  1588.     if (priorityString) 
  1589.     {
  1590.         // Backend deals only untranslated priority; we have to do some mapping here
  1591.         if (strstr(priorityString, "Highest"))
  1592.             m_pComposeBar->m_iPriorityIdx = MSG_HighestPriority - 2;
  1593.         else if (strstr(priorityString, "High"))
  1594.             m_pComposeBar->m_iPriorityIdx = MSG_HighPriority - 2;
  1595.         else if (strstr(priorityString, "Lowest"))
  1596.             m_pComposeBar->m_iPriorityIdx = MSG_LowestPriority - 2;
  1597.         else if (strstr(priorityString, "Low"))
  1598.             m_pComposeBar->m_iPriorityIdx = MSG_LowPriority - 2;
  1599.         else 
  1600.             m_pComposeBar->m_iPriorityIdx = MSG_NormalPriority - 2;
  1601.     }
  1602.  
  1603.     switch (MSG_GetHTMLAction(GetMsgPane())) {
  1604.         default:
  1605.         case MSG_HTMLAskUser:
  1606.             m_pComposeBar->m_pszMessageFormat = strdup(szLoadString(IDS_FORMAT_ASKME));
  1607.             break;
  1608.         case MSG_HTMLUseMultipartAlternative:
  1609.             m_pComposeBar->m_pszMessageFormat = strdup(szLoadString(IDS_FORMAT_BOTH));
  1610.             break;
  1611.         case MSG_HTMLConvertToPlaintext:
  1612.             m_pComposeBar->m_pszMessageFormat = strdup(szLoadString(IDS_FORMAT_PLAIN));
  1613.             break;
  1614.         case MSG_HTMLSendAsHTML:
  1615.             m_pComposeBar->m_pszMessageFormat = strdup(szLoadString(IDS_FORMAT_HTML));
  1616.             break;
  1617.     }
  1618.  
  1619.     m_pComposeBar->SetAttachMyCard(MSG_GetCompBoolHeader(GetMsgPane(),MSG_ATTACH_VCARD_BOOL_HEADER_MASK));
  1620.     m_pComposeBar->SetReturnReceipt(MSG_GetCompBoolHeader(GetMsgPane(),MSG_RETURN_RECEIPT_BOOL_HEADER_MASK));
  1621.     m_pComposeBar->SetUseUUENCODE(MSG_GetCompBoolHeader(GetMsgPane(),MSG_UUENCODE_BINARY_BOOL_HEADER_MASK));
  1622.     UpdateSecurityOptions();
  1623.  
  1624.     m_bInitialized = TRUE;
  1625. }
  1626.  
  1627. void CComposeFrame::UpdateSecurityOptions(void)
  1628. {
  1629.     m_pComposeBar->SetSigned(MSG_GetCompBoolHeader(GetMsgPane(),MSG_SIGNED_BOOL_HEADER_MASK));
  1630.     m_pComposeBar->SetEncrypted(MSG_GetCompBoolHeader(GetMsgPane(),MSG_ENCRYPTED_BOOL_HEADER_MASK));
  1631. }
  1632.  
  1633. void CComposeFrame::GoldDoneLoading ()
  1634. {
  1635.    MSG_InitializeCompositionPane(GetMsgPane(),m_pOldContext,m_pFields);
  1636.    PostMessage(WM_COMP_SET_INITIAL_FOCUS);
  1637.    UpdateAttachmentInfo();
  1638. }
  1639.  
  1640. ////////////////////////////////////////////////////////////////////////////////////
  1641. // Begin the pseudo-backend code here.
  1642.  
  1643. const char * MSG_HeaderMaskToString(MSG_HEADER_SET header)
  1644. {
  1645.     const char * retval = NULL;
  1646.     switch (header)
  1647.     {
  1648.         case MSG_TO_HEADER_MASK:
  1649.             retval = szLoadString(IDS_ADDRESSTO);
  1650.             break;
  1651.         case MSG_CC_HEADER_MASK:
  1652.             retval = szLoadString(IDS_ADDRESSCC);
  1653.             break;
  1654.         case MSG_BCC_HEADER_MASK:
  1655.             retval = szLoadString(IDS_ADDRESSBCC);
  1656.             break;
  1657.         case MSG_REPLY_TO_HEADER_MASK:
  1658.             retval = szLoadString(IDS_ADDRESSREPLYTO);
  1659.             break;
  1660.         case MSG_NEWSGROUPS_HEADER_MASK:
  1661.             retval = szLoadString(IDS_ADDRESSNEWSGROUP);
  1662.             break;
  1663.         case MSG_FOLLOWUP_TO_HEADER_MASK:
  1664.             retval = szLoadString(IDS_ADDRESSFOLLOWUPTO);
  1665.             break;
  1666.         default:
  1667.             XP_ASSERT(0);
  1668.     }
  1669.     return retval;
  1670. }
  1671.  
  1672. MSG_HEADER_SET MSG_StringToHeaderMask(char * string)
  1673. {
  1674.     MSG_HEADER_SET retval = 0;
  1675.     if (!stricmp(szLoadString(IDS_ADDRESSTO),string))
  1676.         retval = MSG_TO_HEADER_MASK;
  1677.     else if (!stricmp(szLoadString(IDS_ADDRESSCC),string))
  1678.         retval = MSG_CC_HEADER_MASK;
  1679.     else if (!stricmp(szLoadString(IDS_ADDRESSBCC),string))
  1680.         retval = MSG_BCC_HEADER_MASK;
  1681.     else if (!stricmp(szLoadString(IDS_ADDRESSREPLYTO),string))
  1682.         retval = MSG_REPLY_TO_HEADER_MASK;
  1683.     else if (!stricmp(szLoadString(IDS_ADDRESSNEWSGROUP),string))
  1684.         retval = MSG_NEWSGROUPS_HEADER_MASK;
  1685.     else if (!stricmp(szLoadString(IDS_ADDRESSFOLLOWUPTO),string))
  1686.         retval = MSG_FOLLOWUP_TO_HEADER_MASK;
  1687.     else
  1688.         XP_ASSERT(0);
  1689.     return retval;
  1690. }
  1691.  
  1692. BOOL CComposeFrame::OnCmdMsg(UINT nID, int nCode, void* pExtra, AFX_CMDHANDLERINFO* pHandlerInfo)
  1693. {
  1694.    BOOL bRetVal = CGenericFrame::OnCmdMsg(nID,nCode,pExtra,pHandlerInfo);
  1695.    if (nCode == CN_UPDATE_COMMAND_UI)
  1696.       if (!bRetVal && !m_bUseHtml)
  1697.          bRetVal = m_Editor.OnCmdMsg(nID,nCode,pExtra,pHandlerInfo);
  1698.    return bRetVal;
  1699. }
  1700.  
  1701. void CComposeFrame::OnToggleMessageToolbar()
  1702. {
  1703.     GetChrome()->ShowToolbar(ID_COMPOSE_MESSAGE_TOOLBAR, !GetChrome()->GetToolbarVisible(ID_COMPOSE_MESSAGE_TOOLBAR));
  1704. }
  1705.  
  1706. void CComposeFrame::OnUpdateToggleMessageToolbar(CCmdUI* pCmdUI)
  1707. {
  1708.    if( pCmdUI->m_pMenu ){
  1709.       pCmdUI->m_pMenu->ModifyMenu(IDM_OPT_MESSAGEBAR_TOGGLE, MF_BYCOMMAND | MF_STRING, CASTUINT(IDM_OPT_MESSAGEBAR_TOGGLE),
  1710.                                   szLoadString(GetChrome()->GetToolbarVisible(ID_COMPOSE_MESSAGE_TOOLBAR) ?
  1711.                                                IDS_HIDE_MESSAGE_TOOLBAR : IDS_SHOW_MESSAGE_TOOLBAR ) );
  1712.    }   
  1713.    pCmdUI->Enable(TRUE);
  1714. }
  1715.  
  1716. void CComposeFrame::OnToggleAddressArea()
  1717. {
  1718.     m_pComposeBar->OnToggleShow();
  1719. }
  1720.  
  1721. void CComposeFrame::OnUpdateToggleAddressArea(CCmdUI * pCmdUI)
  1722. {
  1723.    //CLM: Change to a Show|Hide pair of strings
  1724.    if( pCmdUI->m_pMenu ){
  1725.       pCmdUI->m_pMenu->ModifyMenu(IDM_MESSAGEBODYONLY, MF_BYCOMMAND | MF_STRING, CASTUINT(IDM_MESSAGEBODYONLY),
  1726.                                   szLoadString(CASTUINT(m_pComposeBar->IsVisible() ?
  1727.                                                IDS_HIDE_ADDRESS_AREA : IDS_SHOW_ADDRESS_AREA)) );
  1728.    }   
  1729.    pCmdUI->Enable(TRUE);
  1730. }
  1731.  
  1732. #define UNSECURE_INDEX        9
  1733. #define SECURE_INDEX        11
  1734. #define UNSEC_SIGNED_INDEX    8
  1735. #define SEC_SIGNED_INDEX    10
  1736.  
  1737. void CComposeFrame::OnUpdateSecurity(CCmdUI * pCmdUI)
  1738. {
  1739.     XP_Bool bSigned = m_pComposeBar->GetSigned();
  1740.     XP_Bool bEncrypted = m_pComposeBar->GetEncrypted();
  1741.     LPNSTOOLBAR pIToolBar;
  1742.     m_pChrome->QueryInterface( IID_INSToolBar, (LPVOID *) &pIToolBar );
  1743.     if ( pIToolBar ) {
  1744.         CCommandToolbar *pToolBar = (CCommandToolbar *) CWnd::FromHandlePermanent( pIToolBar->GetHWnd() );
  1745.         
  1746.         int index = bEncrypted ? 
  1747.                     (bSigned ? SEC_SIGNED_INDEX : SECURE_INDEX) :
  1748.                     (bSigned ? UNSEC_SIGNED_INDEX : UNSECURE_INDEX);
  1749.  
  1750.         pToolBar->ReplaceButtonBitmapIndex(ID_SECURITY, index);
  1751.         pIToolBar->Release();
  1752.     }
  1753.    OnUpdateButtonGeneral(pCmdUI);
  1754. }
  1755.  
  1756. void CComposeFrame::OnUpdateSecureStatus(CCmdUI *pCmdUI)
  1757. {
  1758.     XP_Bool bSigned = m_pComposeBar->GetSigned();
  1759.     XP_Bool bEncrypted = m_pComposeBar->GetEncrypted();
  1760.  
  1761.     if (pCmdUI->m_nID == IDS_SECURITY_STATUS)
  1762.         pCmdUI->Enable(bEncrypted);
  1763.     else
  1764.         pCmdUI->Enable(bSigned);
  1765. }
  1766.  
  1767. char * CComposeFrame::PromptMessageSubject()
  1768. {
  1769.     CWnd * pWnd = GetFocus();
  1770.     CString csText;
  1771.     CString csDefault;
  1772.     csText.LoadString(IDS_COMPOSE_NOSUBJECT);
  1773.     csDefault.LoadString(IDS_COMPOSE_DEFAULTNOSUBJECT);
  1774.     MWContext * pContext = GetMainContext()->GetContext();
  1775.     char * ptr = ABSTRACTCX(pContext)->Prompt(pContext, csText, csDefault);
  1776.     pWnd->SetFocus();
  1777.     return ptr;
  1778. }
  1779.  
  1780. void CComposeFrame::OnSecurity()
  1781. {
  1782.     m_pComposeBar->UpdateHeaderInfo ( );
  1783.     CGenericFrame::OnSecurity();
  1784. }
  1785.  
  1786. void CComposeFrame::RefreshNewEncoding(int16 doc_csid, BOOL bSave )
  1787. {
  1788.     int16 win_csid = INTL_DocToWinCharSetID(doc_csid);
  1789.     INTL_CharSetInfo c = LO_GetDocumentCharacterSetInfo( GetMainContext()->GetContext() );
  1790.  
  1791.     INTL_SetCSIDocCSID( c, doc_csid );    
  1792.     INTL_SetCSIWinCSID( c, win_csid );
  1793.     
  1794.     SetCSID( doc_csid );
  1795. }
  1796.  
  1797. LRESULT CComposeFrame::OnFindReplace(WPARAM wParam, LPARAM lParam) 
  1798. {
  1799.    if (!m_bUseHtml)
  1800.    {
  1801.       return m_Editor.OnFindReplace(wParam,lParam);
  1802.    }
  1803.    return CGenericFrame::OnFindReplace(wParam,lParam);
  1804. }
  1805.  
  1806. void CComposeFrame::GetMessageString(UINT MenuID, CString& Message) const
  1807. {
  1808. #ifdef EDITOR
  1809.     // static function for both CEditFrame and CComposeFrame
  1810.     //  to get runtime-determined statusline strings for menus
  1811.     if( edt_GetMessageString(GetActiveView(), MenuID, Message) )
  1812.         return;
  1813. #endif
  1814.  
  1815.     CGenericFrame::GetMessageString(MenuID, Message);
  1816. }
  1817.  
  1818. // OnSetMessageString - Override of CGenericFrame's WM_SETMESSAGESTRING message handler. We need this 
  1819. // because the base class is supressing the dynamically-created menu help strings for Composer
  1820. LRESULT CComposeFrame::OnSetMessageString(WPARAM wParam, LPARAM lParam)
  1821. {
  1822.     if( edt_IsEditorDynamicMenu(wParam) )
  1823.         return CFrameWnd::OnSetMessageString(wParam, lParam);
  1824.     else
  1825.         return CGenericFrame::OnSetMessageString(wParam, lParam);
  1826. }
  1827.  
  1828. // rhp - Added for sending the message when the window is not shown
  1829. // This is to wait until attachments are loaded for MAPI Operations
  1830. void CComposeFrame::UpdateComposeWindowForMAPI(void) 
  1831. { 
  1832.     if (GetMAPISendMode() == MAPI_SEND)
  1833.     {
  1834.       PostMessage(WM_COMMAND, IDM_SEND); 
  1835.       SetMAPISendMode(MAPI_IGNORE);
  1836.     }
  1837.     else if (GetMAPISendMode() == MAPI_SAVE)
  1838.     {
  1839.       PostMessage(WM_COMMAND, IDM_SAVEASDRAFT); 
  1840.       SetMAPISendMode(MAPI_IGNORE);
  1841.     }
  1842. } 
  1843.