//
// PAGE.CPP
// WB Page Handling
//
// Copyright Microsoft 1998-
//

// PRECOMP
#include "precomp.h"


//
//
// Function:    GetData
//
// Purpose:     Get a pointer to the external representation of a graphic
//
//
PWB_GRAPHIC PG_GetData
(
    WB_PAGE_HANDLE      hPage,
    WB_GRAPHIC_HANDLE   hGraphic
)
{
    MLZ_EntryOut(ZONE_FUNCTION, "PG_GetData");

    // Get the pointer from the core
    PWB_GRAPHIC  pHeader = NULL;

    UINT uiReturn = g_pwbCore->WBP_GraphicGet(hPage, hGraphic, &pHeader);
    if (uiReturn != 0)
    {
        // Throw an exception
        DefaultExceptionHandler(WBFE_RC_WB, uiReturn);
    }

    return pHeader;
}


//
//
// Function:    AllocateGraphic
//
// Purpose:     Allocate memory for a graphic
//
//
PWB_GRAPHIC PG_AllocateGraphic
(
    WB_PAGE_HANDLE      hPage,
    DWORD               length
)
{
    MLZ_EntryOut(ZONE_FUNCTION, "PG_AllocateGraphic");

    // Release the object (function never fails)
    PWB_GRAPHIC pHeader = NULL;

    UINT uiReturn = g_pwbCore->WBP_GraphicAllocate(hPage, length, &pHeader);
    if (uiReturn != 0)
    {
        // Throw exception
        DefaultExceptionHandler(WBFE_RC_WB, uiReturn);
    }

    return pHeader;
}


//
//
// Function:    First (crect)
//
// Purpose:     Return the first object in the page (bottommost Z-order)
//              that intersects the bounding rectangle
//
//
//CHANGED BY RAND - for object hit check
DCWbGraphic* PG_First
(
    WB_PAGE_HANDLE      hPage,
    WB_GRAPHIC_HANDLE * phGraphic,
    LPCRECT             pRectUpdate,
    BOOL                bCheckReallyHit
)
{
    UINT                uiReturn = 0;
    BOOL         empty = TRUE;
    PWB_GRAPHIC  pHeader = NULL;
    DCWbGraphic* pGraphic = NULL;
    RECT         rc;

    MLZ_EntryOut(ZONE_FUNCTION, "PG_First");

    uiReturn = g_pwbCore->WBP_GraphicHandle(hPage, NULL, FIRST, phGraphic);
    if (uiReturn == WB_RC_NO_SUCH_GRAPHIC)
    {
        return(pGraphic);
    }

    if (uiReturn != 0)
    {
        // Throw an exception
        DefaultExceptionHandler(WBFE_RC_WB, uiReturn);
	    return NULL;
    }

    if (pRectUpdate == NULL)
    {
        // Read the graphic
        // We have got what we want
        TRACE_MSG(("Got the object we want"));
        pGraphic = DCWbGraphic::ConstructGraphic(hPage, *phGraphic);
    }
    else
    {
        pHeader = PG_GetData(hPage, *phGraphic);
		if(pHeader == NULL)
		{
			return NULL;
		}

        rc.left   = pHeader->rectBounds.left;
        rc.top    = pHeader->rectBounds.top;
        rc.right  = pHeader->rectBounds.right;
        rc.bottom = pHeader->rectBounds.bottom;
        empty = !::IntersectRect(&rc, &rc, pRectUpdate);

        g_pwbCore->WBP_GraphicRelease(hPage, *phGraphic, pHeader);

        if (empty)
        {
            TRACE_MSG(("First object not needed - go to next"));
            pGraphic = PG_Next(hPage, phGraphic, pRectUpdate, bCheckReallyHit);
        }
        else
        {
            pGraphic = DCWbGraphic::ConstructGraphic(hPage, *phGraphic);

            if( bCheckReallyHit && (pGraphic != NULL) )
            {
                // do a real object hit test since we
                // know its bounding rect has hit
                if( !pGraphic->CheckReallyHit( pRectUpdate ) )
                {
                    delete pGraphic;
                    pGraphic = PG_Next(hPage, phGraphic, pRectUpdate, TRUE); // look again
                }
            }
        }
    }

    return(pGraphic);
}


