#include "precomp.h"
#include <version.h>
#include <nmhelp.h>

//
// VIEW.CPP
// The frame, widgets, and client area that presents the shared apps/desktop
// for a remote host.
//
// Copyright(c) Microsoft 1997-
//

//
// NOTE:
// The client of the shared view frame represents the virtual desktop (VD)
// of the host.  For 3.0 hosts, the VD is the same as the screen.  But for
// 2.x hosts, the VD is the union of the screen size of all hosts.  Hence
// the recalculation every time someone starts sharing or changes screen
// size, and the extra fun this entails for existing shared 2.x views.
//

#define MLZ_FILE_ZONE  ZONE_CORE


// Help file
static const TCHAR s_cszHtmlHelpFile[] = TEXT("conf.chm");

//
// VIEW_Init()
//
BOOL  VIEW_Init(void)
{
    BOOL        rc = FALSE;
    WNDCLASSEX  wc;


    DebugEntry(VIEW_Init);

    //
    // Register the frame window class.
    // NOTE:  Change CS_NOCLOSE if/when we ever let you close the view
    // of a person's shared apps.
    //
    wc.cbSize           = sizeof(wc);
    wc.style            = CS_DBLCLKS | CS_NOCLOSE;
    wc.lpfnWndProc      = VIEWFrameWindowProc;
    wc.cbClsExtra       = 0;
    wc.cbWndExtra       = 0;
    wc.hInstance        = g_asInstance;
    wc.hIcon            = NULL;
    wc.hCursor          = ::LoadCursor(NULL, IDC_ARROW);
    wc.hbrBackground    = (HBRUSH)(COLOR_3DFACE+1);
    wc.lpszMenuName     = NULL;
    wc.lpszClassName    = VIEW_FRAME_CLASS_NAME;
    wc.hIconSm          = NULL;

    if (!RegisterClassEx(&wc))
    {
        ERROR_OUT(("Failed to register AS Frame class"));
        DC_QUIT;
    }

    //
    // Register the view window class.  This sits in the client area of
    // the frame along with the statusbar, tray, etc.  It displays
    // the remote host's shared contents.
    //
    wc.cbSize           = sizeof(wc);
    wc.style            = CS_DBLCLKS | CS_NOCLOSE;
    wc.lpfnWndProc      = VIEWClientWindowProc;
    wc.cbClsExtra       = 0;
    wc.cbWndExtra       = 0;
    wc.hInstance        = g_asInstance;
    wc.hIcon            = NULL;
    wc.hCursor          = NULL;
    wc.hbrBackground    = NULL;
    wc.lpszMenuName     = NULL;
    wc.lpszClassName    = VIEW_CLIENT_CLASS_NAME;
    wc.hIconSm          = NULL;

    if (!RegisterClassEx(&wc))
    {
        ERROR_OUT(("Failed to register AS Client class"));
        DC_QUIT;
    }

    //
    // Register the window bar class.  This hugs the bottom of
    // frames for shared apps (not desktop) and acts like a tray
    // surrogate.  It allows controllers to minimize, restore, and
    // activate shared windows that may not be on screen currently
    // and therefore not in the view area.
    //
    // It also is handy reference for what top level windows are shared
    // currently.
    //
    wc.cbSize           = sizeof(wc);
    wc.style            = 0;
    wc.lpfnWndProc      = VIEWWindowBarProc;
    wc.cbClsExtra       = 0;
    wc.cbWndExtra       = 0;
    wc.hInstance        = g_asInstance;
    wc.hIcon            = NULL;
    wc.hCursor          = ::LoadCursor(NULL, IDC_ARROW);
    wc.hbrBackground    = (HBRUSH)(COLOR_3DFACE+1);
    wc.lpszMenuName     = NULL;
    wc.lpszClassName    = VIEW_WINDOWBAR_CLASS_NAME;
    wc.hIconSm          = NULL;

    if (!RegisterClassEx(&wc))
    {
        ERROR_OUT(("Failed to register AS WindowBar class"));
        DC_QUIT;
    }

    //
    // Register the window bar items class.  This is a child of the window
    // bar and contains the actual items.
    //
    wc.cbSize           = sizeof(wc);
    wc.style            = 0;
    wc.lpfnWndProc      = VIEWWindowBarItemsProc;
    wc.cbClsExtra       = 0;
    wc.cbWndExtra       = 0;
    wc.hInstance        = g_asInstance;
    wc.hIcon            = NULL;
    wc.hCursor          = ::LoadCursor(NULL, IDC_ARROW);
    wc.hbrBackground    = (HBRUSH)(COLOR_3DFACE+1);
    wc.lpszMenuName     = NULL;
    wc.lpszClassName    = VIEW_WINDOWBARITEMS_CLASS_NAME;
    wc.hIconSm          = NULL;

    if (!RegisterClassEx(&wc))
    {
        ERROR_OUT(("Failed to register AS WindowBarItems class"));
        DC_QUIT;
    }

    //
    // Register the full screen exit button class.  This is a child of the
    // the view client when present.
    //
    wc.cbSize           = sizeof(wc);
    wc.style            = 0;
    wc.lpfnWndProc      = VIEWFullScreenExitProc;
    wc.cbClsExtra       = 0;
    wc.cbWndExtra       = 0;
    wc.hInstance        = g_asInstance;
    wc.hIcon            = NULL;
    wc.hCursor          = ::LoadCursor(NULL, IDC_ARROW);
    wc.hbrBackground    = NULL;
    wc.lpszMenuName     = NULL;
    wc.lpszClassName    = VIEW_FULLEXIT_CLASS_NAME;
    wc.hIconSm          = NULL;

    if (!RegisterClassEx(&wc))
    {
        ERROR_OUT(("Failed to register AS full screen exit class"));
        DC_QUIT;
    }

    rc = TRUE;

DC_EXIT_POINT:

    DebugExitBOOL(VIEW_Init, rc);
    return(rc);
}


//
// VIEW_Term()
//
void  VIEW_Term(void)
{
    DebugEntry(VIEW_Term);

    //
    // Free all resources we created (or may have created in window class
    // case).
    //
    UnregisterClass(VIEW_FULLEXIT_CLASS_NAME, g_asInstance);
    UnregisterClass(VIEW_WINDOWBARITEMS_CLASS_NAME, g_asInstance);
    UnregisterClass(VIEW_WINDOWBAR_CLASS_NAME, g_asInstance);
    UnregisterClass(VIEW_CLIENT_CLASS_NAME, g_asInstance);
    UnregisterClass(VIEW_FRAME_CLASS_NAME, g_asInstance);

    DebugExitVOID(VIEW_Term);
}



//
// VIEW_ShareStarting()
// Creates share resources
//
BOOL ASShare::VIEW_ShareStarting(void)
{
    BOOL        rc = FALSE;
    HBITMAP     hbmpT;
    TEXTMETRIC  tm;
    HDC         hdc;
    HFONT       hfnOld;
    char        szRestore[256];
    SIZE        extent;

    DebugEntry(ASShare::VIEW_ShareStarting);

    ASSERT(m_viewVDSize.x == 0);
    ASSERT(m_viewVDSize.y == 0);

    //
    // Get NODROP cursor
    //
    m_viewNotInControl = ::LoadCursor(NULL, IDC_NO);

    //
    // Get MOUSEWHEEL lines metric
    //
    SystemParametersInfo(SPI_GETWHEELSCROLLLINES, 0,
        &m_viewMouseWheelScrollLines, 0);

    //
    // Create a pattern brush from the obscured bitmap
    //
    hbmpT = LoadBitmap(g_asInstance, MAKEINTRESOURCE(IDB_OBSCURED));
    m_viewObscuredBrush = CreatePatternBrush(hbmpT);
    DeleteBitmap(hbmpT);

    if (!m_viewObscuredBrush)
    {
        ERROR_OUT(( "Failed to create obscured bitmap brush"));
        DC_QUIT;
    }

    //
    // NOTE THAT since the icons are VGA colors, we don't need to recreate
    // our brush on a SYSCOLOR change.
    //

    // Get the full screen cancel icon
    m_viewFullScreenExitIcon = (HICON)LoadImage(g_asInstance,
        MAKEINTRESOURCE(IDI_CANCELFULLSCREEN), IMAGE_ICON,
        GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON),
        LR_DEFAULTCOLOR);

    m_viewEdgeCX    = ::GetSystemMetrics(SM_CXEDGE);
    m_viewEdgeCY    = ::GetSystemMetrics(SM_CYEDGE);

    //
    // Get metrics of GUI_FONT, the one we use in the window bar and
    // status bar.
    //
    LoadString(g_asInstance, IDS_RESTORE, szRestore, sizeof(szRestore));

    hdc = ::GetDC(NULL);
    hfnOld = (HFONT)::SelectObject(hdc, ::GetStockObject(DEFAULT_GUI_FONT));

    ::GetTextMetrics(hdc, &tm);

    ::GetTextExtentPoint(hdc, szRestore, lstrlen(szRestore), &extent);

    ::SelectObject(hdc, hfnOld);
    ::ReleaseDC(NULL, hdc);

    //
    // Calculate size of full screen button
    // Edge on left + margin on left + sm icon + margin + text + margin on
    //      right + edge on right == 5 edges + sm icon + text
    //
    m_viewFullScreenCX = extent.cx + 5*m_viewEdgeCX + GetSystemMetrics(SM_CXSMICON);
    m_viewFullScreenCY = max(GetSystemMetrics(SM_CYSMICON), extent.cy) + 4*m_viewEdgeCY;

    //
    // Calculate size of items on window bar
    //
    m_viewItemCX = 4*m_viewEdgeCX + ::GetSystemMetrics(SM_CXSMICON) +
        m_viewEdgeCX + VIEW_MAX_ITEM_CHARS * tm.tmAveCharWidth;
    m_viewItemCY = max(::GetSystemMetrics(SM_CYSMICON), tm.tmHeight) +
        2*m_viewEdgeCY + 2*m_viewEdgeCY;

    //
    // Calculate the width & height of the items scroll buttons.  We want
    // to make sure it fits, but isn't ungainly.
    //
    m_viewItemScrollCX = ::GetSystemMetrics(SM_CXHSCROLL);
    m_viewItemScrollCX = 2 * min(m_viewItemScrollCX, m_viewItemCY);

    m_viewItemScrollCY = ::GetSystemMetrics(SM_CYHSCROLL);
    m_viewItemScrollCY = min(m_viewItemScrollCY, m_viewItemCY);


    //
    // Calculate height of active window bar.  We leave a CYEDGE gap on the
    // top.  between it and the sunken border around the view client.
    //
    m_viewWindowBarCY = m_viewItemCY + m_viewEdgeCY;

    //
    // Calculate height of status bar.  It's height of GUIFONT plus edge
    // space.
    //

    m_viewStatusBarCY = tm.tmHeight + 4*m_viewEdgeCY;

    rc = TRUE;

DC_EXIT_POINT:
    DebugExitBOOL(ASShare::VIEW_ShareStarting, rc);
    return(rc);
}



//
// VIEW_ShareEnded()
// Cleans up resources for share
//
void ASShare::VIEW_ShareEnded(void)
{
    DebugEntry(ASShare::VIEW_ShareEnded);

    //
    // Destroy the full screen cancel icon
    //
    if (m_viewFullScreenExitIcon != NULL)
    {
        DestroyIcon(m_viewFullScreenExitIcon);
        m_viewFullScreenExitIcon = NULL;
    }

    if (m_viewObscuredBrush != NULL)
    {
        DeleteBrush(m_viewObscuredBrush);
        m_viewObscuredBrush = NULL;
    }

    DebugExitVOID(ASShre::VIEW_ShareEnded);
}




//
// VIEW_PartyLeftShare()
//
// This is called when somebody leaves a share.  We need this to
// simulate what back-level systems did to calculate the virtual desktop
// size.  They didn't recalc when someone stopped shared, that person's
// screne size counted until they left the share.
//
void ASShare::VIEW_PartyLeftShare(ASPerson * pasPerson)
{
    DebugEntry(ASShare::VIEW_PartyLeftShare);

    ValidatePerson(pasPerson);

    // If this dude ever shared, now remove him from the VD total
    if (pasPerson->viewExtent.x != 0)
    {
        pasPerson->viewExtent.x            = 0;
        pasPerson->viewExtent.y            = 0;
        VIEW_RecalcVD();
    }

    DebugExitVOID(ASShare::VIEW_PartyLeftShare);
}




//
// VIEW_HostStarting()
//
// Called when we start to host.
//
BOOL ASHost::VIEW_HostStarting(void)
{
    DebugEntry(ASHost:VIEW_HostStarting);

    m_pShare->VIEW_RecalcExtent(m_pShare->m_pasLocal);
    m_pShare->VIEW_RecalcVD();

    DebugExitBOOL(ASHost::VIEW_HostStarting, TRUE);
    return(TRUE);
}


//
// VIEW_ViewStarting()
// Called when someone in the meeting starts to share.  For all in the
// conference, we keep a running tally of the VD, but use it only for
// 2.x views.  For remotes only, we create a view of their desktop.
//
BOOL ASShare::VIEW_ViewStarting(ASPerson * pasHost)
{
    BOOL    rc = FALSE;
    HWND    hwnd;
    RECT    rcSize;

    DebugEntry(ASShare::VIEW_ViewStarting);

    ValidateView(pasHost);

    //
    // First, calculate the extents, and the VD size.
    //
    VIEW_RecalcExtent(pasHost);
    VIEW_RecalcVD();

    //
    // Next, create scratch regions
    //
    pasHost->m_pView->m_viewExtentRgn = CreateRectRgn(0, 0, 0, 0);
    pasHost->m_pView->m_viewScreenRgn = CreateRectRgn(0, 0, 0, 0);
    pasHost->m_pView->m_viewPaintRgn  = CreateRectRgn(0, 0, 0, 0);
    pasHost->m_pView->m_viewScratchRgn = CreateRectRgn(0, 0, 0, 0);

    if (!pasHost->m_pView->m_viewExtentRgn || !pasHost->m_pView->m_viewScreenRgn || !pasHost->m_pView->m_viewPaintRgn || !pasHost->m_pView->m_viewScratchRgn)
    {
        ERROR_OUT(("ViewStarting: Couldn't create scratch regions"));
        DC_QUIT;
    }


    ASSERT(pasHost->m_pView->m_viewFrame == NULL);
    ASSERT(pasHost->m_pView->m_viewClient  == NULL);
    ASSERT(pasHost->m_pView->m_viewSharedRgn == NULL);
    ASSERT(pasHost->m_pView->m_viewObscuredRgn == NULL);
    ASSERT(pasHost->m_pView->m_viewPos.x == 0);
    ASSERT(pasHost->m_pView->m_viewPos.y == 0);
    ASSERT(pasHost->m_pView->m_viewPage.x == 0);
    ASSERT(pasHost->m_pView->m_viewPage.y == 0);

    ASSERT(!pasHost->m_pView->m_viewStatusBarOn);
    ASSERT(!pasHost->m_pView->m_viewWindowBarOn);
    ASSERT(!pasHost->m_pView->m_viewFullScreen);

    pasHost->m_pView->m_viewStatusBarOn = TRUE;
    if (pasHost->hetCount != HET_DESKTOPSHARED)
    {
        pasHost->m_pView->m_viewWindowBarOn = TRUE;
    }

    //
    // Calculate the ideal size for this window.
    //
    VIEWFrameGetSize(pasHost, &rcSize);

    //
    // Create the frame.  This will in turn create its children.
    //
    pasHost->m_pView->m_viewMenuBar = ::LoadMenu(g_asInstance,
        MAKEINTRESOURCE(IDM_FRAME));
    if (!pasHost->m_pView->m_viewMenuBar)
    {
        ERROR_OUT(("ViewStarting: couldn't load frame menu"));
        DC_QUIT;
    }

    //
    // Do once-only capabilities/menu stuff.
    //

    //
    // SEND CTRL+ALT+DEL:
    // Append Ctrl+Alt+Del after separator to control menu, if this
    // is a view of a service host on NT.
    //
    if (pasHost->hetCount == HET_DESKTOPSHARED)
    {
        //
        // Remove applications submenu
        //
        DeleteMenu(pasHost->m_pView->m_viewMenuBar, IDSM_WINDOW,
            MF_BYPOSITION);

        if ((pasHost->cpcCaps.general.typeFlags & AS_SERVICE) &&
            (pasHost->cpcCaps.general.OS == CAPS_WINDOWS)     &&
            (pasHost->cpcCaps.general.OSVersion == CAPS_WINDOWS_NT))
        {
            HMENU   hSubMenu;
            MENUITEMINFO mii;
            CHAR szMenu[32];

            hSubMenu = GetSubMenu(pasHost->m_pView->m_viewMenuBar, IDSM_CONTROL);

            ZeroMemory(&mii, sizeof(mii));

            // Separator
            mii.cbSize  = sizeof(mii);
            mii.fMask   = MIIM_TYPE;
            mii.fType   = MFT_SEPARATOR;
            InsertMenuItem(hSubMenu, -1, TRUE, &mii);

            // Send Ctrl-Alt-Del command
            mii.fMask   = MIIM_ID | MIIM_STATE | MIIM_TYPE;
            mii.fType   = MFT_STRING;
            mii.fState  = MFS_ENABLED;
            mii.wID     = CMD_CTRLALTDEL;

            LoadString(g_asInstance, IDS_CMD_CTRLALTDEL, szMenu,
                                                    sizeof(szMenu));
            mii.dwTypeData  = szMenu;
            mii.cch         = lstrlen(szMenu);

            InsertMenuItem(hSubMenu, -1, TRUE, &mii);
        }
    }

    //
    // FULL SCREEN:
    // We only enable Full Screen for 3.0 hosts (since with 2.x desktop
    // scrolling the view area can change) who have screen sizes identical
    // to ours.
    //
    if ((pasHost->cpcCaps.general.version >= CAPS_VERSION_30) &&
        (pasHost->cpcCaps.screen.capsScreenWidth ==
            m_pasLocal->cpcCaps.screen.capsScreenWidth) &&
        (pasHost->cpcCaps.screen.capsScreenHeight ==
            m_pasLocal->cpcCaps.screen.capsScreenHeight))
    {
        ::EnableMenuItem(pasHost->m_pView->m_viewMenuBar, CMD_VIEWFULLSCREEN,
            MF_ENABLED | MF_BYCOMMAND);
    }

    if (m_pasLocal->m_caControlledBy)
    {
        WARNING_OUT(("VIEWStarting: currently controlled, create view hidden"));
    }

    //
    // If we are currently controlled, create the frame invisible since
    // we hid all the visible ones when we started being this way.
    //
    hwnd = CreateWindowEx(
            WS_EX_WINDOWEDGE,
            VIEW_FRAME_CLASS_NAME,  // See RegisterClass() call.
            NULL,
            WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_THICKFRAME | WS_MINIMIZEBOX |
                WS_MAXIMIZEBOX | WS_CLIPCHILDREN | (!m_pasLocal->m_caControlledBy ? WS_VISIBLE : 0),
            CW_USEDEFAULT,
            CW_USEDEFAULT,
            pasHost->viewExtent.x >= m_pasLocal->cpcCaps.screen.capsScreenWidth ?
                CW_USEDEFAULT : rcSize.right - rcSize.left,

            pasHost->viewExtent.y >= m_pasLocal->cpcCaps.screen.capsScreenHeight ?
                CW_USEDEFAULT : rcSize.bottom - rcSize.top,
            NULL,
            pasHost->m_pView->m_viewMenuBar,
            g_asInstance,
            pasHost                       // Pass in person ptr
            );

    if (hwnd == NULL)
    {
        ERROR_OUT(("ViewStarting: couldn't create frame window"));
        DC_QUIT;
    }

    //
    // OK, now we've created this frame window.  Go through the sizing
    // process again to make sure the scrollbars are OK.
    //
    VIEWClientExtentChange(pasHost, FALSE);

    if (!m_pasLocal->m_caControlledBy)
    {
        SetForegroundWindow(hwnd);
        UpdateWindow(hwnd);
    }

#ifdef _DEBUG
    TRACE_OUT(("TIME TO SEE SOMETHING: %08d MS",
        ::GetTickCount() - g_asSession.scShareTime));
    g_asSession.scShareTime = 0;
#endif // DEBUG

    rc = TRUE;

DC_EXIT_POINT:
    DebugExitBOOL(ASShare::VIEW_ViewStarting, rc);
    return(rc);
}


//
// VIEW_ViewEnded()
//
// Called when someone we are viewing stops hosting, so we can clean up.
//
void  ASShare::VIEW_ViewEnded(ASPerson * pasHost)
{
    DebugEntry(ASShare::VIEW_ViewEnded);

    ValidateView(pasHost);

    if (pasHost->m_pView->m_viewInformDlg != NULL)
    {
        SendMessage(pasHost->m_pView->m_viewInformDlg, WM_COMMAND, IDCANCEL, 0);
        ASSERT(!pasHost->m_pView->m_viewInformDlg);
        ASSERT(!pasHost->m_pView->m_viewInformMsg);
        ASSERT(IsWindowEnabled(pasHost->m_pView->m_viewFrame));
    }

    if (pasHost->m_pView->m_viewFrame != NULL)
    {
        //
        // The frame is the parent of the view, toolbar, etc.  Those
        // should all be NULL when we return.
        //
        DestroyWindow(pasHost->m_pView->m_viewFrame);
        ASSERT(pasHost->m_pView->m_viewFrame == NULL);
    }

    ASSERT(pasHost->m_pView->m_viewClient == NULL);

    if (pasHost->m_pView->m_viewMenuBar != NULL)
    {
        ::DestroyMenu(pasHost->m_pView->m_viewMenuBar);
        pasHost->m_pView->m_viewMenuBar = NULL;
    }

    if (pasHost->m_pView->m_viewSharedRgn != NULL)
    {
        DeleteRgn(pasHost->m_pView->m_viewSharedRgn);
        pasHost->m_pView->m_viewSharedRgn = NULL;
    }

    if (pasHost->m_pView->m_viewObscuredRgn != NULL)
    {
        DeleteRgn(pasHost->m_pView->m_viewObscuredRgn);
        pasHost->m_pView->m_viewObscuredRgn = NULL;
    }

    //
    // Destroy scratch regions
    //
    if (pasHost->m_pView->m_viewScratchRgn != NULL)
    {
        DeleteRgn(pasHost->m_pView->m_viewScratchRgn);
        pasHost->m_pView->m_viewScratchRgn = NULL;
    }

    if (pasHost->m_pView->m_viewPaintRgn != NULL)
    {
        DeleteRgn(pasHost->m_pView->m_viewPaintRgn);
        pasHost->m_pView->m_viewPaintRgn = NULL;
    }

    if (pasHost->m_pView->m_viewScreenRgn != NULL)
    {
        DeleteRgn(pasHost->m_pView->m_viewScreenRgn);
        pasHost->m_pView->m_viewScreenRgn = NULL;
    }

    if (pasHost->m_pView->m_viewExtentRgn != NULL)
    {
        DeleteRgn(pasHost->m_pView->m_viewExtentRgn);
        pasHost->m_pView->m_viewExtentRgn = NULL;
    }


    pasHost->m_pView->m_viewPos.x                = 0;
    pasHost->m_pView->m_viewPos.y                = 0;
    pasHost->m_pView->m_viewPage.x               = 0;
    pasHost->m_pView->m_viewPage.y               = 0;
    pasHost->m_pView->m_viewPgSize.x             = 0;
    pasHost->m_pView->m_viewPgSize.y             = 0;
    pasHost->m_pView->m_viewLnSize.x             = 0;
    pasHost->m_pView->m_viewLnSize.y             = 0;

    DebugExitVOID(ASShare::VIEW_ViewEnded);
}



