windows-server-2003/printscan/faxsrv/clientconsole/mainfrm.cpp

// MainFrm.cpp : implementation of the CMainFrame class
//

#include "stdafx.h"

#define __FILE_ID__     5

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

extern CClientConsoleApp theApp;

/////////////////////////////////////////////////////////////////////////////
// CMainFrame

IMPLEMENT_DYNCREATE(CMainFrame, CFrameWnd)

BEGIN_MESSAGE_MAP(CMainFrame, CFrameWnd)
    //{{AFX_MSG_MAP(CMainFrame)
    ON_WM_CREATE()
    ON_WM_CLOSE()
    ON_WM_SETTINGCHANGE()
    ON_WM_SYSCOLORCHANGE()
    //}}AFX_MSG_MAP
    ON_COMMAND(ID_HELP_FINDER,             OnHelpContents)
    ON_MESSAGE(WM_HELP,                    OnHelp)                   // F1
    ON_COMMAND(ID_VIEW_REFRESH_FOLDER,     OnRefreshFolder)
    ON_COMMAND(ID_SEND_NEW_FAX,            OnSendNewFax)
    ON_COMMAND(ID_RECEIVE_NEW_FAX,         OnReceiveNewFax)
    ON_COMMAND(ID_TOOLS_USER_INFO,         OnViewOptions)
    ON_COMMAND(ID_TOOLS_CONFIG_WIZARD,     OnToolsConfigWizard)
    ON_COMMAND(ID_TOOLS_ADMIN_CONSOLE,     OnToolsAdminConsole)    
    ON_COMMAND(ID_TOOLS_MONITOR,           OnToolsMonitor)    
    ON_COMMAND(ID_VIEW_COVER_PAGES,        OnToolsCoverPages)    
    ON_COMMAND(ID_VIEW_SERVER_STATUS,      OnToolsServerStatus)    
    ON_COMMAND(ID_TOOLS_FAX_PRINTER_PROPS, OnToolsFaxPrinterProps)    
    ON_COMMAND(ID_VIEW_SELECT_COLUMNS,     OnSelectColumns)
    ON_COMMAND(ID_IMPORT_INBOX,            OnImportInbox)
    ON_COMMAND(ID_IMPORT_SENT,             OnImportSentItems)
    ON_UPDATE_COMMAND_UI_RANGE(ID_TOOLS_CONFIG_WIZARD, ID_TOOLS_MONITOR, OnUpdateWindowsXPTools)
    ON_UPDATE_COMMAND_UI(ID_VIEW_SELECT_COLUMNS,          OnUpdateSelectColumns)        
    ON_UPDATE_COMMAND_UI(ID_VIEW_SERVER_STATUS,           OnUpdateServerStatus)       
    ON_UPDATE_COMMAND_UI(ID_VIEW_REFRESH_FOLDER,          OnUpdateRefreshFolder)
    ON_UPDATE_COMMAND_UI(ID_INDICATOR_FOLDER_ITEMS_COUNT, OnUpdateFolderItemsCount)
    ON_UPDATE_COMMAND_UI(ID_INDICATOR_ACTIVITY,           OnUpdateActivity)    
    ON_UPDATE_COMMAND_UI(ID_SEND_NEW_FAX,                 OnUpdateSendNewFax)
    ON_UPDATE_COMMAND_UI(ID_RECEIVE_NEW_FAX,              OnUpdateReceiveNewFax)
    ON_UPDATE_COMMAND_UI(ID_IMPORT_SENT,                  OnUpdateImportSent)
    ON_UPDATE_COMMAND_UI(ID_HELP_FINDER,                  OnUpdateHelpContents)    
    ON_MESSAGE(WM_POPUP_ERROR,                            OnPopupError)
    ON_MESSAGE(WM_CONSOLE_SET_ACTIVE_FOLDER,              OnSetActiveFolder)
    ON_MESSAGE(WM_CONSOLE_SELECT_ITEM,                    OnSelectItem)
    ON_MESSAGE(WM_QUERYENDSESSION, OnQueryEndSession)
    ON_NOTIFY(NM_DBLCLK, AFX_IDW_STATUS_BAR, OnStatusBarDblClk )
END_MESSAGE_MAP()


//
// List of indices of items used in the Incoming folder
//
#define INCOMING_DEF_COL_NUM   8

static MsgViewItemType IncomingColumnsUsed[] = 
                {
                    MSG_VIEW_ITEM_ICON,                    // default 0 
                    MSG_VIEW_ITEM_TRANSMISSION_START_TIME, // default 1 
                    MSG_VIEW_ITEM_TSID,                    // default 2
                    MSG_VIEW_ITEM_CALLER_ID,               // default 3 
                    MSG_VIEW_ITEM_STATUS,                  // default 4 
                    MSG_VIEW_ITEM_EXTENDED_STATUS,         // default 5 
                    MSG_VIEW_ITEM_CURRENT_PAGE,            // default 6 
                    MSG_VIEW_ITEM_SIZE,                    // default 7 
                    MSG_VIEW_ITEM_SERVER,          
                    MSG_VIEW_ITEM_CSID,            
                    MSG_VIEW_ITEM_DEVICE,          
                    MSG_VIEW_ITEM_ROUTING_INFO,    
                    MSG_VIEW_ITEM_SEND_TIME,   // schedule time
                    MSG_VIEW_ITEM_TRANSMISSION_END_TIME,
                    MSG_VIEW_ITEM_ID,              
                    MSG_VIEW_ITEM_NUM_PAGES, 
                    MSG_VIEW_ITEM_RETRIES,         
                    MSG_VIEW_ITEM_END              // End of list
                };


//
// List of indices of items used in the Inbox folder
//
#define INBOX_DEF_COL_NUM   8

static MsgViewItemType InboxColumnsUsed[] = 
                {
                    MSG_VIEW_ITEM_ICON,                    // default 0 
                    MSG_VIEW_ITEM_TRANSMISSION_START_TIME, // default 1 
                    MSG_VIEW_ITEM_TSID,                    // default 2 
                    MSG_VIEW_ITEM_CALLER_ID,               // default 3 
                    MSG_VIEW_ITEM_NUM_PAGES,               // default 4 
                    MSG_VIEW_ITEM_STATUS,                  // default 5 
                    MSG_VIEW_ITEM_SIZE,                    // default 6 
                    MSG_VIEW_ITEM_CSID,                    // default 7
                    MSG_VIEW_ITEM_SERVER,                
                    MSG_VIEW_ITEM_TRANSMISSION_END_TIME, 
                    MSG_VIEW_ITEM_TRANSMISSION_DURATION, 
                    MSG_VIEW_ITEM_DEVICE,                
                    MSG_VIEW_ITEM_ROUTING_INFO,          
                    MSG_VIEW_ITEM_ID,                    
                    MSG_VIEW_ITEM_END              // End of list
                };

//
// List of indices of items used in the sent items folder
//
#define SENT_ITEMS_DEF_COL_NUM   8