//
//
// Function:    Next
//
// Purpose:     Return the next graphic in the page (going up through the
//              Z-order).  GetFirst must have been called before this
//              member.
//
DCWbGraphic* PG_Next
(
    WB_PAGE_HANDLE      hPage,
    WB_GRAPHIC_HANDLE * phGraphic,
    LPCRECT     pRectUpdate,
    BOOL        bCheckReallyHit
)
{
    UINT        uiReturn = 0;
    BOOL         empty = TRUE;
    PWB_GRAPHIC  pHeader = NULL;
    DCWbGraphic* pGraphic = NULL;
    RECT        rc;

    MLZ_EntryOut(ZONE_FUNCTION, "PG_Next");

    while (uiReturn == 0)
    {
        uiReturn = g_pwbCore->WBP_GraphicHandle(hPage, *phGraphic,
                AFTER, phGraphic);
        if (uiReturn == WB_RC_NO_SUCH_GRAPHIC)
        {
            return(pGraphic);
        }
        else if (uiReturn != 0)
        {
            // Throw an exception
            DefaultExceptionHandler(WBFE_RC_WB, uiReturn);
		    return NULL;
        }

        if (pRectUpdate == NULL)
        {
            // Read the graphic
            // We have got what we want
            TRACE_MSG(("Got the object we want"));
            pGraphic = DCWbGraphic::ConstructGraphic(hPage, *phGraphic);
            break;
        }
        else
        {
            pHeader = PG_GetData(hPage, *phGraphic);

            rc.left   = pHeader->rectBounds.left;
            rc.top    = pHeader->rectBounds.top;
            rc.right  = pHeader->rectBounds.right;
            rc.bottom = pHeader->rectBounds.bottom;
            empty = !::IntersectRect(&rc, &rc, pRectUpdate);

            g_pwbCore->WBP_GraphicRelease(hPage, *phGraphic, pHeader);
            if (!empty)
            {
                TRACE_MSG(("Found the one we want - breaking out"));
                pGraphic = DCWbGraphic::ConstructGraphic(hPage, *phGraphic);

                if( bCheckReallyHit && (pGraphic != NULL) )
                {
                    // do a real object hit test since we
                    // know its bounding rect has hit
                    if( pGraphic->CheckReallyHit( pRectUpdate ) )
                        break;
                    else
                    {
                        delete pGraphic; // look again
                        pGraphic = NULL;
                    }
                }
                else
                    break; // found it
            }
        }
    }

    return(pGraphic);
}


//
//
// Function:    After
//
// Purpose:     Return the graphic after the specified graphic (going up
//              through the Z-order).
//
//
DCWbGraphic* PG_After
(
    WB_PAGE_HANDLE      hPage,
    const DCWbGraphic&  graphic
)
{
    MLZ_EntryOut(ZONE_FUNCTION, "PG_After");

    WB_GRAPHIC_HANDLE hGraphic;
    UINT uiReturn = g_pwbCore->WBP_GraphicHandle(hPage, graphic.Handle(),
            AFTER, &hGraphic);

    if (uiReturn == WB_RC_NO_SUCH_GRAPHIC)
    {
        return(NULL);
    }

    if (uiReturn != 0)
    {
        // Throw an exception
        DefaultExceptionHandler(WBFE_RC_WB, uiReturn);
		return NULL;
    }

    // Read the graphic
    return(DCWbGraphic::ConstructGraphic(hPage, hGraphic));
}

//
//
// Function:    Before
//
// Purpose:     Return the graphic before the specified graphic (going down
//              through the Z-order).
//
//
DCWbGraphic* PG_Before
(
    WB_PAGE_HANDLE      hPage,
    const DCWbGraphic&  graphic
)
{
    MLZ_EntryOut(ZONE_FUNCTION, "PG_Before");

    WB_GRAPHIC_HANDLE hGraphic;
    UINT uiReturn = g_pwbCore->WBP_GraphicHandle(hPage, graphic.Handle(),
            BEFORE, &hGraphic);

    if (uiReturn == WB_RC_NO_SUCH_GRAPHIC)
    {
        return(NULL);
    }

    if (uiReturn != 0)
    {
        // Throw an exception
        DefaultExceptionHandler(WBFE_RC_WB, uiReturn);
	    return NULL;
    }

    // Read the graphic
    return(DCWbGraphic::ConstructGraphic(hPage, hGraphic));
}