//
// VIEW_InControl()
//
// Called when we start/stop controlling this host.  We enable the
// toolbar, statusbar, tray, etc., and change the cursor from being the
// nodrop.
//
void ASShare::VIEW_InControl
(
    ASPerson *  pasHost,
    BOOL        fStart
)
{
    POINT       ptCursor;

    DebugEntry(ASShare::VIEW_InControl);

    //
    // We're changing our state, and that affects the contents of our
    // menu bar.  So cancel out of menu mode, and spare problems/faults/
    // inapplicable commands.
    //
    if (pasHost->m_pView->m_viewInMenuMode)
    {
        SendMessage(pasHost->m_pView->m_viewFrame, WM_CANCELMODE, 0, 0);
        ASSERT(!pasHost->m_pView->m_viewInMenuMode);
    }

    //
    // If starting in control and a message is up, kill it.  Then bring our
    // window to the front.
    //
    if (fStart)
    {
        if (pasHost->m_pView->m_viewInformDlg != NULL)
        {
            SendMessage(pasHost->m_pView->m_viewInformDlg, WM_COMMAND, IDCANCEL, 0);
            ASSERT(!pasHost->m_pView->m_viewInformDlg);
            ASSERT(!pasHost->m_pView->m_viewInformMsg);
            ASSERT(IsWindowEnabled(pasHost->m_pView->m_viewFrame));
        }

        SetForegroundWindow(pasHost->m_pView->m_viewFrame);
    }

    //
    // App Sharing (not desktop sharing) stuff
    //
    if (pasHost->hetCount && (pasHost->hetCount != HET_DESKTOPSHARED))
    {
        //
        // Enable/disable window bar
        //
        ASSERT(IsWindow(pasHost->m_pView->m_viewWindowBar));
        ::EnableWindow(::GetDlgItem(pasHost->m_pView->m_viewWindowBar,
            IDVIEW_ITEMS), fStart);

        //
        // Enable/Disable Applications submenu
        //
        EnableMenuItem(pasHost->m_pView->m_viewMenuBar, IDSM_WINDOW,
            (fStart ? MF_ENABLED : MF_GRAYED) | MF_BYPOSITION);

        if (!pasHost->m_pView->m_viewFullScreen)
        {
            DrawMenuBar(pasHost->m_pView->m_viewFrame);
        }
    }

    //
    // Change title bar
    //
    VIEW_HostStateChange(pasHost);

    //
    // Turn off/on shadow cursors
    //
    CM_UpdateShadowCursor(pasHost, fStart, pasHost->cmPos.x, pasHost->cmPos.y,
        pasHost->cmHotSpot.x, pasHost->cmHotSpot.y);

    //
    // This will reset cursor image:
    //      * from nodrop to shared if in control
    //      * from shared to nodrop if not in control
    //
    // This will also, if in control, cause a mousemove to get sent to the
    // host we're controlling so his cursor pos is synced with ours, if the
    // mouse is over the frame client area.
    //
    GetCursorPos(&ptCursor);
    SetCursorPos(ptCursor.x, ptCursor.y);

    DebugExitVOID(ASShare::VIEW_InControl);
}



//
// VIEW_PausedInControl()
//
// Updates status bar etc. when control is paused.
//
void ASShare::VIEW_PausedInControl
(
    ASPerson *  pasHost,
    BOOL        fPaused
)
{
    DebugEntry(ASShare::VIEW_PausedInControl);

    ValidatePerson(pasHost);

    ASSERT(pasHost->m_caControlledBy == m_pasLocal);

    //
    // Update status bar
    //

    //
    // Disable/Enable window menu
    //

    //
    // Put shadow cursors on/off
    //

    //
    // Jiggle cursor
    //

    DebugExitVOID(ASShare::VIEW_PausedInControl);
}



//
// VIEW_HostStateChange()
//
// Called when a host's state has changed, via broadcast notification or
// local operations.
//
// We update the titlebar and commands.
//
void ASShare::VIEW_HostStateChange
(
    ASPerson *  pasHost
)
{
    char        szFormat[256];
    char        szTitleText[256];
    char        szOtherPart[128];

    DebugEntry(ASShare::VIEW_HostStateChange);

    ValidatePerson(pasHost);

    //
    // If this person isn't hosting anymore, don't do anything.  We're
    // cleaning up after him.
    //
    if (!pasHost->hetCount)
    {
        DC_QUIT;
    }

    //
    // Make up trailing string
    //
    if (pasHost->m_caControlledBy)
    {
        LoadString(g_asInstance, IDS_TITLE_INCONTROL, szFormat, sizeof(szFormat));
        wsprintf(szOtherPart, szFormat, pasHost->m_caControlledBy->scName);
    }
    else if (pasHost->m_caAllowControl)
    {
        LoadString(g_asInstance, IDS_TITLE_CONTROLLABLE, szOtherPart, sizeof(szOtherPart));
    }
    else
    {
        szOtherPart[0] = 0;
    }

    if (pasHost->hetCount == HET_DESKTOPSHARED)
    {
        LoadString(g_asInstance, IDS_TITLE_SHAREDDESKTOP, szFormat, sizeof(szFormat));
    }
    else
    {
        ASSERT(pasHost->hetCount);
        LoadString(g_asInstance, IDS_TITLE_SHAREDPROGRAMS, szFormat, sizeof(szFormat));
    }

    wsprintf(szTitleText, szFormat, pasHost->scName, szOtherPart);

    ::SetWindowText(pasHost->m_pView->m_viewFrame, szTitleText);

DC_EXIT_POINT:
    DebugExitVOID(ASShare::VIEW_HostStateChange);
}



//
// VIEW_UpdateStatus()
//
// Updates the PERMANENT status of this frame.  When we go into menu mode,
// the strings shown are temporary only, not saved.  When we come out of
// menu mode, we put back the temporary status.
//
void ASShare::VIEW_UpdateStatus
(
    ASPerson *  pasHost,
    UINT        idsStatus
)
{
    DebugEntry(ASShare::VIEW_UpdateStatus);

    ValidatePerson(pasHost);

    pasHost->m_pView->m_viewStatus = idsStatus;
    VIEWFrameSetStatus(pasHost, idsStatus);

    DebugExitVOID(ASShare::VIEW_UpdateStatus);
}


void ASShare::VIEWFrameSetStatus
(
    ASPerson *  pasHost,
    UINT        idsStatus
)
{
    char szStatus[256];

    DebugEntry(ASShare::VIEWFrameSetStatus);

    if (idsStatus != IDS_STATUS_NONE)
    {
        LoadString(g_asInstance, idsStatus, szStatus, sizeof(szStatus));
    }
    else
    {
        szStatus[0] = 0;
    }
    ::SetWindowText(pasHost->m_pView->m_viewStatusBar, szStatus);

    DebugExitVOID(ASShare::VIEWFrameSetStatus);
}




//
// VIEW_Message()
//
// Puts up a message to inform the end user of something.
//
void ASShare::VIEW_Message
(
    ASPerson *  pasHost,
    UINT        ids
)
{
    DebugEntry(ASShare::VIEW_Message);

    ValidateView(pasHost);

    if (!pasHost->m_pView)
    {
        WARNING_OUT(("Can't show VIEW message; [%d] not hosting", pasHost->mcsID));
        DC_QUIT;
    }

    if (pasHost->m_pView->m_viewInformDlg)
    {
        // Kill the previous one
        TRACE_OUT(("Killing previous informational mesage for [%d]",
            pasHost->mcsID));
        SendMessage(pasHost->m_pView->m_viewInformDlg, WM_COMMAND, IDCANCEL, 0);
        ASSERT(!pasHost->m_pView->m_viewInformDlg);
        ASSERT(!pasHost->m_pView->m_viewInformMsg);
    }

    if (m_pasLocal->m_caControlledBy)
    {
        WARNING_OUT(("VIEW_Message:  ignoring, view is hidden since we're controlled"));
    }
    else
    {
        pasHost->m_pView->m_viewInformMsg = ids;
        pasHost->m_pView->m_viewInformDlg = CreateDialogParam(g_asInstance,
            ((ids != IDS_ABOUT) ? MAKEINTRESOURCE(IDD_INFORM) : MAKEINTRESOURCE(IDD_ABOUT)),
            pasHost->m_pView->m_viewFrame, VIEWDlgProc, (LPARAM)pasHost);
        if (!pasHost->m_pView->m_viewInformDlg)
        {
            ERROR_OUT(("Failed to create inform message box for [%d]",
                pasHost->mcsID));
            pasHost->m_pView->m_viewInformMsg = 0;
        }
    }

DC_EXIT_POINT:
    DebugExitVOID(ASShare::VIEW_Message);
}



//
// VIEWStartControlled()
//
// If we are about to start being controlled, we hide all the frames
// to get them out of the way AND prevent hangs caused by modal loop code
// in Win9x title bar dragging.
//
void ASShare::VIEWStartControlled(BOOL fStart)
{
    ASPerson *  pasT;

    DebugEntry(ASShare::VIEWStartControlled);

    for (pasT = m_pasLocal; pasT != NULL; pasT = pasT->pasNext)
    {
        if (pasT->m_pView)
        {
            if (fStart)
            {
                ASSERT(IsWindowVisible(pasT->m_pView->m_viewFrame));
                ShowOwnedPopups(pasT->m_pView->m_viewFrame, FALSE);
                SetWindowPos(pasT->m_pView->m_viewFrame, NULL, 0, 0, 0, 0,
                    SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOZORDER |
                    SWP_HIDEWINDOW);
            }
            else
            {
                ASSERT(!IsWindowVisible(pasT->m_pView->m_viewFrame));
                SetWindowPos(pasT->m_pView->m_viewFrame, NULL, 0, 0, 0, 0,
                    SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOZORDER |
                    SWP_SHOWWINDOW);
                ShowOwnedPopups(pasT->m_pView->m_viewFrame, TRUE);
            }
        }
    }

    DebugEntry(ASShare::VIEWStartControlled);
}


//
// VIEW_DlgProc()
//
// Handles informing user dialog
//
INT_PTR CALLBACK VIEWDlgProc
(
    HWND        hwnd,
    UINT        message,
    WPARAM      wParam,
    LPARAM      lParam
)
{
    return(g_asSession.pShare->VIEW_DlgProc(hwnd, message, wParam, lParam));
}


BOOL ASShare::VIEW_DlgProc
(
    HWND        hwnd,
    UINT        message,
    WPARAM      wParam,
    LPARAM      lParam
)
{
    BOOL        rc = TRUE;
    ASPerson *  pasHost;

    DebugEntry(VIEW_DlgProc);

    pasHost = (ASPerson *)GetWindowLongPtr(hwnd, GWLP_USERDATA);
    if (pasHost)
    {
        ValidateView(pasHost);
    }

    switch (message)
    {
        case WM_INITDIALOG:
        {
            char szT[256];
            char szRes[512];
            RECT rcText;
            RECT rcOwner;

            pasHost = (ASPerson *)lParam;
            ValidateView(pasHost);
            pasHost->m_pView->m_viewInformDlg = hwnd;

            SetWindowLongPtr(hwnd, GWLP_USERDATA, lParam);

            ASSERT(pasHost->m_pView->m_viewInformMsg);

            if (pasHost->m_pView->m_viewInformMsg == IDS_ABOUT)
            {
                // About box
                GetDlgItemText(hwnd, CTRL_ABOUTVERSION, szT, sizeof(szT));
                wsprintf(szRes, szT, VER_PRODUCTRELEASE_STR,
                    VER_PRODUCTVERSION_STR);
                SetDlgItemText(hwnd, CTRL_ABOUTVERSION, szRes);
            }
            else
            {
                HDC     hdc;
                HFONT   hfn;

                // Set title.
                if ((pasHost->m_pView->m_viewInformMsg >= IDS_ERR_TAKECONTROL_FIRST) &&
                    (pasHost->m_pView->m_viewInformMsg <= IDS_ERR_TAKECONTROL_LAST))
                {
                    LoadString(g_asInstance, IDS_TITLE_TAKECONTROL_FAILED,
                        szT, sizeof(szT));
                    SetWindowText(hwnd, szT);
                }

                // Set message
                LoadString(g_asInstance, pasHost->m_pView->m_viewInformMsg,
                    szT, sizeof(szT));
                wsprintf(szRes, szT, pasHost->scName);
                SetDlgItemText(hwnd, CTRL_INFORM, szRes);

                // Center the message vertically
                GetWindowRect(GetDlgItem(hwnd, CTRL_INFORM), &rcOwner);
                MapWindowPoints(NULL, hwnd, (LPPOINT)&rcOwner, 2);

                rcText = rcOwner;

                hdc = GetDC(hwnd);
                hfn = (HFONT)SendDlgItemMessage(hwnd, CTRL_INFORM, WM_GETFONT, 0, 0);
                hfn = SelectFont(hdc, hfn);

                DrawText(hdc, szRes, -1, &rcText, DT_NOCLIP | DT_EXPANDTABS |
                    DT_NOPREFIX | DT_WORDBREAK | DT_CALCRECT);

                SelectFont(hdc, hfn);
                ReleaseDC(hwnd, hdc);

                ASSERT((rcText.bottom - rcText.top) <= (rcOwner.bottom - rcOwner.top));

                SetWindowPos(GetDlgItem(hwnd, CTRL_INFORM), NULL,
                    rcOwner.left,
                    ((rcOwner.top + rcOwner.bottom) - (rcText.bottom - rcText.top)) / 2,
                    (rcOwner.right - rcOwner.left),
                    rcText.bottom - rcText.top,
                    SWP_NOACTIVATE | SWP_NOZORDER);
            }

            // Disable owner
            EnableWindow(pasHost->m_pView->m_viewFrame, FALSE);

            // Show window, centered around owner midpoint
            GetWindowRect(pasHost->m_pView->m_viewFrame, &rcOwner);
            GetWindowRect(hwnd, &rcText);

            SetWindowPos(hwnd, NULL,
                ((rcOwner.left + rcOwner.right) - (rcText.right - rcText.left)) / 2,
                ((rcOwner.top + rcOwner.bottom) - (rcText.bottom - rcText.top)) / 2,
                0, 0, SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOZORDER);

            ShowWindow(hwnd, SW_SHOWNORMAL);
            UpdateWindow(hwnd);
            break;
        }

        case WM_COMMAND:
        {
            switch (GET_WM_COMMAND_ID(wParam, lParam))
            {
                case IDOK:
                case IDCANCEL:
                {
                    if(pasHost)
                    {
                        ASSERT(!IsWindowEnabled(pasHost->m_pView->m_viewFrame));
                        EnableWindow(pasHost->m_pView->m_viewFrame, TRUE);
                    }

                    DestroyWindow(hwnd);
                    break;
                }
            }
            break;
        }

        case WM_DESTROY:
        {
            if (pasHost)
            {
                pasHost->m_pView->m_viewInformDlg = NULL;
                pasHost->m_pView->m_viewInformMsg = 0;
            }

            SetWindowLongPtr(hwnd, GWLP_USERDATA, NULL);
            break;
        }

        default:
        {
            rc = FALSE;
            break;
        }
    }

    DebugExitBOOL(VIEW_DlgProc, rc);
    return(rc);
}



//
// VIEW_RecalcExtent()
//
// This recalculates the extent of the view of the host.
//
void ASShare::VIEW_RecalcExtent(ASPerson * pasHost)
{
    DebugEntry(ASShare::VIEW_RecalcExtent);

    TRACE_OUT(("VIEW_RecalcExtent:  New view extent (%04d, %04d) for [%d] version %x",
        pasHost->viewExtent.x, pasHost->viewExtent.y,
        pasHost->mcsID, pasHost->cpcCaps.general.version));

    //
    // Compute the extent of the view:
    //      For 2.x dudes, it's the VD size (union of all hosts)
    //      For 3.0 dudes, it's the host screen size
    //
    // REMOVE THIS WHEN 2.X COMPAT IS GONE
    //
    if (pasHost->cpcCaps.general.version >= CAPS_VERSION_30)
    {
        pasHost->viewExtent.x = pasHost->cpcCaps.screen.capsScreenWidth;
        pasHost->viewExtent.y = pasHost->cpcCaps.screen.capsScreenHeight;
    }
    else
    {
        //
        // We do this so that the window is created the right size in the
        // first place.  Then in VIEW_RecalcVD nothing will happen to it,
        // because the extent won't alter.
        //
        pasHost->viewExtent.x = max(m_viewVDSize.x, pasHost->cpcCaps.screen.capsScreenWidth);
        pasHost->viewExtent.y = max(m_viewVDSize.y, pasHost->cpcCaps.screen.capsScreenHeight);
    }

    DebugExitVOID(ASShare::VIEW_RecalcExtent);
}

//
// VIEW_RecalcVD()
// This recalculates the virtual desktop size when a remote starts/stops
// sharing, or if a host's screen changes size.  The VD is the union of
// all the screen sizes of those hosting.  2.x nodes work in a virtual
// desktop, and may scroll over.  For each 2.x view, we want the client to
// represent the VD, but with only the stuff on screen on the host to be
// interactable.
//
void ASShare::VIEW_RecalcVD(void)
{
    POINT       ptVDNew;
    ASPerson *  pas;

    DebugEntry(ASShare::VIEW_RecalcVD);

    //
    // First, loop through all the hosts and recompute the VD.
    //
    ptVDNew.x = 0;
    ptVDNew.y = 0;

    for (pas = m_pasLocal; pas != NULL; pas = pas->pasNext)
    {
        //
        // NOTE:
        // For local dudes, we won't have an HWND.  Use viewExtent, if
        // we don't think the person is sharing, it will be zero.
        //
        if (pas->viewExtent.x != 0)
        {
            TRACE_OUT(("VIEW_RecalcVD: Found host [%d], screen size (%04d, %04d)",
                pas->mcsID, pas->cpcCaps.screen.capsScreenWidth, pas->cpcCaps.screen.capsScreenHeight));

            ptVDNew.x = max(ptVDNew.x, pas->cpcCaps.screen.capsScreenWidth);
            ptVDNew.y = max(ptVDNew.y, pas->cpcCaps.screen.capsScreenHeight);

            TRACE_OUT(("VIEW_RecalcVD: Computed VD size now (%04d, %04d)",
                ptVDNew.x, ptVDNew.y));
        }
    }

    //
    // If the VD size didn't change, we're done.
    //
    if ((ptVDNew.x != m_viewVDSize.x) || (ptVDNew.y != m_viewVDSize.y))
    {
        TRACE_OUT(("VIEW_RecalcVD: VD size changed from (%04d, %04d) to (%04d, %04d)",
            m_viewVDSize.x, m_viewVDSize.y, ptVDNew.x, ptVDNew.y));

        m_viewVDSize = ptVDNew;

        //
        // Now loop through all the 2.x hosts, and update their extent, then
        // have them do the resize voodoo so the scrollbar pos isn't out of
        // range, etc.
        //
        // NOTE:  Since us, the local guy, is not 2.x we can skip ourselves.
        //
        ValidatePerson(m_pasLocal);

        for (pas = m_pasLocal->pasNext; pas != NULL; pas = pas->pasNext)
        {
            if ((pas->cpcCaps.general.version < CAPS_VERSION_30) && (pas->m_pView != NULL))
            {
                ASSERT(m_viewVDSize.x != 0);
                ASSERT(m_viewVDSize.y != 0);

                // Potential resize/range change
                if ((pas->viewExtent.x != m_viewVDSize.x) ||
                    (pas->viewExtent.y != m_viewVDSize.y))
                {
                    TRACE_OUT(("VIEW_RecalcVD: Found 2.x host [%d], must update old extent (%04d, %04d)",
                        pas->mcsID, pas->viewExtent.x, pas->viewExtent.y));

                    VIEW_RecalcExtent(pas);
                    VIEWClientExtentChange(pas, TRUE);
                }
            }
        }
    }

    DebugExitVOID(ASShare::VIEW_RecalcVD);
}


//
// VIEW_IsPointShared()
// This determines, given a point relative to the client of the view for
// the remote on this system, if it is in a shared area.
//
BOOL  ASShare::VIEW_IsPointShared
(
    ASPerson *  pasHost,
    POINT       ptLocal
)
{
    BOOL        rc = FALSE;
    RECT        rcClient;

    DebugEntry(ASShare::VIEW_IsPointShared);

    ValidateView(pasHost);

    //
    // Convert to client coords, and adjust for scrolling offset.  That
    // result is the equivalent point on the host desktop.
    //
    GetClientRect(pasHost->m_pView->m_viewClient, &rcClient);
    if (!PtInRect(&rcClient, ptLocal))
    {
        TRACE_OUT(("VIEW_IsPointShared: point not in client area"));
        return(FALSE);
    }

    //
    // The obscured and shared areas are saved in frame client coords,
    // so we don't need to account for the scroll position all the time.
    // When the scroll position changes the regions are updated.
    //

    //
    // NOTE that this order works for both desktop and app sharing
    //
    if ((pasHost->m_pView->m_viewObscuredRgn != NULL) &&
        PtInRegion(pasHost->m_pView->m_viewObscuredRgn, ptLocal.x, ptLocal.y))
    {
        rc = FALSE;
    }
    else if ((pasHost->m_pView->m_viewSharedRgn != NULL) &&
        !PtInRegion(pasHost->m_pView->m_viewSharedRgn, ptLocal.x, ptLocal.y))
    {
        rc = FALSE;
    }
    else
    {
        //
        // 2.x hosts may be scrolled over.  If so, shared stuff offscreen
        // is also considered to be obscured.
        //
        RECT    rcScreen;

        //
        // Compute what part of the VD, in local client coords, is visible
        // on the remote's screen.
        //
        SetRect(&rcScreen, 0, 0, pasHost->cpcCaps.screen.capsScreenWidth, pasHost->cpcCaps.screen.capsScreenHeight);

        OffsetRect(&rcScreen,
            pasHost->m_pView->m_dsScreenOrigin.x - pasHost->m_pView->m_viewPos.x,
            pasHost->m_pView->m_dsScreenOrigin.y - pasHost->m_pView->m_viewPos.y);
        if (!PtInRect(&rcScreen, ptLocal))
        {
            TRACE_OUT(("VIEW_IsPointShared: point is in shared stuff but not visible on remote screen"));
            rc = FALSE;
        }
        else
        {
            rc = TRUE;
        }
    }

    DebugExitBOOL(AShare::VIEW_IsPointShared, rc);
    return(rc);
}



//
// VIEW_ScreenChanged()
//
void  ASShare::VIEW_ScreenChanged(ASPerson * pasPerson)
{
    DebugEntry(ASShare::VIEW_ScreenChanged);

    ValidatePerson(pasPerson);

    //
    // Recompute the extent
    //
    VIEW_RecalcExtent(pasPerson);
    VIEWClientExtentChange(pasPerson, TRUE);

    VIEW_RecalcVD();

    DebugExitVOID(ASShare::VIEW_ScreenChanged);
}