static MsgViewItemType SentItemsColumnsUsed[] = 
                {
                    MSG_VIEW_ITEM_ICON,                   // default 0
                    MSG_VIEW_ITEM_TRANSMISSION_START_TIME,// default 1
                    MSG_VIEW_ITEM_RECIPIENT_NAME,         // default 2
                    MSG_VIEW_ITEM_RECIPIENT_NUMBER,       // default 3
                    MSG_VIEW_ITEM_SUBJECT,                // default 4
                    MSG_VIEW_ITEM_DOC_NAME,               // default 5
                    MSG_VIEW_ITEM_NUM_PAGES,              // default 6
                    MSG_VIEW_ITEM_SIZE,                   // default 7
                    MSG_VIEW_ITEM_SERVER,
                    MSG_VIEW_ITEM_USER,
                    MSG_VIEW_ITEM_PRIORITY,
                    MSG_VIEW_ITEM_CSID,
                    MSG_VIEW_ITEM_TSID,
                    MSG_VIEW_ITEM_ORIG_TIME,
                    MSG_VIEW_ITEM_RETRIES,
                    MSG_VIEW_ITEM_ID,
                    MSG_VIEW_ITEM_BROADCAST_ID,
                    MSG_VIEW_ITEM_SUBMIT_TIME,
                    MSG_VIEW_ITEM_TRANSMISSION_DURATION,
                    MSG_VIEW_ITEM_TRANSMISSION_END_TIME,
                    MSG_VIEW_ITEM_BILLING,
                    MSG_VIEW_ITEM_SENDER_NAME,
                    MSG_VIEW_ITEM_SENDER_NUMBER,
                    MSG_VIEW_ITEM_END    // End of list
                };

//
// List of indices of items used in the Outbox folder
//

#define OUTBOX_DEF_COL_NUM   9

static MsgViewItemType OutboxColumnsUsed[] = 
                {
                    MSG_VIEW_ITEM_ICON,             // default 0
                    MSG_VIEW_ITEM_SUBMIT_TIME,      // default 1
                    MSG_VIEW_ITEM_RECIPIENT_NAME,   // default 2
                    MSG_VIEW_ITEM_RECIPIENT_NUMBER, // default 3
                    MSG_VIEW_ITEM_SUBJECT,          // default 4
                    MSG_VIEW_ITEM_DOC_NAME,         // default 5
                    MSG_VIEW_ITEM_STATUS,           // default 6
                    MSG_VIEW_ITEM_EXTENDED_STATUS,  // default 7                    
                    MSG_VIEW_ITEM_CURRENT_PAGE,     // default 8                    
                    MSG_VIEW_ITEM_SEND_TIME,        
                    MSG_VIEW_ITEM_SERVER,    
                    MSG_VIEW_ITEM_NUM_PAGES,       
                    MSG_VIEW_ITEM_USER,        
                    MSG_VIEW_ITEM_PRIORITY,    
                    MSG_VIEW_ITEM_CSID,        
                    MSG_VIEW_ITEM_TSID,        
                    MSG_VIEW_ITEM_ORIG_TIME,   
                    MSG_VIEW_ITEM_SIZE,        
                    MSG_VIEW_ITEM_DEVICE,        
                    MSG_VIEW_ITEM_RETRIES,     
                    MSG_VIEW_ITEM_ID,      
                    MSG_VIEW_ITEM_BROADCAST_ID,
                    MSG_VIEW_ITEM_BILLING,         
                    MSG_VIEW_ITEM_END    // End of list
                };

//
// Status bar indicators
//
static UINT indicators[] =
{
    ID_SEPARATOR,           // status line indicator (menu item)
    ID_INDICATOR_FOLDER_ITEMS_COUNT,  // status line indicator (num of folder items)
    ID_INDICATOR_ACTIVITY,            // status line indicator (Activity)
};


/////////////////////////////////////////////////////////////////////////////
// CMainFrame construction/destruction

CMainFrame::CMainFrame() :
    m_pInitialRightPaneView (NULL),
    m_pLeftView (NULL),
    m_pIncomingView(NULL),
    m_pInboxView(NULL),
    m_pSentItemsView(NULL),
    m_pOutboxView(NULL)
{}

CMainFrame::~CMainFrame()
{
}

int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
    int iRes = 0;
    DWORD dwRes;
    DBG_ENTER(TEXT("CMainFrame::OnCreate"), (HRESULT &)iRes);

    if (CFrameWnd::OnCreate(lpCreateStruct) == -1)
    {
        iRes = -1;
        CALL_FAIL (STARTUP_ERR, TEXT("CFrameWnd::OnCreate"), iRes);
        return iRes;
    }

    FrameToSavedLayout();

    //
    // Create the toolbar
    //  
    if (!m_wndToolBar.CreateEx(this) ||
        !m_wndToolBar.LoadToolBar(IDR_MAINFRAME))
    {
        iRes = -1;
        CALL_FAIL (STARTUP_ERR, 
                   TEXT("CToolBar::CreateEx or CToolBar::LoadToolBar"), 
                   iRes);
        return iRes;
    }
    //
    // Create the rebar and place the toolbar + dialogbar in it.
    //
    if (!m_wndReBar.Create(this) ||
        !m_wndReBar.AddBar(&m_wndToolBar))
    {
        iRes = -1;
        CALL_FAIL (STARTUP_ERR, 
                   TEXT("CReBar::Create or CReBar::AddBar"), 
                   iRes);
        return iRes;
    }
    //
    // Create the status bar
    //
    if (!m_wndStatusBar.CreateEx (this, SBARS_SIZEGRIP | SBT_TOOLTIPS) ||
        !m_wndStatusBar.SetIndicators (indicators, sizeof(indicators)/sizeof(UINT)))
    {
        iRes = -1;
        CALL_FAIL (STARTUP_ERR, 
                   TEXT("CStatusBar::CreateEx or CStatusBar::SetIndicators"), 
                   iRes);
        return iRes;
    }

    //
    // set pane width
    //
    m_wndStatusBar.SetPaneInfo(STATUS_PANE_ITEM_COUNT, 
                               ID_INDICATOR_FOLDER_ITEMS_COUNT, 
                               SBPS_NORMAL, 
                               80);
    m_wndStatusBar.SetPaneInfo(STATUS_PANE_ACTIVITY, 
                               ID_INDICATOR_ACTIVITY,           
                               SBPS_STRETCH, 
                               200);

    // TODO: Remove this if you don't want tool tips
    m_wndToolBar.SetBarStyle(m_wndToolBar.GetBarStyle() | CBRS_TOOLTIPS | CBRS_FLYBY);
    //
    // Load strings used for display throughout the application - priority & job status
    //
    dwRes = CViewRow::InitStrings ();
    if (ERROR_SUCCESS != dwRes)
    {
        iRes = -1;
        CALL_FAIL (RESOURCE_ERR, TEXT("CJob::InitStrings"), dwRes);
        return iRes;
    }
    return iRes;
}

BOOL CMainFrame::OnCreateClient(LPCREATESTRUCT /*lpcs*/,
    CCreateContext* pContext)
{
    BOOL bRes = TRUE;
    DBG_ENTER(TEXT("CMainFrame::OnCreateClient"), bRes);
    //
    // Create splitter window
    //
    if (!m_wndSplitter.CreateStatic(this, 1, 2))
    {
        bRes = FALSE;
        CALL_FAIL (STARTUP_ERR, TEXT("CSplitterWnd::CreateStatic"), bRes);
        return bRes;
    }
    CRect r;
    GetWindowRect(r);

    int iLeftWidth = int(r.Width()*0.32),
        iRightWidth = int(r.Width()*0.68);

    if (!m_wndSplitter.CreateView(0, 
                                  0, 
                                  RUNTIME_CLASS(CLeftView), 
                                  CSize(iLeftWidth, r.Height()), 
                                  pContext
                                 ) ||
        !m_wndSplitter.CreateView(0, 
                                  1, 
                                  RUNTIME_CLASS(CClientConsoleView), 
                                  CSize(iRightWidth, r.Height()), 
                                  pContext
                                 )
       )
    {
        m_wndSplitter.DestroyWindow();
        bRes = FALSE;
        CALL_FAIL (STARTUP_ERR, TEXT("CSplitterWnd::CreateView"), bRes);
        return bRes;
    }
    m_pInitialRightPaneView = GetRightPane ();
    m_pLeftView = (CLeftView *)(m_wndSplitter.GetPane(0,0));

    SplitterToSavedLayout();

    return bRes;
}   // CMainFrame::OnCreateClient

BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs)
{
    BOOL bRes = TRUE;
    DBG_ENTER(TEXT("CMainFrame::PreCreateWindow"), bRes);
    
    //
    // The following line removes the document name from the application's title.
    //
    cs.style &= ~FWS_ADDTOTITLE;
    //
    // Use the unique class name so that FindWindow can later locate it.
    //
    cs.lpszClass = theApp.GetClassName();

    if( !CFrameWnd::PreCreateWindow(cs) )
    {
        bRes = FALSE;
        CALL_FAIL (STARTUP_ERR, TEXT("CFrameWnd::PreCreateWindow"), bRes);
        return bRes;
    }
    return bRes;
}

/////////////////////////////////////////////////////////////////////////////
// CMainFrame diagnostics

#ifdef _DEBUG
void CMainFrame::AssertValid() const
{
    CFrameWnd::AssertValid();
}

void CMainFrame::Dump(CDumpContext& dc) const
{
    CFrameWnd::Dump(dc);
}

#endif //_DEBUG

/////////////////////////////////////////////////////////////////////////////
// CMainFrame message handlers

CListView* CMainFrame::GetRightPane()
{
    CWnd* pWnd = m_wndSplitter.GetPane(0, 1);
    return (CListView *)pWnd;
}

void 
CMainFrame::SwitchRightPaneView(
    CListView *pNewView
)
/*++

Routine name : CMainFrame::SwitchRightPaneView

Routine description:

    Switches the view displayed in the right pane to a new view

Author:

    Eran Yariv (EranY), Jan, 2000

Arguments:

    pNewView            [in] - View to display in the right pane

Return Value:

    None.

--*/
{
    DBG_ENTER(TEXT("CMainFrame::SwitchRightPaneView"));
    ASSERT_VALID (&m_wndSplitter);
    if (!pNewView)
    {
        //
        // Switch back to our initial right pane view
        //
        pNewView = m_pInitialRightPaneView;
    }
    ASSERTION (pNewView);
    ASSERT_KINDOF (CListView, pNewView);
    //
    // Get window at current pane
    //
    CWnd *pPaneWnd = m_wndSplitter.GetPane (0,1);
    ASSERT_VALID (pPaneWnd);
    CListView *pCurrentView = static_cast<CListView*> (pPaneWnd);        
    //
    // Exchange view window ID's so RecalcLayout() works.
    //
    UINT uCurrentViewId = ::GetWindowLong(pCurrentView->m_hWnd, GWL_ID);
    UINT uNewViewId =     ::GetWindowLong(pNewView->m_hWnd,     GWL_ID);
    if (uCurrentViewId == uNewViewId)
    {
        //
        // Same view - do nothing
        //
        return;
    }
    ::SetWindowLong(pCurrentView->m_hWnd, GWL_ID, uNewViewId);
    ::SetWindowLong(pNewView->m_hWnd,     GWL_ID, uCurrentViewId);
    //
    // Hide current view and show the new view
    //
    pCurrentView->ShowWindow(SW_HIDE);
    pNewView->ShowWindow(SW_SHOW);
    SetActiveView(pNewView);
    //
    // Cause redraw in new view
    //
    pNewView->Invalidate();
    //
    // Recalc frame layout
    //
    m_wndSplitter.RecalcLayout ();
}   // CMainFrame::SwitchRightPaneView

void CMainFrame::OnRefreshFolder()
/*++

Routine name : CMainFrame::OnRefreshFolder

Routine description:

    Called by the framework to refresh the current folder (F5)

Author:

    Eran Yariv (EranY), Jan, 2000

Arguments:


Return Value:

    None.

--*/
{
    DBG_ENTER(TEXT("CMainFrame::OnRefreshFolder"));
    DWORD dwRes = GetLeftView()->RefreshCurrentFolder ();
}

void 
CMainFrame::OnSelectColumns()
{
    DBG_ENTER(TEXT("CMainFrame::OnSelectColumns"));

    DWORD dwRes = m_pLeftView->OpenSelectColumnsDlg();
    if(ERROR_SUCCESS != dwRes)
    {
        CALL_FAIL (GENERAL_ERR, TEXT("CLeftView::OpenSelectColumnsDlg"), dwRes);
        PopupError(dwRes);
    }
}

void 
CMainFrame::OnUpdateSelectColumns(
    CCmdUI* pCmdUI
)
{
    DBG_ENTER(TEXT("CMainFrame::OnUpdateSelectColumns"));

    pCmdUI->Enable(m_pLeftView->CanOpenSelectColumnsDlg());
}

void 
CMainFrame::OnUpdateFolderItemsCount(
    CCmdUI* pCmdUI
) 
/*++

Routine name : CMainFrame::OnUpdateFolderItemsCount

Routine description:

    status bar indication of folder items count

Author:

    Alexander Malysh (AlexMay), Jan, 2000

Arguments:

    pCmdUI                        [in/out] 

Return Value:

    None.

--*/
{
    CString cstrText;
    if(NULL != m_pLeftView)
    {
        int nItemCount = m_pLeftView->GetDataCount();
        //
        // if nItemCount < 0 this information is not relevant
        //
        if(nItemCount >= 0)
        {
            CString cstrFormat;
            DWORD dwRes = LoadResourceString (cstrFormat, 
                            (1 == nItemCount) ? IDS_STATUS_BAR_ITEM : IDS_STATUS_BAR_ITEMS);
            if (ERROR_SUCCESS != dwRes)
            {
                goto exit;
            }
            
            try
            {
                cstrText.Format(cstrFormat, nItemCount);
            }
            catch(...)
            {
                dwRes = ERROR_NOT_ENOUGH_MEMORY;
                goto exit;
            }
        }
    }

exit:
    pCmdUI->SetText (cstrText);
}

void 
CMainFrame::OnStatusBarDblClk( 
    NMHDR* pNotifyStruct, 
    LRESULT* result 
)
{
    POINT pt;
    GetCursorPos(&pt);

    CRect rc;
    m_wndStatusBar.GetItemRect(STATUS_PANE_ACTIVITY, &rc);
    m_wndStatusBar.ClientToScreen(&rc);

    if(rc.PtInRect(pt))
    {
        OnToolsServerStatus();
    }
}

void 
CMainFrame::OnUpdateActivity(
    CCmdUI* pCmdUI
)
{
    CString cstrText;
    HICON hIcon = NULL;

    if (!m_pLeftView)
    {
        //
        // No left view yet
        //
        return;
    }

    if (!m_pLeftView->GetActivity(cstrText, hIcon))
    {
        //
        // Activity string is to be ignored
        //
        cstrText.Empty ();
    }

    CStatusBarCtrl& barCtrl = m_wndStatusBar.GetStatusBarCtrl();
    barCtrl.SetIcon(STATUS_PANE_ACTIVITY, hIcon);
    pCmdUI->SetText (cstrText);
}

void 
CMainFrame::OnUpdateRefreshFolder(
    CCmdUI* pCmdUI
) 
/*++

Routine name : CMainFrame::OnUpdateRefreshFolder

Routine description:

    Called by the framework to know if the current folder can be refreshed (F5)

Author:

    Eran Yariv (EranY), Jan, 2000

Arguments:

    pCmdUI          [in] - Answer buffer

Return Value:

    None.

--*/
{
    pCmdUI->Enable(GetLeftView()->CanRefreshFolder());
}