//
//
// Function:    FirstPointer
//
// Purpose:     Return the first remote pointer object that is currently
//              active on this page.
//
//
DCWbGraphicPointer* PG_FirstPointer
(
    WB_PAGE_HANDLE  hPage,
    POM_OBJECT * ppUserNext
)
{
    MLZ_EntryOut(ZONE_FUNCTION, "PG_FirstPointer");

    // Get the handle of the first user
    g_pwbCore->WBP_PersonHandleFirst(ppUserNext);

    // Return the next pointer that is active on this page
    return PG_LookForPointer(hPage, *ppUserNext);
}

//
//
// Function:    LocalPointer
//
// Purpose:     Return the local user's pointer, if it is active on this
//              page.
//
//
DCWbGraphicPointer* PG_LocalPointer
(
    WB_PAGE_HANDLE  hPage
)
{
    MLZ_EntryOut(ZONE_FUNCTION, "PG_LocalPointer");

    DCWbGraphicPointer* pResult = NULL;

    // Get the local user
    POM_OBJECT    hUser;
    g_pwbCore->WBP_PersonHandleLocal(&hUser);
    WbUser* pUser = WB_GetUser(hUser);

    // Check whether the pointer is active, and is on this page
    if ((pUser != NULL)             &&
        (pUser->IsUsingPointer())   &&
        (pUser->PointerPage() == hPage))
    {
        pResult = pUser->GetPointer();
    }

    // Return the next pointer that is active on this page
    return pResult;
}

//
//
// Function:    NextPointer
//
// Purpose:     Return the next pointer in use.
//              FirstPointer must have been called before this member.
//
//
DCWbGraphicPointer* PG_NextPointer
(
    WB_PAGE_HANDLE  hPage,
    POM_OBJECT *    ppUserNext
)
{
    MLZ_EntryOut(ZONE_FUNCTION, "PG_NextPointer");

    DCWbGraphicPointer* pPointer;

    // Go forward one from the current user
    UINT uiReturn = g_pwbCore->WBP_PersonHandleNext(*ppUserNext, ppUserNext);
    if (uiReturn == 0)
    {
        pPointer = PG_LookForPointer(hPage, *ppUserNext);
    }
    else
    {
        if (uiReturn != WB_RC_NO_SUCH_PERSON)
        {
            ERROR_OUT(("Error getting next user handle"));
        }

        pPointer = NULL;
    }

    return(pPointer);
}

//
//
// Function:    NextPointer
//
// Purpose:     Return the next pointer in use.
//
//
DCWbGraphicPointer* PG_NextPointer
(
    WB_PAGE_HANDLE              hPage,
    const DCWbGraphicPointer*   pStartPointer
)
{
    MLZ_EntryOut(ZONE_FUNCTION, "PG_NextPointer");

    DCWbGraphicPointer* pPointer;

    // Go forward one from passed pointer
    POM_OBJECT hUser;
    UINT uiReturn = g_pwbCore->WBP_PersonHandleNext((pStartPointer->GetUser())->Handle(),
                                           &hUser);

    if (uiReturn == 0)
    {
        pPointer = PG_LookForPointer(hPage, hUser);
    }
    else
    {
        if (uiReturn != WB_RC_NO_SUCH_PERSON)
        {
            ERROR_OUT(("Error from WBP_PersonHandleNext"));
        }

        pPointer = NULL;
    }

    return(pPointer);
}


//
//
// Function:    LookForPointer
//
// Purpose:     Look for the first pointer active on this page, starting
//              the serach with the user whose handle is passed in.
//
//
DCWbGraphicPointer* PG_LookForPointer
(
    WB_PAGE_HANDLE  hPage,
    POM_OBJECT      hUser
)
{
    MLZ_EntryOut(ZONE_FUNCTION, "PG_LookForPointer");

    DCWbGraphicPointer* pPointer = NULL;
    WbUser*             pUser;
    UINT                result = 0;

    // Scan the users (starting with the one passed in)
    for (;;)
    {
        // Check if the user has an active pointer on this page
        pUser = WB_GetUser(hUser);

        if ((pUser != NULL) &&
            (pUser->IsUsingPointer()) &&
            (pUser->PointerPage() == hPage))
        {
            pPointer = pUser->GetPointer();
            break;
        }

        // Get the next user
        result = g_pwbCore->WBP_PersonHandleNext(hUser, &hUser);
        if (result != 0)
        {
            if (result != WB_RC_NO_SUCH_PERSON)
            {
                ERROR_OUT(("Error from WBP_PersonHandleNext"));
            }
            break;
        }
    }

    return(pPointer);
}