//
// VIEW_SetHostRegions()
// This sets the new shared & obscured areas.
//
// Note that this routine takes responsibility for the regions pass in; it
// will delete them and/or the old ones if necessary.
//
void  ASShare::VIEW_SetHostRegions
(
    ASPerson *  pasHost,
    HRGN        rgnShared,
    HRGN        rgnObscured
)
{
    DebugEntry(ASShare::VIEW_SetHostRegions);

    ValidateView(pasHost);

    //
    // Return immediately if either region handle is bogus.  This can happen
    // when we are running low on memory.
    //
    if (!rgnShared || !rgnObscured)
    {
        ERROR_OUT(("Bad host regions for person [%u]", pasHost->mcsID));

        if (rgnShared != NULL)
        {
            DeleteRgn(rgnShared);
        }

        if (rgnObscured != NULL)
        {
            DeleteRgn(rgnObscured);
        }
    }
    else
    {
        HRGN    hrgnInvalid;
#ifdef _DEBUG
        RECT    rcT;

        ::GetRgnBox(rgnShared, &rcT);
        TRACE_OUT(("Shared region {%04d, %04d, %04d, %04d} for host [%d]",
            rcT.left, rcT.top, rcT.right, rcT.bottom, pasHost->mcsID));

        ::GetRgnBox(rgnObscured, &rcT);
        TRACE_OUT(("Obscured region {%04d, %04d, %04d, %04d} for host [%d]",
            rcT.left, rcT.top, rcT.right, rcT.bottom, pasHost->mcsID));
#endif // _DEBUG

        //
        // Update the current shared, obscured areas.  Adjust for the
        // scroll position so these are saved in client-relative coords.
        //
        OffsetRgn(rgnShared, -pasHost->m_pView->m_viewPos.x, -pasHost->m_pView->m_viewPos.y);
        OffsetRgn(rgnObscured, -pasHost->m_pView->m_viewPos.x, -pasHost->m_pView->m_viewPos.y);

        //
        // The invalid area is whatever changed in the obscured area and
        // the shared area.  In other words, the union - the intersection.
        //
        hrgnInvalid = NULL;

        if (pasHost->m_pView->m_viewSharedRgn != NULL)
        {
            HRGN    hrgnU;
            HRGN    hrgnI;

            ASSERT(pasHost->m_pView->m_viewObscuredRgn != NULL);

            //
            // If we're in a low memory situation, just invalidate everything
            // and hope it can be repainted.
            //
            hrgnU = CreateRectRgn(0, 0, 0, 0);
            hrgnI = CreateRectRgn(0, 0, 0, 0);
            if (!hrgnU || !hrgnI)
                goto SkipMinimalInvalidate;

            hrgnInvalid = CreateRectRgn(0, 0, 0, 0);
            if (!hrgnInvalid)
                goto SkipMinimalInvalidate;


            //
            // WE'RE GOING TO DO THE SAME THING FOR BOTH SHARED AND
            // OBSCURED REGIONS.
            //

            // Get the union of the old and new shared regions
            UnionRgn(hrgnU, pasHost->m_pView->m_viewSharedRgn, rgnShared);

            // Get the intersection of the old and new shared regions
            IntersectRgn(hrgnI, pasHost->m_pView->m_viewSharedRgn, rgnShared);

            //
            // The intersection is what used to be shared and is still shared.
            // The rest is changing, it needs to be repainted.  That's the
            // union minus the intersection.
            //
            SubtractRgn(hrgnU, hrgnU, hrgnI);
#ifdef _DEBUG
            GetRgnBox(hrgnU, &rcT);
            TRACE_OUT(("VIEW_SetHostRegions: Shared area change {%04d, %04d, %04d, %04d}",
                rcT.left, rcT.top, rcT.right, rcT.bottom));
#endif // _DEBUG

            // Add this to the invalidate total
            UnionRgn(hrgnInvalid, hrgnInvalid, hrgnU);

            //
            // REPEAT FOR THE OBSCURED REGION
            //
            UnionRgn(hrgnU, pasHost->m_pView->m_viewObscuredRgn, rgnObscured);
            IntersectRgn(hrgnI, pasHost->m_pView->m_viewObscuredRgn, rgnObscured);
            SubtractRgn(hrgnU, hrgnU, hrgnI);

#ifdef _DEBUG
            GetRgnBox(hrgnU, &rcT);
            TRACE_OUT(("VIEW_SetHostRegions: Obscured area change {%04d, %04d, %04d, %04d}",
                rcT.left, rcT.top, rcT.right, rcT.bottom));
#endif // _DEBUG
            UnionRgn(hrgnInvalid, hrgnInvalid, hrgnU);

SkipMinimalInvalidate:
            //
            // Clean up scratch regions
            //
            if (hrgnI != NULL)
                DeleteRgn(hrgnI);
            if (hrgnU != NULL)
                DeleteRgn(hrgnU);

            DeleteRgn(pasHost->m_pView->m_viewSharedRgn);
            pasHost->m_pView->m_viewSharedRgn = rgnShared;

            DeleteRgn(pasHost->m_pView->m_viewObscuredRgn);
            pasHost->m_pView->m_viewObscuredRgn = rgnObscured;

            //
            // DO NOT CALL VIEW_InvalidateRgn here, that expects a region in
            // screen coords of pasHost.  We have a region that is
            // client coords relative.  So just call InvalidateRgn() directly.
            //
            InvalidateRgn(pasHost->m_pView->m_viewClient, hrgnInvalid, FALSE);

            if (hrgnInvalid != NULL)
                DeleteRgn(hrgnInvalid);
        }
        else
        {
            RECT    rcBound;

            // The shared & obscured regions are both NULL or both non-NULL
            ASSERT(pasHost->m_pView->m_viewObscuredRgn == NULL);

            pasHost->m_pView->m_viewSharedRgn = rgnShared;
            pasHost->m_pView->m_viewObscuredRgn = rgnObscured;

            //
            // This is the first SWL packet we've received.  Snap the
            // scrollbars to the start of the total shared area.  This avoids
            // having the view come up, but look empty because the shared
            // apps are out of the range.  We do this even if the user
            // scrolled around in the window already.
            //
            // The total shared area is the union of the real shared +
            // obscured shared areas.  Convert back to remote VD coords!
            //
            UnionRgn(pasHost->m_pView->m_viewScratchRgn, rgnShared, rgnObscured);
            GetRgnBox(pasHost->m_pView->m_viewScratchRgn, &rcBound);
            OffsetRect(&rcBound, pasHost->m_pView->m_viewPos.x, pasHost->m_pView->m_viewPos.y);

            //
            // Is any part of what was shared within the extent of the view?
            // If not, we can't do anything--there's nothing to show.
            //
            if ((rcBound.right <= 0) ||
                (rcBound.left  >= pasHost->viewExtent.x) ||
                (rcBound.bottom <= 0) ||
                (rcBound.top >= pasHost->viewExtent.y))
            {
                TRACE_OUT(("VIEW_SetHostRegions:  Can't snap to shared area; none is visible"));
            }
            else
            {
                //
                // Use top left corner of bounds
                // VIEWClientScroll() will pin position w/in range
                //
                VIEWClientScroll(pasHost, rcBound.left, rcBound.top);
            }

            InvalidateRgn(pasHost->m_pView->m_viewClient, NULL, FALSE);
        }
    }

    DebugExitVOID(ASShare::VIEW_SetHostRegions);
}


//
// VIEW_InvalidateRect()
// Repaints the given rect.  This is for EXTERNAL code which passes in VD
// coords.  We convert to client coordinates by accounting for the scroll
// position.
//
void  ASShare::VIEW_InvalidateRect
(
    ASPerson *  pasPerson,
    LPRECT      lprc
)
{
    DebugEntry(ASShare::VIEW_InvalidateRect);

    ValidateView(pasPerson);

    //
    // Convert to client coords
    //
    if (lprc != NULL)
    {
        OffsetRect(lprc, -pasPerson->m_pView->m_viewPos.x, -pasPerson->m_pView->m_viewPos.y);
    }

    InvalidateRect(pasPerson->m_pView->m_viewClient, lprc, FALSE);

    //
    // Convert back so caller doesn't get a modified lprc
    //
    if (lprc != NULL)
    {
        OffsetRect(lprc, pasPerson->m_pView->m_viewPos.x, pasPerson->m_pView->m_viewPos.y);
    }

    DebugExitVOID(ASShare::VIEW_InvalidateRect);
}



//
// VIEW_InvalidateRgn()
// Repaints the given region.  This is for EXTERNAL code which passes in VD
// coords.  We convert to client coordinates by accounting fo the scroll
// position.
//
void  ASShare::VIEW_InvalidateRgn
(
    ASPerson *  pasHost,
    HRGN        rgnInvalid
)
{
#ifdef _DEBUG
    //
    // Make sure we the invalid region goes back to the caller unaltered,
    // even though we modify it temporarily here to avoid a copy.
    //
    RECT        rcBoundBefore;
    RECT        rcBoundAfter;
#endif // _DEBUG

    DebugEntry(ASShare::VIEW_InvalidateRgn);

    ValidatePerson(pasHost);

    //
    // Adjust the region if the frame view is scrolled over.
    //
    if (rgnInvalid != NULL)
    {
#ifdef _DEBUG
        GetRgnBox(rgnInvalid, &rcBoundBefore);
#endif // _DEBUG

        OffsetRgn(rgnInvalid, -pasHost->m_pView->m_viewPos.x, -pasHost->m_pView->m_viewPos.y);

#ifdef _DEBUG
        TRACE_OUT(("VIEW_InvalidateRgn: Invalidating area {%04d, %04d, %04d, %04d}",
            rcBoundBefore.left, rcBoundBefore.top, rcBoundBefore.right, rcBoundBefore.bottom));
#endif // _DEBUG
    }
    else
    {
        TRACE_OUT(("VIEW_InvalidateRgn: Invalidating entire client area"));
    }

    InvalidateRgn(pasHost->m_pView->m_viewClient, rgnInvalid, FALSE);

    if (rgnInvalid != NULL)
    {
        OffsetRgn(rgnInvalid, pasHost->m_pView->m_viewPos.x, pasHost->m_pView->m_viewPos.y);
#ifdef _DEBUG
        GetRgnBox(rgnInvalid, &rcBoundAfter);
        ASSERT(EqualRect(&rcBoundBefore, &rcBoundAfter));
#endif // _DEBUG
    }

    DebugExitVOID(ASShare::VIEW_InvalidateRgn);
}