LRESULT 
CMainFrame::OnPopupError (
    WPARAM wParam, 
    LPARAM lParam)
/*++

Routine name : CMainFrame::OnPopupError

Routine description:

    Handles the WM_POPUP_ERROR messages

Author:

    Eran Yariv (EranY), Jan, 2000

Arguments:

    wParam   [in]     - Error code
    lParam   [in]     - Hiword contains the __FILE_ID__ and 
                        Loword contains the line number

Return Value:

    Standard result code

--*/
{
    DWORD dwErrCode = (DWORD) wParam;
    WORD  wFileId   = HIWORD(DWORD(lParam));
    WORD  wLineNumber = LOWORD(DWORD(lParam));

    CErrorDlg ErrDlg(dwErrCode, wFileId, wLineNumber);
    return ErrDlg.DoModal (); 
}   // CMainFrame::OnPopupError


LRESULT 
CMainFrame::OnSelectItem (
    WPARAM wParam, 
    LPARAM lParam)
/*++

Routine name : CMainFrame::OnSelectItem

Routine description:

    Handles the WM_CONSOLE_SELECT_ITEM messages

Author:

    Eran Yariv (EranY), May, 2001

Arguments:

    wParam   [in]     - Low 32-bits of message id
    lParam   [in]     - High 32-bits of message id

Return Value:

    Standard result code

--*/
{
    DBG_ENTER(TEXT("CMainFrame::OnSelectItem"), TEXT("wParam=%ld, lParam=%ld"), wParam, lParam);


    ULARGE_INTEGER uli;
    uli.LowPart = wParam;
    uli.HighPart = lParam;

    if (!m_pLeftView)
    {
        return FALSE;
    }

    CFolderListView* pCurView = m_pLeftView->GetCurrentView();
    if (!pCurView)
    {
        return FALSE;
    }
    pCurView->SelectItemById(uli.QuadPart);
    return TRUE;
}   // CMainFrame::OnSelectItem


LRESULT 
CMainFrame::OnSetActiveFolder (
    WPARAM wParam, 
    LPARAM lParam)
/*++

Routine name : CMainFrame::OnSetActiveFolder

Routine description:

    Handles the WM_CONSOLE_SET_ACTIVE_FOLDER messages

Author:

    Eran Yariv (EranY), May, 2001

Arguments:

    wParam   [in]     - FolderType value
    lParam   [in]     - Unused

Return Value:

    Standard result code

--*/
{
    DBG_ENTER(TEXT("CMainFrame::OnSetActiveFolder"), TEXT("wParam=%ld, lParam=%ld"), wParam, lParam);

    if (wParam > FOLDER_TYPE_INCOMING)
    {
        VERBOSE (GENERAL_ERR, TEXT("wParam is out of range - message ignored"));
        return FALSE;
    }
    
    if (!m_pLeftView)
    {
        return FALSE;
    }
    m_pLeftView->SelectFolder (FolderType(wParam));
    return TRUE;
}   // CMainFrame::OnSetActiveFolder

DWORD   
CMainFrame::CreateFolderViews (
    CDocument *pDoc
)
/*++

Routine name : CMainFrame::CreateFolderViews

Routine description:

    Creates the 4 global views used for folders display

Author:

    Eran Yariv (EranY), Jan, 2000

Arguments:

    pDoc            [in] - Pointer to document to attach to the new views

Return Value:

    Standard Win32 error code

--*/
{
    DWORD dwRes = ERROR_SUCCESS;
    DBG_ENTER(TEXT("CMainFrame::CreateFolderViews"), dwRes);

    DWORD dwChildID = AFX_IDW_PANE_FIRST + 10;

    ASSERTION (!m_pIncomingView && !m_pInboxView && !m_pSentItemsView && !m_pOutboxView);

    //
    // Create incoming view
    //
    dwRes = CreateDynamicView (dwChildID++,
                               CLIENT_INCOMING_VIEW,
                               RUNTIME_CLASS(CFolderListView), 
                               pDoc,
                               (PINT)IncomingColumnsUsed,
                               INCOMING_DEF_COL_NUM,
                               (CFolderListView **)&m_pIncomingView,
                               FOLDER_TYPE_INCOMING);
    if (ERROR_SUCCESS != dwRes)
    {
        CALL_FAIL (GENERAL_ERR, TEXT("CMainFrame::CreateDynamicView (Incoming)"), dwRes);
        return dwRes;
    }

    //
    // Create inbox view
    //
    dwRes = CreateDynamicView (dwChildID++,
                               CLIENT_INBOX_VIEW,
                               RUNTIME_CLASS(CFolderListView), 
                               pDoc,
                               (PINT)InboxColumnsUsed,
                               INBOX_DEF_COL_NUM,
                               (CFolderListView **)&m_pInboxView,
                               FOLDER_TYPE_INBOX);
    if (ERROR_SUCCESS != dwRes)
    {
        CALL_FAIL (GENERAL_ERR, TEXT("CMainFrame::CreateDynamicView (Inbox)"), dwRes);
        return dwRes;
    }

    //
    // Create SentItems view
    //
    dwRes = CreateDynamicView (dwChildID++,
                               CLIENT_SENT_ITEMS_VIEW,
                               RUNTIME_CLASS(CFolderListView),
                               pDoc,
                               (PINT)SentItemsColumnsUsed,
                               SENT_ITEMS_DEF_COL_NUM,
                               (CFolderListView **)&m_pSentItemsView,
                               FOLDER_TYPE_SENT_ITEMS);
    if (ERROR_SUCCESS != dwRes)
    {
        CALL_FAIL (GENERAL_ERR, TEXT("CMainFrame::CreateDynamicView (SentItems)"), dwRes);
        return dwRes;
    }

    //
    // Create Outbox view
    //
    dwRes = CreateDynamicView (dwChildID++,
                               CLIENT_OUTBOX_VIEW,
                               RUNTIME_CLASS(CFolderListView),
                               pDoc,
                               (PINT)OutboxColumnsUsed,
                               OUTBOX_DEF_COL_NUM,
                               (CFolderListView **)&m_pOutboxView,
                               FOLDER_TYPE_OUTBOX);
    if (ERROR_SUCCESS != dwRes)
    {
        CALL_FAIL (GENERAL_ERR, TEXT("CMainFrame::CreateDynamicView (Outbox)"), dwRes);
        return dwRes;
    }

    return dwRes;
}   // CMainFrame::CreateFolderViews