//
//
// Function:    GraphicUpdate
//
// Purpose:     Update an existing graphic
//
//
void PG_GraphicUpdate
(
    WB_PAGE_HANDLE      hPage,
    WB_GRAPHIC_HANDLE * phGraphic,
    PWB_GRAPHIC         pHeader
)
{
    MLZ_EntryOut(ZONE_FUNCTION, "PG_GraphicUpdate");

    UINT uiReturn = g_pwbCore->WBP_GraphicUpdateRequest(hPage,
            *phGraphic, pHeader);

    if (uiReturn != 0)
    {
        if( uiReturn == OM_RC_OBJECT_DELETED )
        {
            // somebody nuked our object, try to put it back (bug 4416)
            g_pwbCore->WBP_GraphicAddLast(hPage, pHeader, phGraphic);
        }

        // Throw exception - exception code will special case 
        // OM_RC_OBJECT_DELETED and cancel drawing
        DefaultExceptionHandler(WBFE_RC_WB, uiReturn);
	    return;
    }
}


//
//
// Function:    GraphicReplace
//
// Purpose:     Replace an existing graphic
//
//
void PG_GraphicReplace
(
    WB_PAGE_HANDLE      hPage,
    WB_GRAPHIC_HANDLE * phGraphic,
    PWB_GRAPHIC         pHeader
)
{
    MLZ_EntryOut(ZONE_FUNCTION, "PG_GraphicReplace");

    UINT uiReturn = g_pwbCore->WBP_GraphicReplaceRequest(hPage,
        *phGraphic, pHeader);

    if (uiReturn != 0)
    {
        if (uiReturn == OM_RC_OBJECT_DELETED)
        {
            // somebody nuked our object, try to put it back (bug 4416)
            g_pwbCore->WBP_GraphicAddLast(hPage, pHeader, phGraphic);
        }

        // Throw exception - exception code will special case 
        // OM_RC_OBJECT_DELETED and cancel drawing
        DefaultExceptionHandler(WBFE_RC_WB, uiReturn);
	    return;
    }
}


//
//
// Function:    Clear
//
// Purpose:     Delete all graphics on the page
//
//
void PG_Clear
(
    WB_PAGE_HANDLE  hPage
)
{
    UINT uiReturn = g_pwbCore->WBP_PageClear(hPage);

    if (uiReturn != 0)
    {
        // Throw exception
        DefaultExceptionHandler(WBFE_RC_WB, uiReturn);
	    return;
    }
}


//
//
// Function:    Delete
//
// Purpose:     Delete the specified graphic
//
//
void PG_GraphicDelete
(
    WB_PAGE_HANDLE      hPage,
    const DCWbGraphic&  graphic
)
{
    MLZ_EntryOut(ZONE_FUNCTION, "PG_GraphicDelete");

    UINT uiReturn = g_pwbCore->WBP_GraphicDeleteRequest(hPage, graphic.Handle());
    if (uiReturn != 0)
    {
        // Throw exception
        DefaultExceptionHandler(WBFE_RC_WB, uiReturn);
	    return;
    }
}