//
// VIEWClientExtentChange()
//
void ASShare::VIEWClientExtentChange(ASPerson * pasHost, BOOL fRedraw)
{
    RECT    rcl;
    SCROLLINFO si;

    DebugEntry(ASShare::VIEWClientExtentChange);

    ValidatePerson(pasHost);
    if (!pasHost->m_pView)
        DC_QUIT;

#ifdef _DEBUG
    //
    // The client area (page size) shouldn't have changed.  Only the
    // extent has.
    //
    GetClientRect(pasHost->m_pView->m_viewClient, &rcl);
    ASSERT(pasHost->m_pView->m_viewPage.x == rcl.right - rcl.left);
    ASSERT(pasHost->m_pView->m_viewPage.y == rcl.bottom - rcl.top);
#endif // _DEBUG

    pasHost->m_pView->m_viewPgSize.x = pasHost->viewExtent.x / 8;
    pasHost->m_pView->m_viewPgSize.y = pasHost->viewExtent.y / 8;
    pasHost->m_pView->m_viewLnSize.x = pasHost->viewExtent.x / 64;
    pasHost->m_pView->m_viewLnSize.y = pasHost->viewExtent.y / 64;

    //
    // Move the scroll position to the origin.
    //

    //
    // Clip the current scroll pos if we need to, now that the extent
    // has changed size.
    //
    VIEWClientScroll(pasHost, pasHost->m_pView->m_viewPos.x, pasHost->m_pView->m_viewPos.y);

    si.cbSize = sizeof(SCROLLINFO);
    si.fMask = SIF_PAGE|SIF_POS|SIF_RANGE|SIF_DISABLENOSCROLL;

    // Set vertical info.  Is vert pos out of range now?
    si.nMin = 0;
    si.nMax = pasHost->viewExtent.y - 1;
    si.nPage = pasHost->m_pView->m_viewPage.y;
    si.nPos = pasHost->m_pView->m_viewPos.y;
    ASSERT(si.nPos <= si.nMax);

    TRACE_OUT(("VIEWClientExtentChange: Setting VERT scroll info:"));
    TRACE_OUT(("VIEWClientExtentChange:     nMin    %04d", si.nMin));
    TRACE_OUT(("VIEWClientExtentChange:     nMax    %04d", si.nMax));
    TRACE_OUT(("VIEWClientExtentChange:     nPage   %04d", si.nPage));
    TRACE_OUT(("VIEWClientExtentChange:     nPos    %04d", si.nPos));
    SetScrollInfo(pasHost->m_pView->m_viewClient, SB_VERT, &si, TRUE );

    // Set horizontal (x) information
    si.nMin = 0;
    si.nMax = pasHost->viewExtent.x - 1;
    si.nPage = pasHost->m_pView->m_viewPage.x;
    si.nPos = pasHost->m_pView->m_viewPos.x;
    ASSERT(si.nPos <= si.nMax);

    TRACE_OUT(("VIEWClientExtentChange: Setting HORZ scroll info:"));
    TRACE_OUT(("VIEWClientExtentChange:     nMin    %04d", si.nMin));
    TRACE_OUT(("VIEWClientExtentChange:     nMax    %04d", si.nMax));
    TRACE_OUT(("VIEWClientExtentChange:     nPage   %04d", si.nPage));
    TRACE_OUT(("VIEWClientExtentChange:     nPos    %04d", si.nPos));
    SetScrollInfo(pasHost->m_pView->m_viewClient, SB_HORZ, &si, TRUE );

    if (fRedraw)
    {
        // Is the frame window too big now?
        if ( (pasHost->m_pView->m_viewPage.x > pasHost->viewExtent.x) ||
             (pasHost->m_pView->m_viewPage.y > pasHost->viewExtent.y) )
        {
            TRACE_OUT(("VIEWClientExtentChange: client size (%04d, %04d) now bigger than view extent (%04d, %04d)",
                pasHost->m_pView->m_viewPage.x, pasHost->m_pView->m_viewPage.y,
                pasHost->viewExtent.x, pasHost->viewExtent.y));

            //
            // Calculate the ideal size for this window.
            //
            VIEWFrameGetSize(pasHost, &rcl);

            SetWindowPos( pasHost->m_pView->m_viewFrame,
                NULL, 0, 0, rcl.right - rcl.left, rcl.bottom - rcl.top,
                SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
        }

        TRACE_OUT(("VIEWClientExtentChange: Invalidating client area"));
        VIEW_InvalidateRgn(pasHost, NULL);
    }

DC_EXIT_POINT:
    DebugExitVOID(ASShare::VIEWClientExtentChange);
}



//
// VIEWFrameWindowProc()
//
LRESULT CALLBACK VIEWFrameWindowProc
(
    HWND        hwnd,
    UINT        message,
    WPARAM      wParam,
    LPARAM      lParam
)
{
    return(g_asSession.pShare->VIEW_FrameWindowProc(hwnd, message, wParam, lParam));
}


LRESULT ASShare::VIEW_FrameWindowProc
(
    HWND        hwnd,
    UINT        message,
    WPARAM      wParam,
    LPARAM      lParam
)
{
    LRESULT     rc = 0;
    ASPerson *  pasHost;

    DebugEntry(VIEW_FrameWindowProc);

    pasHost = (ASPerson *)GetWindowLongPtr(hwnd, GWLP_USERDATA);
    if (pasHost)
    {
        ValidateView(pasHost);
    }

    switch (message)
    {
        case WM_NCCREATE:
        {
            // Get the passed in host pointer, and set in our window long
            pasHost = (ASPerson *)((LPCREATESTRUCT)lParam)->lpCreateParams;
            SetWindowLongPtr(hwnd, GWLP_USERDATA, (LPARAM)pasHost);

            pasHost->m_pView->m_viewFrame = hwnd;

            //
            // Set the window icon
            //
            SendMessage(hwnd, WM_SETICON, ICON_BIG, (LPARAM)
                ((pasHost->hetCount == HET_DESKTOPSHARED) ?
                  g_hetDeskIcon : g_hetASIcon));
            goto DefWndProc;
            break;
        }

        case WM_NCDESTROY:
        {
            if (pasHost != NULL)
            {
                pasHost->m_pView->m_viewFrame = NULL;
            }

            goto DefWndProc;
            break;
        }

        case WM_CREATE:
        {
            // Set title
            VIEW_HostStateChange(pasHost);

            if (!VIEWFrameCreate(pasHost))
            {
                ERROR_OUT(("VIEWFrameWindowProc: errors in creation handling for [%d]", pasHost->mcsID));
                rc = -1;
            }

            break;
        }

        case WM_DESTROY:
        {
            //
            // Clear menu bar; we always destroy it ourself.
            //
            ::SetMenu(hwnd, NULL);
            break;
        }

        case WM_ACTIVATE:
        {
            //
            // If we're switching back to the view of the host we're in
            // control of, update the key states.
            //
            if (wParam)
            {
                SetFocus(pasHost->m_pView->m_viewClient);
            }
            else
            {
                //
                // If we're full screen but are deactivating, kick out of
                // full screenmode.
                //
                if (pasHost->m_pView->m_viewFullScreen)
                {
                    // Do this later, so title bar state isn't messed up
                    ::PostMessage(hwnd, WM_COMMAND, MAKELONG(CMD_VIEWFULLSCREEN, 0), 0);
                }
            }
            break;
        }

        case WM_ENTERMENULOOP:
        {
            pasHost->m_pView->m_viewInMenuMode = TRUE;
            break;
        }

        case WM_EXITMENULOOP:
        {
            pasHost->m_pView->m_viewInMenuMode = FALSE;
            break;
        }

        case WM_COMMAND:
        {
            VIEWFrameCommand(pasHost, wParam, lParam);
            break;
        }

        case WM_INITMENU:
        {
            if ((HMENU)wParam == pasHost->m_pView->m_viewMenuBar)
            {
                VIEWFrameInitMenuBar(pasHost);
            }
            break;
        }

        case WM_MENUSELECT:
        {
            VIEWFrameOnMenuSelect(pasHost, wParam, lParam);
            break;
        }

        case WM_PALETTECHANGED:
            //
            // The system palette has changed - repaint the window.
            //
            VIEW_InvalidateRgn(pasHost, NULL);

            //
            // The system palette has changed.  If we are not the
            // window that triggered this message then realize our
            // palette now to set up our new palette mapping.
            //
            if ((HWND)wParam == hwnd)
            {
                //
                // If this window caused the change return without
                // realizing our logical palette or we could end up in
                // an infinite loop.
                //
                break;
            }
            TRACE_OUT(("Palette changed - fall through to realize palette (%x)",
                                                           hwnd));

            //
            // Do not break here but FALL THROUGH to the code which
            // realizes the remote palette into this window.  This allows
            // the window to grab some color entries for itself in the new
            // system palette.
            //

        case WM_QUERYNEWPALETTE:
            rc = FALSE;

            if (message == WM_QUERYNEWPALETTE)
            {
                TRACE_OUT(( "WM_QUERYNEWPALETTE hwnd(%x)", hwnd));
            }

            if (g_usrPalettized)
            {
                HDC         hdc;
                HPALETTE    hPalOld;
                UINT        cChangedEntries;

                //
                // Realize this window's palette, and force a repaint
                // if necessary.
                //
                hdc = GetDC(hwnd);
                hPalOld = SelectPalette(hdc, pasHost->pmPalette, FALSE);
                cChangedEntries = RealizePalette(hdc);
                SelectPalette(hdc, hPalOld, FALSE);
                ReleaseDC(hwnd, hdc);

                rc = (cChangedEntries > 0);
                if (rc)
                {
                    // Have to repaint this window
                    VIEW_InvalidateRgn(pasHost, NULL);
                }
            }
            break;

        case WM_GETMINMAXINFO:
        {
            RECT rcFrame;
            LPMINMAXINFO lpmmi = (LPMINMAXINFO) lParam;
            int cx,cy;

            if (!pasHost)
            {
                // We're not created yet; bail.
                break;
            }

            //
            // Calculate the ideal maximized size for this window
            //
            VIEWFrameGetSize(pasHost, &rcFrame);

            //
            // If it's bigger than the local screen, clip it.
            //
            cx = min(rcFrame.right - rcFrame.left, m_pasLocal->cpcCaps.screen.capsScreenWidth);
            cy = min(rcFrame.bottom - rcFrame.top, m_pasLocal->cpcCaps.screen.capsScreenHeight);

            lpmmi->ptMaxSize.x = cx;
            lpmmi->ptMaxSize.y = cy;

            lpmmi->ptMaxTrackSize.x = cx;
            lpmmi->ptMaxTrackSize.y = cy;

            //
            // Make sure that we don't size this window too narrow.  Keep
            // space for borders and one window bar button + scroll ctl.
            //
            lpmmi->ptMinTrackSize.x = 2*::GetSystemMetrics(SM_CXSIZEFRAME) +
                (m_viewItemCX + m_viewEdgeCX) + m_viewItemScrollCX;

            //
            // And prevent sizing too short.  Keep space for borders, menu
            // bar, status bar, and window bar
            //
            lpmmi->ptMinTrackSize.y = 2*::GetSystemMetrics(SM_CYSIZEFRAME) +
                ::GetSystemMetrics(SM_CYCAPTION) + ::GetSystemMetrics(SM_CYMENU);

            if (pasHost->m_pView->m_viewWindowBarOn)
            {
                lpmmi->ptMinTrackSize.y += m_viewWindowBarCY + m_viewEdgeCY;
            }

            if (pasHost->m_pView->m_viewStatusBarOn)
            {
                lpmmi->ptMinTrackSize.y += m_viewStatusBarCY + m_viewEdgeCY;
            }
            break;
        }

        case WM_SIZE:
        {
            if (wParam != SIZE_MINIMIZED)
            {
                VIEWFrameResize(pasHost);
            }
            break;
        }

        default:
DefWndProc:
            rc = DefWindowProc(hwnd, message, wParam, lParam);
            break;

    }

    DebugExitDWORD(ASShare::VIEW_FrameWindowProc, rc);
    return(rc);
}



//
// VIEWFrameCreate()
//
BOOL ASShare::VIEWFrameCreate(ASPerson * pasPerson)
{
    RECT    rect;
    BOOL    rc = FALSE;

    DebugEntry(VIEWFrameCreate);

    ValidateView(pasPerson);

    //
    // Creates the children which lie in the frame's client:
    //      * the toolbar hugs the top
    //      * the statusbar hugs the bottom
    //      * the tray hugs the left underneath the toolbar and above the
    //          statusbar
    //      * the view fills in what's left
    //

    GetClientRect(pasPerson->m_pView->m_viewFrame, &rect);

    //
    // Create the statusbar (hugs bottom)
    //
    pasPerson->m_pView->m_viewStatusBar = ::CreateWindowEx(0, STATUSCLASSNAME,
        NULL, WS_CHILD | WS_VISIBLE | CCS_NOPARENTALIGN | CCS_NOMOVEY | CCS_NORESIZE |
        SBARS_SIZEGRIP,
        rect.left, rect.bottom - m_viewStatusBarCY, rect.right - rect.left,
        m_viewStatusBarCY, pasPerson->m_pView->m_viewFrame, NULL, g_asInstance,
        NULL);
    if (!pasPerson->m_pView->m_viewStatusBar)
    {
        ERROR_OUT(("Couldn't create statusbar for frame of person [%d]", pasPerson->mcsID));
        DC_QUIT;
    }

    rect.bottom -= m_viewStatusBarCY + m_viewEdgeCY;


    //
    // Create the tray (hugs top of status bar, bottom of view)
    // BUT NOT FOR DESKTOP SHARING
    //
    if (pasPerson->hetCount != HET_DESKTOPSHARED)
    {
        pasPerson->m_pView->m_viewWindowBar = ::CreateWindowEx(0,
            VIEW_WINDOWBAR_CLASS_NAME, NULL,
            WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_VISIBLE | WS_CHILD,
            rect.left, rect.bottom - m_viewWindowBarCY,
            rect.right - rect.left, m_viewWindowBarCY,
            pasPerson->m_pView->m_viewFrame, NULL, g_asInstance, pasPerson);
        if (!pasPerson->m_pView->m_viewWindowBar)
        {
            ERROR_OUT(("VIEWFrameCreate: Failed to create window bar"));
            DC_QUIT;
        }

        // Subtract tray space + an edge above it of margin
        rect.bottom -= m_viewWindowBarCY + m_viewEdgeCY;
    }

    //
    // Create the view (takes up rest of client)
    //
    if (!CreateWindowEx(WS_EX_CLIENTEDGE,
            VIEW_CLIENT_CLASS_NAME, NULL,
            WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_VISIBLE | WS_CHILD |
                WS_VSCROLL | WS_HSCROLL,
            rect.left, rect.top,
            rect.right - rect.left, rect.bottom - rect.top,
            pasPerson->m_pView->m_viewFrame,
            NULL, g_asInstance, pasPerson))
    {
        ERROR_OUT(("VIEWFrameCreate: Failed to create view"));
        DC_QUIT;
    }

    rc = TRUE;

DC_EXIT_POINT:
    DebugExitBOOL(ASShare::VIEWFrameCreate, rc);
    return(rc);
}



//
// VIEWFrameResize()
// Repositions the child windows when the frame is resized.
//
void ASShare::VIEWFrameResize(ASPerson * pasPerson)
{
    RECT    rect;

    DebugEntry(ASShare::VIEWFrameResize);

    ValidateView(pasPerson);

    GetClientRect(pasPerson->m_pView->m_viewFrame, &rect);

    //
    // Move the statusbar
    //
    if ((pasPerson->m_pView->m_viewStatusBar != NULL) &&
        (pasPerson->m_pView->m_viewStatusBarOn))
    {
        MoveWindow(pasPerson->m_pView->m_viewStatusBar, rect.left,
            rect.bottom - m_viewStatusBarCY, rect.right - rect.left,
            m_viewStatusBarCY, TRUE);
        rect.bottom -= m_viewStatusBarCY + m_viewEdgeCY;
    }

    //
    // Move the tray
    //
    if ((pasPerson->m_pView->m_viewWindowBar != NULL) &&
        (pasPerson->m_pView->m_viewWindowBarOn))
    {
        MoveWindow(pasPerson->m_pView->m_viewWindowBar, rect.left,
            rect.bottom - m_viewWindowBarCY, rect.right - rect.left,
            m_viewWindowBarCY, TRUE);
        rect.bottom -= m_viewWindowBarCY + m_viewEdgeCY;
    }

    //
    // Move the view
    //
    MoveWindow(pasPerson->m_pView->m_viewClient, rect.left, rect.top,
        rect.right - rect.left, rect.bottom - rect.top, TRUE);

    DebugExitVOID(ASShare::VIEWFrameResize);
}



//
// VIEWFrameResizeChanged()
//
// Called when the widgets of the frame (the status bar, the window bar, etc.)
// come or go.  We may need to shrink the window, if the view is going
// to end up being bigger than the host's desktop.
//
void ASShare::VIEWFrameResizeChanged(ASPerson * pasHost)
{
    RECT            rcView;

    DebugEntry(ASShare::VIEWFrameResizeChanged);

    // Get current view size
    GetClientRect(pasHost->m_pView->m_viewClient, &rcView);

    //
    // The view area can't be bigger than the remote's desktop area
    //
    if ((rcView.bottom - rcView.top)  >= pasHost->viewExtent.y)
    {
        RECT            rcWindowCur;
        RECT            rcWindowMax;

        // Get current frame size
        GetWindowRect(pasHost->m_pView->m_viewFrame, &rcWindowCur);

        // Get maximum frame size
        VIEWFrameGetSize(pasHost, &rcWindowMax);

        // Resize vertically to just hold everything
        SetWindowPos(pasHost->m_pView->m_viewFrame, NULL, 0, 0,
            rcWindowCur.right - rcWindowCur.left,
            rcWindowMax.bottom - rcWindowMax.top,
            SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOZORDER);
    }
    else
    {
        // We can stay the same size, and just shuffle the pieces around
        VIEWFrameResize(pasHost);
    }

    DebugExitVOID(ASShare::VIEWFrameResizeChanged);
}



//
// VIEWFrameCommand()
//
// Handles commands from menus/accelerators for frame views
//
void ASShare::VIEWFrameCommand
(
    ASPerson*   pasHost,
    WPARAM      wParam,
    LPARAM      lParam
)
{
    UINT            cmd;
    MENUITEMINFO    mi;

    DebugEntry(ASShare::VIEWFrameCommand);

    ValidateView(pasHost);

    cmd = GET_WM_COMMAND_ID(wParam, lParam);
    switch (cmd)
    {
        case CMD_TAKECONTROL:
        {
            CA_TakeControl(pasHost);
            break;
        }

        case CMD_CANCELCONTROL:
        {
            CA_CancelTakeControl(pasHost, TRUE);
            break;
        }

        case CMD_RELEASECONTROL:
        {
            CA_ReleaseControl(pasHost, TRUE);
            break;
        }

        case CMD_CTRLALTDEL:
        {
            AWC_SendMsg(pasHost->mcsID, AWC_MSG_SAS, 0, 0);
            break;
        }

        case CMD_VIEWSTATUSBAR:
        {
            ASSERT(::IsWindow(pasHost->m_pView->m_viewStatusBar));

            // Toggle show/hide of status bar, then resize
            if (pasHost->m_pView->m_viewStatusBarOn)
            {
                pasHost->m_pView->m_viewStatusBarOn = FALSE;
                ::ShowWindow(pasHost->m_pView->m_viewStatusBar, SW_HIDE);
            }
            else
            {
                pasHost->m_pView->m_viewStatusBarOn = TRUE;
                ::ShowWindow(pasHost->m_pView->m_viewStatusBar, SW_SHOW);
            }

            VIEWFrameResizeChanged(pasHost);
            break;
        }

        case CMD_VIEWWINDOWBAR:
        {
            ASSERT(::IsWindow(pasHost->m_pView->m_viewWindowBar));

            // Toggle show/hide of window bar, then resize
            if (pasHost->m_pView->m_viewWindowBarOn)
            {
                pasHost->m_pView->m_viewWindowBarOn = FALSE;
                ::ShowWindow(pasHost->m_pView->m_viewWindowBar, SW_HIDE);
            }
            else
            {
                pasHost->m_pView->m_viewWindowBarOn = TRUE;
                ::ShowWindow(pasHost->m_pView->m_viewWindowBar, SW_SHOW);
            }

            VIEWFrameResizeChanged(pasHost);
            break;
        }

        case CMD_VIEWFULLSCREEN:
        {
            VIEWFrameFullScreen(pasHost, (pasHost->m_pView->m_viewFullScreen == 0));
            break;
        }

        case CMD_HELPTOPICS:
        {
            VIEWFrameHelp(pasHost);
            break;
        }

        case CMD_HELPABOUT:
        {
            VIEWFrameAbout(pasHost);
            break;
        }

        default:
        {
            if ((cmd >= CMD_APPSTART) && (cmd < CMD_APPMAX))
            {
                if ((pasHost->m_caControlledBy == m_pasLocal) &&
                    !pasHost->m_caControlPaused)
                {
                    //
                    // This is a request to activate a host window.
                    // Get the item data, the remote HWND, then look to see
                    // if it's still on the tray.
                    //
                    ZeroMemory(&mi, sizeof(mi));
                    mi.cbSize   = sizeof(mi);
                    mi.fMask    = MIIM_DATA;
                    GetMenuItemInfo(GetSubMenu(pasHost->m_pView->m_viewMenuBar,
                        IDSM_WINDOW), cmd, FALSE, &mi);
                    if (!mi.dwItemData)
                    {
                        ERROR_OUT(("No item data for command %d", cmd));
                    }
                    else
                    {
                        PWNDBAR_ITEM pItem;

                        COM_BasedListFind(LIST_FIND_FROM_FIRST,
                            &(pasHost->m_pView->m_viewWindowBarItems),
                            (void**)&pItem, FIELD_OFFSET(WNDBAR_ITEM, chain),
                            FIELD_OFFSET(WNDBAR_ITEM, winIDRemote),
                            mi.dwItemData, FIELD_SIZE(WNDBAR_ITEM, winIDRemote));
                        if (pItem)
                        {
                            VIEWWindowBarDoActivate(pasHost, pItem);
                        }
                    }
                }
            }
            else if ((cmd >= CMD_FORWARDCONTROLSTART) && (cmd < CMD_FORWARDCONTROLMAX))
            {
                if ((pasHost->m_caControlledBy == m_pasLocal) &&
                    !pasHost->m_caControlPaused)
                {
                    //
                    // This is a request to pass control.  Get the item data,
                    // the remote's MCS ID, then look to see if this person is
                    // still in the share.  If so, pass control to them.
                    //
                    ZeroMemory(&mi, sizeof(mi));
                    mi.cbSize   = sizeof(mi);
                    mi.fMask    = MIIM_DATA;
                    GetMenuItemInfo(GetSubMenu(GetSubMenu(pasHost->m_pView->m_viewMenuBar,
                        IDSM_CONTROL), POS_FORWARDCONTROLCMD), cmd, FALSE, &mi);
                    if (!mi.dwItemData)
                    {
                        ERROR_OUT(("No item data for command %d", cmd));
                    }
                    else
                    {
                        ASPerson * pasT;

                        if (SC_ValidateNetID((MCSID)mi.dwItemData, &pasT))
                        {
                            CA_PassControl(pasHost, pasT);
                        }
                    }
                }
            }
            else
            {
                ERROR_OUT(("Unrecognized WM_COMMAND id"));
            }
            break;
        }
    }

    DebugExitVOID(ASShare::VIEWFrameCommand);
}



//
// ASShare::VIEWFrameInitMenuBar()
//
void ASShare::VIEWFrameInitMenuBar(ASPerson*   pasHost)
{
    HMENU       hMenu;
    HMENU       hSubMenu;
    int         iItem;
    MENUITEMINFO    mi;
    UINT        cmd;
    UINT        ids;
    UINT        flags;
    char        szItem[256];

    DebugEntry(ASShare::VIEWFrameInitMenu);

    ValidateView(pasHost);
    hMenu = pasHost->m_pView->m_viewMenuBar;
    ASSERT(hMenu);

    //
    // CONTROL MENU
    //

    cmd = CMD_TAKECONTROL;
    ids = IDS_CMD_TAKECONTROL;
    flags = MF_ENABLED;

    if (pasHost->m_caControlledBy == m_pasLocal)
    {
        ASSERT(pasHost->m_caAllowControl);

        cmd = CMD_RELEASECONTROL;
        ids = IDS_CMD_RELEASECONTROL;

        //
        // If the remote is unattended and we're in control, no releasing.
        //
        if (pasHost->cpcCaps.general.typeFlags & AS_UNATTENDED)
            flags = MF_GRAYED;
    }
    else if ((m_caWaitingForReplyFrom == pasHost) &&
             (m_caWaitingForReplyMsg == CA_REPLY_REQUEST_TAKECONTROL))
    {
        ASSERT(pasHost->m_caAllowControl);

        cmd = CMD_CANCELCONTROL;
        ids = IDS_CMD_CANCELCONTROL;
    }
    else if (!pasHost->m_caAllowControl || pasHost->m_caControlledBy)
    {
        //
        // Host isn't allowing control, or somebody else is in control right
        // now.
        //
        flags = MF_GRAYED;
    }
    flags |= MF_STRING | MF_BYPOSITION;

    ::LoadString(g_asInstance, ids, szItem, sizeof(szItem));

    hSubMenu = GetSubMenu(hMenu, IDSM_CONTROL);
    ModifyMenu(hSubMenu, POS_CONTROLCMD, flags, cmd, szItem);

    //
    // If we're in control, and there's another 3.0 dude in the conference,
    // enable PassControl and build the popup.
    //
    EnableMenuItem(hSubMenu, POS_FORWARDCONTROLCMD, MF_GRAYED | MF_BYPOSITION);
    if ((pasHost->m_caControlledBy == m_pasLocal)   &&
        !pasHost->m_caControlPaused                 &&
        (pasHost->cpcCaps.general.version >= CAPS_VERSION_30))
    {
        ASPerson *  pasT;
        HMENU       hPassMenu;

        hPassMenu = GetSubMenu(hSubMenu, POS_FORWARDCONTROLCMD);
        ASSERT(IsMenu(hPassMenu));

        //
        // Delete existing items.
        //
        iItem = GetMenuItemCount(hPassMenu);
        while (iItem > 0)
        {
            iItem--;
            DeleteMenu(hPassMenu, iItem, MF_BYPOSITION);
        }

        //
        // Add items for the other 3.0 nodes besides us & the host.
        //
        iItem = CMD_FORWARDCONTROLSTART;
        pasT = m_pasLocal->pasNext;
        while (pasT != NULL)
        {
            if ((pasT != pasHost) &&
                (pasT->cpcCaps.general.version >= CAPS_VERSION_30))
            {
                //
                // This dude is a candidate.  We must store the MCS IDs since the
                // any person could go away while we're in menu mode.
                //
                ZeroMemory(&mi, sizeof(mi));
                mi.cbSize       = sizeof(mi);
                mi.fMask        = MIIM_ID | MIIM_STATE | MIIM_TYPE | MIIM_DATA;
                mi.fType        = MFT_STRING;
                mi.fState       = MFS_ENABLED;
                mi.wID          = iItem;
                mi.dwItemData   = pasT->mcsID;
                mi.dwTypeData   = pasT->scName;
                mi.cch          = lstrlen(pasT->scName);

                //
                // Append this to the menu
                //
                InsertMenuItem(hPassMenu, -1, TRUE, &mi);

                iItem++;
            }

            pasT = pasT->pasNext;
        }

        //
        // Enable the Pass Control submenu if there's somebody on the
        // menu.
        //
        if (iItem != CMD_FORWARDCONTROLSTART)
        {
            EnableMenuItem(hSubMenu, POS_FORWARDCONTROLCMD, MF_ENABLED | MF_BYPOSITION);
        }
    }


    //
    // APPLICATIONS MENU
    //
    if ((pasHost->hetCount != HET_DESKTOPSHARED)  &&
        (pasHost->m_caControlledBy == m_pasLocal) &&
        !pasHost->m_caControlPaused)
    {
        PWNDBAR_ITEM pItem;

        hSubMenu = GetSubMenu(hMenu, IDSM_WINDOW);

        //
        // Delete existing items.
        //
        iItem = GetMenuItemCount(hSubMenu);
        while (iItem > 0)
        {
            iItem--;
            DeleteMenu(hSubMenu, iItem, MF_BYPOSITION);
        }

        //
        // Add window bar items.
        //
        iItem = CMD_APPSTART;
        pItem = (PWNDBAR_ITEM)COM_BasedListFirst(&(pasHost->m_pView->m_viewWindowBarItems),
            FIELD_OFFSET(WNDBAR_ITEM, chain));
        while (pItem && (iItem < CMD_APPMAX))
        {
            ZeroMemory(&mi, sizeof(mi));
            mi.cbSize       = sizeof(mi);
            mi.fMask        = MIIM_ID | MIIM_STATE | MIIM_TYPE | MIIM_DATA;
            mi.fType        = MFT_STRING;

            mi.fState       = MFS_ENABLED;
            if (pItem == pasHost->m_pView->m_viewWindowBarActiveItem)
            {
                mi.fState |= MFS_CHECKED;
            }

            mi.wID          = iItem;
            mi.dwItemData   = pItem->winIDRemote;
            mi.dwTypeData   = pItem->szText;
            mi.cch          = lstrlen(pItem->szText);

            //
            // Append this to the menu
            //
            InsertMenuItem(hSubMenu, -1, TRUE, &mi);

            iItem++;
            pItem = (PWNDBAR_ITEM)COM_BasedListNext(&(pasHost->m_pView->m_viewWindowBarItems),
                pItem, FIELD_OFFSET(WNDBAR_ITEM, chain));
        }

        if (iItem == CMD_APPSTART)
        {
            char    szBlank[128];

            //
            // Append a disabled, blank item
            //
            ZeroMemory(&mi, sizeof(mi));
            mi.cbSize   = sizeof(mi);
            mi.fMask    = MIIM_ID | MIIM_STATE | MIIM_TYPE;
            mi.fType    = MFT_STRING;
            mi.fState   = MFS_DISABLED;
            mi.wID      = iItem;

            LoadString(g_asInstance, IDS_CMD_BLANKPROGRAM, szBlank, sizeof(szBlank));
            mi.dwTypeData   = szBlank;
            mi.cch          = lstrlen(szBlank);

            InsertMenuItem(hSubMenu, -1, TRUE, &mi);
        }
    }

    //
    // VIEW MENU
    //

    // Status bar
    ASSERT(::IsWindow(pasHost->m_pView->m_viewStatusBar));
    if (pasHost->m_pView->m_viewStatusBarOn)
    {
        ::CheckMenuItem(hMenu, CMD_VIEWSTATUSBAR, MF_CHECKED | MF_BYCOMMAND);
    }
    else
    {
        ::CheckMenuItem(hMenu, CMD_VIEWSTATUSBAR, MF_UNCHECKED | MF_BYCOMMAND);
    }

    // Window bar
    if (!pasHost->m_pView->m_viewWindowBar)
    {
        ::EnableMenuItem(hMenu, CMD_VIEWWINDOWBAR, MF_GRAYED | MF_BYCOMMAND);
    }
    else if (pasHost->m_pView->m_viewWindowBarOn)
    {
        ::CheckMenuItem(hMenu, CMD_VIEWWINDOWBAR, MF_CHECKED | MF_BYCOMMAND);
    }
    else
    {
        ::CheckMenuItem(hMenu, CMD_VIEWWINDOWBAR, MF_UNCHECKED | MF_BYCOMMAND);
    }

    DebugExitVOID(ASShare::VIEWFrameInitMenu);
}




//
// VIEWFrameOnMenuSelect()
//
void ASShare::VIEWFrameOnMenuSelect
(
    ASPerson *      pasHost,
    WPARAM          wParam,
    LPARAM          lParam
)
{
    HMENU           hMenu;
    int             uItem;
    UINT            flags;
    UINT            idsStatus = IDS_STATUS_NONE;

    DebugEntry(ASShare::VIEWFrameOnMenuSelect);

    //
    // Extract the params out (menuselect is messy)
    //
    hMenu   = (HMENU)lParam;
    uItem   = (int)LOWORD(wParam);
    if ((short)HIWORD(wParam) == -1)
    {
        flags = 0xFFFFFFFF;
    }
    else
    {
        flags = HIWORD(wParam);
    }

    if ((LOWORD(flags) == 0xFFFF) && !hMenu)
    {
        // Menu mode is ending.  Put back original status.
        idsStatus = pasHost->m_pView->m_viewStatus;
        DC_QUIT;
    }

    if (!(flags & MF_POPUP))
    {
        if (flags & MF_SEPARATOR)
        {
            // No status
        }
        else if (flags & MF_SYSMENU)
        {
            // No status
        }
        else if ((uItem >= CMD_APPSTART) && (uItem < CMD_APPMAX))
        {
            // One of an unbounded set of items in the Window popup
            idsStatus = IDS_STATUS_CMDS_APP;
        }
        else if ((uItem >= CMD_FORWARDCONTROLSTART) && (uItem < CMD_FORWARDCONTROLMAX))
        {
            // One of an unbounded set of items in the Forward Control popup
            idsStatus = IDS_STATUS_CMDS_FORWARD;
        }
        else
        {
            // A normal command, just add offset to CMD id
            idsStatus = uItem + IDS_STATUS_CMD_START;
        }
    }
    else
    {
        // This is a popup menu
        if (hMenu == pasHost->m_pView->m_viewMenuBar)
        {
            // It's a popup from the top level menu bar.  uItem is the index
            switch (uItem)
            {
                case IDSM_CONTROL:
                    idsStatus = IDS_STATUS_MENU_CONTROL;
                    break;

                case IDSM_VIEW:
                    idsStatus = IDS_STATUS_MENU_VIEW;
                    break;

                case IDSM_WINDOW:
                    idsStatus = IDS_STATUS_MENU_WINDOW;
                    break;

                case IDSM_HELP:
                    idsStatus = IDS_STATUS_MENU_HELP;
                    break;

                default:
                    ERROR_OUT(("AS: Unknown submenu index %d of frame", uItem));
                    break;
            }
        }
        else if (hMenu == GetSubMenu(pasHost->m_pView->m_viewMenuBar, IDSM_CONTROL))
        {
            // This is a popup off the Control menu.  The only one we have is Forward
            idsStatus = IDS_STATUS_MENU_FORWARDCONTROL;
        }
        else if (flags & MF_SYSMENU)
        {
            // System menu
        }
    }

DC_EXIT_POINT:
    VIEWFrameSetStatus(pasHost, idsStatus);

    DebugEntry(ASShare::VIEWFrameOnMenuSelect);
}


//
// VIEWFrameHelp()
//
void ASShare::VIEWFrameHelp(ASPerson * pasHost)
{
    DebugEntry(ASShare::VIEWFrameHelp);

    ShowNmHelp(s_cszHtmlHelpFile);

    DebugExitVOID(ASShare::VIEWFrameHelp);
}



//
// VIEWFrameAbout()
//
void ASShare::VIEWFrameAbout(ASPerson * pasHost)
{
    DebugEntry(ASShare::VIEWFrameAbout);

    //
    // We make use of the standard centered-disabled-goes-away properly
    // VIEW_Message() stuff.
    //
    VIEW_Message(pasHost, IDS_ABOUT);

    DebugExitVOID(ASShare::VIEWFrameAbout);
}




//
// VIEWFrameGetSize()
// This returns back a rectangle for the ideal size of the frame.  It will
// fit the view, menu, tools, tray, status, etc.
//
void ASShare::VIEWFrameGetSize(ASPerson * pasPerson, LPRECT lprc)
{
    DebugEntry(ASShare::VIEWFrameGetSize);

    ValidateView(pasPerson);

    VIEWClientGetSize(pasPerson, lprc);

    //
    // Add in space for tray.
    // NOTE that for DESKTOP SHARING we don't have a tray
    //
    if (pasPerson->m_pView->m_viewWindowBarOn)
    {
        lprc->bottom += m_viewWindowBarCY + m_viewEdgeCY;
    }

    //
    // Add in space for statusbar if it's on, etc.
    //
    if (pasPerson->m_pView->m_viewStatusBarOn)
    {
        lprc->bottom += m_viewStatusBarCY + m_viewEdgeCY;
    }

    if (!pasPerson->m_pView->m_viewFullScreen)
    {
        //
        // Adjust for frame styles including menu bar.
        //
        AdjustWindowRectEx(lprc, WS_OVERLAPPEDWINDOW, TRUE, WS_EX_WINDOWEDGE);
    }

    DebugExitVOID(ASShare::VIEWFrameGetSize);
}




//
// VIEWFrameFullScreen()
//
// This puts into or out of screen mode.  We remove all the frame goop
// including scrollbars, so that the view area is identical to the screen.
//
void ASShare::VIEWFrameFullScreen(ASPerson * pasPerson, BOOL fFull)
{
    LONG    lStyle;
    RECT    rcNew;

    DebugEntry(ASShare::VIEWFrameFullScreen);

    //
    // Turn redraw OFF
    //
    ::SendMessage(pasPerson->m_pView->m_viewFrame, WM_SETREDRAW, FALSE, 0);

    if (fFull)
    {
        //
        // We're going into full screen mode.
        //

        ASSERT(!pasPerson->m_pView->m_viewFullScreen);
        pasPerson->m_pView->m_viewFullScreen = TRUE;

        //
        // Save old window rect
        //
        ::GetWindowRect(pasPerson->m_pView->m_viewFrame,
            &pasPerson->m_pView->m_viewSavedWindowRect);

        //
        // Save old scroll pos and set to the origin.  Do this BEFORE
        // clearing style bits.
        //
        pasPerson->m_pView->m_viewSavedPos = pasPerson->m_pView->m_viewPos;
        VIEWClientScroll(pasPerson, 0, 0);

        //
        // Save current status bar state before turning it off temporarily.
        //
        if (pasPerson->m_pView->m_viewStatusBarOn)
        {
            pasPerson->m_pView->m_viewSavedStatusBarOn = TRUE;
            pasPerson->m_pView->m_viewStatusBarOn = FALSE;
            ::ShowWindow(pasPerson->m_pView->m_viewStatusBar, SW_HIDE);
        }
        else
        {
            pasPerson->m_pView->m_viewSavedStatusBarOn = FALSE;
        }

        //
        // Save current window bar state before turning it off temporarily.
        //
        if (pasPerson->m_pView->m_viewWindowBarOn)
        {
            pasPerson->m_pView->m_viewSavedWindowBarOn = TRUE;
            pasPerson->m_pView->m_viewWindowBarOn = FALSE;
            ::ShowWindow(pasPerson->m_pView->m_viewWindowBar, SW_HIDE);
        }
        else
        {
            pasPerson->m_pView->m_viewSavedWindowBarOn = FALSE;
        }

        //
        // Remove all frame and client bits.
        //
        lStyle = ::GetWindowLong(pasPerson->m_pView->m_viewFrame, GWL_EXSTYLE);
        lStyle &= ~WS_EX_WINDOWEDGE;
        ::SetWindowLong(pasPerson->m_pView->m_viewFrame, GWL_EXSTYLE, lStyle);

        lStyle = ::GetWindowLong(pasPerson->m_pView->m_viewFrame, GWL_STYLE);
        lStyle &= ~(WS_CAPTION | WS_THICKFRAME);
        lStyle |= WS_POPUP;
        ::SetWindowLong(pasPerson->m_pView->m_viewFrame, GWL_STYLE, lStyle);

        lStyle = ::GetWindowLong(pasPerson->m_pView->m_viewClient, GWL_EXSTYLE);
        lStyle &= ~WS_EX_CLIENTEDGE;
        ::SetWindowLong(pasPerson->m_pView->m_viewClient, GWL_EXSTYLE, lStyle);

        lStyle = ::GetWindowLong(pasPerson->m_pView->m_viewClient, GWL_STYLE);
        lStyle &= ~(WS_HSCROLL | WS_VSCROLL);
        ::SetWindowLong(pasPerson->m_pView->m_viewClient, GWL_STYLE, lStyle);

        //
        // Remove the menu bar
        //
        ::SetMenu(pasPerson->m_pView->m_viewFrame, NULL);

        //
        // Set up to size window the size of the screen.
        //
        rcNew.left      = 0;
        rcNew.top       = 0;
        rcNew.right     = m_pasLocal->cpcCaps.screen.capsScreenWidth;
        rcNew.bottom    = m_pasLocal->cpcCaps.screen.capsScreenHeight;

        //
        // Create the moveable escape-out button in the lower right corner.
        //
        ::CreateWindowEx(0, VIEW_FULLEXIT_CLASS_NAME, NULL,
            WS_CHILD | WS_VISIBLE,
            rcNew.right - m_viewFullScreenCX - 2*m_viewEdgeCX,
            rcNew.top +  2*m_viewEdgeCY,
            m_viewFullScreenCX, m_viewFullScreenCY,
            pasPerson->m_pView->m_viewClient,
            (HMENU)0,
            g_asInstance,
            pasPerson);
    }
    else
    {
        //
        // We're coming out of full screen mode.
        //

        //
        // Destroy the escape-out button
        //
        ::DestroyWindow(::GetDlgItem(pasPerson->m_pView->m_viewClient, 0));

        //
        // Put back the menu bar.  Do this BEFORE clearing the full screen bit
        //
        ::SetMenu(pasPerson->m_pView->m_viewFrame, pasPerson->m_pView->m_viewMenuBar);

        ASSERT(pasPerson->m_pView->m_viewFullScreen);
        pasPerson->m_pView->m_viewFullScreen = FALSE;


        //
        // Put back old status bar state.
        //
        if (pasPerson->m_pView->m_viewSavedStatusBarOn)
        {
            pasPerson->m_pView->m_viewStatusBarOn = TRUE;
            ::ShowWindow(pasPerson->m_pView->m_viewStatusBar, SW_SHOW);
        }

        //
        // Put back old window bar state.
        //
        if (pasPerson->m_pView->m_viewSavedWindowBarOn)
        {
            pasPerson->m_pView->m_viewWindowBarOn = TRUE;
            ::ShowWindow(pasPerson->m_pView->m_viewWindowBar, SW_SHOW);
        }

        //
        // Add back all frame and client bits.
        //
        lStyle = ::GetWindowLong(pasPerson->m_pView->m_viewFrame, GWL_EXSTYLE);
        lStyle |= WS_EX_WINDOWEDGE;
        ::SetWindowLong(pasPerson->m_pView->m_viewFrame, GWL_EXSTYLE, lStyle);

        lStyle = ::GetWindowLong(pasPerson->m_pView->m_viewFrame, GWL_STYLE);
        lStyle &= ~(WS_POPUP);
        lStyle |= (WS_CAPTION | WS_THICKFRAME);
        ::SetWindowLong(pasPerson->m_pView->m_viewFrame, GWL_STYLE, lStyle);

        lStyle = ::GetWindowLong(pasPerson->m_pView->m_viewClient, GWL_EXSTYLE);
        lStyle |= WS_EX_CLIENTEDGE;
        ::SetWindowLong(pasPerson->m_pView->m_viewClient, GWL_EXSTYLE, lStyle);

        lStyle = ::GetWindowLong(pasPerson->m_pView->m_viewClient, GWL_STYLE);
        lStyle |= (WS_HSCROLL | WS_VSCROLL);
        ::SetWindowLong(pasPerson->m_pView->m_viewClient, GWL_STYLE, lStyle);

        //
        // Put back old scroll pos AFTER style bits restore.
        //
        VIEWClientScroll(pasPerson, pasPerson->m_pView->m_viewSavedPos.x,
            pasPerson->m_pView->m_viewSavedPos.y);

        //
        // Restore the window back to where it started.
        //
        rcNew = pasPerson->m_pView->m_viewSavedWindowRect;
    }

    //
    // Resize, reframe, and repaint from scratch.
    //
    ::SendMessage(pasPerson->m_pView->m_viewFrame, WM_SETREDRAW, TRUE, 0);

    ::SetWindowPos(pasPerson->m_pView->m_viewFrame, NULL, rcNew.left,
        rcNew.top, rcNew.right - rcNew.left, rcNew.bottom - rcNew.top,
        SWP_NOZORDER | SWP_NOACTIVATE | SWP_FRAMECHANGED | SWP_NOCOPYBITS);

    DebugExitVOID(ASShare::VIEWFrameFullScreen);
}



//
// VIEWClientGetSize()
// This returns back a rectangle for the ideal size of the view part of the
// frame client.  It will fit the extent of what we're viewing on the remote
// plus scrollbars.
//
void ASShare::VIEWClientGetSize(ASPerson * pasPerson, LPRECT lprc)
{
    DebugEntry(ASShare::VIEWClientGetSize);

    ValidateView(pasPerson);

    lprc->left  = 0;
    lprc->top   = 0;
    lprc->right = pasPerson->viewExtent.x;
    lprc->bottom = pasPerson->viewExtent.y;

    if (!pasPerson->m_pView->m_viewFullScreen)
    {
        AdjustWindowRectEx(lprc, WS_CHILD, FALSE, WS_EX_CLIENTEDGE);

        lprc->right += GetSystemMetrics(SM_CXVSCROLL);
        lprc->bottom += GetSystemMetrics(SM_CYHSCROLL);
    }

    DebugExitVOID(ASShare::VIEWClientGetSize);
}


//
// VIEWClientWindowProc()
// Handles messages for the view window, a child in the client of the frame
// which displays the contents of the remote host's shared apps.
//
LRESULT CALLBACK VIEWClientWindowProc
(
    HWND        hwnd,
    UINT        message,
    WPARAM      wParam,
    LPARAM      lParam
)
{
    return(g_asSession.pShare->VIEW_ViewWindowProc(hwnd, message, wParam, lParam));
}


LRESULT ASShare::VIEW_ViewWindowProc
(
    HWND        hwnd,
    UINT        message,
    WPARAM      wParam,
    LPARAM      lParam
)
{
    LRESULT     rc = 0;
    RECT        rcl;
    POINT       mousePos;
    SCROLLINFO  si;
    ASPerson *  pasPerson;

    DebugEntry(ASShare::VIEW_ViewWindowProc);

    pasPerson = (ASPerson *)GetWindowLongPtr(hwnd, GWLP_USERDATA);
    if (pasPerson)
    {
        ValidateView(pasPerson);
    }

    switch (message)
    {
        case WM_NCCREATE:
        {
            // Get the passed in host pointer, and set in our window long
            pasPerson = (ASPerson *)((LPCREATESTRUCT)lParam)->lpCreateParams;
            SetWindowLongPtr(hwnd, GWLP_USERDATA, (LPARAM)pasPerson);

            pasPerson->m_pView->m_viewClient = hwnd;
            goto DefWndProc;
            break;
        }

        case WM_NCDESTROY:
        {
            if (pasPerson != NULL)
            {
                pasPerson->m_pView->m_viewClient = NULL;
            }

            goto DefWndProc;
            break;
        }

        case WM_ERASEBKGND:
        {
            //
            // BOGUS LAURABU:  Paint on erase then validate for faster
            // response.

            //
            rc = TRUE;
            break;
        }

        case WM_PAINT:
        {
            VIEWClientPaint(pasPerson);
            break;
        }

        case WM_SETFOCUS:
        {
            pasPerson->m_pView->m_viewFocus = TRUE;
            pasPerson->m_pView->m_viewMouseWheelDelta = 0;
            break;
        }

        case WM_KILLFOCUS:
        {
            pasPerson->m_pView->m_viewFocus = FALSE;
            pasPerson->m_pView->m_viewMouseWheelDelta = 0;
            break;
        }

        case WM_LBUTTONDOWN:
        case WM_RBUTTONDOWN:
        case WM_MBUTTONDOWN:
        {
            VIEWClientMouseDown(pasPerson, message, wParam, lParam);
            break;
        }

        case WM_LBUTTONUP:
        case WM_RBUTTONUP:
        case WM_MBUTTONUP:
        {
            VIEWClientMouseUp(pasPerson, message, wParam, lParam, TRUE);
            break;
        }

        case WM_MOUSEMOVE:
        {
            VIEWClientMouseMove(pasPerson, message, wParam, lParam);
            break;
        }

        case WM_MOUSEWHEEL:
        {
            //
            // We've handled it no matter what, don't pass it up the chain.
            //
            rc = TRUE;

            //
            // If we're not controlling this dude, try to use the mousewheel
            // to scroll.
            //
            if ((pasPerson->m_caControlledBy != m_pasLocal) ||
                pasPerson->m_caControlPaused)
            {
                VIEWClientMouseWheel(pasPerson, wParam, lParam);
                break;
            }

            //
            // FALL THROUGH
            // Otherwise, we send the MOUSEWHEEL message to the host.
            //
        }

        case WM_LBUTTONDBLCLK:
        case WM_RBUTTONDBLCLK:
        case WM_MBUTTONDBLCLK:
        {
            VIEWClientMouseMsg(pasPerson, message, wParam, lParam);
            break;
        }

        case WM_TIMER:
        {
            if (wParam == IDT_AUTOSCROLL)
            {
                VIEWClientAutoScroll(pasPerson);
            }
            break;
        }

        case WM_CAPTURECHANGED:
        {
            //
            // Check if capture got stolen away from us, if we think the
            // buttons are down fake a button up.
            //
            if (pasPerson->m_pView->m_viewMouseFlags != 0)
            {
                VIEWClientCaptureStolen(pasPerson);
            }
            break;
        }

        case WM_KEYDOWN:
        {
            WPARAM  wScrollNotify;
            UINT    uMsg;

            if ((pasPerson->m_caControlledBy == m_pasLocal) &&
                !pasPerson->m_caControlPaused)
            {
                goto KeyInput;
            }

            if (pasPerson->m_pView->m_viewFullScreen)
            {
                if (wParam == VK_ESCAPE)
                {
                    //
                    // Kick out of full screen mode.
                    //
                    VIEWFrameFullScreen(pasPerson, FALSE);
                }

                goto DefWndProc;
            }

            //
            // UP, DOWN, LEFT, and RIGHT are unambiguous about which
            // scrollbar is intended.
            //
            // For the others, unmodified is vertical and SHIFT is
            // horizontal.
            //
            if (::GetKeyState(VK_SHIFT) < 0)
            {
                uMsg = WM_HSCROLL;
            }
            else
            {
                uMsg = WM_VSCROLL;
            }

            switch (wParam)
            {
                //
                // These aren't ambiguous, we know which scrollbar is meant
                // by the direction.
                //
                case VK_UP:
                    wScrollNotify = SB_LINEUP;
                    uMsg = WM_VSCROLL;
                    break;

                case VK_DOWN:
                    wScrollNotify = SB_LINEDOWN;
                    uMsg = WM_VSCROLL;
                    break;

                case VK_LEFT:
                    wScrollNotify = SB_LINEUP;
                    uMsg = WM_HSCROLL;
                    break;

                case VK_RIGHT:
                    wScrollNotify = SB_LINEDOWN;
                    uMsg = WM_HSCROLL;
                    break;

                //
                // These are ambiguous, hence the SHIFT key as a
                // modifier.
                //
                case VK_PRIOR:
                    wScrollNotify = SB_PAGEUP;
                    break;

                case VK_NEXT:
                    wScrollNotify = SB_PAGEDOWN;
                    break;

                case VK_HOME:
                    wScrollNotify = SB_TOP;
                    break;

                case VK_END:
                    wScrollNotify = SB_BOTTOM;
                    break;

                default:
                    goto DefWndProc;
                    break;
            }

            SendMessage(hwnd, uMsg, MAKELONG(wScrollNotify, 0), 0L);
            break;
        }

        case WM_SYSKEYDOWN:
        {
            if ((pasPerson->m_caControlledBy == m_pasLocal) &&
                !pasPerson->m_caControlPaused)
            {
                goto KeyInput;
            }

            //
            // ALT-ENTER toggles full screen state, if it's available
            //
            if ((wParam == VK_RETURN) &&
                !(::GetMenuState(pasPerson->m_pView->m_viewMenuBar,
                CMD_VIEWFULLSCREEN, MF_BYCOMMAND) & MF_DISABLED))
            {
                VIEWFrameFullScreen(pasPerson,
                    (pasPerson->m_pView->m_viewFullScreen == 0));
            }
            goto DefWndProc;
            break;
        }


        case WM_KEYUP:
        case WM_SYSKEYUP:
        {
            //
            // If we're controlling this node, pass it along.  Otherwise,
            // call DefWindowProc() so key accels like Alt+Space for system
            // menu will kick in.
            //
            if ((pasPerson->m_caControlledBy == m_pasLocal) &&
                !pasPerson->m_caControlPaused)
            {
KeyInput:
                IM_OutgoingKeyboardInput(pasPerson, (UINT)wParam, (UINT)lParam);
            }
            else
            {
                goto DefWndProc;
            }
            break;
        }

        case WM_SETCURSOR:
        {
            if ((LOWORD(lParam) == HTCLIENT) && ((HWND)wParam == hwnd))
            {
                HCURSOR hCursor;
                POINT   cursorPoint;

                if ((pasPerson->m_caControlledBy == m_pasLocal) &&
                    !pasPerson->m_caControlPaused)
                {
                    hCursor = m_cmArrowCursor;

                    //
                    // Only set the remote cursor if we're over shared space.
                    //
                    if (pasPerson->m_pView->m_viewFocus)
                    {
                        GetCursorPos(&cursorPoint);
                        ScreenToClient(hwnd, &cursorPoint);

                        if (VIEW_IsPointShared(pasPerson, cursorPoint))
                        {
                            hCursor = pasPerson->cmhRemoteCursor;
                        }
                    }
                }
                else
                {
                    // NoDrop
                    hCursor = m_viewNotInControl;
                }

                SetCursor(hCursor);

                rc = TRUE;
            }
            else
            {
                // Let defwindowproc handle it
                goto DefWndProc;
            }
            break;
        }

        case WM_SIZE:
        {
            //
            // If we're in full screen mode, there are no scrollbars.
            //
            if (!pasPerson->m_pView->m_viewFullScreen)
            {
                int xNewPos;
                int yNewPos;

                xNewPos = pasPerson->m_pView->m_viewPos.x;
                yNewPos = pasPerson->m_pView->m_viewPos.y;

                GetClientRect(hwnd, &rcl);
                pasPerson->m_pView->m_viewPage.x = rcl.right - rcl.left;
                pasPerson->m_pView->m_viewPage.y = rcl.bottom - rcl.top;
                TRACE_OUT(("WM_SIZE: Set page size (%04d, %04d)",
                    pasPerson->m_pView->m_viewPage.x, pasPerson->m_pView->m_viewPage.y));

                //
                // Scroll window if necessary.
                //
                si.cbSize = sizeof(SCROLLINFO);
                si.fMask = SIF_PAGE|SIF_DISABLENOSCROLL;

                // Set new HORIZONTAL proportional scroll button size
                si.nPage = pasPerson->m_pView->m_viewPage.x;
                SetScrollInfo(hwnd, SB_HORZ, &si, TRUE );

                // Set new VERTICAL proportional scroll button size
                si.nPage = pasPerson->m_pView->m_viewPage.y;
                SetScrollInfo(hwnd, SB_VERT, &si, TRUE );

                //
                // This will make sure the scroll pos is pinned properly
                //
                VIEWClientScroll(pasPerson, pasPerson->m_pView->m_viewPos.x, pasPerson->m_pView->m_viewPos.y);
            }
            break;
        }

        case WM_HSCROLL:
        {
            int xNewPos;    // new position

            switch (GET_WM_HSCROLL_CODE(wParam, lParam))
            {
                case SB_PAGEUP:
                    xNewPos = pasPerson->m_pView->m_viewPos.x - pasPerson->m_pView->m_viewPgSize.x;
                    break;
                case SB_PAGEDOWN:
                    xNewPos = pasPerson->m_pView->m_viewPos.x + pasPerson->m_pView->m_viewPgSize.x;
                    break;
                case SB_LINEUP:
                    xNewPos = pasPerson->m_pView->m_viewPos.x - pasPerson->m_pView->m_viewLnSize.x;
                    break;
                case SB_LINEDOWN:
                    xNewPos = pasPerson->m_pView->m_viewPos.x + pasPerson->m_pView->m_viewLnSize.x;
                    break;
                case SB_TOP:
                    xNewPos = 0;
                    break;
                case SB_BOTTOM:
                    xNewPos = pasPerson->viewExtent.x;
                    break;

                case SB_THUMBTRACK:
                case SB_THUMBPOSITION:
                    xNewPos = GET_WM_HSCROLL_POS(wParam, lParam);
                    break;

                default:
                    xNewPos = pasPerson->m_pView->m_viewPos.x;
                    break;
            }

            //
            // This will pin the desired scroll pos in the range, and if
            // nothing has changed, won't scroll.
            //
            VIEWClientScroll(pasPerson, xNewPos, pasPerson->m_pView->m_viewPos.y);
            break;
        }

        case WM_VSCROLL:
        {
            int yNewPos;    // new position

            switch (GET_WM_VSCROLL_CODE(wParam, lParam))
            {
                case SB_PAGEUP:
                    yNewPos = pasPerson->m_pView->m_viewPos.y - pasPerson->m_pView->m_viewPgSize.y;
                    break;
                case SB_PAGEDOWN:
                    yNewPos = pasPerson->m_pView->m_viewPos.y + pasPerson->m_pView->m_viewPgSize.y;
                    break;
                case SB_LINEUP:
                    yNewPos = pasPerson->m_pView->m_viewPos.y - pasPerson->m_pView->m_viewLnSize.y;
                    break;
                case SB_LINEDOWN:
                    yNewPos = pasPerson->m_pView->m_viewPos.y + pasPerson->m_pView->m_viewLnSize.y;
                    break;
                case SB_TOP:
                    yNewPos = 0;
                    break;
                case SB_BOTTOM:
                    yNewPos = pasPerson->viewExtent.y;
                    break;

                case SB_THUMBTRACK:
                case SB_THUMBPOSITION:
                    yNewPos = GET_WM_VSCROLL_POS(wParam, lParam);
                    break;

                default:
                    yNewPos = pasPerson->m_pView->m_viewPos.y;
                    break;
            }

            //
            // This will pin the desired scroll pos in the range, and if
            // nothing has changed, won't scroll.
            //
            VIEWClientScroll(pasPerson, pasPerson->m_pView->m_viewPos.x, yNewPos);
            break;
        }

        default:
DefWndProc:
            rc = DefWindowProc(hwnd, message, wParam, lParam);
            break;
    }

    DebugExitDWORD(ASShare::VIEW_ViewWindowProc, rc);
    return(rc);
}




//
// VIEWClientPaint()
//
// This paints the client area of the view frame.  We paint
//      (1) The obscured area, in the obscured pattern
//          * parts of shared regions that are covered up
//          * parts of shared regions that are offscreen/off the VD
//      (2) The shared area, from the bitmap
//      (3) The deadspace, in COLOR_APPWORKSPACE
//
void  ASShare::VIEWClientPaint(ASPerson * pasPerson)
{
    PAINTSTRUCT     ps;
    HDC             hdcView;
    HPALETTE        hOldPal;
    HPALETTE        hOldPal2;
    RECT            rcT;

    DebugEntry(ASShare::VIEWClientPaint);

    ValidateView(pasPerson);

    hdcView = BeginPaint(pasPerson->m_pView->m_viewClient, &ps);
    if (hdcView == NULL)
    {
        WARNING_OUT(( "Failed to get hdc for frame window %08X", pasPerson->m_pView->m_viewClient));
        DC_QUIT;
    }

    if (IsRectEmpty(&ps.rcPaint))
    {
        TRACE_OUT(("Nothing to paint but got WM_PAINT message"));
        DC_QUIT;
    }

    TRACE_OUT(("VIEWClientPaint: Painting total client area {%04d, %04d, %04d, %04d}",
        ps.rcPaint.left, ps.rcPaint.top, ps.rcPaint.right, ps.rcPaint.bottom));


    //
    // In desktop sharing, viewSharedRgn is NULL
    //
    if (pasPerson->m_pView->m_viewSharedRgn != NULL)
    {
        POINT           ptOrigin;
        HBRUSH          hbrT;

        //
        // First, create paint area region
        //
        SetRectRgn(pasPerson->m_pView->m_viewPaintRgn, ps.rcPaint.left, ps.rcPaint.top,
            ps.rcPaint.right, ps.rcPaint.bottom);

        //
        // Second, compute the VD area not currently on screen.  Do this
        // in CLIENT coords.
        //
        SetRectRgn(pasPerson->m_pView->m_viewExtentRgn,
            -pasPerson->m_pView->m_viewPos.x,
            -pasPerson->m_pView->m_viewPos.y,
            -pasPerson->m_pView->m_viewPos.x + pasPerson->viewExtent.x,
            -pasPerson->m_pView->m_viewPos.y + pasPerson->viewExtent.y);

        SetRectRgn(pasPerson->m_pView->m_viewScreenRgn,
            -pasPerson->m_pView->m_viewPos.x + pasPerson->m_pView->m_dsScreenOrigin.x,
            -pasPerson->m_pView->m_viewPos.y + pasPerson->m_pView->m_dsScreenOrigin.y,
            -pasPerson->m_pView->m_viewPos.x + pasPerson->m_pView->m_dsScreenOrigin.x + pasPerson->cpcCaps.screen.capsScreenWidth,
            -pasPerson->m_pView->m_viewPos.y + pasPerson->m_pView->m_dsScreenOrigin.y + pasPerson->cpcCaps.screen.capsScreenHeight);

        SubtractRgn(pasPerson->m_pView->m_viewExtentRgn, pasPerson->m_pView->m_viewExtentRgn, pasPerson->m_pView->m_viewScreenRgn);

        //
        // pasPerson->m_pView->m_viewExtentRgn is now the offscreen parts of the VD, and therefore
        // any shared areas lying in them should be treated as obscured.
        //

        //
        // Now, compute the real obscured area.  It's the covered up bits
        // plus open parts of shared stuff not currently on screen.
        //
        IntersectRgn(pasPerson->m_pView->m_viewScratchRgn, pasPerson->m_pView->m_viewExtentRgn, pasPerson->m_pView->m_viewSharedRgn);
        UnionRgn(pasPerson->m_pView->m_viewScratchRgn, pasPerson->m_pView->m_viewScratchRgn, pasPerson->m_pView->m_viewObscuredRgn);

        // Calc what part of the obscured region to actually paint
        IntersectRgn(pasPerson->m_pView->m_viewScratchRgn, pasPerson->m_pView->m_viewScratchRgn, pasPerson->m_pView->m_viewPaintRgn);
        if (GetRgnBox(pasPerson->m_pView->m_viewScratchRgn, &rcT) > NULLREGION)
        {
            TRACE_OUT(("VIEWClientPaint:    Painting obscured client area {%04d, %04d, %04d, %04d}",
                rcT.left, rcT.top, rcT.right, rcT.bottom));

            //
            // Remove this area so we have what's left to paint.
            //
            SubtractRgn(pasPerson->m_pView->m_viewPaintRgn, pasPerson->m_pView->m_viewPaintRgn, pasPerson->m_pView->m_viewScratchRgn);

            //
            // We do NOT want to use FillRgn; it ignores the brush origin.
            // So we select this in as the clip region and PatBlt instead.
            //
            SelectClipRgn(hdcView, pasPerson->m_pView->m_viewScratchRgn);

#ifdef _DEBUG
            //
            // NOTE:  Do NOT move this--we're using ptOrigin for scratch.
            //
            GetDCOrgEx(hdcView, &ptOrigin);
            TRACE_OUT(("VIEWClientPaint:    Setting brush origin to {%04d, %04d}, screen {%04d, %04d}",
                -pasPerson->m_pView->m_viewPos.x, -pasPerson->m_pView->m_viewPos.y,
                ptOrigin.x - pasPerson->m_pView->m_viewPos.x,
                ptOrigin.y - pasPerson->m_pView->m_viewPos.y));
#endif

            //
            // Align the brush with where the view's real origin would be, in
            // client coords.  We do that by accounting for being scrolled over.
            //
            SetBrushOrgEx(hdcView, -pasPerson->m_pView->m_viewPos.x,
                -pasPerson->m_pView->m_viewPos.y, &ptOrigin);
            UnrealizeObject(m_viewObscuredBrush);
            hbrT = SelectBrush(hdcView, m_viewObscuredBrush);

            PatBlt(hdcView,
                rcT.left, rcT.top,
                rcT.right - rcT.left,
                rcT.bottom - rcT.top,
                PATCOPY);

            SelectBrush(hdcView, hbrT);
            SetBrushOrgEx(hdcView, ptOrigin.x, ptOrigin.y, NULL);

            SelectClipRgn(hdcView, NULL);
        }

        //
        // Paint the deadspace area, set up clipping for app sharing.
        // This also works for desktop sharing, where there are no obscured or
        // shared regions, the whole area paints.
        //

        //
        // The deadspace is whatever's left over in the paint region
        // (already subtracted the obscured region) after subtracting the
        // shared area
        //
        SubtractRgn(pasPerson->m_pView->m_viewScratchRgn, pasPerson->m_pView->m_viewPaintRgn, pasPerson->m_pView->m_viewSharedRgn);

        if (GetRgnBox(pasPerson->m_pView->m_viewScratchRgn, &rcT) > NULLREGION)
        {
            TRACE_OUT(("VIEWClientPaint:    Painting dead client area {%04d, %04d, %04d, %04d}",
                rcT.left, rcT.top, rcT.right, rcT.bottom));
            FillRgn(hdcView, pasPerson->m_pView->m_viewScratchRgn, GetSysColorBrush(COLOR_APPWORKSPACE));
        }

        //
        // Compute what part of the shared area needs painting (the part
        // that lies on the remote screen actually).
        //
        IntersectRgn(pasPerson->m_pView->m_viewScratchRgn, pasPerson->m_pView->m_viewSharedRgn, pasPerson->m_pView->m_viewScreenRgn);
        IntersectRgn(pasPerson->m_pView->m_viewScratchRgn, pasPerson->m_pView->m_viewScratchRgn, pasPerson->m_pView->m_viewPaintRgn);

        // Now select in the piece of what we're painting as the clip region
        SelectClipRgn(hdcView, pasPerson->m_pView->m_viewScratchRgn);
    }

    //
    // Blt the shared region
    //
    if (GetClipBox(hdcView, &rcT) > NULLREGION)
    {
        TRACE_OUT(("VIEWClientPaint:    Painting shared client area {%04x, %04x, %04x, %04x}",
            rcT.left, rcT.top, rcT.right, rcT.bottom));

        if (g_usrPalettized)
        {
            ASSERT(pasPerson->pmPalette != NULL);

            //
            // Select and realize the current remote palette into the
            // screen and shadow bitmap DCs.
            //
            hOldPal = SelectPalette(pasPerson->m_pView->m_usrDC, pasPerson->pmPalette, FALSE);
            RealizePalette(pasPerson->m_pView->m_usrDC);

            hOldPal2 = SelectPalette( hdcView, pasPerson->pmPalette, FALSE);
            RealizePalette(hdcView);
        }

        //
        // The host bitmap is in screen coords, not VD coords, so
        // adjust for being scrolled over...
        //
        BitBlt(hdcView,
            rcT.left, rcT.top, rcT.right - rcT.left, rcT.bottom - rcT.top,
            pasPerson->m_pView->m_usrDC,
            rcT.left + pasPerson->m_pView->m_viewPos.x - pasPerson->m_pView->m_dsScreenOrigin.x,
            rcT.top + pasPerson->m_pView->m_viewPos.y - pasPerson->m_pView->m_dsScreenOrigin.y,
            SRCCOPY);

        if (g_usrPalettized)
        {
            ASSERT(pasPerson->pmPalette != NULL);

            SelectPalette(pasPerson->m_pView->m_usrDC, hOldPal, FALSE);
            SelectPalette(hdcView, hOldPal2, FALSE);
        }
    }

    //
    // Deselect the clip region, or we won't be able to draw shadow cursors
    // that lie outside the shared area.
    //
    if (pasPerson->m_pView->m_viewSharedRgn != NULL)
    {
        SelectClipRgn(hdcView, NULL);
    }

    //
    // Draw the shadow cursor.
    //
    CM_DrawShadowCursor(pasPerson, hdcView);

DC_EXIT_POINT:

    if (hdcView != NULL)
        EndPaint(pasPerson->m_pView->m_viewClient, &ps);

    DebugExitVOID(ASShare::VIEWClientPaint);
}



//
// VIEWClientScroll()
//
// This is the common place where the scroll position is altered.  If
// necessary the contents are scrolled over, the regions (always in client
// coords) are adjusted, and new info about our origin is sent to remotes.
//
// We first make sure the scroll position is pinned properly within the
// range.
//
// The return value is whether scrolling happened or not.
//
BOOL ASShare::VIEWClientScroll
(
    ASPerson *  pasPerson,
    int         xNew,
    int         yNew
)
{
    int         dx;
    int         dy;

    DebugEntry(ASShare::VIEWClientScroll);

    //
    // First, pin the requested new position within the range
    //
    //
    // Pin x pos
    //
    if (xNew < 0)
        xNew = 0;

    if (xNew + pasPerson->m_pView->m_viewPage.x > pasPerson->viewExtent.x)
        xNew = pasPerson->viewExtent.x - pasPerson->m_pView->m_viewPage.x;

    //
    // Pin y pos
    //
    if (yNew < 0)
        yNew = 0;

    if (yNew + pasPerson->m_pView->m_viewPage.y > pasPerson->viewExtent.y)
        yNew = pasPerson->viewExtent.y - pasPerson->m_pView->m_viewPage.y;

    //
    // How much are we going to scroll by?
    //
    dx = pasPerson->m_pView->m_viewPos.x - xNew;
    dy = pasPerson->m_pView->m_viewPos.y - yNew;

    // Updates
    if (dx || dy)
    {
        //
        // Adjust regions
        //
        if (pasPerson->m_pView->m_viewObscuredRgn != NULL)
            OffsetRgn(pasPerson->m_pView->m_viewObscuredRgn, dx, dy);

        if (pasPerson->m_pView->m_viewSharedRgn != NULL)
            OffsetRgn(pasPerson->m_pView->m_viewSharedRgn, dx, dy);

        pasPerson->m_pView->m_viewPos.x = xNew;
        pasPerson->m_pView->m_viewPos.y = yNew;

        ScrollWindowEx(pasPerson->m_pView->m_viewClient,
                    dx,
                    dy,
                    NULL,
                    NULL,
                    NULL,
                    NULL,
                    SW_SCROLLCHILDREN | SW_INVALIDATE);

        if (dx)
        {
            SetScrollPos(pasPerson->m_pView->m_viewClient, SB_HORZ, xNew, TRUE);
        }

        if (dy)
        {
            SetScrollPos(pasPerson->m_pView->m_viewClient, SB_VERT, yNew, TRUE);
        }
    }

    DebugExitBOOL(ASShare::VIEWClientScroll, (dx || dy));
    return(dx || dy);
}


//
// VIEWClientMouseDown()
//
void ASShare::VIEWClientMouseDown
(
    ASPerson *      pasPerson,
    UINT            message,
    WPARAM          wParam,
    LPARAM          lParam
)
{
    DebugEntry(ASShare::VIEWClientMouseDown);

    ValidateView(pasPerson);

    //
    // On the first button down, set capture so all mouse messages come
    // to us until capture is released or stolen.
    //
    if (!pasPerson->m_pView->m_viewMouseFlags)
    {
        //
        // If this is RBUTTONDOWN, track the Collaborate pop up...
        //
        ASSERT(!pasPerson->m_pView->m_viewMouseOutside);
        SetCapture(pasPerson->m_pView->m_viewClient);
    }

    //
    // Remember what button is down.
    //
    switch (message)
    {
        case WM_LBUTTONDOWN:
            pasPerson->m_pView->m_viewMouseFlags |= MK_LBUTTON;
            break;

        case WM_RBUTTONDOWN:
            pasPerson->m_pView->m_viewMouseFlags |= MK_RBUTTON;
            break;

        case WM_MBUTTONDOWN:
            pasPerson->m_pView->m_viewMouseFlags |= MK_MBUTTON;
            break;
    }

    //
    // Save the current mouse position
    //
    pasPerson->m_pView->m_viewMouse.x = GET_X_LPARAM(lParam);
    pasPerson->m_pView->m_viewMouse.y = GET_Y_LPARAM(lParam);

    VIEWClientMouseMsg(pasPerson, message, wParam, lParam);

    DebugExitVOID(ASShare::VIEWClientMouseDown);
}


//
// VIEWClientMouseUp()
//
void ASShare::VIEWClientMouseUp
(
    ASPerson *      pasPerson,
    UINT            message,
    WPARAM          wParam,
    LPARAM          lParam,
    BOOL            fReleaseCapture
)
{
    DebugEntry(ASShare::VIEWClientMouseUp);

    switch (message)
    {
        case WM_LBUTTONUP:
            if (pasPerson->m_pView->m_viewMouseFlags & MK_LBUTTON)
                pasPerson->m_pView->m_viewMouseFlags &= ~MK_LBUTTON;
            else
                fReleaseCapture = FALSE;        // From dbl-click
            break;

        case WM_RBUTTONUP:
            if (pasPerson->m_pView->m_viewMouseFlags & MK_RBUTTON)
                pasPerson->m_pView->m_viewMouseFlags &= ~MK_RBUTTON;
            else
                fReleaseCapture = FALSE;        // From dbl-click
            break;

        case WM_MBUTTONUP:
            if (pasPerson->m_pView->m_viewMouseFlags & MK_MBUTTON)
                pasPerson->m_pView->m_viewMouseFlags &= ~MK_MBUTTON;
            else
                fReleaseCapture = FALSE;        // From dbl-click
            break;
    }

    //
    // Should we release capture?
    // We don't just want to release capture on a button up.  The user may
    // press one button down then another; we don't want to release capture
    // until all buttons are up.
    //
    if (!pasPerson->m_pView->m_viewMouseFlags)
    {
        if (pasPerson->m_pView->m_viewMouseOutside)
        {
            pasPerson->m_pView->m_viewMouseOutside = FALSE;
            KillTimer(pasPerson->m_pView->m_viewClient, IDT_AUTOSCROLL);
        }

        if (fReleaseCapture)
            ReleaseCapture();
    }

    //
    // Save the current mouse position
    //
    pasPerson->m_pView->m_viewMouse.x = GET_X_LPARAM(lParam);
    pasPerson->m_pView->m_viewMouse.y = GET_Y_LPARAM(lParam);

    VIEWClientMouseMsg(pasPerson, message, wParam, lParam);

    DebugExitVOID(ASShare::VIEWClientMouseUp);
}



//
// VIEWClientCaptureStolen()
// Called when capture gets stolen away from us, like by Alt-Tab.
//
void ASShare::VIEWClientCaptureStolen(ASPerson * pasPerson)
{
    DebugEntry(ASShare::VIEWClientCaptureStolen);

    //
    // We need to fake a button up for each button we think is down.
    // Use the current cursor pos.
    //
    if (pasPerson->m_pView->m_viewMouseFlags & MK_MBUTTON)
    {
        VIEWClientMouseUp(pasPerson, WM_MBUTTONUP, pasPerson->m_pView->m_viewMouseFlags,
            MAKELPARAM(pasPerson->m_pView->m_viewMouse.x, pasPerson->m_pView->m_viewMouse.y),
            FALSE);
    }

    if (pasPerson->m_pView->m_viewMouseFlags & MK_RBUTTON)
    {
        VIEWClientMouseUp(pasPerson, WM_RBUTTONUP, pasPerson->m_pView->m_viewMouseFlags,
            MAKELPARAM(pasPerson->m_pView->m_viewMouse.x, pasPerson->m_pView->m_viewMouse.y),
            FALSE);
    }

    if (pasPerson->m_pView->m_viewMouseFlags & MK_LBUTTON)
    {
        VIEWClientMouseUp(pasPerson, WM_LBUTTONUP, pasPerson->m_pView->m_viewMouseFlags,
            MAKELPARAM(pasPerson->m_pView->m_viewMouse.x, pasPerson->m_pView->m_viewMouse.y),
            FALSE);
    }

    DebugExitVOID(ASShare::VIEWClientCaptureStolen);
}


//
// VIEWClientMouseMove()
//
void ASShare::VIEWClientMouseMove
(
    ASPerson *      pasPerson,
    UINT            message,
    WPARAM          wParam,
    LPARAM          lParam
)
{
    RECT            rcClient;

    DebugEntry(ASShare::VIEWClientMouseMove);

    if (!pasPerson->m_pView->m_viewFocus)
    {
        // Ignore mouse moves over windows that don't have the focus
        DC_QUIT;
    }

    //
    // Save the current mouse position
    //
    pasPerson->m_pView->m_viewMouse.x = GET_X_LPARAM(lParam);
    pasPerson->m_pView->m_viewMouse.y = GET_Y_LPARAM(lParam);

    GetClientRect(pasPerson->m_pView->m_viewClient, &rcClient);

    //
    // If any button is down, check whether we should kick in
    // autoscroll detection.
    //
    if (pasPerson->m_pView->m_viewMouseFlags)
    {
        // Is the mouse inside or outside the client for the first time?
        if (PtInRect(&rcClient, pasPerson->m_pView->m_viewMouse))
        {
            //
            // Was the mouse outside the client before?  If so, kill our
            // autoscroll timer, we're not dragging outside.
            //
            if (pasPerson->m_pView->m_viewMouseOutside)
            {
                pasPerson->m_pView->m_viewMouseOutside = FALSE;
                KillTimer(pasPerson->m_pView->m_viewClient, IDT_AUTOSCROLL);
            }
        }
        else
        {
            //
            // Is the first time the mouse is outside the client?  If so,
            // set our autoscroll timer to the default value.  When it goes
            // off, the autoscroll code will scroll by some multiple of
            // how far away the mouse is from the client.
            //
            if (!pasPerson->m_pView->m_viewMouseOutside)
            {
                //
                // The Windows scrollbar code uses 1/8 of the double-click
                // time, so we do also.
                //
                pasPerson->m_pView->m_viewMouseOutside = TRUE;
                SetTimer(pasPerson->m_pView->m_viewClient, IDT_AUTOSCROLL,
                    GetDoubleClickTime() / 8, NULL);
            }

            //
            // LAURABU BOGUS!
            // When IM_Periodic goop is gone for controlling, do NOT
            // pass along mouse outside messages.  Only the autoscroll
            // timer will fake a mouse move in this case.  Either that,
            // or clip the position to the nearest client area equivalent.
            //
        }
    }

    VIEWClientMouseMsg(pasPerson, message, wParam, lParam);

DC_EXIT_POINT:
    DebugExitVOID(ASShare::VIEWClientMouseMove);
}



//
// VIEWClientMouseMsg()
//
void ASShare::VIEWClientMouseMsg
(
    ASPerson *      pasPerson,
    UINT            message,
    WPARAM          wParam,
    LPARAM          lParam
)
{
    POINT           mousePos;

    DebugEntry(ASShare::VIEWClientMouseMsg);

    //
    // Extract the mouse position from <lParam> and package it
    // in a POINT structure.  These coordinates are relative to our
    // client area.  So convert to remote's desktop by adjusting for
    // scroll position.
    //
    // Be careful when converting the LOWORD and HIWORD values
    // because the positions are signed values.
    //
    mousePos.x = GET_X_LPARAM(lParam) + pasPerson->m_pView->m_viewPos.x;
    mousePos.y = GET_Y_LPARAM(lParam) + pasPerson->m_pView->m_viewPos.y;

    //
    // These coords represent the SCREEN coords on the host.
    //
    if (pasPerson->m_caControlledBy == m_pasLocal)
    {
        if (!pasPerson->m_caControlPaused)
        {
            IM_OutgoingMouseInput(pasPerson, &mousePos, message, (UINT)wParam);
        }
    }
    else if (pasPerson->m_caAllowControl && !pasPerson->m_caControlledBy &&
        (message == WM_LBUTTONDBLCLK))
    {
        //
        // If we're already waiting for control of this person, don't bother
        // trying to take control again.
        //
        if ((m_caWaitingForReplyFrom != pasPerson) &&
            (m_caWaitingForReplyMsg  != CA_REPLY_REQUEST_TAKECONTROL))
        {
            CA_TakeControl(pasPerson);
        }
    }

    DebugExitVOID(ASShare::VIEWClientMouse);
}


//
// VIEWClientMouseWheel()
//
// Unbelievably complicated, messy, nonsensical Intellimouse wheel handling
// to scroll the client.  Since the Intellimouse makes no distinction for
// which direction to scroll in, we basically have to guess.  We don't want
// to be unpredictable and decide which direction to scroll based on how
// much is visible in each dimenion.
//
// So instead, we assume horizontal.  If the horizontal scrollbar is disabled,
// then we try vertical.  If that's disabled, we do nothing.
//
// We do NOT handle zoom and datazoom flavors.
//
// Note that this code comes from the listbox/sample source.
//
void ASShare::VIEWClientMouseWheel
(
    ASPerson *      pasHost,
    WPARAM          wParam,
    LPARAM          lParam
)
{
    int             cDetants;

    DebugEntry(ASShare::VIEWClientMouseWheel);

    //
    // The LOWORD of wParam has key state information.
    // The HIWORD of wParam is the number of mouse wheel clicks.
    //

    //
    // We don't do zoom/datazoom
    //
    if (wParam & (MK_SHIFT | MK_CONTROL))
    {
        DC_QUIT;
    }

    pasHost->m_pView->m_viewMouseWheelDelta -= (int)(short)HIWORD(wParam);
    cDetants = pasHost->m_pView->m_viewMouseWheelDelta / WHEEL_DELTA;

    if (cDetants && (m_viewMouseWheelScrollLines > 0))
    {
        POINT           ptPos;

        pasHost->m_pView->m_viewMouseWheelDelta %= WHEEL_DELTA;

        //
        // The basic idea is that we scroll some number of lines, the
        // number being cDetants.
        //
        ptPos = pasHost->m_pView->m_viewPos;

        //
        // To be consistent with other apps, and with our keyboard
        // accelerators, try the vertical direction first.
        //
        if (pasHost->m_pView->m_viewPage.y < pasHost->viewExtent.y)
        {
            ptPos.y += cDetants * pasHost->m_pView->m_viewLnSize.y;
        }
        else if (pasHost->m_pView->m_viewPage.x < pasHost->viewExtent.x)
        {
            ptPos.x += cDetants * pasHost->m_pView->m_viewLnSize.x;
        }
        else
        {
            // Nothing to scroll, the whole view fits in the client area.
        }

        VIEWClientScroll(pasHost, ptPos.x, ptPos.y);
    }

DC_EXIT_POINT:
    DebugExitVOID(ASShare::VIEWClientMouseWheel);
}


//
// VIEWClientAutoScroll()
//
void ASShare::VIEWClientAutoScroll(ASPerson * pasPerson)
{
    int     dx;
    int     dy;
    RECT    rcClient;

    DebugEntry(ASShare::VIEWClientAutoScroll);

    ValidateView(pasPerson);
    ASSERT(pasPerson->m_pView->m_viewMouseOutside);

    //
    // Do scrolling.  The amount is dependent on how far outside the
    // client area we are.
    //
    GetClientRect(pasPerson->m_pView->m_viewClient, &rcClient);

    // Horizontal scrolling?
    if (pasPerson->m_pView->m_viewMouse.x < rcClient.left)
    {
        dx = pasPerson->m_pView->m_viewMouse.x - rcClient.left;
    }
    else if (pasPerson->m_pView->m_viewMouse.x >= rcClient.right)
    {
        dx = pasPerson->m_pView->m_viewMouse.x - rcClient.right + 1;
    }
    else
    {
        dx = 0;
    }


    // Vertical scrolling?
    if (pasPerson->m_pView->m_viewMouse.y < rcClient.top)
    {
        dy = pasPerson->m_pView->m_viewMouse.y - rcClient.top;
    }
    else if (pasPerson->m_pView->m_viewMouse.y >= rcClient.bottom)
    {
        dy = pasPerson->m_pView->m_viewMouse.y - rcClient.bottom + 1;
    }
    else
    {
        dy = 0;
    }

    // For every 32 pixel blocks outside the client, scroll one line amount
    if (dx)
        dx = MulDiv(pasPerson->m_pView->m_viewLnSize.x, dx, 32);
    if (dy)
        dy = MulDiv(pasPerson->m_pView->m_viewLnSize.y, dy, 32);

    // Do scrolling.
    if (VIEWClientScroll(pasPerson, pasPerson->m_pView->m_viewPos.x + dx,
            pasPerson->m_pView->m_viewPos.y + dy))
    {
        //
        // The scroll position actually changed.  So fake a mouse move
        // to the current location so that the remote's
        // cursor will be in the same spot as ours.  If our scroll pos has
        // changed, we're mapping to a different place on the remote.
        //
        VIEWClientMouseMsg(pasPerson, WM_MOUSEMOVE, pasPerson->m_pView->m_viewMouseFlags,
            MAKELPARAM(pasPerson->m_pView->m_viewMouse.x, pasPerson->m_pView->m_viewMouse.y));
    }

    DebugExitVOID(ASShare::VIEWClientAutoScroll);
}



//
// VIEW_SyncCursorPos()
//
// This is called when we see a CM_SYNC pos packet broadcasted from a
// host.  It means that we should sync our cursor to the corresponding
// position in our view.  This happens when the cursor is moved by
// an app, constrained by clipping, or we're too out of whack because it's
// taking too long.
//
// This will only do something if the frame is active and our cursor is
// currently over the client area.  If we need to, we will scroll the
// client over to make the corresponding point visible.
//
void ASShare::VIEW_SyncCursorPos
(
    ASPerson *      pasHost,
    int             xRemote,
    int             yRemote
)
{
    POINT           ptCursor;
    RECT            rcClient;
    int             xNewPos;
    int             yNewPos;
    int             xMargin;
    int             yMargin;

    DebugEntry(ASShare::VIEW_SyncCursorPos);

    ValidateView(pasHost);
    if (!pasHost->m_pView->m_viewFocus)
    {
        // The frame isn't active, do nothing
        DC_QUIT;
    }

    //
    // Is our mouse currently over the client area?
    //
    GetCursorPos(&ptCursor);
    ScreenToClient(pasHost->m_pView->m_viewClient, &ptCursor);
    GetClientRect(pasHost->m_pView->m_viewClient, &rcClient);

    if (!PtInRect(&rcClient, ptCursor))
    {
        // No sense in snapping cursor
        DC_QUIT;
    }

    //
    // Is the remote point in range of our view?  If not, we must scroll it.
    //

    // The margin is the page size if there's room, nothing if not
    xMargin = pasHost->m_pView->m_viewPgSize.x;
    if (xMargin >= rcClient.right - rcClient.left)
        xMargin = 0;

    xNewPos = pasHost->m_pView->m_viewPos.x;
    if ((xRemote < pasHost->m_pView->m_viewPos.x) ||
        (xRemote >= pasHost->m_pView->m_viewPos.x + (rcClient.right - rcClient.left)))
    {
        //
        // Scroll over more than just enough to pin the point on the left
        // side.
        //
        xNewPos = xRemote - xMargin;
    }

    yMargin = pasHost->m_pView->m_viewPgSize.y;
    if (yMargin >= rcClient.bottom - rcClient.top)
        yMargin = 0;

    yNewPos = pasHost->m_pView->m_viewPos.y;
    if ((yRemote < pasHost->m_pView->m_viewPos.y) ||
        (yRemote >= yNewPos + (rcClient.bottom - rcClient.top)))
    {
        //
        // Scroll over more than just enough to pin the point on the top
        // side.
        //
        yNewPos = yRemote - yMargin;
    }

    VIEWClientScroll(pasHost, xNewPos, yNewPos);

    ptCursor.x = xRemote - pasHost->m_pView->m_viewPos.x;
    ptCursor.y = yRemote - pasHost->m_pView->m_viewPos.y;
    ClientToScreen(pasHost->m_pView->m_viewClient, &ptCursor);

    SetCursorPos(ptCursor.x, ptCursor.y);

DC_EXIT_POINT:
    DebugExitVOID(ASShare::VIEW_SyncCursorPos);
}



//
// VIEWWindowBarProc()
//
LRESULT CALLBACK VIEWWindowBarProc
(
    HWND        hwnd,
    UINT        message,
    WPARAM      wParam,
    LPARAM      lParam
)
{
    return(g_asSession.pShare->VIEW_WindowBarProc(hwnd, message, wParam, lParam));
}



LRESULT ASShare::VIEW_WindowBarProc
(
    HWND        hwnd,
    UINT        message,
    WPARAM      wParam,
    LPARAM      lParam
)
{
    LRESULT     rc = 0;
    ASPerson *  pasHost;

    DebugEntry(ASShare::VIEW_WindowBarProc);

    pasHost = (ASPerson *)GetWindowLongPtr(hwnd, GWLP_USERDATA);
    if (pasHost)
    {
        ValidateView(pasHost);
    }

    switch (message)
    {
        case WM_NCCREATE:
        {
            // Get & save the person this view is for.
            pasHost = (ASPerson *)((LPCREATESTRUCT)lParam)->lpCreateParams;
            ValidateView(pasHost);
            SetWindowLongPtr(hwnd, GWLP_USERDATA, (LPARAM)pasHost);

            pasHost->m_pView->m_viewWindowBar = hwnd;
            goto DefWndProc;
            break;
        }

        case WM_NCDESTROY:
        {
            if (pasHost != NULL)
            {
                pasHost->m_pView->m_viewWindowBar = NULL;
            }

            goto DefWndProc;
            break;
        }

        case WM_CREATE:
        {
            if (!VIEWWindowBarCreate(pasHost, hwnd))
            {
                ERROR_OUT(("VIEWWndBarProc: couldn't create more item"));
                rc = -1;
            }
            break;
        }

        case WM_SIZE:
        {
            VIEWWindowBarResize(pasHost, hwnd);
            break;
        }

        case WM_HSCROLL:
        {
            VIEWWindowBarItemsScroll(pasHost, wParam, lParam);
            break;
        }

        default:
DefWndProc:
        {
            rc = DefWindowProc(hwnd, message, wParam, lParam);
            break;
        }
    }

    DebugExitDWORD(ASShare::VIEW_WindowBarProc, rc);
    return(rc);
}




//
// VIEWWindowBarCreate()
// Handles creation for the window bar.  We make the next/prev buttons on
// the right side, which stay there always.  They are disabled if all the
// window bar items fit, and one or both are enabled if not.
//
BOOL ASShare::VIEWWindowBarCreate
(
    ASPerson *  pasHost,
    HWND        hwndBar
)
{
    BOOL    rc = FALSE;
    RECT    rect;

    DebugEntry(ASShare::VIEWWindowBarCreate);

    ::GetClientRect(hwndBar, &rect);
    rect.top   += m_viewEdgeCY;
    rect.right -= m_viewItemScrollCX;

    //
    // Create the scrollbar, vertically centered, right-justified.
    //
    if (!::CreateWindowEx(0, "ScrollBar", NULL,
        WS_CHILD | WS_VISIBLE | SBS_HORZ | WS_CLIPSIBLINGS | WS_DISABLED,
        rect.right,
        (rect.top + rect.bottom - m_viewItemScrollCY) / 2,
        m_viewItemScrollCX, m_viewItemScrollCY,
        hwndBar, (HMENU)IDVIEW_SCROLL,
        g_asInstance, NULL))
    {
        ERROR_OUT(("VIEWWindowBarCreate:  Unable to create scroll ctrl"));
        DC_QUIT;
    }

    //
    // Create the windowbar, an integral number of items wide (including
    // trailing margin).
    //
    pasHost->m_pView->m_viewWindowBarItemFitCount =
        (rect.right - rect.left) / (m_viewItemCX + m_viewEdgeCX);

    if (!::CreateWindowEx(0, VIEW_WINDOWBARITEMS_CLASS_NAME, NULL,
        WS_CHILD | WS_VISIBLE | WS_DISABLED | WS_CLIPSIBLINGS,
        rect.left, rect.top,
        pasHost->m_pView->m_viewWindowBarItemFitCount * (m_viewItemCX + m_viewEdgeCX),
        m_viewItemCY,
        hwndBar, (HMENU)IDVIEW_ITEMS,
        g_asInstance, pasHost))
    {
        ERROR_OUT(("VIEWWindowBarCreate:  Unable to create window bar item list"));
        DC_QUIT;
    }

    rc = TRUE;

DC_EXIT_POINT:
    DebugExitBOOL(ASShare::VIEWWindowBarCreate, rc);
    return(rc);
}



//
// VIEWWindowBarResize()
//
// This is called when the window bar is resized, due to the frame being
// sized horizontally.
//
// It right-justifies the scroll control, then resizes the window list to
// hold however many integral items fit across.
//
void ASShare::VIEWWindowBarResize
(
    ASPerson *  pasHost,
    HWND        hwndBar
)
{
    RECT        rc;

    DebugEntry(ASShare::VIEWWindowBarResize);

    ValidateView(pasHost);

    //
    // Recalculate the page size, the # of items that fit across.
    // If it's different, invalidate the right side of the window bar client.
    // Move the scrollbar control, and update the scroll info.
    //

    // What might change is the number that fit across.
    ::GetClientRect(hwndBar, &rc);
    rc.top   += m_viewEdgeCY;
    rc.right -= m_viewItemScrollCX;

    // Move the scroll control, right justified.
    ::MoveWindow(::GetDlgItem(hwndBar, IDVIEW_SCROLL), rc.right,
        (rc.top + rc.bottom - m_viewItemScrollCY) / 2,
        m_viewItemScrollCX, m_viewItemScrollCY, TRUE);

    //
    // Resize the window items list to fit an integral # of items again.
    //
    pasHost->m_pView->m_viewWindowBarItemFitCount =
        (rc.right - rc.left) / (m_viewItemCX + m_viewEdgeCX);

    ::MoveWindow(::GetDlgItem(hwndBar, IDVIEW_ITEMS), rc.left, rc.top,
        pasHost->m_pView->m_viewWindowBarItemFitCount * (m_viewItemCX + m_viewEdgeCX),
        m_viewItemCY, TRUE);

    //
    // Update the scroll page and pos if necessary.
    //
    VIEWWindowBarItemsScroll(pasHost, GET_WM_HSCROLL_MPS(SB_ENDSCROLL, 0, NULL));

    DebugExitVOID(ASShare::VIEWWindowBarResize);
}




//
// VIEW_WindowBarUpdateItem()
//
// This is ONLY called for items, in the new SWL packet, that are window
// bar items.  We don't call it with non-windowbar items.  When done
// looping through the SWL entries, we can then remove the items on the
// window bar that were NOT seen in the new SWL packet.
//
// We will either create a new item on the window bar, or update an existing
// one.  In the first case, that is always a change.  In the latter, there's
// a change only if the item text changed.
//
BOOL ASShare::VIEW_WindowBarUpdateItem
(
    ASPerson *          pasHost,
    PSWLWINATTRIBUTES   pWinNew,
    LPSTR               pText
)
{
    PWNDBAR_ITEM        pItem;
    BOOL                viewAnyChanges = FALSE;

    DebugEntry(ASView::VIEW_WindowBarUpdateItem);

    ValidateView(pasHost);

    ASSERT(pWinNew->flags & SWL_FLAG_WINDOW_HOSTED);
    ASSERT(pWinNew->flags & SWL_FLAG_WINDOW_TASKBAR);

    //
    // NOTE:
    // aswlLast holds the _previous_ attributes for the windows, from
    // the previous SWL packet.  pWinNew holds the _new_ attributes for
    // the window, from the SWL packet being processed, and these
    // haven't taken effect yet.
    //

    // Does this new item already exist on the tray?
    COM_BasedListFind(LIST_FIND_FROM_FIRST, &(pasHost->m_pView->m_viewWindowBarItems),
        (void**)&pItem, FIELD_OFFSET(WNDBAR_ITEM, chain),
        FIELD_OFFSET(WNDBAR_ITEM, winIDRemote),
        pWinNew->winID, FIELD_SIZE(WNDBAR_ITEM, winIDRemote));

    if (pItem)
    {
        //
        // Update this item, and mark it as seen.
        //
        ASSERT(pItem->winIDRemote == pWinNew->winID);

        pItem->flags = pWinNew->flags | SWL_FLAG_INTERNAL_SEEN;

        //
        // Is anything going to result in a visual change?  That's only
        // the text currently.  And we only display VIEW_MAX_ITEM_CHARS at
        // most, an end ellipsis if there's too much.
        //

        //
        // NOTE that the items are always created with maximum space for
        // text, since we cannot realloc.
        //
        if (lstrcmp(pItem->szText, pText))
        {
            lstrcpyn(pItem->szText, pText, sizeof(pItem->szText));
            viewAnyChanges = TRUE;
        }
    }
    else
    {
        //
        // Create a new item.
        //
        //
        // A WNDBAR_ITEM also includes maximum space for text that we will
        // store.
        //
        pItem = (PWNDBAR_ITEM) new WNDBAR_ITEM;
        if (!pItem)
        {
            ERROR_OUT(("VIEW_WindowBarUpdateItem: no memory to create new item for remote hwnd 0x%08x",
               pWinNew->winID));
        }
        else
        {
            ::ZeroMemory(pItem, sizeof(*pItem));

            SET_STAMP(pItem, WNDITEM);

            pItem->winIDRemote  = pWinNew->winID;

            //
            // Add SEEN to the flags; when we're done we'll remove items we haven't
            // seen.
            //
            pItem->flags        = pWinNew->flags | SWL_FLAG_INTERNAL_SEEN;

            lstrcpyn(pItem->szText, pText, sizeof(pItem->szText));

            // Append to end of list
            COM_BasedListInsertBefore(&(pasHost->m_pView->m_viewWindowBarItems),
                &(pItem->chain));

            // Success!
            pasHost->m_pView->m_viewWindowBarItemCount++;

            viewAnyChanges = TRUE;
        }
    }

    DebugExitBOOL(ASShare::VIEW_UpdateWindowItem, viewAnyChanges);
    return(viewAnyChanges);
}


//
// VIEW_WindowBarEndUpdateItems()
//
// This turns redraw on and invalidates the window bar so it will repaint.
//
void ASShare::VIEW_WindowBarEndUpdateItems
(
    ASPerson *          pasHost,
    BOOL                viewAnyChanges
)
{
    PWNDBAR_ITEM        pItem;
    PWNDBAR_ITEM        pNext;

    DebugEntry(ASShare::VIEW_WindowBarEndUpdateItems);

    ValidateView(pasHost);

    //
    // Walk the window bar item list.  Keep the ones marked as seen, but
    // remove the ones we haven't seen.
    //
    pItem = (PWNDBAR_ITEM)COM_BasedListFirst(&(pasHost->m_pView->m_viewWindowBarItems),
        FIELD_OFFSET(WNDBAR_ITEM, chain));
    while (pItem)
    {
        pNext = (PWNDBAR_ITEM)COM_BasedListNext(&(pasHost->m_pView->m_viewWindowBarItems),
            pItem, FIELD_OFFSET(WNDBAR_ITEM, chain));

        //
        // If this item wasn't seen (existing & still existing, or new)
        // during processing, it's gone.  Delete it.
        //
        if (pItem->flags & SWL_FLAG_INTERNAL_SEEN)
        {
            //
            // This was just added or is still around, keep it.
            // But of course clear the flag, so we are clear for
            // processing the next SWL packet.
            //
            pItem->flags &= ~SWL_FLAG_INTERNAL_SEEN;
        }
        else
        {
            //
            // Remove it.
            //

            // We're killing the active item, clear it out.
            if (pItem == pasHost->m_pView->m_viewWindowBarActiveItem)
            {
                pasHost->m_pView->m_viewWindowBarActiveItem = NULL;
            }

            COM_BasedListRemove(&(pItem->chain));

            delete pItem;
            --pasHost->m_pView->m_viewWindowBarItemCount;
            ASSERT(pasHost->m_pView->m_viewWindowBarItemCount >= 0);

            //
            // Something changed in our list
            //
            viewAnyChanges = TRUE;
        }

        pItem = pNext;
    }

    //
    // No need to check for changes here--they would only occur if
    // an item was removed in the middle, caused by Destroy which we already
    // account for, or if items were appended to the end, which we account
    // for in Update.
    //
    if (viewAnyChanges)
    {
        // Turn off redraw on window list
        ::SendDlgItemMessage(pasHost->m_pView->m_viewWindowBar, IDVIEW_ITEMS,
                WM_SETREDRAW, FALSE, 0);

        // Adjust pos
        VIEWWindowBarItemsScroll(pasHost, GET_WM_HSCROLL_MPS(SB_ENDSCROLL, 0, NULL));

        // Figure out active window again.
        VIEW_WindowBarChangedActiveWindow(pasHost);

        // Turn back on redraw
        ::SendDlgItemMessage(pasHost->m_pView->m_viewWindowBar, IDVIEW_ITEMS,
                WM_SETREDRAW, TRUE, 0);

        // Repaint the items.
        ::InvalidateRect(::GetDlgItem(pasHost->m_pView->m_viewWindowBar, IDVIEW_ITEMS),
                NULL, TRUE);
    }
    else
    {
        //
        // ALWAYS do this -- our real SWL list has changed, regardless of whether
        // the window bar has.  And therefore we may have a different ancestor
        // relationship.
        //
        VIEW_WindowBarChangedActiveWindow(pasHost);
    }

    DebugExitVOID(ASShare::VIEW_EndUpdateWindowList);
}



//
// VIEW_WindowBarChangedActiveWindow()
//
// This is called when the active window has changed, as discovered via an
// AWC packet from the host, or when we get a new SWL packet and the shared
// list is different so the window bar items may have changed.
//
// It's quite common for the active window to be (a) nothing, meaning no
// shared app window is active or (b) not something relating to what's on
// the window bar currently.  The latter is a transitory condition, caused
// because SWL packets come before AWC packets.
//
void ASShare::VIEW_WindowBarChangedActiveWindow(ASPerson * pasHost)
{
    PWNDBAR_ITEM        pItem;
    PSWLWINATTRIBUTES   pWin;
    int                 iWin;
    UINT_PTR            activeWinID;
    TSHR_UINT32         ownerWinID;

    DebugEntry(ASShare::VIEW_WindowBarChangedActiveWindow);

    ValidateView(pasHost);

    //
    // Map this remote window to the closest window bar item in the
    // ancestor hierarchy.
    //

    pItem = NULL;
    activeWinID = pasHost->awcActiveWinID;

    while (activeWinID != 0)
    {
        //
        // Is this on the window bar?
        //
        COM_BasedListFind(LIST_FIND_FROM_FIRST,
            &(pasHost->m_pView->m_viewWindowBarItems),
            (void**)&pItem, FIELD_OFFSET(WNDBAR_ITEM, chain),
            FIELD_OFFSET(WNDBAR_ITEM, winIDRemote),
            activeWinID, FIELD_SIZE(WNDBAR_ITEM, winIDRemote));

        if (pItem)
        {
            // Yes.
            TRACE_OUT(("VIEW_UpdateActiveWindow:  Window 0x%08x found", activeWinID));
            break;
        }

        //
        // Try to go up the chain to this window's owner.  Find this item,
        // then grab the owner of it, and try again.
        //
        ownerWinID  = 0;

        for (iWin = 0, pWin = pasHost->m_pView->m_aswlLast;
             iWin < pasHost->m_pView->m_swlCount;
             iWin++, pWin++)
        {
            if (pWin->winID == activeWinID)
            {
                // Found it.
                ownerWinID = pWin->ownerWinID;
                break;
            }
        }

        activeWinID = ownerWinID;
    }

    //
    // Now see if the active item is different.
    //
    VIEWWindowBarChangeActiveItem(pasHost, pItem);

    DebugExitVOID(ASShare::VIEW_WindowBarChangedActiveWindow);
}


//
// VIEWWindowBarFirstVisibleItem()
//
// This returns a pointer to the first visible item.  We must loop through
// the invisible items first.  Since this doesn't happen with a lot of
// frequence, and the size of the list is rarely that big, this is fine.
//
// We return NULL if the list is empty.
//
PWNDBAR_ITEM ASShare::VIEWWindowBarFirstVisibleItem(ASPerson * pasHost)
{
    PWNDBAR_ITEM    pItem;
    int             iItem;

    ValidateView(pasHost);

    if (!pasHost->m_pView->m_viewWindowBarItemCount)
    {
        pItem = NULL;
        DC_QUIT;
    }

    ASSERT(pasHost->m_pView->m_viewWindowBarItemFirst < pasHost->m_pView->m_viewWindowBarItemCount);

    pItem = (PWNDBAR_ITEM)COM_BasedListFirst(&(pasHost->m_pView->m_viewWindowBarItems),
        FIELD_OFFSET(WNDBAR_ITEM, chain));
    for (iItem = 0; iItem < pasHost->m_pView->m_viewWindowBarItemFirst; iItem++)
    {
        ASSERT(pItem);

        pItem = (PWNDBAR_ITEM)COM_BasedListNext(&(pasHost->m_pView->m_viewWindowBarItems),
            pItem, FIELD_OFFSET(WNDBAR_ITEM, chain));
    }

    ASSERT(pItem);

DC_EXIT_POINT:
    DebugExitPVOID(ASShare::VIEWWindowBarFirstVisibleItem, pItem);
    return(pItem);
}




//
// VIEWWindowBarChangeActiveItem()
//
// Updates the active item on the window bar.  This happens when either
// we get a new AWC packet telling us there's a new active window on the host,
// or when we get a SWL packet, which may have added/removed items.  This
// also happens when one is clicked on and the user is in control of the host.
//
void ASShare::VIEWWindowBarChangeActiveItem
(
    ASPerson *      pasHost,
    PWNDBAR_ITEM    pItem
)
{
    DebugEntry(ASShare::VIEWWindowBarChangeActiveItem);


    //
    // If it's the active one already, nothing to do.
    //
    if (pItem == pasHost->m_pView->m_viewWindowBarActiveItem)
    {
        TRACE_OUT(("VIEWWindowBarChangeActiveItem: activating current item, nothing to do"));
        DC_QUIT;
    }

    //
    // Now make the visual change
    //
    if (pasHost->m_pView->m_viewWindowBarActiveItem)
    {
        VIEWWindowBarItemsInvalidate(pasHost, pasHost->m_pView->m_viewWindowBarActiveItem);
    }

    pasHost->m_pView->m_viewWindowBarActiveItem = pItem;

    if (pItem)
    {
        VIEWWindowBarItemsInvalidate(pasHost, pItem);
    }

DC_EXIT_POINT:
    DebugExitVOID(ASShare::VIEWWindowBarChangeActiveItem);
}





//
// VIEWWindowBarItemsScroll()
//
// This is called when the end user presses a scroll button to shuffle over
// the visible window bar items.  And also when items are added/removed
// so that scroll stuff is adjusted.
//
void ASShare::VIEWWindowBarItemsScroll
(
    ASPerson *      pasHost,
    WPARAM          wParam,
    LPARAM          lParam
)
{
    int             oldPos;
    int             newPos;
    SCROLLINFO      si;

    DebugEntry(ASShare::VIEWWindowBarItemsScroll);

    ValidateView(pasHost);

    oldPos = pasHost->m_pView->m_viewWindowBarItemFirst;

    switch (GET_WM_HSCROLL_CODE(wParam, lParam))
    {
        case SB_LINEUP:
        case SB_PAGEUP:
            newPos = oldPos - 1;
            break;

        case SB_LINEDOWN:
        case SB_PAGEDOWN:
            newPos = oldPos + 1;
            break;

        case SB_TOP:
            newPos = 0;
            break;

        case SB_BOTTOM:
            newPos = pasHost->m_pView->m_viewWindowBarItemCount;
            break;

        case SB_THUMBTRACK:
        case SB_THUMBPOSITION:
            newPos = GET_WM_HSCROLL_POS(wParam, lParam);
            break;

        default:
            newPos = oldPos;
            break;

    }

    //
    // Pin position into range, taking care to show the maximum number
    // of items that will fit in the space.
    //
    if (newPos + pasHost->m_pView->m_viewWindowBarItemFitCount >
        pasHost->m_pView->m_viewWindowBarItemCount)
    {
        newPos = pasHost->m_pView->m_viewWindowBarItemCount -
            pasHost->m_pView->m_viewWindowBarItemFitCount;
    }

    if (newPos < 0)
        newPos = 0;

    //
    // Has the position changed?
    //
    if (newPos != oldPos)
    {
        pasHost->m_pView->m_viewWindowBarItemFirst = newPos;

        //
        // Scroll the item area over.  This will do nothing if redraw is off.
        // Conveniently!
        //
        ::ScrollWindowEx(::GetDlgItem(pasHost->m_pView->m_viewWindowBar, IDVIEW_ITEMS),
            (oldPos - newPos) * (m_viewItemCX + m_viewEdgeCX),
            0,
            NULL, NULL, NULL, NULL,
            SW_INVALIDATE | SW_ERASE);
    }

    //
    // If nothing's changed, no big deal.
    //
    ::ZeroMemory(&si, sizeof(si));

    si.cbSize = sizeof(SCROLLINFO);
    si.fMask = SIF_DISABLENOSCROLL | SIF_POS | SIF_PAGE | SIF_RANGE;

    si.nMin  = 0;
    si.nMax  = pasHost->m_pView->m_viewWindowBarItemCount - 1;
    si.nPage = pasHost->m_pView->m_viewWindowBarItemFitCount;
    si.nPos  = pasHost->m_pView->m_viewWindowBarItemFirst;

    ::SetScrollInfo(::GetDlgItem(pasHost->m_pView->m_viewWindowBar, IDVIEW_SCROLL),
        SB_CTL, &si, TRUE);

    DebugExitVOID(ASShare::VIEWWindowBarItemsScroll);
}





//
// VIEWWindowBarItemsProc()
//
LRESULT CALLBACK VIEWWindowBarItemsProc
(
    HWND        hwnd,
    UINT        message,
    WPARAM      wParam,
    LPARAM      lParam
)
{
    return(g_asSession.pShare->VIEW_WindowBarItemsProc(hwnd, message, wParam, lParam));
}



LRESULT ASShare::VIEW_WindowBarItemsProc
(
    HWND        hwnd,
    UINT        message,
    WPARAM      wParam,
    LPARAM      lParam
)
{
    LRESULT     rc = 0;
    ASPerson *  pasHost;

    DebugEntry(ASShare::VIEW_WindowBarItemsProc);

    pasHost = (ASPerson *)GetWindowLongPtr(hwnd, GWLP_USERDATA);
    if (pasHost)
    {
        ValidateView(pasHost);
    }

    switch (message)
    {
        case WM_NCCREATE:
        {
            // Get & save the person this view is for.
            pasHost = (ASPerson *)((LPCREATESTRUCT)lParam)->lpCreateParams;
            ValidateView(pasHost);
            SetWindowLongPtr(hwnd, GWLP_USERDATA, (LPARAM)pasHost);

            COM_BasedListInit(&(pasHost->m_pView->m_viewWindowBarItems));
            goto DefWndProc;
            break;
        }

        case WM_NCDESTROY:
        {
            if (pasHost != NULL)
            {
                // Loop through the items, killing the head, until done.
                PWNDBAR_ITEM    pItem;

                while (pItem = (PWNDBAR_ITEM)COM_BasedListFirst(
                    &(pasHost->m_pView->m_viewWindowBarItems),
                    FIELD_OFFSET(WNDBAR_ITEM, chain)))
                {
                    COM_BasedListRemove(&(pItem->chain));

                    delete pItem;
                }

                //
                // Zero these out for safety.  Yes, we're about to free
                // m_pView altogether, so find out if we're referencing
                // stuff that's gone.
                //
                pasHost->m_pView->m_viewWindowBarItemCount = 0;
                pasHost->m_pView->m_viewWindowBarActiveItem = NULL;
            }

            goto DefWndProc;
            break;
        }

        case WM_ENABLE:
        {
            // Repaint the items, disabled or pressable.
            ::InvalidateRect(hwnd, NULL, FALSE);
            break;
        }

        case WM_PAINT:
        {
            VIEWWindowBarItemsPaint(pasHost, hwnd);
            break;
        }

        case WM_LBUTTONDOWN:
        {
            VIEWWindowBarItemsClick(pasHost, hwnd,
                GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
            break;
        }

        default:
DefWndProc:
        {
            rc = DefWindowProc(hwnd, message, wParam, lParam);
            break;
        }
    }

    DebugExitDWORD(ASShare::VIEW_WindowBarItemsProc, rc);
    return(rc);
}




//
// VIEWWindowBarItemsPaint()
//
void ASShare::VIEWWindowBarItemsPaint
(
    ASPerson *      pasHost,
    HWND            hwndItems
)
{
    HFONT           hfnT;
    COLORREF        clrText;
    int             bkMode;
    PWNDBAR_ITEM    pItem;
    PAINTSTRUCT     ps;
    int             xT;
    RECT            rcItem;

    DebugEntry(ASShare::VIEWWindowBarItemsPaint);

    ValidateView(pasHost);

    ::BeginPaint(hwndItems, &ps);

    //
    // Skip over the visible items to the left of the paint area.
    //
    xT = 0;
    pItem = VIEWWindowBarFirstVisibleItem(pasHost);
    while (pItem && (xT + m_viewItemCX < ps.rcPaint.left))
    {
        pItem = (PWNDBAR_ITEM)COM_BasedListNext(&(pasHost->m_pView->m_viewWindowBarItems),
            pItem, FIELD_OFFSET(WNDBAR_ITEM, chain));
        xT += m_viewItemCX + m_viewEdgeCX;
    }

    //
    // Setup painting objects, etc.
    //
    hfnT = SelectFont(ps.hdc, ::GetStockObject(DEFAULT_GUI_FONT));
    if ((pasHost->m_caControlledBy != m_pasLocal) || pasHost->m_caControlPaused)
    {
        clrText = ::GetSysColor(COLOR_GRAYTEXT);
    }
    else
    {
        clrText = ::GetSysColor(COLOR_BTNTEXT);
    }
    clrText = ::SetTextColor(ps.hdc, clrText);
    bkMode = ::SetBkMode(ps.hdc, TRANSPARENT);

    //
    // Now paint the visible items within the paint area.
    //
    while (pItem && (xT < ps.rcPaint.right))
    {
        rcItem.left     = xT;
        rcItem.top      = 0;
        rcItem.right    = rcItem.left + m_viewItemCX;
        rcItem.bottom   = rcItem.top + m_viewItemCY;

        //
        // Draw button area, pressed in & checked for current tray item.
        //
        DrawFrameControl(ps.hdc, &rcItem, DFC_BUTTON,
        DFCS_BUTTONPUSH | DFCS_ADJUSTRECT |
        ((pItem == pasHost->m_pView->m_viewWindowBarActiveItem) ? (DFCS_PUSHED | DFCS_CHECKED) : 0));

        // Subtract some margin.
        ::InflateRect(&rcItem, -m_viewEdgeCX, -m_viewEdgeCY);

        if (pItem == pasHost->m_pView->m_viewWindowBarActiveItem)
        {
            // Offset one for pushed effect
            ::OffsetRect(&rcItem, 1, 1);
        }

        //
        // Draw icon
        //
        ::DrawIconEx(ps.hdc, rcItem.left,
            (rcItem.top + rcItem.bottom - ::GetSystemMetrics(SM_CYSMICON)) / 2,
            g_hetASIconSmall,
            ::GetSystemMetrics(SM_CXSMICON),
            ::GetSystemMetrics(SM_CYSMICON),
            0, NULL, DI_NORMAL);

        rcItem.left += ::GetSystemMetrics(SM_CXSMICON) + m_viewEdgeCX;

        //
        // Draw item text
        //
        ::DrawText(ps.hdc, pItem->szText, -1, &rcItem, DT_NOCLIP | DT_EXPANDTABS |
            DT_NOPREFIX | DT_VCENTER | DT_SINGLELINE | DT_END_ELLIPSIS);

        pItem = (PWNDBAR_ITEM)COM_BasedListNext(&(pasHost->m_pView->m_viewWindowBarItems),
            pItem, FIELD_OFFSET(WNDBAR_ITEM, chain));
        xT += m_viewItemCX + m_viewEdgeCX;
    }

    ::SetBkMode(ps.hdc, bkMode);
    ::SetTextColor(ps.hdc, clrText);
    SelectFont(ps.hdc, hfnT);

    ::EndPaint(hwndItems, &ps);

    DebugExitVOID(ASShare::VIEWWindowBarItemsPaint);
}



//
// VIEWWindowBarItemsClick()
//
// Handles a left click on the window bar area.  When we are in control, this
// will try to activate/restore the remote window the clicked item represents.
//
void ASShare::VIEWWindowBarItemsClick
(
    ASPerson *  pasHost,
    HWND        hwndItems,
    int         x,
    int         y
)
{
    RECT            rc;
    PWNDBAR_ITEM    pItemT;

    DebugEntry(ASShare::VIEWWindowBarClick);

    ValidateView(pasHost);

    //
    // If we're not in control of this host, or there aren't any items, we're
    // done.
    //
    if ((pasHost->m_caControlledBy != m_pasLocal)   ||
        pasHost->m_caControlPaused                  ||
        (!pasHost->m_pView->m_viewWindowBarItemCount))
    {
        DC_QUIT;
    }

    ::GetClientRect(hwndItems, &rc);

    //
    // Start at first visible item.
    //
    pItemT = VIEWWindowBarFirstVisibleItem(pasHost);
    while (pItemT && (rc.left < rc.right))
    {
        // Is x in range?
        if ((x >= rc.left) && (x < rc.left + m_viewItemCX))
        {
            // YES!  We've found the item.  If it's different than the
            // current one, send a packet to the host.
            //
            // LAURABU BUGBUG:
            // Should we do this always?  Is it possible to have an active
            // item whose z-order would change if the active button was
            // pressed again?
            //
            // We're trying to avoid sending a ton of requests from somebody
            // who clicks repeatedly on the same button, when we haven't
            // received an AWC notification back.
            //
            VIEWWindowBarDoActivate(pasHost, pItemT);
            break;
        }

        pItemT = (PWNDBAR_ITEM)COM_BasedListNext(&(pasHost->m_pView->m_viewWindowBarItems),
            pItemT, FIELD_OFFSET(WNDBAR_ITEM, chain));
        rc.left += m_viewItemCX + m_viewEdgeCX;
    }

DC_EXIT_POINT:
    DebugExitVOID(ASShare::VIEWWindowBarItemsClick);
}



//
// VIEWWindowBarDoActivate()
//
// Sends command to remote host requesting the window be activated and
// maybe unminimized.
//
// This is used when clicking on a button or choosing the window's item in
// the Applications menu.
//
void ASShare::VIEWWindowBarDoActivate
(
    ASPerson *      pasHost,
    PWNDBAR_ITEM    pItem
)
{
    DebugEntry(ASShare::VIEWWindowBarDoActivate);

    ValidateView(pasHost);
    if (pItem != pasHost->m_pView->m_viewWindowBarActiveItem)
    {
        // Activate  it.  If we can't send an activate request,
        // do not update the active item.
        //
        if (!AWC_SendMsg(pasHost->mcsID, AWC_MSG_ACTIVATE_WINDOW,
            pItem->winIDRemote, 0))
        {
            ERROR_OUT(("VIEWWindowBarDoActivate: can't send AWC packet so failing"));
        }
        else
        {
            VIEWWindowBarChangeActiveItem(pasHost, pItem);
        }
    }

    // Try to restore if minimized no matter what.
    if (pItem->flags & SWL_FLAG_WINDOW_MINIMIZED)
    {
        AWC_SendMsg(pasHost->mcsID, AWC_MSG_RESTORE_WINDOW, pItem->winIDRemote, 0);
    }

    DebugExitVOID(ASShare::VIEWWindowBarDoActivate);
}


//
// VIEWWindowBarItemsInvalidate()
//
// This invalidates the window bar item, if it's visible in the window bar
// list currently.
//
void ASShare::VIEWWindowBarItemsInvalidate
(
    ASPerson *      pasHost,
    PWNDBAR_ITEM    pItem
)
{
    PWNDBAR_ITEM    pItemT;
    RECT            rc;

    DebugEntry(ASShare::VIEWWindowBarItemsInvalidate);

    ValidateView(pasHost);

    ASSERT(pItem);

    ::GetClientRect(::GetDlgItem(pasHost->m_pView->m_viewWindowBar, IDVIEW_ITEMS),
        &rc);

    //
    // Start at the first visible item, and see if any in the visible range
    // are this one.  There will never be that many items visible across,
    // it's not heinous to do this.
    //
    pItemT = VIEWWindowBarFirstVisibleItem(pasHost);
    while (pItemT && (rc.left < rc.right))
    {
        if (pItemT == pItem)
        {
            // Found it, it's in the visible range.  Invalidate it.
            rc.right = rc.left + m_viewItemCX;
            ::InvalidateRect(::GetDlgItem(pasHost->m_pView->m_viewWindowBar,
                IDVIEW_ITEMS), &rc, TRUE);
            break;
        }

        pItemT = (PWNDBAR_ITEM)COM_BasedListNext(&(pasHost->m_pView->m_viewWindowBarItems),
            pItemT, FIELD_OFFSET(WNDBAR_ITEM, chain));
        rc.left += m_viewItemCX + m_viewEdgeCX;
    }

    DebugExitVOID(ASShare::VIEWWindowBarItemsInvalidate);
}




//
// VIEWFullScreenExitProc()
//
// Window handler for full screen exit button.
//
LRESULT CALLBACK VIEWFullScreenExitProc
(
    HWND        hwnd,
    UINT        message,
    WPARAM      wParam,
    LPARAM      lParam
)
{
    return(g_asSession.pShare->VIEW_FullScreenExitProc(hwnd, message, wParam, lParam));
}



//
// VIEW_FullScreenExitProc()
//
LRESULT ASShare::VIEW_FullScreenExitProc
(
    HWND        hwnd,
    UINT        message,
    WPARAM      wParam,
    LPARAM      lParam
)
{
    LRESULT     rc = 0;
    ASPerson *  pasHost;

    DebugEntry(VIEW_FullScreenExitProc);

    pasHost = (ASPerson *)GetWindowLongPtr(hwnd, GWLP_USERDATA);
    if (pasHost)
    {
        ValidateView(pasHost);
    }

    switch (message)
    {
        case WM_NCCREATE:
        {
            // Get the passed in host pointer, and set in our window long
            pasHost = (ASPerson *)((LPCREATESTRUCT)lParam)->lpCreateParams;
            SetWindowLongPtr(hwnd, GWLP_USERDATA, (LPARAM)pasHost);

            goto DefWndProc;
            break;
        }

        case WM_NCDESTROY:
        {
            //
            // Make sure tracking is stopped.
            //
            pasHost->m_pView->m_viewFullScreenExitTrack = FALSE;
            break;
        }

        case WM_ERASEBKGND:
        {
            rc = TRUE;
            break;
        }

        case WM_PAINT:
        {
            VIEWFullScreenExitPaint(pasHost, hwnd);
            break;
        }

        case WM_LBUTTONDOWN:
        {
            //
            // Start tracking to move or click button.
            //
            pasHost->m_pView->m_viewFullScreenExitTrack = TRUE;
            pasHost->m_pView->m_viewFullScreenExitMove = FALSE;

            // Original click, relative to our client
            pasHost->m_pView->m_viewFullScreenExitStart.x =
                GET_X_LPARAM(lParam);
            pasHost->m_pView->m_viewFullScreenExitStart.y =
                GET_Y_LPARAM(lParam);

            // Set capture, and wait for moves/button up
            SetCapture(hwnd);
            break;
        }

        case WM_MOUSEMOVE:
        {
            if (pasHost->m_pView->m_viewFullScreenExitTrack)
            {
                POINT   ptMove;

                ptMove.x = GET_X_LPARAM(lParam);
                ptMove.y = GET_Y_LPARAM(lParam);

                //
                // If we're not in move mode, see if this has pushed us over
                // the tolerance.
                //
                if (!pasHost->m_pView->m_viewFullScreenExitMove)
                {
                    if ((abs(ptMove.x - pasHost->m_pView->m_viewFullScreenExitStart.x) >
                            GetSystemMetrics(SM_CXDRAG))    ||
                        (abs(ptMove.y - pasHost->m_pView->m_viewFullScreenExitStart.y) >
                            GetSystemMetrics(SM_CYDRAG)))
                    {
                        //
                        // User has moved out of tolerance zone, must be
                        // dragging to move the button out of the way.
                        //
                        pasHost->m_pView->m_viewFullScreenExitMove = TRUE;
                    }
                }

                if (pasHost->m_pView->m_viewFullScreenExitMove)
                {
                    RECT    rcWindow;

                    //
                    // Move the button so that the cursor is over the
                    // same point as originally clicked on.
                    //

                    // Get our current position, in parent coordsinates.
                    GetWindowRect(hwnd, &rcWindow);
                    MapWindowPoints(NULL, GetParent(hwnd), (LPPOINT)&rcWindow, 2);

                    // Offset it by the amount of the move.
                    OffsetRect(&rcWindow,
                        ptMove.x - pasHost->m_pView->m_viewFullScreenExitStart.x,
                        ptMove.y - pasHost->m_pView->m_viewFullScreenExitStart.y);
                    SetWindowPos(hwnd, NULL, rcWindow.left, rcWindow.top, 0, 0,
                        SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOZORDER);
                }
            }
            break;
        }

        case WM_LBUTTONUP:
        {
            if (pasHost->m_pView->m_viewFullScreenExitTrack)
            {
                //
                // This will send us CAPTURECHANGED, causing us to clear
                // the ExitTrack flag.
                //
                ReleaseCapture();

                //
                // If we never transitioned into move mode, then this was
                // a click on the button.
                //
                if (!pasHost->m_pView->m_viewFullScreenExitMove)
                {
                    //
                    // This was a click, send a command.
                    //
                    PostMessage(pasHost->m_pView->m_viewFrame, WM_COMMAND, CMD_VIEWFULLSCREEN, 0);
                }
            }
            break;
        }

        case WM_CAPTURECHANGED:
        {
            //
            // If we're tracking, something happened, so cancel out.
            //
            if (pasHost->m_pView->m_viewFullScreenExitTrack)
            {
                pasHost->m_pView->m_viewFullScreenExitTrack = FALSE;
            }
            break;
        }

        default:
DefWndProc:
            rc = DefWindowProc(hwnd, message, wParam, lParam);
            break;
    }

    DebugExitDWORD(VIEW_FullScreenExitProc, rc);
    return(rc);

}



//
// VIEWFullScreenExitPaint()
//
// Paints the full screen button.
//
void ASShare::VIEWFullScreenExitPaint
(
    ASPerson *  pasHost,
    HWND        hwnd
)
{
    RECT        rc;
    PAINTSTRUCT ps;
    char        szRestore[256];
    HFONT       hfnOld;
    COLORREF    txtColor;
    COLORREF    bkColor;

    DebugEntry(ASShare::VIEWFullScreenExitPaint);

    BeginPaint(hwnd, &ps);

    GetClientRect(hwnd, &rc);
    DrawFrameControl(ps.hdc, &rc, DFC_BUTTON, DFCS_BUTTONPUSH |
        DFCS_ADJUSTRECT);

    // Margin adjustments...
    InflateRect(&rc, -m_viewEdgeCX, -m_viewEdgeCY);

    DrawIconEx(ps.hdc, rc.left,
        (rc.top + rc.bottom - GetSystemMetrics(SM_CYSMICON)) / 2,
        m_viewFullScreenExitIcon,
        GetSystemMetrics(SM_CXSMICON),
        GetSystemMetrics(SM_CYSMICON),
        0, NULL, DI_NORMAL);
    rc.left += GetSystemMetrics(SM_CXSMICON) + m_viewEdgeCX;

    hfnOld = SelectFont(ps.hdc, GetStockObject(DEFAULT_GUI_FONT));
    txtColor = SetTextColor(ps.hdc, GetSysColor(COLOR_BTNTEXT));
    bkColor = SetBkColor(ps.hdc, GetSysColor(COLOR_BTNFACE));

    LoadString(g_asInstance, IDS_RESTORE, szRestore, sizeof(szRestore));
    DrawText(ps.hdc, szRestore, -1, &rc, DT_NOCLIP | DT_EXPANDTABS |
        DT_NOPREFIX | DT_VCENTER | DT_SINGLELINE);

    SetBkColor(ps.hdc, bkColor);
    SetTextColor(ps.hdc, txtColor);
    SelectFont(ps.hdc, hfnOld);
    EndPaint(hwnd, &ps);

    DebugExitVOID(ASShare::VIEWFullScreenExitPaint);
}