DWORD   
CMainFrame::CreateDynamicView (
    DWORD             dwChildId, 
    LPCTSTR           lpctstrName, 
    CRuntimeClass*    pViewClass,
    CDocument*        pDoc,
    int*              pColumnsUsed,
    DWORD             dwDefaultColNum,
    CFolderListView** ppNewView,
    FolderType        type
)
/*++

Routine name : CMainFrame::CreateDynamicView

Routine description:

    Creates a new view dynamically

Author:

    Eran Yariv (EranY), Jan, 2000

Arguments:

    dwChildId       [in ] - New child id (within the splitter) of the view
    lpctstrName     [in ] - Name of the view
    pViewClass      [in ] - Class of the view
    pDoc            [in ] - Pointer to document to attach to the new view
    pColumnsUsed    [in ] - List of columns to use in the view
    dwDefaultColNum [in ] - default column number
    ppNewView       [out] - Pointer to newly created view

Return Value:

    Standard Win32 error code

--*/
{
    DWORD dwRes = ERROR_SUCCESS;
    DBG_ENTER(TEXT("CMainFrame::CreateDynamicView"), dwRes);

    ASSERTION (pDoc);

    CCreateContext contextT;
    contextT.m_pNewViewClass = pViewClass;
    contextT.m_pCurrentDoc = pDoc;
    contextT.m_pNewDocTemplate = pDoc->GetDocTemplate();
    contextT.m_pLastView = NULL;
    contextT.m_pCurrentFrame = NULL;
    try
    {
        *ppNewView = (CFolderListView*)(pViewClass->CreateObject());
        if (NULL == *ppNewView)
        {
            dwRes = ERROR_NOT_ENOUGH_MEMORY;
            CALL_FAIL (MEM_ERR, TEXT ("CRuntimeClass::CreateObject"), dwRes);
            return dwRes;
        }
    }
    catch (CException *pException)
    {
        TCHAR wszCause[1024];

        pException->GetErrorMessage (wszCause, 1024);
        pException->Delete ();
        VERBOSE (EXCEPTION_ERR,
                 TEXT("CreateObject caused exception : %s"), 
                 wszCause);
        dwRes = ERROR_NOT_ENOUGH_MEMORY;
        return dwRes;
    }

    (*ppNewView)->SetType(type);

    ASSERT((*ppNewView)->m_hWnd == NULL);       // Not yet created

    DWORD dwStyle = WS_CHILD            |       // Child window (of splitter)
                    WS_BORDER           |       // Has borders
                    LVS_REPORT          |       // Report style
                    LVS_SHAREIMAGELISTS |       // All views use one global image list
                    LVS_SHOWSELALWAYS;          // Always show selected items

    //
    // Create the view 
    //
    CRect rect;
    if (!(*ppNewView)->Create(NULL, 
                              lpctstrName, 
                              dwStyle,
                              rect, 
                              &m_wndSplitter, 
                              dwChildId, 
                              &contextT))
    {
        dwRes = ERROR_GEN_FAILURE;
        CALL_FAIL (WINDOW_ERR, TEXT("CFolderListView::Create"), dwRes);
        //
        // pWnd will be cleaned up by PostNcDestroy
        //
        return dwRes;
    }

    //
    // Init the columns
    //
    dwRes = (*ppNewView)->InitColumns (pColumnsUsed, dwDefaultColNum);
    if (ERROR_SUCCESS != dwRes)
    {
        CALL_FAIL (GENERAL_ERR, TEXT("CFolderListView::InitColumns"), dwRes);
    }

    dwRes = (*ppNewView)->ReadLayout(lpctstrName);
    if (ERROR_SUCCESS != dwRes)
    {
        CALL_FAIL (GENERAL_ERR, TEXT("CFolderListView::ReadLayout"), dwRes);
    }

    (*ppNewView)->ColumnsToLayout();


    return dwRes;
}   // CMainFrame::CreateDynamicView

void 
CMainFrame::SaveLayout()
/*++

Routine name : CMainFrame::SaveLayout

Routine description:

    saves windows layout to the registry

Return Value:

    None.

--*/
{
    DBG_ENTER(TEXT("CMainFrame::SaveLayout"));

    DWORD dwRes = ERROR_SUCCESS;

    //
    // save folders layout
    //
    dwRes = m_pIncomingView->SaveLayout(CLIENT_INCOMING_VIEW);
    if (ERROR_SUCCESS != dwRes)
    {
        CALL_FAIL (GENERAL_ERR, TEXT("CFolderListView::SaveLayout"), dwRes);
    }
    dwRes = m_pInboxView->SaveLayout(CLIENT_INBOX_VIEW);
    if (ERROR_SUCCESS != dwRes)
    {
        CALL_FAIL (GENERAL_ERR, TEXT("CFolderListView::SaveLayout"), dwRes);
    }

    dwRes = m_pSentItemsView->SaveLayout(CLIENT_SENT_ITEMS_VIEW);
    if (ERROR_SUCCESS != dwRes)
    {
        CALL_FAIL (GENERAL_ERR, TEXT("CFolderListView::SaveLayout"), dwRes);
    }

    dwRes = m_pOutboxView->SaveLayout(CLIENT_OUTBOX_VIEW);
    if (ERROR_SUCCESS != dwRes)
    {
        CALL_FAIL (GENERAL_ERR, TEXT("CFolderListView::SaveLayout"), dwRes);
    }
    
    //
    // save main frame layout
    //
    WINDOWPLACEMENT wndpl;
    if(!GetWindowPlacement(&wndpl))
    {
        CALL_FAIL (WINDOW_ERR, TEXT("CMainFrame::GetWindowPlacement"), 0);
    }
    else
    {
        BOOL bRes = TRUE;
        bRes &= theApp.WriteProfileInt(CLIENT_MAIN_FRAME, 
                                       CLIENT_MAXIMIZED, 
                                       (SW_SHOWMAXIMIZED == wndpl.showCmd));
        bRes &= theApp.WriteProfileInt(CLIENT_MAIN_FRAME, 
                                       CLIENT_NORMAL_POS_TOP, 
                                       wndpl.rcNormalPosition.top);
        bRes &= theApp.WriteProfileInt(CLIENT_MAIN_FRAME, 
                                       CLIENT_NORMAL_POS_RIGHT, 
                                       wndpl.rcNormalPosition.right);
        bRes &= theApp.WriteProfileInt(CLIENT_MAIN_FRAME, 
                                       CLIENT_NORMAL_POS_BOTTOM, 
                                       wndpl.rcNormalPosition.bottom);
        bRes &= theApp.WriteProfileInt(CLIENT_MAIN_FRAME, 
                                       CLIENT_NORMAL_POS_LEFT, 
                                       wndpl.rcNormalPosition.left);        

        int cxCur, cxMin;
        m_wndSplitter.GetColumnInfo(0, cxCur, cxMin);
        bRes &= theApp.WriteProfileInt(CLIENT_MAIN_FRAME, CLIENT_SPLITTER_POS, cxCur);
        if (!bRes)
        {
            VERBOSE (DBG_MSG, TEXT("Could not save one or more window positions"));
        }
    }
}

LRESULT 
CMainFrame::OnQueryEndSession(
    WPARAM, 
    LPARAM
)
/*++

Routine name : CMainFrame::OnQueryEndSession

Routine description:

    The system shutdown message handler
    Saves windows layout to the registry

Return Value:

    TRUE If the application can terminate conveniently
    FALSE otherwise

--*/
{
    DBG_ENTER(TEXT("CMainFrame::OnQueryEndSession"));

    SaveLayout();

    return TRUE;
}

void 
CMainFrame::OnClose() 
/*++

Routine name : CMainFrame::OnClose

Routine description:

    saves windows layout to the registry

Author:

    Alexander Malysh (AlexMay), Jan, 2000

Arguments:


Return Value:

    None.

--*/
{
    DBG_ENTER(TEXT("CMainFrame::OnClose"));

    SaveLayout();

    CFrameWnd::OnClose();
}