//
//
// Function:    SelectLast
//
// Purpose:     Select the last object whose bounding rectangle contains
//              the point specified.
//
//
DCWbGraphic* PG_SelectLast
(
    WB_PAGE_HANDLE  hPage,
    POINT           point
)
{
    RECT            rectHit;
    DCWbGraphic*    pGraphic = NULL;
    DCWbGraphic*    pGraphicPrev = NULL;
    WB_GRAPHIC_HANDLE hGraphic;

    UINT uiReturn = g_pwbCore->WBP_GraphicSelect(hPage, point, NULL, LAST,
                                              &hGraphic);
    if (uiReturn == WB_RC_NO_SUCH_GRAPHIC)
    {
        return(pGraphic);
    }

    if (uiReturn != 0)
    {
        // Throw exception
        DefaultExceptionHandler(WBFE_RC_WB, uiReturn);
	    return NULL;
    }

    // Get the graphic
    pGraphic = DCWbGraphic::ConstructGraphic(hPage, hGraphic);

    // Check to see if its really hit
    if (pGraphic != NULL)
    {
        MAKE_HIT_RECT(rectHit, point);
        if (!pGraphic->CheckReallyHit( &rectHit ))
        {
            // have to look some more
            pGraphicPrev = PG_SelectPrevious(hPage, *pGraphic, point );
            if( pGraphic != pGraphicPrev )
            {
                delete pGraphic;
                pGraphic = pGraphicPrev;
            }
        }
    }

    return(pGraphic);
}


//
//
// Function:    SelectPrevious
//
// Purpose:     Select the previous object whose bounding rectangle contains
//              the point specified.
//
//
DCWbGraphic* PG_SelectPrevious
(
    WB_PAGE_HANDLE      hPage,
    const DCWbGraphic&  graphic,
    POINT               point
)
{
    RECT        rectHit;
    DCWbGraphic* pGraphic = NULL;
    WB_GRAPHIC_HANDLE hGraphic;
    WB_GRAPHIC_HANDLE hGraphicPrev;

    MLZ_EntryOut(ZONE_FUNCTION, "PG_SelectPrevious");

    MAKE_HIT_RECT(rectHit, point );

    hGraphic = graphic.Handle();
    while ( (g_pwbCore->WBP_GraphicSelect(hPage, point,
                                       hGraphic, BEFORE, &hGraphicPrev ))
            != WB_RC_NO_SUCH_GRAPHIC )
    {
        // Get the graphic
        pGraphic = DCWbGraphic::ConstructGraphic(hPage, hGraphicPrev);

        if( pGraphic == NULL )
            break;

        if( pGraphic->CheckReallyHit( &rectHit ) )
            break;

        hGraphic = hGraphicPrev;

        delete pGraphic;
        pGraphic = NULL;
    }


    return(pGraphic);
}



//
//
// Function:    IsTopmost
//
// Purpose:     Return TRUE if the specified graphic is topmost on the page
//
//
BOOL PG_IsTopmost
(
    WB_PAGE_HANDLE      hPage,
    const DCWbGraphic*  pGraphic
)
{
    MLZ_EntryOut(ZONE_FUNCTION, "PG_IsTopmost");

    WB_GRAPHIC_HANDLE hGraphic;
    UINT uiReturn = g_pwbCore->WBP_GraphicHandle(hPage, NULL, LAST, &hGraphic);

    if (uiReturn != 0)
    {
        // Throw an exception
        DefaultExceptionHandler(WBFE_RC_WB, uiReturn);
	    return FALSE;
    }

    return (pGraphic->Handle() == hGraphic);
}

//
//
// Function:    Draw
//
// Purpose:     Draw the contents of the page into the specified device
//              context.
//
//
void PG_Draw
(
    WB_PAGE_HANDLE  hPage,
    HDC             hDC,
    BOOL            thumbNail
)
{
    WB_GRAPHIC_HANDLE   hStart;

    MLZ_EntryOut(ZONE_FUNCTION, "PG_Draw");

    //
    // Draw the graphic objects
    //
    DCWbGraphic* pGraphic = PG_First(hPage, &hStart);
    while (pGraphic != NULL)
    {
        pGraphic->Draw(hDC, thumbNail);

        // Release the current graphic
        delete pGraphic;

        // Get the next one
        pGraphic = PG_Next(hPage, &hStart);
    }
}

//CHANGED BY RAND
#define WB_MIN_PRINT_MARGIN_SIZE     (30)

//
//
// Function:    Print
//
// Purpose:     Print the contents of the page to the specified printer. The
//              contents are scaled to "best fit" on the page. i.e. the
//              largest scaling factor that preserves the aspect ratio of
//              the page is used.
//
//
void PG_Print
(
    WB_PAGE_HANDLE  hPage,
    HDC             hdc,
    LPCRECT         lprcPrint
)
{
    int pageWidth;
    int pageHeight;
    int areaHeight;
    int areaWidth;
    int areaAspectRatio;
    int pageAspectRatio;
    int nPhysOffsetX;
    int nPhysOffsetY;
    int nPhysWidth;
    int nPhysHeight;
    int nVOffsetX;
    int nVOffsetY;

    // get physical printer params
    nPhysOffsetX = GetDeviceCaps(hdc, PHYSICALOFFSETX );
    nPhysOffsetY = GetDeviceCaps(hdc, PHYSICALOFFSETY );
    nPhysWidth   = GetDeviceCaps(hdc, PHYSICALWIDTH );
    nPhysHeight  = GetDeviceCaps(hdc, PHYSICALHEIGHT );

    // calc correct printer area (allow for bugs in some drivers...)
    if( nPhysOffsetX <= 0 )
    {
        nPhysOffsetX = WB_MIN_PRINT_MARGIN_SIZE;
        nVOffsetX = nPhysOffsetX;
    }
    else
        nVOffsetX = 0;

    if( nPhysOffsetY <= 0 )
    {
        nPhysOffsetY = WB_MIN_PRINT_MARGIN_SIZE;
        nVOffsetY = nPhysOffsetY;
    }
    else
        nVOffsetY = 0;


    // get and adjust printer page area
    pageWidth  = GetDeviceCaps(hdc, HORZRES );
    pageHeight = GetDeviceCaps(hdc, VERTRES );

    if( pageWidth >= (nPhysWidth - nPhysOffsetX) )
    {
        // HORZRES is lying to us, compensate
        pageWidth = nPhysWidth - 2*nPhysOffsetX;
    }

    if( pageHeight >= (nPhysHeight - nPhysOffsetY) )
    {
        // VERTRES is lying to us, compensate
        pageHeight = nPhysHeight - 2*nPhysOffsetY;
    }


    // adjust printer area to get max fit for Whiteboard page
    areaWidth  = lprcPrint->right - lprcPrint->left;
    areaHeight = lprcPrint->bottom - lprcPrint->top;
    areaAspectRatio = ((100 * areaHeight + (areaWidth/2))/(areaWidth));
    pageAspectRatio = ((100 * pageHeight + (pageWidth/2))/(pageWidth));

    if (areaAspectRatio < pageAspectRatio)
        pageHeight  = ((pageWidth * areaHeight + (areaWidth/2))/areaWidth);
    else 
    if (areaAspectRatio > pageAspectRatio)
        pageWidth = ((pageHeight * areaWidth + (areaHeight/2))/areaHeight);

    // set up xforms

   	::SetMapMode(hdc, MM_ANISOTROPIC );
    ::SetWindowExtEx(hdc, areaWidth, areaHeight,NULL );
    ::SetWindowOrgEx(hdc, 0,0, NULL );
    ::SetViewportExtEx(hdc, pageWidth, pageHeight, NULL );
    ::SetViewportOrgEx(hdc, nVOffsetX, nVOffsetY, NULL );
    
    // draw the page
    PG_Draw(hPage, hdc);
}



//
//
// Function:    AreaInUse
//
// Purpose:     Return the bounding rectangle of all graphics on the page
//
//
void PG_GetAreaInUse
(
    WB_PAGE_HANDLE      hPage,
    LPRECT              lprcArea
)
{
    WB_GRAPHIC_HANDLE   hStart;
    RECT                rcBounds;

    MLZ_EntryOut(ZONE_FUNCTION, "PG_AreaInUse");

    ::SetRectEmpty(lprcArea);

    // Union together the rects of all the graphics
    DCWbGraphic* pGraphic = PG_First(hPage, &hStart);
    while (pGraphic != NULL)
    {
        pGraphic->GetBoundsRect(&rcBounds);
        ::UnionRect(lprcArea, lprcArea, &rcBounds);

        // Release the current graphic
        delete pGraphic;

        // Get the next one
        pGraphic = PG_Next(hPage, &hStart);
    }
}