void 
CMainFrame::FrameToSavedLayout()
/*++

Routine name : CMainFrame::FrameToSavedLayout

Routine description:

    reads main frame size and position from registry and resize the window

Author:

    Alexander Malysh (AlexMay), Jan, 2000

Arguments:


Return Value:

    None.

--*/
{
    DBG_ENTER(TEXT("CMainFrame::FrameToSavedLayout"));

    WINDOWPLACEMENT wndpl;
    if(!GetWindowPlacement(&wndpl))
    {
        CALL_FAIL (WINDOW_ERR, TEXT("CMainFrame::GetWindowPlacement"), 0);
        return;
    }

    wndpl.rcNormalPosition.top = theApp.GetProfileInt(CLIENT_MAIN_FRAME, 
                                                    CLIENT_NORMAL_POS_TOP, -1);
    wndpl.rcNormalPosition.right = theApp.GetProfileInt(CLIENT_MAIN_FRAME, 
                                                    CLIENT_NORMAL_POS_RIGHT, -1);
    wndpl.rcNormalPosition.bottom = theApp.GetProfileInt(CLIENT_MAIN_FRAME, 
                                                    CLIENT_NORMAL_POS_BOTTOM, -1);
    wndpl.rcNormalPosition.left = theApp.GetProfileInt(CLIENT_MAIN_FRAME, 
                                                        CLIENT_NORMAL_POS_LEFT, -1);

    if(wndpl.rcNormalPosition.top    < 0 || wndpl.rcNormalPosition.right < 0 ||
       wndpl.rcNormalPosition.bottom < 0 ||  wndpl.rcNormalPosition.left < 0)
    {
        VERBOSE (DBG_MSG, TEXT("Could not load one or more window positions"));
        return;
    }

    if(!SetWindowPlacement(&wndpl))
    {
        CALL_FAIL (WINDOW_ERR, TEXT("CMainFrame::SetWindowPlacement"), 0);
    }
}

void 
CMainFrame::SplitterToSavedLayout()
{
    DBG_ENTER(TEXT("CMainFrame::SplitterToSavedLayout"));
    //
    // set splitter position according to saved value
    //
    int xPos = theApp.GetProfileInt(CLIENT_MAIN_FRAME, CLIENT_SPLITTER_POS, -1);
    if(xPos < 0)
    {
        VERBOSE (DBG_MSG, TEXT("Could not load splitter position"));
        return;
    }
    
    m_wndSplitter.SetColumnInfo(0, xPos, 10);
}


void 
CMainFrame::ActivateFrame(
    int nCmdShow
) 
{
    //
    // maximize according to saved value
    //
    BOOL bMaximized = theApp.GetProfileInt(CLIENT_MAIN_FRAME, CLIENT_MAXIMIZED, 0);
    if (bMaximized)
    {
        nCmdShow = SW_SHOWMAXIMIZED;
    }
    CFrameWnd::ActivateFrame(nCmdShow);
}

//
// MAX_NUM_SERVERS is defined to limit the range of messages we consider 
// as server notification. 
// 
#define MAX_NUM_SERVERS             256

LRESULT 
CMainFrame::WindowProc( 
    UINT message, 
    WPARAM wParam, 
    LPARAM lParam 
)
/*++

Routine name : CMainFrame::WindowProc

Routine description:

    Handle windows messages before MFC dispatches them.
    Here we handle notification messages from the servers.

Author:

    Eran Yariv (EranY), Jan, 2000

Arguments:

    message           [in]     - Specifies the Windows message to be processed
    wParam            [in]     - 
    lParam            [in]     - 

Return Value:

    TRUE if mesage was handled by the function, FALSE otherwise.

--*/
{
    BOOL bRes = FALSE;  
    BOOL bBadMsg = FALSE;
    if ((WM_SERVER_NOTIFY_BASE > message) ||
        (WM_SERVER_NOTIFY_BASE + MAX_NUM_SERVERS < message))
    {
        //
        // This is not a server notification message
        //
        return CFrameWnd::WindowProc(message, wParam, lParam);
    }
    //
    // From now on, we're dealing with a server notification
    //
    DBG_ENTER(TEXT("CMainFrame::WindowProc"), 
              bRes, 
              TEXT("Msg=0x%08x, lParam=0x%08x, wParam=0x%08x"),
              message,
              lParam,
              wParam);

    //
    // This message should not be processed any more
    //
    bRes = TRUE;
    //
    // Try looking up the server node for which this message is intended
    //
    CServerNode *pServer = CServerNode::LookupServerFromMessageId (message);
    FAX_EVENT_EX *pEvent = (FAX_EVENT_EX *)(lParam);
    ASSERTION (pEvent);
    ASSERTION (sizeof (FAX_EVENT_EX) == pEvent->dwSizeOfStruct);
    if (pServer)
    {
        //
        // Tell the server a notification has arrived for it
        //
        VERBOSE (DBG_MSG, TEXT("Message was coming from %s"), pServer->Machine());
        try
        {
            //
            // Protect against bogus messages
            //
            DWORD dwRes = pServer->OnNotificationMessage (pEvent);
            if (ERROR_SUCCESS != dwRes)
            {
                CALL_FAIL (GENERAL_ERR, TEXT("CServerNode::OnNotificationMessage"), dwRes);
            }
        }            
        catch (...)
        {
            bBadMsg = TRUE;
        }
    }
    else
    {
        VERBOSE (DBG_MSG, TEXT("Got server notification - No server found as sink"));
    }
    //
    // Processed or not - delete the message
    //
    if (!bBadMsg)
    {
        try
        {
            //
            // Protect against bogus messages
            // ... and ...
            // Plant a special value here to catch reuse of the same pointer
            //
            pEvent->dwSizeOfStruct = 0xbabe;
            FaxFreeBuffer (pEvent);
        }        
        catch (...)
        {
            bBadMsg = TRUE;
        }
    }        
    if (bBadMsg)
    {
        VERBOSE (GENERAL_ERR, TEXT("Exception while processing windows message as notification"));
        ASSERTION_FAILURE;
    }    
    return bRes;
} // CMainFrame::WindowProc

void 
CMainFrame::OnToolsAdminConsole()
{
    DBG_ENTER(TEXT("CMainFrame::OnToolsAdminConsole"));
	InvokeServiceManager(m_hWnd, GetResourceHandle(), IDS_ADMIN_CONSOLE_TITLE);
}

void 
CMainFrame::OnToolsConfigWizard()
/*++

Routine name : CMainFrame::OnToolsConfigWizard

Routine description:

    Fax Configuration Wizard invocation

Return Value:

  none

--*/
{
    DBG_ENTER(TEXT("CMainFrame::OnToolsConfigWizard"));

    //
    // explicit launch
    //
    theApp.LaunchConfigWizard(TRUE);
}

void 
CMainFrame::OnToolsMonitor()
/*++

Routine name : CMainFrame::OnToolsMonitor

Routine description:

    Open Fax Monitor dialog

Return Value:

  none

--*/
{
    DBG_ENTER(TEXT("CMainFrame::OnToolsMonitor"));

    HWND hWndFaxMon = ::FindWindow(FAXSTAT_WINCLASS, NULL);
    if (hWndFaxMon) 
    {
        ::PostMessage(hWndFaxMon, WM_FAXSTAT_OPEN_MONITOR, 0, 0);
    }
}

void 
CMainFrame::OnToolsFaxPrinterProps()
/*++

Routine name : CMainFrame::OnToolsFaxPrinterProps

Routine description:

    Open Fax Printer Properties dialog

Return Value:

  none

--*/ 
{
    DBG_ENTER(TEXT("CMainFrame::OnToolsMonitor"));
    //
    // Open fax printer properties
    //
    FaxPrinterProperty(0);
}