//
//
// Function:    PG_InitializePalettes
//
// Purpose:     Create palettes for display and print (if necessary)
//
//
void PG_InitializePalettes(void)
{
    MLZ_EntryOut(ZONE_FUNCTION, "PG_InitializePalettes");

    // If the palettes are not yet initialized - initialize them now
    if (!g_bPalettesInitialized)
    {
        ASSERT(!g_hRainbowPaletteDisplay);

        // Get the number of colors supported by the screen
        // We only need an info DC for this, not a full DC
        HDC     hdc;

        hdc = ::CreateIC("DISPLAY", NULL, NULL, NULL);
        if (!hdc)
        {
            return;
        }

        // Determine whether the device supports palettes
        int iBitsPixel = ::GetDeviceCaps(hdc, BITSPIXEL);
        int iPlanes    = ::GetDeviceCaps(hdc, PLANES);
        int iNumColors = iBitsPixel * iPlanes;

        ::DeleteDC(hdc);

        // If we need the palette, create it.
        // We only need the palette on a 8bpp machine. Anything less (4bpp)
        // and there will be no palette, anything more is a pure color display.
        if ((iNumColors == 8) &&
            (g_hRainbowPaletteDisplay = CreateColorPalette()))
        {
            // Show that we want to use the palette
            g_bUsePalettes = TRUE;

        }
        else
        {
            g_bUsePalettes = FALSE;
        }

        // Show that we have now initialized the palette information
        g_bPalettesInitialized = TRUE;
    }
}

//
//
// Function:    PG_GetPalette
//
// Purpose:     Return the palette for use with this page.
//              This object is temporary and should not be stored.
//
//
HPALETTE PG_GetPalette(void)
{
    MLZ_EntryOut(ZONE_FUNCTION, "PG_GetPalette");

    // If the palettes are not yet initialized - initialize them now
    PG_InitializePalettes();

    if (g_bUsePalettes)
    {
        // If we are using a non-default palette, set the return value
        return(g_hRainbowPaletteDisplay);
    }
    else
    {
        return(NULL);
    }
}


void PG_ReinitPalettes(void)
{
    MLZ_EntryOut(ZONE_FUNCTION, "PG_ReinitPalettes");

    if (g_hRainbowPaletteDisplay)
    {
        if (g_pDraw->m_hDCCached)
        {
            // Select out the rainbow palette so we can delete it
            ::SelectPalette(g_pDraw->m_hDCCached, (HPALETTE)::GetStockObject(DEFAULT_PALETTE), TRUE);
        }
        ::DeletePalette(g_hRainbowPaletteDisplay);
        g_hRainbowPaletteDisplay = NULL;
    }

    g_bPalettesInitialized = FALSE;
    PG_InitializePalettes();
}



//
//
// Function : PG_GetObscuringRect
//
// Purpose  : Return the intersection of a graphic and any objects which
//            obscure it
//
//
void PG_GetObscuringRect
(
    WB_PAGE_HANDLE  hPage,
    DCWbGraphic*    pGraphic,
    LPRECT          lprcObscuring
)
{
    DCWbGraphic* pNextGraphic;
    RECT         rc;
    RECT         rcBounds;

    MLZ_EntryOut(ZONE_FUNCTION, "PG_GetObscuringRect");

    ::SetRectEmpty(lprcObscuring);
    pGraphic->GetBoundsRect(&rcBounds);

    // Loop through all the objects which are above the given one in the
    // Z-order, checking to see if they overlap the given object

    pNextGraphic = pGraphic;
    while (pNextGraphic = PG_After(hPage, *pNextGraphic))
    {
        // Get the bounding rectangle of the next object
        pNextGraphic->GetBoundsRect(&rc);

        // Check the intersection of the rectangles
        ::IntersectRect(&rc, &rc, &rcBounds);

        // Add the intersection to the obscuring rectangle
        ::UnionRect(lprcObscuring, lprcObscuring, &rc);
    }

    // check text editbox if its up - bug 2185
    if (g_pMain->m_drawingArea.TextEditActive())
    {
        g_pMain->m_drawingArea.GetTextEditBoundsRect(&rc);
        ::IntersectRect(&rc, &rc, &rcBounds);
        ::UnionRect(lprcObscuring, lprcObscuring, &rc);
    }
}