void 
CMainFrame::OnUpdateWindowsXPTools(
    CCmdUI* pCmdUI
)
/*++

Routine name : CMainFrame::OnToolsConfigWizard

Routine description:

    Delete Fax Configuration Wizard and Admin Console 
    menu items for non Windows XP plarform

Return Value:

  none

--*/
{
    DBG_ENTER(TEXT("CMainFrame::OnUpdateConfigWizard"));
    
    if(pCmdUI->m_pMenu)
    {
        if(!IsWinXPOS())
        {
            pCmdUI->m_pMenu->DeleteMenu(ID_TOOLS_CONFIG_WIZARD,     MF_BYCOMMAND);
            pCmdUI->m_pMenu->DeleteMenu(ID_TOOLS_ADMIN_CONSOLE,     MF_BYCOMMAND);
            pCmdUI->m_pMenu->DeleteMenu(ID_TOOLS_MONITOR,           MF_BYCOMMAND);
            pCmdUI->m_pMenu->DeleteMenu(ID_TOOLS_FAX_PRINTER_PROPS, MF_BYCOMMAND);
        }
        else
        {
            //
            // Windows XP OS - check SKU
            //
            if (IsDesktopSKU() || !IsFaxComponentInstalled(FAX_COMPONENT_ADMIN))
            {
                pCmdUI->m_pMenu->DeleteMenu(ID_TOOLS_ADMIN_CONSOLE, MF_BYCOMMAND);
            }

            if(!IsFaxComponentInstalled(FAX_COMPONENT_CONFIG_WZRD))
            {
                pCmdUI->m_pMenu->DeleteMenu(ID_TOOLS_CONFIG_WIZARD, MF_BYCOMMAND);
            } 

            if(!IsFaxComponentInstalled(FAX_COMPONENT_MONITOR))
            {
                pCmdUI->m_pMenu->DeleteMenu(ID_TOOLS_MONITOR, MF_BYCOMMAND);
            }

            //
            // Local fax printer properties
            //
            CClientConsoleDoc* pDoc = (CClientConsoleDoc*)GetActiveDocument();
            if(NULL == pDoc)
            {
                ASSERTION_FAILURE;
                return;
            }
            //
            // Find local fax server
            // if it is not installed disable the menu item
            //
            if(!pDoc->FindServerByName(NULL) || !IsFaxComponentInstalled(FAX_COMPONENT_DRIVER_UI))
            {
                pCmdUI->m_pMenu->DeleteMenu(ID_TOOLS_FAX_PRINTER_PROPS, MF_BYCOMMAND);
            }            
        }

        if(pCmdUI->m_pMenu->GetMenuItemCount() == 4)
        {
            //
            // delete the menu separator
            //
            pCmdUI->m_pMenu->DeleteMenu(3, MF_BYPOSITION);
        }
    }
}

void 
CMainFrame::OnUpdateSendNewFax(
    CCmdUI* pCmdUI
)
{ 
    BOOL bEnable = FALSE;

    CClientConsoleDoc* pDoc = (CClientConsoleDoc*)GetActiveDocument();
    if(NULL != pDoc)
    {
        bEnable = pDoc->IsSendFaxEnable();
    }

    pCmdUI->Enable(bEnable); 
}


void 
CMainFrame::OnUpdateReceiveNewFax(
    CCmdUI* pCmdUI
)
{ 
    BOOL bEnable = FALSE;

    if (IsWinXPOS ())
    {   
        //
        // Receive now works only in Windows XP
        //
        CClientConsoleDoc* pDoc = (CClientConsoleDoc*)GetActiveDocument();
        if(NULL != pDoc)
        {
            bEnable = pDoc->CanReceiveNow();
        }
    }
    pCmdUI->Enable(bEnable); 
}

void 
CMainFrame::OnReceiveNewFax()
/*++

Routine name : CMainFrame::OnReceiveNewFax

Routine description:

    Starts receiving now

Author:

    Eran Yariv (EranY). Mar, 2001

Arguments:


Return Value:

    None.

--*/
{
    DBG_ENTER(TEXT("CMainFrame::OnReceiveNewFax"));

    HWND hWndFaxMon = ::FindWindow(FAXSTAT_WINCLASS, NULL);
    if (hWndFaxMon) 
    {
        ::PostMessage(hWndFaxMon, WM_FAXSTAT_RECEIVE_NOW, 0, 0);
    }
}   // CMainFrame::OnReceiveNewFax
    

void 
CMainFrame::OnSendNewFax()
/*++

Routine name : CMainFrame::OnSendNewFax

Routine description:

    start send fax wizard

Author:

    Alexander Malysh (AlexMay), Feb, 2000

Arguments:


Return Value:

    None.

--*/
{
    DWORD dwRes = ERROR_SUCCESS;
    DBG_ENTER(TEXT("CMainFrame::OnSendNewFax"));
    
    //
    // get send fax wizard location
    //
    CString cstrFaxSend;
    dwRes = GetAppLoadPath(cstrFaxSend);
    if(ERROR_SUCCESS != dwRes)
    {
        PopupError(dwRes);
        CALL_FAIL (GENERAL_ERR, TEXT("GetAppLoadPath"), dwRes);
        return;
    }

    try
    {
        cstrFaxSend += FAX_SEND_IMAGE_NAME;
    }
    catch(...)
    {
        dwRes = ERROR_NOT_ENOUGH_MEMORY;
        PopupError(dwRes);
        CALL_FAIL (MEM_ERR, TEXT("CString::operator+"), dwRes);
        return ;
    }

    //
    // start send fax wizard
    //
    HINSTANCE hWizard = ShellExecute(NULL, 
                                     TEXT("open"), 
                                     cstrFaxSend, 
                                     NULL, 
                                     NULL, 
                                     SW_RESTORE 
                                    );    
    if((DWORD_PTR)hWizard <= 32)
    {
        //
        // error
        //
        dwRes = PtrToUlong(hWizard);
        PopupError(dwRes);
        CALL_FAIL (GENERAL_ERR, TEXT("ShellExecute"), dwRes);
        return;
    }

} // CMainFrame::OnSendNewFax

void 
CMainFrame::OnViewOptions()
{
    DBG_ENTER(TEXT("CMainFrame::OnViewOptions"));

    CUserInfoDlg userInfo;
    if(userInfo.DoModal() == IDABORT)
    {
        DWORD dwRes = userInfo.GetLastDlgError();
        CALL_FAIL (GENERAL_ERR, TEXT("CUserInfoDlg::DoModal"), dwRes);
        PopupError(dwRes);
    }
}

void
CMainFrame::OnToolsCoverPages()
{
    DBG_ENTER(TEXT("CMainFrame::OnToolsCoverPages"));

    CCoverPagesDlg cpDlg;
    if(cpDlg.DoModal() == IDABORT)
    {
        DWORD dwRes = cpDlg.GetLastDlgError();
        CALL_FAIL (GENERAL_ERR, TEXT("CCoverPagesDlg::DoModal"), dwRes);
        PopupError(dwRes);
    }
}

void 
CMainFrame::OnSettingChange(
    UINT uFlags, 
    LPCTSTR lpszSection
) 
{
    DWORD dwRes = ERROR_SUCCESS;
    DBG_ENTER(TEXT("CMainFrame::OnSettingChange"));

    CFrameWnd::OnSettingChange(uFlags, lpszSection);

    if(lpszSection && !_tcscmp(lpszSection, TEXT("devices")))
    {
        //
        // some change in the system devices
        //
        CClientConsoleDoc* pDoc = (CClientConsoleDoc*)GetActiveDocument();
        if(NULL != pDoc)
        {
            dwRes = pDoc->RefreshServersList();
            if(ERROR_SUCCESS != dwRes)
            {
                CALL_FAIL (GENERAL_ERR, TEXT("CClientConsoleDoc::RefreshServersList"), dwRes);
            }
        }
    }
} // CMainFrame::OnSettingChange