//
// ZGreaterGraphic()
//
// Determines which handle, hLastGraphic or hTestGraphic, is first in the 
// ZOrder (greater and consequently "underneath" the other graphic). If 
// hTestGraphic is NULL then the first graphic is returned.
//
WB_GRAPHIC_HANDLE PG_ZGreaterGraphic
(
    WB_PAGE_HANDLE      hPage,
    WB_GRAPHIC_HANDLE   hLastGraphic, 
    WB_GRAPHIC_HANDLE   hTestGraphic
)
{
    MLZ_EntryOut(ZONE_FUNCTION, "PG_ZGreaterGraphic");

    WB_GRAPHIC_HANDLE hGraphic;
    WB_GRAPHIC_HANDLE hCurrentGraphic;

    if (g_pwbCore->WBP_GraphicHandle(hPage, NULL, FIRST, &hGraphic) != 0)
        return(NULL);

    if (hTestGraphic == NULL)
        return(hGraphic);

    if (hLastGraphic == NULL)
        return(hTestGraphic);

    // search for which one is deeper
    while (hGraphic != NULL)
    {
        if ((hGraphic == hLastGraphic) ||
            (hGraphic == hTestGraphic))
            return( hGraphic );

        hCurrentGraphic = hGraphic;
        if (g_pwbCore->WBP_GraphicHandle(hPage, hCurrentGraphic, AFTER, &hGraphic) != 0)
            return( NULL );
    }

    // didn't find either one
    return( NULL );
}



//
//
// Function:    GetNextPage
//
// Purpose:     Return the next page of graphic objects
//
//
WB_PAGE_HANDLE PG_GetNextPage
(
    WB_PAGE_HANDLE  hPage
)
{
    MLZ_EntryOut(ZONE_FUNCTION, "PG_GetNextPage");

    // Get the handle of the next page
    WB_PAGE_HANDLE hNextPage = NULL;
    UINT uiReturn = g_pwbCore->WBP_PageHandle(hPage, PAGE_AFTER, &hNextPage);

    switch (uiReturn)
    {
        case 0:
            // Got the previous page OK, return it
            break;

        case WB_RC_NO_SUCH_PAGE:
            // There is no previous page, return this page
            hNextPage = hPage;
            break;

        default:
            // Throw an exception recording the return code
            DefaultExceptionHandler(WBFE_RC_WB, uiReturn);
            break;
    }

    return(hNextPage);
}

//
//
// Function:    GetPreviousPage
//
// Purpose:     Return the previous page of graphic objects
//
//
WB_PAGE_HANDLE PG_GetPreviousPage
(
    WB_PAGE_HANDLE  hPage
)
{
    MLZ_EntryOut(ZONE_FUNCTION, "PG_GetPreviousPage");

    // Get the handle of the previous page
    WB_PAGE_HANDLE hPreviousPage;
    UINT uiReturn = g_pwbCore->WBP_PageHandle(hPage, PAGE_BEFORE,
                                             &hPreviousPage);

    switch (uiReturn)
    {
        case 0:
            // Got the next page OK, return it
            break;

        case WB_RC_NO_SUCH_PAGE:
            // There is no next page, return this page
            hPreviousPage = hPage;
            break;

        default:
            // Throw an exception recording the return code
            DefaultExceptionHandler(WBFE_RC_WB, uiReturn);
            break;
    }

    return(hPreviousPage);
}

//
//
// Function:    GetPageNumber
//
// Purpose:     Return the page with the given page number
//
//
WB_PAGE_HANDLE PG_GetPageNumber(UINT uiPageNo)
{
    MLZ_EntryOut(ZONE_FUNCTION, "PG_GetPageNumber");

    // Ensure that the requested page number is within range
    uiPageNo = min(uiPageNo, g_pwbCore->WBP_ContentsCountPages());
    uiPageNo = max(1, uiPageNo);

    // Get the handle of the page with the specified page number
    WB_PAGE_HANDLE hPage;
    UINT uiReturn = g_pwbCore->WBP_PageHandleFromNumber(uiPageNo, &hPage);

    // Since we have been careful to ensure that the page number was
    // in bounds we should always get a good return code from the core.
    ASSERT(uiReturn == 0);

    // Return a page object created from the returned handle
    return(hPage);
}