LONG 
CMainFrame::OnHelp(
    UINT wParam, 
    LONG lParam
)
/*++

Routine name : CMainFrame::OnHelp

Routine description:

    F1 key handler

Author:

    Alexander Malysh (AlexMay), Mar, 2000

Arguments:

    wParam                        [in]     - 
    lParam                        [in]     - LPHELPINFO

Return Value:

    LONG

--*/
{  
    DWORD dwRes = ERROR_SUCCESS;
    DBG_ENTER(TEXT("CMainFrame::OnHelp"));

    if(!IsFaxComponentInstalled(FAX_COMPONENT_HELP_CLIENT_CHM))
    {
        //
        // The help file is not installed
        //
        return TRUE;
    }

    if(NULL != m_pLeftView)
    {
        dwRes = m_pLeftView->OpenHelpTopic();
        if(ERROR_SUCCESS != dwRes)
        {
            CALL_FAIL (GENERAL_ERR, TEXT("CLeftView::OpenHelpTopic"),dwRes);
        }
    }
    else
    {
        OnHelpContents();
    }

    return TRUE;
}

void 
CMainFrame::OnUpdateHelpContents(CCmdUI* pCmdUI)
{
    pCmdUI->Enable(IsFaxComponentInstalled(FAX_COMPONENT_HELP_CLIENT_CHM));
}

void 
CMainFrame::OnHelpContents()
/*++

Routine name : CMainFrame::OnHelpContents

Routine description:

    Help Contents menu item handler

Author:

    Alexander Malysh (AlexMay), Mar, 2000

Arguments:


Return Value:

    None.

--*/
{
    DWORD dwRes = ERROR_SUCCESS;
    DBG_ENTER(TEXT("CMainFrame::OnHelpContents"));

    dwRes = ::HtmlHelpTopic(m_hWnd, FAX_HELP_WELCOME);
    if(ERROR_SUCCESS != dwRes)
    {
        CALL_FAIL (GENERAL_ERR, TEXT("HtmlHelpTopic"),dwRes);
    }
}

void 
CMainFrame::OnUpdateServerStatus(
    CCmdUI* pCmdUI
)
{
    BOOL bEnable = FALSE;

    CClientConsoleDoc* pDoc = (CClientConsoleDoc*)GetActiveDocument();
    if(NULL != pDoc)
    {
        bEnable = pDoc->GetServerCount() > 0;
    }

    pCmdUI->Enable(bEnable);
}

void 
CMainFrame::OnToolsServerStatus()
{
    DBG_ENTER(TEXT("CMainFrame::OnToolsServerStatus"));

    CClientConsoleDoc* pDoc = (CClientConsoleDoc*)GetActiveDocument();
    if(pDoc->GetServerCount() == 0)
    {
        //
        // no fax printer install
        //
        return;
    }

    CServerStatusDlg srvStatus(pDoc);
    if(srvStatus.DoModal() == IDABORT)
    {
        DWORD dwRes = srvStatus.GetLastDlgError();
        CALL_FAIL (GENERAL_ERR, TEXT("CServerStatusDlg::DoModal"), dwRes);
        PopupError(dwRes);
    }
}
void 
CMainFrame::OnImportSentItems()
{
    ImportArchive(TRUE);
}

void 
CMainFrame::OnImportInbox()
{
    ImportArchive(FALSE);
}


void 
CMainFrame::ImportArchive(
    BOOL bSentArch
)
/*++

Routine name : CMainFrame::ImportArchive

Routine description:

    Import W2K MS faxes into the fax archive

Arguments:

    bSentArch - [in] TRUE for Sent Items, FALSE for Inbox

Return Value:

    None.

--*/
{
    DWORD dwRes = ERROR_SUCCESS;
    DBG_ENTER(TEXT("CMainFrame::ImportArchive"));

#ifdef UNICODE

    HKEY   hRegKey;
    DWORD  dwSize;
    DWORD  dwFlags = 0;
    WCHAR* pszFolder = NULL;

    CFolderDialog dlgFolder;

    //
    // Read initial import folder
    //
    if ((hRegKey = OpenRegistryKey(HKEY_LOCAL_MACHINE, REGKEY_FAX_SETUP, TRUE, KEY_QUERY_VALUE)))
    {
        if(bSentArch)
        {
            pszFolder = GetRegistryString(hRegKey, REGVAL_W2K_SENT_ITEMS, NULL);
        }
        else
        {
            pszFolder = GetRegistryStringMultiSz(hRegKey, REGVAL_W2K_INBOX, NULL, &dwSize);
        }

        RegCloseKey(hRegKey);
    }
    else
    {
        CALL_FAIL(GENERAL_ERR, TEXT("OpenRegistryKey"), GetLastError());
    }
    dwRes = dlgFolder.Init(pszFolder, bSentArch ? IDS_IMPORT_TITLE_SENTITEMS : IDS_IMPORT_TITLE_INBOX);
    if(ERROR_SUCCESS != dwRes)
    {
        CALL_FAIL(GENERAL_ERR, TEXT("CMainFrame::ImportArchive"), dwRes);
        goto exit;
    }

    //
    // Display Browse for folder dialog
    //
    if (IsWinXPOS())
    {
        //
        // The new BIF_NONEWFOLDERBUTTON is only defined for WinXP and above
        //
        dwFlags = BIF_NONEWFOLDERBUTTON;
    }

    if(IDOK != dlgFolder.DoModal(dwFlags))
    {
        goto exit;
    }

    //
    // Import the selected folder
    //
    dwRes = ImportArchiveFolderUI(dlgFolder.GetSelectedFolder(), bSentArch, m_hWnd);   
    if(ERROR_SUCCESS != dwRes)
    {
        CALL_FAIL(GENERAL_ERR, TEXT("ImportArchiveFolderUI"), dwRes);
    }

exit:

    MemFree(pszFolder);

#endif // UNICODE

}

void 
CMainFrame::OnUpdateImportSent(CCmdUI* pCmdUI)
{
    if(pCmdUI->m_pMenu)
    {
        if(!IsWinXPOS())
        {

            //
            // Delete the Import menu item and separator for non Windows XP OS
            //
            pCmdUI->m_pMenu->DeleteMenu(15, MF_BYPOSITION);
            pCmdUI->m_pMenu->DeleteMenu(14, MF_BYPOSITION);
        }
    }
}

afx_msg void 
CMainFrame::OnSysColorChange()
{
    //
    // Refresh the image lists we use - force it to refresh
    // Since the image list are static FolderListView members (shared between all instances),
    // we just pick any instance and call it's refresh function with bForce=TRUE.
    //
    if (m_pIncomingView)
    {
        m_pIncomingView->RefreshImageLists(TRUE);
        m_pIncomingView->Invalidate ();
    }
    if (m_pInboxView)
    {
        m_pInboxView->RefreshImageLists(FALSE);
        m_pInboxView->Invalidate ();
    }
    if (m_pSentItemsView)
    {
        m_pSentItemsView->RefreshImageLists(FALSE);
        m_pSentItemsView->Invalidate ();
    }
    if (m_pOutboxView)
    {
        m_pOutboxView->RefreshImageLists(FALSE);
        m_pOutboxView->Invalidate ();
    }
    if (m_pLeftView)
    {
        m_pLeftView->RefreshImageList ();
        m_pLeftView->Invalidate();
    }
    if (m_pInitialRightPaneView)
    {
        m_pInitialRightPaneView->GetListCtrl().SetBkColor(::GetSysColor(COLOR_WINDOW));
    }
}   // CMainFrame::OnSysColorChange