/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
 *
 * The contents of this file are subject to the Netscape Public License
 * Version 1.0 (the "NPL"); you may not use this file except in
 * compliance with the NPL.  You may obtain a copy of the NPL at
 * http://www.mozilla.org/NPL/
 *
 * Software distributed under the NPL is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
 * for the specific language governing rights and limitations under the
 * NPL.
 *
 * The Initial Developer of this code under the NPL is Netscape
 * Communications Corporation.  Portions created by Netscape are
 * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
 * Reserved.
 */

#include "stdafx.h"
#include "cxdc.h"
#include "cntritem.h"
#include "intlwin.h"
#include "mainfrm.h"
#include "npapi.h"
#include "np.h"
#include "feembed.h"
#include "fmabstra.h"
#include "custom.h"
#include "prefapi.h"
#include "feimage.h"
#include "il_icons.h"
#include "intl_csi.h"
#include "prefinfo.h"
#include "cxprint.h"

#ifdef JAVA
#include "java.h"
#endif

// These four are all specified in pixels
#define IMAGE_SMICON_MARGIN	4

#define IMAGE_SMICON_WIDTH	14
#define IMAGE_SMICON_HEIGHT	16

#define IMAGE_SMICON_TEXT_OFFSET	2


#define IS_SECOND_TO_LAST_LAYER(layer) (CL_GetLayerBelow(layer) &&           \
				CL_GetLayerName(CL_GetLayerBelow(layer)) &&  \
		 (strcmp(CL_GetLayerName(CL_GetLayerBelow(layer)),           \
				 LO_BACKGROUND_LAYER_NAME) == 0))

#define LOADBITMAP(id) \
	::LoadBitmap(AfxGetResourceHandle(), MAKEINTRESOURCE(id))                         

CDCCX::CDCCX()	{
//	Purpose:	Constructor for DC Context
//	Arguments:	void 
//	Returns:	none
//	Comments:	Sets the context type basically
//	Revision History:
//		05-27-95	created GAB
//
	m_cxType = DeviceContext;
	m_bOwnDC = FALSE;
	m_bClassDC = FALSE;

	//	Our mapping mode will be anisotropic unless those which derive
	//		set otherwise.
	m_MM = MM_ANISOTROPIC;

	m_pPal = NULL;
    m_lWidth = 0;
    m_lHeight = 0;
	m_iOffset = 0;
	CString csNo(SZ_NO);

	m_pImageDC = NULL;
	curColorSpace = 0;

	//	As a default starting background color, use that of the button face.
	m_rgbBackgroundColor = sysInfo.m_clrBtnFace;
	m_rgbDarkColor = sysInfo.m_clrBtnShadow;
	m_rgbLightColor = sysInfo.m_clrBtnHilite;
    Set3DColors(m_rgbBackgroundColor);

	//	Set that we have no document, and we currently
	//		won't autodelete what may get assigned in.
	m_pDocument = NULL;
	m_bAutoDeleteDocument = FALSE;

    //	No previously selected font.
    m_pSelectedCachedFont = NULL;
	m_lastDCWithCachedFont = NULL;
	
	//	Document has no substance.
	m_lDocWidth = 0;
	m_lDocHeight = 0;
	m_lOrgX = m_lOrgY = 0;


	//	Start out with some default values in the conversions from pix 2 twips.
	m_lConvertX = 1;
	m_lConvertY = 1;
	GetContext()->convertPixX = 1;
	GetContext()->convertPixY = 1;

	// Assume the driver doesn't support 565 mode for 16 bpp DIBs
	m_bRGB565 = FALSE;

	//	Allow resolving of layout elements.
	m_bResolveElements = TRUE;

	//	We're not in an OLE server.
	m_bOleServer = FALSE;

	// Form text entry box font
	m_pFormFixFont = NULL;
	m_pFormPropFont = NULL;
    m_iFormFixCSID = CS_LATIN1;
    m_iFormPropCSID = CS_LATIN1;

	m_bLoadImagesNow = FALSE;
	m_bNexttimeLoadImagesNow = FALSE;   
	
	GetContext()->XpixelsPerPoint = 0;        
	GetContext()->YpixelsPerPoint = 0;        
}

CDCCX::~CDCCX()	{
//	Purpose:	Destructor for DC Context
//	Arguments:	void
//	Returns:	none
//	Comments:
//	Revision History:
//		05-27-95	created GAB
//

	//	If we've got a document, let it know we're gone now.
	if(GetDocument() != NULL)	{
		TRACE("Clearing document context\n");
		GetDocument()->ClearContext();
	}

	if(m_pImageDC != NULL)	{
		if (!IsGridCell()) { // only delete the temporary DC if we are the parent.
			if (m_bUseDibPalColors)	
			::SelectPalette(m_pImageDC, (HPALETTE)::GetStockObject(DEFAULT_PALETTE), TRUE);
			VERIFY(::DeleteDC( m_pImageDC));
		}
	}

	// Do not delete the default palette.
	if(m_pPal && m_pPal != WFE_GetUIPalette(NULL))	{
		VERIFY(::DeleteObject(m_pPal));
	}
	if(m_pDocument != NULL && m_bAutoDeleteDocument == TRUE)	{
		//	We call OnCloseDocument here, to delete the document.
		//	If we do this here, it basically indicates that we created the
		//		document ourselves (probably a print context), and it
		//		wasn't made in the MFC framework.
		m_pDocument->OnCloseDocument();
	}

	if (curColorSpace)
		IL_ReleaseColorSpace(curColorSpace);
}

void CDCCX::DestroyContext()	{
    if(IsDestroyed() == FALSE)  {
	    //	Give the document a chance to copy any needed information before
	    //		we go down.  This helps the OLE server stuff survive while
	    //		the context of the view has gone to the twilight zone and back.
	    if(GetDocument())	{
		    GetDocument()->CacheEphemeralData();
	    }

	    //	Get rid of all our fonts.
	    ClearFontCache();
    }


	//	Call the base.
	CStubsCX::DestroyContext();
}

BOOL CDCCX::ResolveTextExtent(HDC pDC, LPCTSTR pString, int iLength, LPSIZE pSize, CyaFont *pFont)	
{
	return ResolveTextExtent(
		INTL_GetCSIWinCSID(LO_GetDocumentCharacterSetInfo(GetContext()))
		, pDC, pString, iLength, pSize, pFont);
}

#ifdef XP_WIN32
static BOOL
SupportsRGB565(HDC pDC)
{
    BITMAPINFO *lpBMInfo = NULL;
	int			iFlags;
	int			nSize = sizeof(BITMAPINFOHEADER) + 3 * sizeof(RGBQUAD);
    LPDWORD 	lpMasks;

	// Use the QUERYDIBSUPPORT escape to determine if the driver
	// supports RGB565 format DIBs
	lpBMInfo = (BITMAPINFO *)XP_ALLOC(nSize);
	if (!lpBMInfo)
		return FALSE;
    
    memset(lpBMInfo, 0, nSize);    
    lpBMInfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
    lpBMInfo->bmiHeader.biWidth = 10;
    lpBMInfo->bmiHeader.biHeight = 10;
    lpBMInfo->bmiHeader.biPlanes = 1;
    lpBMInfo->bmiHeader.biBitCount = 16;
    lpBMInfo->bmiHeader.biCompression = BI_BITFIELDS;

	// Define the color masks for a RGB565 DIB
    lpMasks = (LPDWORD)lpBMInfo->bmiColors;
	lpMasks[0] = 0xF800;  // red color mask
	lpMasks[1] = 0x07E0;  // green color mask
	lpMasks[2] = 0x001F;  // blue color mask

	// Ask the driver
	::Escape(pDC, QUERYDIBSUPPORT, nSize, (LPCSTR)lpBMInfo, &iFlags);
	XP_FREE(lpBMInfo);

	return (iFlags & (QDI_SETDIBITS | QDI_DIBTOSCREEN | QDI_STRETCHDIB)) != 0;
}
#endif

void CDCCX::PrepareDraw()
{
	if (m_pImageDC) {
		if (m_bUseDibPalColors && m_pPal) 
			::SelectPalette(m_pImageDC, (HPALETTE)GetStockObject(DEFAULT_PALETTE), FALSE);
		::DeleteDC(m_pImageDC);
	}
	m_pImageDC = ::CreateCompatibleDC(GetContextDC());
	if (m_bUseDibPalColors && m_pPal)	{
		::SelectPalette(m_pImageDC, m_pPal, FALSE);
	}

}

void CDCCX::EndDraw()
{
	if (m_pImageDC) {
		if (m_bUseDibPalColors && m_pPal) 
			::SelectPalette(m_pImageDC, (HPALETTE)GetStockObject(DEFAULT_PALETTE), FALSE);
		::DeleteDC(m_pImageDC);
	}
	m_pImageDC = 0;
}


void CDCCX::Initialize(BOOL bOwnDC, RECT *pRect, BOOL bInitialPalette, BOOL bNewMemDC)	{
	//	First thing, we need to create a document
	//		if no one has bothered assigning us one.
	if(m_pDocument == NULL)	{
		m_pDocument = new CGenericDoc();
		m_bAutoDeleteDocument = TRUE;	//	We clean up.
	}

	//	There exists a document.
	//	Let it know which context it can manipulate.
	GetDocument()->SetContext(this);

	HDC hdc = GetContextDC();

	//	Initialize some values which are used in CDC contexts
	//		for drawing purposes.
	SetMappingMode(hdc);
    ::SetBkMode(hdc, TRANSPARENT);

	//	Figure out the depth of the CDC.
	m_iBitsPerPixel = sysInfo.m_iBitsPerPixel;

    //	Now, if the bits per pixel are less than 16, and this device doesn't support
	//		a palette, then we need to set the bits per pixel to a very high value
	//		to emulate true color (so that we don't attempt to use the palette
	//		function later on).
	//	This is the Epson Stylus Color Printer bug fix on Win16.
	if(m_iBitsPerPixel < 16 && (::GetDeviceCaps(hdc, RASTERCAPS) & RC_PALETTE) == 0)	{
        //  24 is the largest common denominator which we should be able to set
        //      in order to avoid palette operations.
        //  Uped to 24 from 16 as the Hewlett Packard Laserjet 5L bug fix on Win32.
			m_iBitsPerPixel = 24;
	}

	//	Detect if we are going to be using DibPalColors. We only do this if the device
	// is a palette device and we never do this when printing
	m_bUseDibPalColors = !IsPrintContext() && (::GetDeviceCaps(hdc, RASTERCAPS) & RC_PALETTE);


	//	Do some stretch blit setup.
#ifndef WIN32
	::SetStretchBltMode(hdc, STRETCH_DELETESCANS);
#else
    ::SetStretchBltMode(hdc, COLORONCOLOR);
#endif

	JMCException* exc = NULL;
	IMGCB* imageLibObj = IMGCBFactory_Create(&exc);

	m_pImageGroupContext = IL_NewGroupContext(GetContext(), (IMGCBIF *)imageLibObj);
    GetContext()->img_cx = m_pImageGroupContext; // Need this to be cross platform.
	IL_AddGroupObserver(m_pImageGroupContext, ImageGroupObserver, (void*)GetContext());

    COLORREF rgbColor = prefInfo.m_rgbBackgroundColor;
	SetTransparentColor(GetRValue(rgbColor), GetGValue(rgbColor), GetBValue(rgbColor));
	if (!IsGridCell()) {
		if(m_iBitsPerPixel < 16) {

			//	Set the transparency to a default color.
			//	This may change below.
			SetTransparentColor(192, 192, 192);

			//	Set up the per-context palette.
			//	This is per-window since not everything goes to the screen, and therefore
			//		won't always have the screen's attributes. (printing, metafiles DCs, etc).
			IL_ColorMap * defaultColorMap =  IL_NewCubeColorMap(NULL, 0,
						   MAX_IMAGE_PALETTE_ENTRIES+1);
			if (bInitialPalette)
				m_pPal = CDCCX::InitPalette(hdc);
			else // If we don't want to initialize the Palette, use the default palette.
				m_pPal = WFE_GetUIPalette(NULL);
			CDCCX::SetColormap(hdc, defaultColorMap, rgbTransparentColor, m_pPal);
			curColorSpace = IL_CreatePseudoColorSpace(defaultColorMap, MAX_IMAGE_PALETTE_ENTRIES+1,
							  m_iBitsPerPixel);
			HPALETTE hOldPal = NULL;
			if(m_pPal)    {
				if ( bInitialPalette) 
					hOldPal = (HPALETTE) ::SelectPalette(hdc, m_pPal, FALSE);
				else
					hOldPal = (HPALETTE) ::SelectPalette(hdc, m_pPal, TRUE);
				int error = RealizePalette(hdc);      // In with the new
			}
#ifdef DEBUG_mhwang
			HWND hwnd = ::GetFocus();
#endif

		}
		else { // use RGB value
			IL_RGBBits colorRGBBits;
		//	Enable true color.
			if(m_iBitsPerPixel >= 16)	{
				if(m_iBitsPerPixel == 16)	{
		#ifdef XP_WIN32
					// If this is Win95 we need to do rounding during quantization of
					// 24 bpp RGB values to 16 bpp RGB values
					if (sysInfo.IsWin4_32() == TRUE &&
						SupportsRGB565(hdc) != FALSE &&
						IsPrintContext() == FALSE) {

						//	Metafiles can't handle this hack.
						//	Also, the image lib will force metafiles to share the
						//		same image even though the settings would be slightly different.
						//	Pump us up to 24 bit images in this case.
						if(GetContextType() == MetaFile)	{
							colorRGBBits.red_shift = 16;  
							colorRGBBits.red_bits = 8;            /* Offset for red channel bits. */
							colorRGBBits.green_shift = 8;           /* Number of bits assigned to green channel. */
							colorRGBBits.green_bits = 8;          /* Offset for green channel bits. */
							colorRGBBits.blue_shift = 0;            /* Number of bits assigned to blue channel. */
							colorRGBBits.blue_bits = 8;           /* Offset for blue channel bits. */
							curColorSpace = IL_CreateTrueColorSpace(&colorRGBBits, 24);

						}
						else	{
							m_bRGB565 = TRUE;  // remember this when building BITMAPINFO struct
							colorRGBBits.red_shift = 11;  
							colorRGBBits.red_bits = 5;            /* Offset for red channel bits. */
							colorRGBBits.green_shift = 5;           /* Number of bits assigned to green channel. */
							colorRGBBits.green_bits = 6;          /* Offset for green channel bits. */
							colorRGBBits.blue_shift = 0;            /* Number of bits assigned to blue channel. */
							colorRGBBits.blue_bits = 5;           /* Offset for blue channel bits. */
							curColorSpace = IL_CreateTrueColorSpace(&colorRGBBits, 16);
						}

					} else {
						colorRGBBits.red_shift = 10;  
						colorRGBBits.red_bits = 5;            /* Offset for red channel bits. */
						colorRGBBits.green_shift = 5;           /* Number of bits assigned to green channel. */
						colorRGBBits.green_bits = 5;          /* Offset for green channel bits. */
						colorRGBBits.blue_shift = 0;            /* Number of bits assigned to blue channel. */
						colorRGBBits.blue_bits = 5;           /* Offset for blue channel bits. */
						curColorSpace =IL_CreateTrueColorSpace(&colorRGBBits, 16);
					}
		#else
					// 16 bpp DIB format isn't supported by all drivers in Win 3.1
					colorRGBBits.red_shift = 16;  
					colorRGBBits.red_bits = 8;            /* Offset for red channel bits. */
					colorRGBBits.green_shift = 8;           /* Number of bits assigned to green channel. */
					colorRGBBits.green_bits = 8;          /* Offset for green channel bits. */
					colorRGBBits.blue_shift = 0;            /* Number of bits assigned to blue channel. */
					colorRGBBits.blue_bits = 8;           /* Offset for blue channel bits. */
					curColorSpace = IL_CreateTrueColorSpace(&colorRGBBits, 24);
		#endif
				}
				else  {
					colorRGBBits.red_shift = 16;  
					colorRGBBits.red_bits = 8;            /* Offset for red channel bits. */
					colorRGBBits.green_shift = 8;           /* Number of bits assigned to green channel. */
					colorRGBBits.green_bits = 8;          /* Offset for green channel bits. */
					colorRGBBits.blue_shift = 0;            /* Number of bits assigned to blue channel. */
					colorRGBBits.blue_bits = 8;           /* Offset for blue channel bits. */
					curColorSpace = IL_CreateTrueColorSpace(&colorRGBBits, 24);
				}
			}
		}
		GetContext()->color_space = curColorSpace; // Need this to be cross platform.
	}
	else {
		MWContext* cxtx = GetParentContext();
		GetContext()->color_space = cxtx->color_space;
		curColorSpace =cxtx->color_space; 
        IL_AddRefToColorSpace(curColorSpace);
        m_bRGB565 = CXDC(cxtx)->m_bRGB565;
	}
    
	IL_AddRefToColorSpace(GetContext()->color_space);
	//	Get image prefs on a per context basis.
    IL_DitherMode ditherMode = IL_Auto; 

	char * prefStr=NULL;
	PREF_CopyCharPref("images.dither",&prefStr);
	// Images
	if (prefStr) {
		if(!strcmpi(prefStr,"yes")) { 
			ditherMode = IL_Dither;
		} else if(!strcmpi(prefStr,"no")) {   // closest
			ditherMode = IL_ClosestColor;
		} else {
			ditherMode = IL_Auto;
		}
		XP_FREE(prefStr);
	}

	PRBool bIncremental = ResolveIncrementalImages();
	IL_DisplayData displayData;
	displayData.dither_mode = IL_Auto;

	if (IsPrintContext())
		displayData.display_type = IL_Printer;
	else
		displayData.display_type = IL_Console;
	displayData.color_space = curColorSpace;
	displayData.progressive_display= bIncremental;
	IL_SetDisplayMode(m_pImageGroupContext, IL_PROGRESSIVE_DISPLAY | IL_DITHER_MODE | IL_COLOR_SPACE | IL_DISPLAY_TYPE,
                  &displayData);

	if (bNewMemDC) {
		if (!IsGridCell()) {  // only create the tempary CD only for gird parent.
		//	Ensure our memory DC exists for speedy image draws.
			m_pImageDC = ::CreateCompatibleDC(hdc);
			if (m_bUseDibPalColors && m_pPal)	{
				::SelectPalette(m_pImageDC, m_pPal, FALSE);
			}
		}
		else {
			MWContext *parentContext = GetParentContext();
			m_pImageDC = CXDC(parentContext)->m_pImageDC; 
		}
	}
	GetContext()->XpixelsPerPoint = ((double)GetDeviceCaps (GetAttribDC(), LOGPIXELSX)) / 72.0 ;
	GetContext()->YpixelsPerPoint = ((double)GetDeviceCaps (GetAttribDC(), LOGPIXELSY)) / 72.0 ;

#ifdef DEBUG_aliu
	double dd = ((double)GetDeviceCaps (hdc, LOGPIXELSX)) / 72.0 ;
	dd = ((double)GetDeviceCaps (hdc, LOGPIXELSY)) / 72.0 ;
#endif

	ReleaseContextDC(hdc);

	//	We optimize those DCs which we know are persistant (don't change or reset
	//		their values) for font caching and other stuff.
	//	As a default, consider all such DC classes as persistent, if not, then
	//		set this value otherwise.
	//	This needs to go at the end of this function, since the mapping mode should
	//		now be correctly set, et al....
	m_bOwnDC = bOwnDC;

#ifdef LAYERS
	GetContext()->compositor = NULL;
#endif // LAYERS

}

//	Default implementation of incremental image display switch.
PRBool CDCCX::ResolveIncrementalImages()
{
    XP_Bool bRetval = prefInfo.m_bAutoLoadImages;
	
	return (bRetval) ? PR_TRUE : PR_FALSE;
}

HPALETTE CDCCX::GetPalette() const	{
	//	Return our palette.
	return(m_pPal);
}


void CDCCX::ClearFontCache()	{
	//	If we're a persistant DC, we need to select a stock object before we release
	//		all the fonts.
	if(IsClassDC() || IsOwnDC())	{
		HDC hdc = GetContextDC();
		::SelectObject(hdc, ::GetStockObject(ANSI_FIXED_FONT));
		ReleaseContextDC(hdc);

		//	We have no previously selected font.
        m_pSelectedCachedFont = NULL;
		m_lastDCWithCachedFont = NULL;

	}

    //  Tell layout to get rid of all of it's cached FE font data
    //      in the LO_TextAttr.
    LO_InvalidateFontData(GetDocumentContext());


    //  Go through our context list of cached fonts and get rid of them all.
    POSITION rIndexnew = m_cplCachedFontList.GetHeadPosition();
    CyaFont *pCachedFont = NULL;
    while(rIndexnew)   {
        pCachedFont = (CyaFont *)m_cplCachedFontList.GetNext(rIndexnew);
        if(pCachedFont) {
            delete pCachedFont;
        }
    }
    //  Remove them all from the list.
    if(!m_cplCachedFontList.IsEmpty())   {
        m_cplCachedFontList.RemoveAll();
    }

    //  Get rid of widget fonts.
	if(m_pFormFixFont) {
		VERIFY(::DeleteObject(m_pFormFixFont));
        m_pFormFixFont = NULL;
    }
	if(m_pFormPropFont)    {
		VERIFY(::DeleteObject(m_pFormPropFont));
        m_pFormPropFont = NULL;
    }
}

void CDCCX::ClearAllFontCaches()	{
	MWContext *pTraverseContext = NULL;
	CAbstractCX *pTraverseCX = NULL;
	XP_List *pTraverse = XP_GetGlobalContextList();
	while (pTraverseContext = (MWContext *)XP_ListNextObject(pTraverse)) {
		if(pTraverseContext != NULL && ABSTRACTCX(pTraverseContext) != NULL)	{
			pTraverseCX = ABSTRACTCX(pTraverseContext);

			if(pTraverseCX->IsDCContext() == TRUE)	{
				CDCCX *pDCCX = VOID2CX(pTraverseCX, CDCCX);
				pDCCX->ClearFontCache();
			}
		}
	}
}


// size is the size of the font from layout
// iBaseSize is the users font size from the encoding
// iOffset is the offset based on increment and decrement font
double CDCCX::CalcFontPointSize(int size, int iBaseSize, int iOffset)
{
	double dFontSize;

	if( iBaseSize <=0 )
           iBaseSize = 10;

/*	size += iOffset;*/
	if(size < 0)
		size = 0;

	if(size  > 8)
		size = 8;

	switch(size)	{
	case 0:
		dFontSize = iBaseSize / 2;
		break;
	case 1:
		dFontSize = 7 * iBaseSize / 10;
		break;
	case 2:
		dFontSize = 85 * iBaseSize / 100;
		break;
	case 4:
		dFontSize = 12 * iBaseSize / 10;
		break;
	case 5:
		dFontSize = 3 * iBaseSize / 2;
		break;
	case 6:
		dFontSize = 2 * iBaseSize;
		break;
	case 7:
		dFontSize = 3 * iBaseSize;
		break;
	case 8:
		dFontSize = 4 * iBaseSize;
		break;
	case 3:
	default:
		dFontSize = iBaseSize;
	}

	//if(MMIsText() != TRUE)	  // for printer scaling to pointsize interface.
//		dFontSize *= 2.8;			//todo  this is a hack!!

	if(GetContext())
		dFontSize *= GetContext()->fontScalingPercentage;

    return dFontSize;

}	// CalcFontPointSize


// Manage DC level font cache: If font is selected into dc, don't do anything.
// Otherwise, call SelectNetscapeFont() and cache it into dc.
// return 1 if we miss any font in pAttr->font_face list.
int CDCCX::SelectNetscapeFontWithCache( HDC hdc, LO_TextAttr *pAttr, CyaFont *& pMyFont )	
{
//	Purpose:	Font selector
//	Arguments:	pDC	The DC in which to select the font
//				pAttr	Layout attributes by which we select the font.
//				pSelected	This is more of a return value.  It sets the reference of
//					the pointer value ot the font actually selected.
//	Returns:	no meaning, old font is saved in CyaFont.
//	Comments:

	//	Determine the size of the font and other stuff.
	//	Get the font out of the cache.
	int		returnCode = 0;		// assuming we don't miss any font.
// #ifdef nofontcache
    CyaFont *pCachedFont = (CyaFont *)pAttr->FE_Data;
	pMyFont = pCachedFont;
	//	See if we've already got this font selected if we're a persistant DC.
	//	We'll assume it's in the font cache if so.
	if(IsOwnDC() == TRUE && m_lastDCWithCachedFont == hdc && m_pSelectedCachedFont) {
		if(  m_pSelectedCachedFont == pCachedFont)   {
			//	Simply return, already selected.
			return( 0 );
		} else { 
			// relase the selected font.
			ReleaseNetscapeFont( hdc, m_pSelectedCachedFont );
			m_pSelectedCachedFont = NULL;
			m_lastDCWithCachedFont = NULL;
			// fall through to select a font.
		}
	} 

	// create font (or use FE_Data cached font) for the text 
	returnCode = SelectNetscapeFont( hdc, pAttr, pMyFont );

	if( ! pMyFont->IsEmptyFont() ) {

		//	If this is a persistant DC, then we mark the font currently selected so that
		//		we don't select it again if the same request comes in.
		//	We don't want to do this if this was the memory DC we're dealing with.
		if(IsOwnDC() == TRUE)	{
			m_lastDCWithCachedFont = hdc;
			m_pSelectedCachedFont = pMyFont;		// pSelectThis;
		}
	}
//#else 
//	returnCode = SelectNetscapeFont( hdc, pAttr, pMyFont );
//#endif // nofontcache

	return( returnCode );

}

// SelectNetscapeFont() does:
// always select the font into dc.
// manage FE_Data level cache.
// Create the font if not cached, 
// follow font list and use default font at last.
// return 1 if the any font in list not found.
// After creation, 
//    cache it into FE_Data, and calculate meanwidth.
//    link-list the font, so it can be deleted when destroy document.
int CDCCX::SelectNetscapeFont( HDC hdc, LO_TextAttr *pAttr, CyaFont *& pMyFont )
{
	// create font for the text and cache it in pAttr->FE_Data.
	EncodingInfo *pEncoding = theApp.m_pIntlFont->GetEncodingInfo(GetContext());
	BOOL bItalic = FALSE;
	BOOL bFixed = FALSE;
	int iFontWeight = FW_NORMAL;
	double	dFontSize;
	int iBaseSize;
	int iCharset = DEFAULT_CHARSET;  // used for Win95 font selection
	char aFontName[MAXFONTFACENAME];
	char		* pCharsetStr;
	int			reCode;
	int		returnCode = 0;		// assuming we don't miss any font.

    CyaFont *pCachedFont = (CyaFont *)pAttr->FE_Data;
	if(pCachedFont != NULL && ! pCachedFont->IsEmptyFont() )	{
		//	It's cached.

		//	use the old font, and select the font.
		pMyFont = pCachedFont;
		pMyFont->PrepareDrawText( hdc );               // actually, select the font into hdc
		return( 0 );                                   // we don't miss this font.
	}

	// retrieve face-name-independent attributes first.

	if(pAttr->fontmask & LO_FONT_BOLD)	{ 
		iFontWeight = FW_BOLD;
	}

	// font_weight has the highest priority.
	if( pAttr->font_weight > 0 )
		iFontWeight = pAttr->font_weight;

	if(pAttr->fontmask & LO_FONT_ITALIC)	{
		bItalic = TRUE;
	}

	if(pAttr->fontmask & LO_FONT_FIXED)	{
		bFixed = TRUE;
	}

	if( bFixed)	{
		iBaseSize = pEncoding->iFixSize;
		iCharset = pEncoding->iFixCharset;
	} else {  // ! bFixed 
        iBaseSize = pEncoding->iPropSize;
		iCharset = pEncoding->iPropCharset;
    }

	//	Map the base size to the real font size.
	dFontSize = CalcFontPointSize(pAttr->size, iBaseSize, m_iOffset);

	// pAttr->point_size has the highest priority.
	if( pAttr->point_size > 0 ) {   
		dFontSize = pAttr->point_size;
 	}
	
	// save the encording flag in font, so it will use textOutW() for Unicode.
	// refer to BOOL CIntlWin::TextOut() in file intlwin.cpp
	// INTL_GetCSIWinCSID(LO_GetDocumentCharacterSetInfo(pContext))
	char *pEncordingStr = NULL;
	int		isUnicode = 0;
#ifdef XP_WIN32
	if ( CIntlWin::UseUnicodeFontAPI( pEncoding->iCSID ) &&
		 ! ( pEncoding->iCSID == CS_UTF8  && CIntlWin::UseVirtualFont()) ) {
		// set the encording to use ::TextOutW()
		pEncordingStr	= "Unicode";
		isUnicode		= 1;
	}
#endif

	int nUnderline = nfUnderlineDontCare ;
	if(pAttr->attrmask & LO_ATTR_ANCHOR) { 
        XP_Bool prefBool = prefInfo.m_bUnderlineAnchors; //  ? prefInfo.m_bUnderlineAnchors->m_Value.xp_bool : TRUE;
		if(prefBool)
			nUnderline = nfUnderlineYes;
	}
	if(pAttr->attrmask & LO_ATTR_UNDERLINE)	{
		nUnderline = nfUnderlineYes;
	}
	
	pMyFont = new CyaFont();

    //  If a font name is listed, use that instead.
    BOOL bUseDefault = TRUE;

    if(pAttr->font_face)    {
        //  Go through the comma delimeted list, and find one that we have.
        char wantedFontName[MAXFONTFACENAME];
		char *pFontName	= NULL;
		int	 offSet = 0;
        do {
			offSet = FEU_ExtractCommaDilimetedFontName(pAttr->font_face, offSet, wantedFontName );

			// for(int iTraverse = 1; pExtracted = FEU_ExtractCommaDilimetedString(pAttr->font_face, iTraverse); iTraverse++)    
			if( offSet > 0 && *wantedFontName != 0)  {
				pFontName = theGlobalNSFont.converGenericFont(wantedFontName);

				strcpy(aFontName, pFontName);
				if(CIntlWin::UseUnicodeFontAPI(pEncoding->iCSID))    {
					iCharset = DEFAULT_CHARSET;
				}
				// On Win95, charset info is important for Wingdings font
				if (sysInfo.m_bWin4 && (strcmpi(aFontName, "wingdings") == 0))
					iCharset = DEFAULT_CHARSET;
				// web font use string for charSet
				pCharsetStr  = theGlobalNSFont.convertToFmiCharset( iCharset );

				if (isUnicode == 0 )
				{
					pEncordingStr = pCharsetStr;
				}

				//	Create the font.
				reCode = pMyFont->CreateNetscapeFont(
					GetContext(),
					hdc,									// HDC		hDC, 
					aFontName,								// char    *FmiName,
					pCharsetStr,							// char    *FmiCharset,
					pEncordingStr,							// char    *FmiEncoding,
					iFontWeight,							// int     FmiWeight,
					bFixed?nfSpacingMonospaced:nfSpacingProportional,			// int     FmiPitch,
					bItalic?nfStyleItalic:nfStyleNormal,	// int     FmiStyle,	
					nUnderline,								// int		FmiUnderline,
					(pAttr->attrmask & LO_ATTR_STRIKEOUT) ? nfStrikeOutYes : nfStrikeOutDontCare, // int     FmiStrikeOut,
					0,										// int     FmiResolutionX,
					::GetDeviceCaps(GetAttribDC(), LOGPIXELSY),		// int     FmiResolutionY,
					dFontSize								// int		fontHeight		// not a fmi field
				); 
				
				//if( theGlobalNSFont.HasFaceName( hdc, pExtracted)) 
					//  Use this.
				if( reCode == FONTERR_OK ) {
					bUseDefault = FALSE;		// we got the font!
				} else {
					// remenber there is font face name not found, 
					returnCode = 1;
				}
			}

            //  Our responsibility to clean this up.
            // XP_FREE(pExtracted);

            //  If we've set that we're using a font, get out.
            if(!bUseDefault) {
                break;
            }
		}	while ( offSet > 0 );  // do  offSet = FEU_ExtractCommaDilimetedFontName() ...
    }	// if(pAttr->font_face)

	if(bUseDefault)  {
		if( bFixed)	
			strcpy(aFontName, pEncoding->szFixName);
		else   // ! bFixed 
			strcpy(aFontName, pEncoding->szPropName);

		if(CIntlWin::UseUnicodeFontAPI(pEncoding->iCSID))    {
			iCharset = DEFAULT_CHARSET;
		}
		// On Win95, charset info is important for Wingdings font
		if (sysInfo.m_bWin4 && (strcmpi(aFontName, "wingdings") == 0))
			iCharset = DEFAULT_CHARSET;
		// web font use string for charSet
		pCharsetStr  = theGlobalNSFont.convertToFmiCharset( iCharset );
		if (isUnicode == 0 )
		{
			pEncordingStr = pCharsetStr;
		}

		//	Create the font.
		reCode = pMyFont->CreateNetscapeFont(
			GetContext(),
			hdc,									// HDC		hDC, 
			aFontName,								// char    *FmiName,
			pCharsetStr,							// char    *FmiCharset,
			pEncordingStr,							// char    *FmiEncoding,
			iFontWeight,							// int     FmiWeight,
			bFixed?nfSpacingMonospaced:nfSpacingProportional,			// int     FmiPitch,
			bItalic?nfStyleItalic:nfStyleNormal,	// int     FmiStyle,	
			nUnderline,								// int		FmiUnderline,
			(pAttr->attrmask & LO_ATTR_STRIKEOUT) ? nfStrikeOutYes : nfStrikeOutDontCare, // int     FmiStrikeOut,
			0,										// int     FmiResolutionX,
			::GetDeviceCaps(GetAttribDC(), LOGPIXELSY),		// int     FmiResolutionY,
			dFontSize								// int		fontHeight		// not a fmi field
		); 
	}

	if( FONTERR_OK != reCode ) {
		// user selected default font failed, use hardcoded default font
		iCharset = DEFAULT_CHARSET;
		
		// web font use string for charSet
		pCharsetStr  = theGlobalNSFont.convertToFmiCharset( iCharset );
		if (isUnicode == 0 )
		{
			pEncordingStr = pCharsetStr;
		}

		// get the face name
#ifdef _WIN32
		LOGFONT   theLogFont;
		CFont	*pCFont= CFont::FromHandle((HFONT)GetStockObject(bFixed?ANSI_FIXED_FONT:ANSI_VAR_FONT));
		pCFont->GetLogFont( &theLogFont );
		strncpy(aFontName, theLogFont.lfFaceName,LF_FACESIZE);
#else
		strncpy(aFontName, ( bFixed? "Courier New" : "Times New Roman" ) ,LF_FACESIZE);
#endif
		//	Create the font.
		reCode = pMyFont->CreateNetscapeFont(
			GetContext(),
			hdc,									// HDC		hDC, 
			aFontName,							// char    *FmiName,
			pCharsetStr,							// char    *FmiCharset,
			pEncordingStr,							// char    *FmiEncoding,
			iFontWeight,							// int     FmiWeight,
			bFixed?nfSpacingMonospaced:nfSpacingProportional,			// int     FmiPitch,
			bItalic?nfStyleItalic:nfStyleNormal,	// int     FmiStyle,	
			nUnderline,								// int		FmiUnderline,
			(pAttr->attrmask & LO_ATTR_STRIKEOUT) ? nfStrikeOutYes : nfStrikeOutDontCare, // int     FmiStrikeOut,
			0,										// int     FmiResolutionX,
			::GetDeviceCaps(GetAttribDC(), LOGPIXELSY),		// int     FmiResolutionY,
			dFontSize								// int		fontHeight		// not a fmi field
		); 
	}

	// 	if( FONTERR_OK != reCode )    real problem, todo show dialog to user!!!

	//	Select the font.
	pMyFont->PrepareDrawText( hdc );               // actually, select the font into hdc

	pMyFont->CalculateMeanWidth( hdc, isUnicode);

	// and cache it in pAttr->FE_Data.
	//	Cache this font for future usage.
	//  First, make sure that the text attribute points to it.
	pAttr->FE_Data = (void *)pMyFont;

	//  Second, add it to our context list of fonts (so we know to delete it later).
	m_cplCachedFontList.AddTail((void *)pMyFont);  // pSelectThis

	return( returnCode );
}	// HFONT CDCCX::SelectNetscapeFont()

void CDCCX::ReleaseNetscapeFontWithCache(HDC hdc, CyaFont * pNetscapeFont)	
{
//#ifdef nofontcache
	if( IsOwnDC() == TRUE )
		return;
	m_pSelectedCachedFont = NULL;
	m_lastDCWithCachedFont = NULL;

//#endif
	ReleaseNetscapeFont(hdc, pNetscapeFont);
}

void CDCCX::ReleaseNetscapeFont(HDC hdc, CyaFont * pNetscapeFont)
{	
	pNetscapeFont->EndDrawText( hdc );					// restore the old font.
}

// m_iOffset can be at most 8 or at least -8 based on the values in
// CalcFontPointSize;
void CDCCX::ChangeFontOffset(int iIncrementor)
{
/*	BOOL bDontReload = (m_iOffset == 8 && iIncrementor >= 0) || (m_iOffset == -8 && iIncrementor <= 0);

	m_iOffset += iIncrementor;
	if(m_iOffset < -8)
		m_iOffset = -8;
	else if(m_iOffset > 8)
		m_iOffset = 8;
	
	if(!bDontReload)*/

	m_iOffset += iIncrementor;
	if(GetContext()){
		GetContext()->fontScalingPercentage = LO_GetScalingFactor(m_iOffset);
	}

	NiceReload();
}



void CDCCX::ExtendCoord(LTRB& Rect)
{
	int32 lOrgX, lOrgY;

	GetDrawingOrigin(&lOrgX, &lOrgY);

	Rect.left += lOrgX;
	Rect.top += lOrgY;
	Rect.right += lOrgX;
	Rect.bottom += lOrgY;
}

BOOL CDCCX::ResolveElement(LTRB& Rect, int32 x, int32 y, int32 x_offset, int32 y_offset,
								int32 width, int32 height)
{
	BOOL bRetval = TRUE;
	//	First, figure the coordinates.
	Rect.left = x + x_offset - m_lOrgX;
	Rect.top = y + y_offset - m_lOrgY;
	Rect.right = Rect.left + width;
	Rect.bottom = Rect.top + height;

	ExtendCoord(Rect);

	//	Return FALSE if this doesn't fall into view of the context.
	if(Rect.top > m_lHeight || Rect.bottom < 0 || Rect.right < 0 || Rect.left > m_lWidth) {
		if(CanBlockDisplay())	{
			bRetval = FALSE;
		}
	}
	return bRetval;
}
BOOL CDCCX::ResolveElement(LTRB& Rect, LO_TextStruct *pText, int iLocation, int32 lStartPos, int32 lEndPos, int iClear)	{
	BOOL bRetval = TRUE;

	//	Subtext, in order to be considered at all, must first pass the text resolution.
	if(ResolveElement(Rect, pText->x, pText->y, pText->x_offset, 
								pText->y_offset,pText->width, pText->height))	{
		//	Adjust the coordinates further for the specific subtext we're going to be
		//		drawing.
		//	This means we actually have to size the text....
		HDC hdc = GetContextDC();
		
		CyaFont	*pMyFont;
		SelectNetscapeFontWithCache( hdc, pText->text_attr, pMyFont );
		CSize sz;
		ResolveTextExtent(hdc, (const char *)pText->text, CASTINT(lStartPos), &sz, pMyFont);
		Rect.left += sz.cx;
		ResolveTextExtent(hdc, (const char *)pText->text + lStartPos, CASTINT(lEndPos - lStartPos + 1), &sz, pMyFont);
		Rect.right = Rect.left + sz.cx;	
		
        Rect.bottom = Rect.top + sz.cy;   

		ReleaseNetscapeFontWithCache( hdc, pMyFont );

		ReleaseContextDC(hdc);

		//	Return FALSE if this doesn't fall into view of the context.
		if(Rect.top > m_lHeight || Rect.bottom < 0 || Rect.right < 0 || Rect.left > m_lWidth) {
			if(CanBlockDisplay())	{
				bRetval = FALSE;
			}
		}
	}
	else if(CanBlockDisplay())	{
		//	Didn't pass even the normal text filter.
		bRetval = FALSE;
	}

	return(bRetval);
}

/* 
 * Note that this was brought back, since form element positions are 
 * expressed in document coordinates, not layer coordinates, so the
 * standard ResolveElement techniques will not work.
 */
BOOL CDCCX::ResolveElement(LTRB& Rect, LO_FormElementStruct *pFormElement)	{
	BOOL bRetval = TRUE;

	//	First, figure the coordinates.
	Rect.left = pFormElement->x + pFormElement->x_offset - m_lOrgX;
	Rect.top = pFormElement->y + pFormElement->y_offset - m_lOrgY;
	Rect.right = Rect.left + pFormElement->width;
	Rect.bottom = Rect.top + pFormElement->height;

	/* Don't call ExtendCoord() for forms.  Form element positions are in
	   document coordinates, not layer coordinates. */

	//	Return FALSE if this doesn't fall into view of the context.
	if(Rect.top > m_lHeight || Rect.bottom < 0 || Rect.right < 0 || Rect.left > m_lWidth) {
		if(CanBlockDisplay())	{
			bRetval = FALSE;
		}
	}

	return(bRetval);
}

BOOL CDCCX::ResolveElement(LTRB& Rect, NI_Pixmap *pImage, int32 lX, int32 lY, 
						   int32 orgx, int32 orgy,
						   uint32 ulWidth, uint32 ulHeight)
{
	BOOL bRetval = TRUE;

	if(ulWidth == 0)	{
		ulWidth = pImage->header.width;
	}

	if(ulHeight == 0)	{
		ulHeight = pImage->header.height;
	}
	Rect.left = orgx + lX - m_lOrgX;
	Rect.top = orgy + lY - m_lOrgY;
	
	ExtendCoord(Rect);

	if (Rect.top < 0 && lX) Rect.top = 0;
	if (Rect.left < 0 && lY) Rect.left = 0;

	Rect.right = Rect.left + ulWidth;
	Rect.bottom = Rect.top + ulHeight;

	return(bRetval);
}

BOOL CDCCX::ResolveElement(LTRB& Rect, LO_TableStruct *pTable, int iLocation)	{
	BOOL bRetval = TRUE;

	//	First, figure the coordinates.
	Rect.left = pTable->x + pTable->x_offset - m_lOrgX;
	Rect.top = pTable->y + pTable->y_offset - m_lOrgY;
	Rect.right = Rect.left + pTable->width;
	Rect.bottom = Rect.top + pTable->height;

	//	Return FALSE if this doesn't fall into view of the context.
	if(Rect.top > m_lHeight || Rect.bottom < 0 || Rect.right < 0 || Rect.left > m_lWidth) {
		if(CanBlockDisplay())	{
			bRetval = FALSE;
		}
	}

	return(bRetval);
}

BOOL CDCCX::ResolveElement(LTRB& Rect, LO_SubDocStruct *pSubDoc, int iLocation)	{
	BOOL bRetval = TRUE;

	//	First, figure the coordinates.
	Rect.left = pSubDoc->x + pSubDoc->x_offset - m_lOrgX;
	Rect.top = pSubDoc->y + pSubDoc->y_offset - m_lOrgY;
	Rect.right = Rect.left + pSubDoc->width;
	Rect.bottom = Rect.top + pSubDoc->height;

	//	Return FALSE if this doesn't fall into view of the context.
	if(Rect.top > m_lHeight || Rect.bottom < 0 || Rect.right < 0 || Rect.left > m_lWidth) {
		if(CanBlockDisplay())	{
			bRetval = FALSE;
		}
	}

	return(bRetval);
}

BOOL CDCCX::ResolveElement(LTRB& Rect, LO_CellStruct *pCell, int iLocation)	{
	BOOL bRetval = TRUE;

	//	First, figure the coordinates.
	Rect.left = pCell->x + pCell->x_offset - m_lOrgX;
	Rect.top = pCell->y + pCell->y_offset - m_lOrgY;
	Rect.right = Rect.left + pCell->width;
	Rect.bottom = Rect.top + pCell->height;

	//	Return FALSE if this doesn't fall into view of the context.
	if(Rect.top > m_lHeight || Rect.bottom < 0 || Rect.right < 0 || Rect.left > m_lWidth) {
		if(CanBlockDisplay())	{
			bRetval = FALSE;
		}
	}

	return(bRetval);
}

BOOL CDCCX::ResolveElement(LTRB& Rect, LO_EmbedStruct *pEmbed, int iLocation, Bool bWindowed)	{
	BOOL bRetval = TRUE;

	//	First, figure the coordinates.
    Rect.left = -m_lOrgX;
    Rect.top = -m_lOrgY;

    // For windowed embeds, we only need the position of the embed,
    // and we ignore the layer origin. For windowless embeds, we only
    // need the layer origin, and not the position of the embed.
    if (bWindowed) {
        Rect.left += pEmbed->x + pEmbed->x_offset + pEmbed->border_width;
        Rect.top += pEmbed->y + pEmbed->y_offset + pEmbed->border_width;
    }
    
	Rect.right = Rect.left + pEmbed->width;
	Rect.bottom = Rect.top + pEmbed->height;

    if (!bWindowed)
        ExtendCoord(Rect);

	//	Return FALSE if this doesn't fall into view of the context.
	if(Rect.top > m_lHeight || Rect.bottom < 0 || Rect.right < 0 || Rect.left > m_lWidth) {
		if(CanBlockDisplay())	{
			bRetval = FALSE;
		}
	}

	return(bRetval);
}

BOOL CDCCX::ResolveElement(LTRB& Rect, LO_LinefeedStruct *pLineFeed, int iLocation)	{
	BOOL bRetval = TRUE;

	//	First, figure the coordinates.
	Rect.left = pLineFeed->x + pLineFeed->x_offset - m_lOrgX;
	Rect.top = pLineFeed->y + pLineFeed->y_offset - m_lOrgY;
	Rect.right = Rect.left + pLineFeed->width;
	Rect.bottom = Rect.top + pLineFeed->height;

	//	Return FALSE if this doesn't fall into view of the context.
	if(Rect.top > m_lHeight || Rect.bottom < 0 || Rect.right < 0 || Rect.left > m_lWidth) {
		if(CanBlockDisplay())	{
			bRetval = FALSE;
		}
	}

	return(bRetval);
}

inline BOOL CDCCX::ResolveLineSolid()	{
	//	Don't default to all solid lines.
	return(FALSE);
}

COLORREF CDCCX::ResolveTextColor(LO_TextAttr *pAttr)	{
//	Purpose:	Determine the Forground color of the attribute.
//	Arguments:	pAttr	The attributes from which we will obtain the color.
//	Returns:	COLORREF	The color.
//	Comments:	Override this if you need finer control over the selections
//					of color such as printing.
//	Revision History:
//		06-09-95	created GAB

	//	Default implementation simply returns the color requested. Make sure that
	// we get the closest match in the palette and not one of the static system
	// colors. or'ing 0x02000000L in here is easier than finding every occurence
	// of SetTextColor downstream
	if(pAttr != NULL)	{
		return(0x02000000L | RGB(pAttr->fg.red, pAttr->fg.green, pAttr->fg.blue));
	}
	else	{
		return(RGB(0,0,0));
	}
}

//
// if we are not in true-color mode snap the color to the palette
//  otherwise they will get dithered to the windows 16-color palette
//  in the view's EraseBackground method
//
COLORREF CDCCX::ResolveBGColor(unsigned uRed, unsigned uGreen, unsigned uBlue)	
{

    int index = 0;
    if ((m_iBitsPerPixel <= 8) && m_pPal) {

        index = ::GetNearestPaletteIndex(m_pPal, RGB(uRed, uGreen, uBlue));

        PALETTEENTRY palEntry;
        ::GetPaletteEntries(m_pPal, index, 1, &palEntry);
        uRed   = palEntry.peRed;
        uGreen = palEntry.peGreen;
        uBlue  = palEntry.peBlue;

    }

	return(RGB(uRed, uGreen, uBlue));

}

BOOL CDCCX::ResolveHRSolid(LO_HorizRuleStruct *pHorizRule)	
{
	//	Determine if an HR is to be solid or 3D.
	//	Override this if you need to specifically control the display of
	//		HRs.
	if((pHorizRule->ele_attrmask & LO_ELE_SHADED) == LO_ELE_SHADED && pHorizRule->thickness > 1) {
		return(FALSE);
	}
	return(TRUE);
}

inline COLORREF CDCCX::ResolveDarkLineColor()	{
	//	By default, return the dark color.
	//	Override if you need to control HR colors.
	return(m_rgbDarkColor);
}

inline COLORREF CDCCX::ResolveLightLineColor()	{
	//	By default, return the light color.
	//	Override if you need to control HR colors.
	return(m_rgbLightColor);
}

COLORREF CDCCX::ResolveBorderColor(LO_TextAttr *pAttr)	{
	//	Default is to simply return the color requested.
	//	Override if you need to control border display.
	if(pAttr != NULL)	{
		return(RGB(pAttr->fg.red, pAttr->fg.green, pAttr->fg.blue));
	}
	else	{
		return(RGB(0,0,0));
	}
}

COLORREF CDCCX::ResolveLOColor(LO_Color *color)	{
	//	Default is to simply return the color requested.
	//	Override if you need to control border display.
	if(color != NULL)	{
		return(RGB(color->red, color->green, color->blue));
	}
	else	{
		return(RGB(0,0,0));
	}
}

void CDCCX::ResolveTransparentColor(unsigned uRed, unsigned uGreen, unsigned uBlue)	{
	//	Sets the transparency color of images.
	//	This in most cases is the same as the background color.
	//	Override this if you take special interest in controlling the background color.

	int iIndex = 0;
	IL_IRGB *rgbTransparent = GetContext()->transparent_pixel;

    if ((m_iBitsPerPixel <= 8) && m_pPal) {
		iIndex = ::GetNearestPaletteIndex(m_pPal, m_rgbBackgroundColor);
		curColorSpace->cmap.index[MAX_IMAGE_PALETTE_ENTRIES] = iIndex;
	}

	//	Simply let the image lib know what's up.
	if (!rgbTransparent) {
        rgbTransparent = XP_NEW_ZAP(IL_IRGB);
		GetContext()->transparent_pixel = rgbTransparent;
	}

    rgbTransparent->index = MAX_IMAGE_PALETTE_ENTRIES;
    rgbTransparent->red = uRed;
    rgbTransparent->green = uGreen;
    rgbTransparent->blue = uBlue;    
}

// rgbLight is used to render the top/left edges, and rgbDark is used to
// render the bottom/right edges
void CDCCX::Display3DBox(LTRB& Rect, COLORREF rgbLight, COLORREF rgbDark, int32 lWidth, BOOL bAdjust)	{
	HDC hDC = GetContextDC();

	//	Adjust the y value by half the height.  We'll need to move it back
	//		to the original position, since we have a reference to the rect.
	int32 lAdjust = 0;
	if(bAdjust == TRUE)	{
		//	This should only happen with HRs!
		lAdjust = Rect.Height() / 2;
		if(MMIsText() == FALSE)	{
			Rect.top -= lAdjust;
			Rect.bottom -= lAdjust;
		}
	}
	else	{
		//	When bAdjust is false, this means we are dealing with a table/cell/subdoc.
		//	To properly draw these, we need to shrink the rect on the right and bottom
		//		by the width.
		lAdjust = lWidth;
		Rect.right -= lAdjust;
		Rect.bottom -= lAdjust;
	}

    // If there's a thick border then miter the join where the different
    // colors meet
	if(lWidth > Pix2TwipsX(1) && ResolveLineSolid() == FALSE)	{
		HPEN    hOldPen = (HPEN)::SelectObject(hDC, GetStockObject(NULL_PEN));
		POINT   aPoints[6];
        HBRUSH  hbDark, hbLight, hOldBrush;
        
        // Make sure that in 256 color mode we get a PALETTE RGB color
        hbDark = ::CreateSolidBrush(0x02000000L | rgbDark);
        hbLight = ::CreateSolidBrush(0x02000000L | rgbLight);

		//	Map all the points.
		//	Left and top.
		aPoints[0].x = CASTINT(Rect.left + lWidth);
		aPoints[0].y = CASTINT(Rect.top + lWidth);
		aPoints[1].x = CASTINT(Rect.left + lWidth);
		aPoints[1].y = CASTINT(Rect.bottom);
		aPoints[2].x = CASTINT(Rect.left);
		aPoints[2].y = CASTINT(Rect.bottom + lWidth);
		aPoints[3].x = CASTINT(Rect.left);
		aPoints[3].y = CASTINT(Rect.top);
		aPoints[4].x = CASTINT(Rect.right + lWidth);
		aPoints[4].y = CASTINT(Rect.top);
		aPoints[5].x = CASTINT(Rect.right);
		aPoints[5].y = CASTINT(Rect.top + lWidth);
		
		hOldBrush = (HBRUSH)::SelectObject(hDC, hbLight);
		::Polygon(hDC, aPoints, 6);

		//	Right and bottom.
		aPoints[0].x = CASTINT(Rect.right);
		aPoints[0].y = CASTINT(Rect.bottom);
		aPoints[3].x = CASTINT(Rect.right + lWidth);
		aPoints[3].y = CASTINT(Rect.bottom + lWidth);
		
		::SelectObject(hDC, hbDark);
		::Polygon(hDC, aPoints, 6);

		::SelectObject(hDC, hOldPen);
		::SelectObject(hDC, hOldBrush);
        VERIFY(::DeleteObject(hbDark));
        VERIFY(::DeleteObject(hbLight));
	}
	else	{
        HBRUSH  hbLight, hbDark, hOldBrush;

        // Left/top edges
        hbLight = ::CreateSolidBrush(0x02000000L | rgbLight);
		hOldBrush = (HBRUSH)::SelectObject(hDC, hbLight);
        
        ::PatBlt(hDC, CASTINT(Rect.left), CASTINT(Rect.top),
            CASTINT(Rect.right - Rect.left), lWidth, PATCOPY);
        ::PatBlt(hDC, CASTINT(Rect.left), CASTINT(Rect.top),
            lWidth, CASTINT(Rect.bottom - Rect.top), PATCOPY);
        
        ::SelectObject(hDC, hOldBrush);
        VERIFY(::DeleteObject(hbLight));

        // Bottom/right edges
        hbDark = ::CreateSolidBrush(0x02000000L | rgbDark);
		hOldBrush = (HBRUSH)::SelectObject(hDC, hbDark);

        ::PatBlt(hDC, CASTINT(Rect.left), CASTINT(Rect.bottom),
            CASTINT(Rect.right - Rect.left), lWidth, PATCOPY);
        ::PatBlt(hDC, CASTINT(Rect.right), CASTINT(Rect.top),
            lWidth, CASTINT(Rect.bottom - Rect.top) + 1, PATCOPY);
		
        ::SelectObject(hDC, hOldBrush);
        VERIFY(::DeleteObject(hbDark));
	}
    //	Reposition.
	if(bAdjust == TRUE)	{
		//	HRs
		if(MMIsText() == FALSE)	{
			Rect.top += lAdjust;
			Rect.bottom += lAdjust;
		}
	}
	else	{
		//	Table/cell/subdoc
		Rect.right += lAdjust;
		Rect.bottom += lAdjust;
	}

	ReleaseContextDC(hDC);
}

static HPEN
CreateStyledPen(COLORREF color, int nWidth, int nPenStyle)
{
#ifdef _WIN32
    LOGBRUSH    lb;
    DWORD       dwPenStyle;
#endif

#ifdef _WIN32
    lb.lbStyle = 0;  // ignored
    lb.lbColor = 0x02000000L | color;
    lb.lbStyle = 0;  // ignored

    dwPenStyle = PS_GEOMETRIC | PS_ENDCAP_SQUARE | PS_JOIN_MITER;

    return ::ExtCreatePen(dwPenStyle | nPenStyle, nWidth, &lb, 0, NULL);
#else
    return ::CreatePen(nPenStyle, nWidth, 0x02000000L | color);
#endif
}

static void
DisplaySpecialBorder(HDC hDC, RECT &r, COLORREF color, int iWidth, BOOL bSolid)
{
	HPEN	hPen = ::CreatePen(PS_DOT, 1, 0x02000000L | color);
	HPEN	hOldPen = (HPEN)::SelectObject(hDC, hPen);
	HBRUSH	hOldBrush = (HBRUSH) ::SelectObject(hDC, ::GetStockObject(NULL_BRUSH));

    ::SetBkMode(hDC, TRANSPARENT);
    for( int i = 0; i < iWidth; i++ )
    {
    	::Rectangle(hDC, r.left, r.top, r.right, r.bottom);
        ::InflateRect(&r, -1, -1);
    }
	
    ::SelectObject(hDC, hOldPen);
	::SelectObject(hDC, hOldBrush);
	VERIFY(::DeleteObject(hPen));
}

static void
DisplaySolidBorder(HDC hDC, RECT &r, COLORREF color, LTRB &widths)
{
	// See if all border edges are the same width
	if (widths.left == widths.top && widths.left == widths.right && widths.left == widths.bottom) {
		HPEN	hPen = ::CreatePen(PS_INSIDEFRAME, widths.left, 0x02000000L | color);
		HPEN	hOldPen = (HPEN)::SelectObject(hDC, hPen);
		HBRUSH	hOldBrush = (HBRUSH) ::SelectObject(hDC, ::GetStockObject(NULL_BRUSH));

		// Draw it using a single rectangle call
		::Rectangle(hDC, r.left, r.top, r.right, r.bottom);
		::SelectObject(hDC, hOldPen);
		::SelectObject(hDC, hOldBrush);
		VERIFY(::DeleteObject(hPen));

	} else {
        HBRUSH  hBrush = ::CreateSolidBrush(0x02000000L | color);
		HBRUSH  hOldBrush = (HBRUSH)::SelectObject(hDC, hBrush);

		// Draw each of the individual edges using PatBlt
		if (widths.left > 0)
			::PatBlt(hDC, r.left, r.top, widths.left, r.bottom - r.top, PATCOPY);

		if (widths.top > 0)
			::PatBlt(hDC, r.left, r.top, r.right - r.left, widths.top, PATCOPY);

		if (widths.right > 0)
			::PatBlt(hDC, r.right - widths.right, r.top, widths.right, r.bottom - r.top, PATCOPY);

		if (widths.bottom > 0)
			::PatBlt(hDC, r.left, r.bottom - widths.bottom, r.right - r.left, widths.bottom, PATCOPY);
		
        ::SelectObject(hDC, hOldBrush);
        VERIFY(::DeleteObject(hBrush));
	}
}

static void
DisplayDoubleBorder(HDC hDC, RECT &r, COLORREF color, LTRB &widths)
{
	LTRB	strokeWidths;

	// Compute the stroke width for each of the edges
	strokeWidths.left = (widths.left + 1) / 3;
	strokeWidths.top = (widths.top + 1) / 3;
	strokeWidths.right = (widths.right + 1) / 3;
	strokeWidths.bottom = (widths.bottom + 1) / 3;

	// Draw the outer lines
	DisplaySolidBorder(hDC, r, color, strokeWidths);

	// Adjust the rectangle to be the inner rectangle
	r.left += CASTINT(widths.left - strokeWidths.left);
	r.top += CASTINT(widths.top - strokeWidths.top);
	r.right -= CASTINT(widths.right - strokeWidths.right);
	r.bottom -= CASTINT(widths.bottom - strokeWidths.bottom);

	// Draw the inner lines
	DisplaySolidBorder(hDC, r, color, strokeWidths);
}

// rgbLight is used to render the top/left edges, and rgbDark is used to
// render the bottom/right edges
void
CDCCX::Display3DBorder(LTRB& Rect, COLORREF rgbLight, COLORREF rgbDark, LTRB &widths)
{
	if (widths.left == widths.top && widths.left == widths.right && widths.left == widths.bottom) {
		// This routine is faster especially for one-pixel thick lines	
		Display3DBox(Rect, rgbLight, rgbDark, widths.left, FALSE);

	} else {
		HDC	hDC = GetContextDC();

		HPEN    hOldPen = (HPEN)::SelectObject(hDC, GetStockObject(NULL_PEN));
		POINT   aPoints[6];
        HBRUSH  hbDark, hbLight, hOldBrush;
        
        // Make sure that in 256 color mode we get a PALETTE RGB color
        hbDark = ::CreateSolidBrush(0x02000000L | rgbDark);
        hbLight = ::CreateSolidBrush(0x02000000L | rgbLight);

		// Map all the points. Draw it inside of the rect. Draw the left
		// and top edges first
		aPoints[0].x = CASTINT(Rect.left + widths.left);
		aPoints[0].y = CASTINT(Rect.top + widths.top);
		aPoints[1].x = CASTINT(Rect.left + widths.left);
		aPoints[1].y = CASTINT(Rect.bottom - widths.bottom);
		aPoints[2].x = CASTINT(Rect.left);
		aPoints[2].y = CASTINT(Rect.bottom);
		aPoints[3].x = CASTINT(Rect.left);
		aPoints[3].y = CASTINT(Rect.top);
		aPoints[4].x = CASTINT(Rect.right);
		aPoints[4].y = CASTINT(Rect.top);
		aPoints[5].x = CASTINT(Rect.right - widths.right);
		aPoints[5].y = CASTINT(Rect.top + widths.top);
		
		hOldBrush = (HBRUSH)::SelectObject(hDC, hbLight);
		::Polygon(hDC, aPoints, 6);

		//	Right and bottom.
		aPoints[0].x = CASTINT(Rect.right - widths.right);
		aPoints[0].y = CASTINT(Rect.bottom - widths.bottom);
		aPoints[3].x = CASTINT(Rect.right);
		aPoints[3].y = CASTINT(Rect.bottom);
		
		::SelectObject(hDC, hbDark);
		::Polygon(hDC, aPoints, 6);

		::SelectObject(hDC, hOldPen);
		::SelectObject(hDC, hOldBrush);
        VERIFY(::DeleteObject(hbDark));
        VERIFY(::DeleteObject(hbLight));
		
		ReleaseContextDC(hDC);
	}
}

// Adjust border for selection feedback of table or cell
// Returns width used in excess of table border (into space between cells)
//  because that will have to be restored to background when removing selection
int32 SetSelectionBorder(int32 *pWidth, int32 iCellSpacing)
{
    int32 iOldWidth = *pWidth;
    int32 iExcess = 0;
    // Allow wider selection if border is very large
    int32 iMaxWidth = 2*ED_SELECTION_BORDER;
    // 
    *pWidth = min(*pWidth,iMaxWidth);
    // Also use spacing between cells if less than maximum
    if( *pWidth < 6 )
    {
        iExcess = min(iCellSpacing, 6-*pWidth);
        *pWidth += iExcess;
    }
    return iExcess;
}

int32
CDCCX::DisplayTableBorder(LTRB& Rect, LO_TableStruct *pTable)
{
    COLORREF    	rgbBorder = ResolveLOColor(&pTable->border_color);
	COLORREF		rgbLight, rgbDark;
    HDC         	hDC;
    int         	nStrokeWidth;
    RECT        	r = {CASTINT(Rect.left), CASTINT(Rect.top), CASTINT(Rect.right), CASTINT(Rect.bottom)};
    LTRB        	insetRect;
	LTRB	borderWidths(pTable->border_left_width, pTable->border_top_width,
								    pTable->border_right_width, pTable->border_bottom_width);
    //TRACE0("DisplayTableBorder\n");

    // Only the Editor sets table elements as selected, so we don't need EDT_IS_EDITOR
    if( pTable->ele_attrmask & LO_ELE_SELECTED )
    {
        // Use the selection background color to draw a solid border
        COLORREF rgbBorder;
        wfe_GetSelectionColors(m_rgbBackgroundColor, NULL, &rgbBorder);
		hDC = GetContextDC();
        // Use same border thickness for all sides - use the minimum Table border thickness
        //  and the space between cells if available
        int32 iBorderWidth = min(borderWidths.bottom,min(borderWidths.top,min(borderWidths.left, borderWidths.right)));
        SetSelectionBorder(&iBorderWidth, pTable->inter_cell_space);
        borderWidths.left = borderWidths.right = borderWidths.top = borderWidths.bottom = iBorderWidth;

	    // Show a solid border up to twice default selection border as the selection feedback
        DisplaySolidBorder(hDC, r, rgbBorder, borderWidths);
		ReleaseContextDC(hDC);
        // Return actual border width used
        return iBorderWidth;
    }
    else
    {

	if (pTable->border_style == BORDER_GROOVE || pTable->border_style == BORDER_RIDGE ||
		pTable->border_style == BORDER_INSET || pTable->border_style == BORDER_OUTSET) {

		// Compute the 3D colors to use. If the border color is the same as the background
		// color then just use the light/dark colors we've already computed
		if (rgbBorder == m_rgbBackgroundColor) {
			rgbLight = m_rgbLightColor;
			rgbDark = m_rgbDarkColor;
		
		} else {
			Compute3DColors(rgbBorder, rgbLight, rgbDark);
		}
	}

	hDC = GetContextDC();
    switch (pTable->border_style) {
        case BORDER_NONE:
            break;

        case BORDER_DOTTED:
        case BORDER_DASHED:
		case BORDER_SOLID:
//			hDC = GetContextDC();
			DisplaySolidBorder(hDC, r, rgbBorder, borderWidths);
//			ReleaseContextDC(hDC);
            break;

		case BORDER_DOUBLE:
//			hDC = GetContextDC();
			DisplayDoubleBorder(hDC, r, rgbBorder, borderWidths);
//			ReleaseContextDC(hDC);
            break;

        case BORDER_GROOVE:
            // This is done as a sunken outer border with a raised inner
            // border. Windows group boxes have this appearance
			borderWidths.left /= 2;
			borderWidths.top /= 2;
			borderWidths.right /= 2;
			borderWidths.bottom /= 2;
            Display3DBorder(Rect, rgbDark, rgbLight, borderWidths);
            insetRect.left = Rect.left + borderWidths.left;
            insetRect.top = Rect.top + borderWidths.top;
            insetRect.right = Rect.right - borderWidths.right;
            insetRect.bottom = Rect.bottom - borderWidths.bottom;
            Display3DBorder(insetRect, rgbLight, rgbDark, borderWidths);
            break;

        case BORDER_RIDGE:
            // This is done as a raised outer border with a sunken inner border
			borderWidths.left /= 2;
			borderWidths.top /= 2;
			borderWidths.right /= 2;
			borderWidths.bottom /= 2;
            Display3DBorder(Rect, rgbLight, rgbDark, borderWidths);
            insetRect.left = Rect.left + borderWidths.left;
            insetRect.top = Rect.top + borderWidths.top;
            insetRect.right = Rect.right - borderWidths.right;
            insetRect.bottom = Rect.bottom - borderWidths.bottom;
            Display3DBorder(insetRect, rgbDark, rgbLight, borderWidths);
            break;

        case BORDER_INSET:
            // This is what Windows refers to as a sunken border
			Display3DBorder(Rect, rgbDark, rgbLight, borderWidths);
            break;

        case BORDER_OUTSET:
            // This is what Windows refers to as a raised border
			Display3DBorder(Rect, rgbLight, rgbDark, borderWidths);
            break;

        default:
            ASSERT(FALSE);
            break;
    }
    }
    return 0;
}

void CDCCX::EditorDisplayZeroWidthBorder(LTRB& Rect, BOOL bSelected){
    // Show a 1-pixel dotted border. Used in the editor
    // Use the same color we would use for a selection background,
    //   but use the opposite color if we will be selecting,
    //   so NOT opperation yields a contrasting color relative to background
    COLORREF rgbColor;
    wfe_GetSelectionColors(m_rgbBackgroundColor, NULL, &rgbColor);

    HDC hdc = GetContextDC();
    // Use dotted line if not selected, or solid if selecting
	HPEN pPen = ::CreatePen(bSelected ? PS_SOLID : PS_DOT, 1, rgbColor);
	HPEN pOldPen = (HPEN)::SelectObject(hdc, pPen);
	::MoveToEx(hdc, CASTINT(Rect.left), CASTINT(Rect.top), NULL);
    ::LineTo(hdc, CASTINT(Rect.right), CASTINT(Rect.top));
    ::LineTo(hdc, CASTINT(Rect.right), CASTINT(Rect.bottom));
	::LineTo(hdc, CASTINT(Rect.left), CASTINT(Rect.bottom));
	::LineTo(hdc, CASTINT(Rect.left), CASTINT(Rect.top));
	::SelectObject(hdc, pOldPen);
	ReleaseContextDC(hdc);
	VERIFY(::DeleteObject(pPen));
}

void CDCCX::DrawRectBorder(LTRB& Rect, COLORREF rgbColor, int32 lWidth)	{
	//	This should only be called for display of the border for images, and embeds.
	HDC hdc = GetContextDC();

	// The border goes outside of the rectangle, so we need to adjust the
	// rectangle accordingly
	int32 lAdjust = lWidth / 2;
	int32 rAdjust = lAdjust;
	if(lWidth % 2)	{
		lAdjust += Pix2TwipsX(1);
	}
	rAdjust += Pix2TwipsX(1);

	LTRB rect(Rect.left - lAdjust, Rect.top - lAdjust,
		Rect.right + rAdjust, Rect.bottom + rAdjust);
	SafeSixteen(rect);

	HPEN hBorder = ::CreatePen(PS_SOLID, CASTINT(lWidth), rgbColor);
	HPEN hOldPen = (HPEN)::SelectObject(hdc, hBorder);
	HBRUSH hOldBrush = (HBRUSH) ::SelectObject(hdc, ::GetStockObject(NULL_BRUSH));

	//	Draw it.
    ::Rectangle(hdc, CASTINT(rect.left), CASTINT(rect.top),
        CASTINT(rect.right), CASTINT(rect.bottom));

	::SelectObject(hdc, hOldBrush);
	::SelectObject(hdc, hOldPen);
	VERIFY(::DeleteObject(hBorder));
	ReleaseContextDC(hdc);

}

void CDCCX::DisplaySelectionFeedback(uint16 ele_attrmask, const LTRB& rect)
{
    BOOL bSelect =  ele_attrmask & LO_ELE_SELECTED;
    // Don't do anything if unselecting any other objects
    //  since these will be completely redrawn.
    if ( !bSelect || !EDT_IS_EDITOR(GetContext()) ) {
        return;
    }
	LTRB Rect(rect.left, rect.top,
		rect.right, rect.bottom);

	SafeSixteen(Rect);
    // Draw selection feedback. It has to fit entirely within rect, because
    // when it's turned off, all that will happen is that it won't be drawn.
	HDC hdc = GetContextDC();

    int32 rWidth = Rect.right - Rect.left;
    int32 rHeight = Rect.bottom - Rect.top;
    if ( rWidth <= (ED_SELECTION_BORDER*2) || rHeight <= (ED_SELECTION_BORDER*2) ) {
        // Too narrow to draw frame. Draw solid.
        RECT r;
		::SetRect(&r, CASTINT(Rect.left), CASTINT(Rect.top),
            CASTINT(Rect.right), CASTINT(Rect.bottom));
        ::InvertRect(hdc, &r);
    }
    else {
    	//	Frame.
    	LTRB inner(Rect.left + ED_SELECTION_BORDER, Rect.top + ED_SELECTION_BORDER,
    		Rect.right - ED_SELECTION_BORDER, Rect.bottom - ED_SELECTION_BORDER);
    	SafeSixteen(inner);

        RECT SelRect;
		::SetRect(&SelRect, CASTINT(Rect.left), CASTINT(Rect.top), CASTINT(Rect.right), CASTINT(inner.top));
  		::InvertRect(hdc, &SelRect);
        ::SetRect(&SelRect, CASTINT(Rect.left), CASTINT(inner.top), CASTINT(inner.left), CASTINT(inner.bottom));
  		::InvertRect(hdc, &SelRect);
        ::SetRect(&SelRect, CASTINT(inner.right), CASTINT(inner.top), CASTINT(Rect.right), CASTINT(inner.bottom));
  		::InvertRect(hdc, &SelRect);
        ::SetRect(&SelRect, CASTINT(Rect.left), CASTINT(inner.bottom), CASTINT(Rect.right), CASTINT(Rect.bottom));
  		::InvertRect(hdc, &SelRect);
    }

	ReleaseContextDC(hdc);
}

void CDCCX::EraseToBackground(const LTRB& rect, int32 borderWidth)
{
	if(!EDT_IS_EDITOR(GetContext())){
        return;
    }
    LTRB Rect(rect.left - borderWidth, rect.top - borderWidth,
		        rect.right + borderWidth, rect.bottom + borderWidth);

    // The editor draws selection feedback. Touch all the pixels so that
    // any pre-existing selection feedback is erased.
	HDC hdc = GetContextDC();
    
    RECT	 destRect;
	::SetRect(&destRect, CASTINT(Twips2PixX(Rect.left)), CASTINT(Twips2PixY(Rect.top)),
        CASTINT(Twips2PixX(Rect.right)), CASTINT(Twips2PixX(Rect.bottom)));

    // Is this really true? (Troy thinks conversion is only needed for 
    //  memory DC)
    // Coordinates to _EraseBkgnd() must be in device units
    // NOTE: _EraseBkgnd() call will use m_pImageDC, that's why we
    // aren't using it
    _EraseBkgnd(hdc,destRect,
			Twips2PixX(GetOriginX() ),
			Twips2PixY(GetOriginY() ),
			NULL);
	ReleaseContextDC(hdc);
}


#ifdef LAYERS
// Erase the background at the given rect. x, y, width and height are
// in document coordinates.
void CDCCX::EraseBackground(MWContext *pContext, int iLocation, 
			    int32 x, int32 y, uint32 width, uint32 height,
			    LO_Color *pColor)
{
	HDC hdc = GetContextDC();
	int32 orgX = GetOriginX();
	int32 orgY = GetOriginY();
	int32 lDrawingOrgX, lDrawingOrgY;
	RECT   eraseRect;
	int32 x0, y0;

	x0 = (x > orgX) ? x - orgX : orgX - x;
	y0 = (y > orgY) ? y - orgY : orgY - y;
	::SetRect(&eraseRect, CASTINT(x0), CASTINT(y0), 
						CASTINT(x0+width), CASTINT(y0+height));
	GetDrawingOrigin(&lDrawingOrgX, &lDrawingOrgY);
	_EraseBkgnd(hdc, eraseRect, orgX-lDrawingOrgX, orgY-lDrawingOrgY, 
				pColor);

	ReleaseContextDC(hdc);
}
#endif /* LAYERS */

static BOOL
CanCreateBrush(HBITMAP hBitmap)
{
	BITMAP	bitmap;

	// We can create a brush if the bitmap is exacly 8x8
	::GetObject(hBitmap, sizeof(bitmap), &bitmap);
	return bitmap.bmWidth == 8 && bitmap.bmHeight == 8;
}


// orgX, orgY, and crRect are interpreted in the logical coordinates
// of pDC
//
// Note: The caller is responsible for having selected the logical palette
// before calling this routine. If not, the call to CreateSolidBrush() will
// get mapped to the nearest system color (probably not the desired behavior)
BOOL CDCCX::_EraseBkgnd(HDC pDC, RECT& crRect, int32 orgX, int32 orgY, 
						LO_Color* bg)
{
	// The order of priority is as follows:
	//   1. passed in image
	//   2. passed in color
	//   3. document backdrop image
	//   4. document solid color
	COLORREF	bgColor = bg ? RGB(bg->red, bg->green, bg->blue) : m_rgbBackgroundColor;
	
	HBRUSH hBrush = NULL;
	if (m_iBitsPerPixel == 16)
		// We don't want a dithered brush
		hBrush = ::CreateSolidBrush(::GetNearestColor(pDC,bgColor));
	else
		hBrush = ::CreateSolidBrush(0x02000000L | bgColor);

	::FillRect(pDC, &crRect, hBrush);

#ifdef DDRAW
	if (GetPrimarySurface()) {
		::FillRect(GetDispDC(), &crRect, hBrush);
	}
#if 0 //DEBUG_mhwang
	TRACE("CDCCX::_EraseBkgnd, %d,%d,%d,%d(ltrb)\n", crRect.left, crRect.top,
								crRect.right, crRect.bottom);
#endif
#endif
	VERIFY(::DeleteObject(hBrush));
	return TRUE;
}





struct iconMap{
	int iIconNum;
	int x;
	int y;
	unsigned int bitmapID;
	unsigned int maskID;
}

#define SMIME_ICON_CX	50
#define SMIME_ICON_CY	30
#define SECADV_ICON_CX	51
#define SECADV_ICON_CY	30

#define ICONMAPSIZE 31

static iconMap[ICONMAPSIZE] = {
	IL_IMAGE_DELAYED, IMAGE_SMICON_WIDTH, IMAGE_SMICON_HEIGHT,IDB_SMIMAGE_DELAYED, IDB_SMIMAGE_MASK,
	IL_IMAGE_NOT_FOUND, IMAGE_ICON_SIZE, IMAGE_ICON_SIZE, IDB_IMAGE_NOTFOUND,IDB_IMAGE_MASK,
	IL_IMAGE_BAD_DATA, IMAGE_ICON_SIZE, IMAGE_ICON_SIZE, IDB_IMAGE_BAD, IDB_IMAGE_BAD_MASK,
	IL_IMAGE_INSECURE, IMAGE_ICON_SIZE, IMAGE_ICON_SIZE, IDB_IMAGE_SEC_REPLACE,IDB_IMAGE_MASK,
	IL_GOPHER_FOLDER,GOPHER_ICON_SIZE, GOPHER_ICON_SIZE + 1, IDB_GOPHER_FOLDER,IDB_GOPHER_FOLDER_MASK,
	IL_GOPHER_IMAGE, GOPHER_ICON_SIZE, GOPHER_ICON_SIZE + 1, IDB_GOPHER_IMAGE,IDB_GOPHER_AUDIO_MASK,
	IL_GOPHER_TEXT, GOPHER_ICON_SIZE, GOPHER_ICON_SIZE+1, IDB_GOPHER_TEXT, IDB_GOPHER_AUDIO_MASK,
	IL_GOPHER_BINARY, GOPHER_ICON_SIZE, GOPHER_ICON_SIZE+1, IDB_GOPHER_BINARY, IDB_GOPHER_AUDIO_MASK,
	IL_GOPHER_SOUND,  GOPHER_ICON_SIZE, GOPHER_ICON_SIZE+1, IDB_GOPHER_AUDIO, IDB_GOPHER_AUDIO_MASK,
	IL_GOPHER_MOVIE, GOPHER_ICON_SIZE, GOPHER_ICON_SIZE+1, IDB_GOPHER_FIND, IDB_GOPHER_FIND_MASK,
	IL_GOPHER_TELNET, GOPHER_ICON_SIZE, GOPHER_ICON_SIZE+1, IDB_GOPHER_TELNET,IDB_GOPHER_TELNET_MASK,
	IL_GOPHER_UNKNOWN, GOPHER_ICON_SIZE, GOPHER_ICON_SIZE+1, IDB_GOPHER_GENERIC, IDB_GOPHER_AUDIO_MASK,
	IL_EDIT_NAMED_ANCHOR, GOPHER_ICON_SIZE, GOPHER_ICON_SIZE+1, IDB_EDIT_NAMED_ANCHOR, 	IDB_EDIT_NAMED_ANCHOR_MASK,
	IL_EDIT_FORM_ELEMENT, GOPHER_ICON_SIZE, GOPHER_ICON_SIZE+1, IDB_EDIT_FORM_ELEMENT,IDB_EDIT_FORM_ELEMENT_MASK,
	IL_EDIT_UNSUPPORTED_TAG, GOPHER_ICON_SIZE, GOPHER_ICON_SIZE+1, IDB_EDIT_UNSUPPORTED_TAG, IDB_EDIT_UNSUPPORTED_TAG_MASK,
	IL_EDIT_UNSUPPORTED_END_TAG, GOPHER_ICON_SIZE, GOPHER_ICON_SIZE+1, IDB_EDIT_UNSUPPORTED_END_TAG, IDB_EDIT_UNSUPPORTED_END_TAG_MASK,
	IL_EDIT_JAVA, GOPHER_ICON_SIZE, GOPHER_ICON_SIZE+1, IDB_EDIT_JAVA, IDB_EDIT_JAVA_MASK,
	IL_EDIT_PLUGIN, GOPHER_ICON_SIZE, GOPHER_ICON_SIZE+1, IDB_EDIT_PLUGIN,IDB_EDIT_PLUGIN_MASK,

	IL_SA_SIGNED, SECADV_ICON_CX, SECADV_ICON_CY, IDB_SASIGNED, IDB_SASIGNED_MASK,
	IL_SA_ENCRYPTED, SECADV_ICON_CX, SECADV_ICON_CY, IDB_SAENCRYPTED, IDB_SAENCRYPTED_MASK,
	IL_SA_NONENCRYPTED, SECADV_ICON_CX, SECADV_ICON_CY, IDB_SAUNENCRYPTED, IDB_SAUNENCRYPTED_MASK,
	IL_SA_SIGNED_BAD, SECADV_ICON_CX, SECADV_ICON_CY, IDB_SASIGNED, IDB_SASIGNED_MASK,
	IL_SA_ENCRYPTED_BAD, SECADV_ICON_CX, SECADV_ICON_CY, IDB_SASIGNEDBAD, IDB_SASIGNEDBAD_MASK,
	IL_SMIME_ATTACHED, SMIME_ICON_CX, SMIME_ICON_CY, IDB_MSGATTACHED, IDB_MSGSTAMPMASK,
	IL_SMIME_SIGNED, SMIME_ICON_CX, SMIME_ICON_CY, IDB_MSGSIGNED, IDB_MSGSTAMPMASK,
	IL_SMIME_ENCRYPTED, SMIME_ICON_CX, SMIME_ICON_CY, IDB_MSGENCRYPTED, IDB_MSGSTAMPMASK,
	IL_SMIME_ENC_SIGNED, SMIME_ICON_CX, SMIME_ICON_CY, IDB_MSGSIGNEDENCRYPTED, IDB_MSGSTAMPMASK,
	IL_SMIME_SIGNED_BAD, SMIME_ICON_CX, SMIME_ICON_CY, IDB_MSGSIGNEDBAD, IDB_MSGSTAMPMASK,
	IL_SMIME_ENCRYPTED_BAD, SMIME_ICON_CX, SMIME_ICON_CY, IDB_MSGENCRYPTEDBAD, IDB_MSGSTAMPMASK,
	IL_SMIME_ENC_SIGNED_BAD, SMIME_ICON_CX, SMIME_ICON_CY, IDB_MSGSIGNEDENCRYPTEDBAD, IDB_MSGSTAMPMASK,

	IL_MSG_ATTACH, 24, 29, IDB_MSGATTACHBUTTON, IDB_MSGATTACHBUTTONMASK
};



void CDCCX::GetIconDimensions(int32* width, int32* height, int iconNumber)
{
    unsigned int bitmapID;    // resource ID of bitmap to load
    unsigned int maskID = 0;  // resource ID of mask (if any)

    if (iconNumber < 0)
        return;

    int x, y;

	for (int i = 0; i < ICONMAPSIZE ; i++) {
		if (iconMap[i].iIconNum == iconNumber) {
			x = iconMap[i].x;
			y = iconMap[i].y;
			bitmapID = iconMap[i].bitmapID;
			maskID = iconMap[i].maskID;
			break;
		}
	}

	if (i == ICONMAPSIZE) { // used default icon here.
		x = GOPHER_ICON_SIZE;
        y = GOPHER_ICON_SIZE + 1;
        bitmapID = IDB_FILE;
        maskID = IDB_GOPHER_AUDIO_MASK;
	}


	*width = CASTINT(x);
	*height = CASTINT(y);
}

#ifndef XP_WIN32
/* Quaternary raster codes */
#define MAKEROP4(fore,back) (DWORD)((((back) << 8) & 0xFF000000) | (fore))
#endif

static BOOL
AlterBackgroundColor(HDC pSrcDC, int width, int height, HBITMAP hMask, HBRUSH hBrush)
{
	HDC	memDC;

	// Create a memory DC for holding the mask
	if (!(memDC = ::CreateCompatibleDC(NULL))) {
		TRACE("AlterBackgroundColor() can't create compatible memory DC!\n");
		return FALSE;
	}

	// Select the mask into the memory DC
	HBITMAP	hOldMaskBitmap = (HBITMAP)::SelectObject(memDC, hMask);

	// Change the transparent bits of the source bitmap to the desired background
	// color by doing an AND raster op
	//
	// The mask is monochrome and will be converted to color to match the depth of
	// the destination. The foreground pixels in the mask are set to 1, and the
	// background pixels to 0. When converting to a color bitmap, white pixels (1)
	// are set to the background color of the DC, and black pixels (0) are set to
	// the text color of the DC
	//
	// Select the brush
	HBRUSH	hOldBrush = (HBRUSH)::SelectObject(pSrcDC, hBrush);

	// Draw the brush where the mask is 0
	::BitBlt(pSrcDC,
				   0,
				   0,
				   width,
				   height,
				   memDC,
				   0,
				   0,
//				   ROP_PSDPxax);
				   MAKEROP4(SRCPAINT, R2_COPYPEN));

	// Restore the DCs
	::SelectObject(memDC, hOldMaskBitmap);
	::SelectObject(pSrcDC, hOldBrush);

	return TRUE;
}

/////////////////////////////////////////////////////////////////////////////
// equivalent to LoadBitmap(), except uses pDC for
// correct color mapping of BMP into pDC's palette.
BOOL CDCCX::cxLoadBitmap(LPCSTR pszBmName, char** bits,  BITMAPINFOHEADER** myBitmapInfo) 
{

    // get the resource from the file
    HBITMAP hBmp = (HBITMAP)FindResource(AfxGetInstanceHandle( ), pszBmName, RT_BITMAP);
    ASSERT(hBmp != NULL);
    if(!hBmp)
        return FALSE;
    HGLOBAL hRes = LoadResource(AfxGetInstanceHandle( ), (HRSRC)hBmp);
    ASSERT(hRes != NULL);
    if(!hRes)
        return FALSE;
    LPBITMAPINFO pPackedDib = (LPBITMAPINFO)(LockResource(hRes));
    ASSERT(pPackedDib != NULL);
    if(!pPackedDib)
        return FALSE;
        
    // build a DDB header for  pDC
    
    // create the DDB
    int iColorTableSize =
        (1 << pPackedDib->bmiHeader.biBitCount) * sizeof(RGBQUAD);
	LPBITMAPINFOHEADER bitmapInfo;
	bitmapInfo = (LPBITMAPINFOHEADER)calloc(sizeof(BITMAPINFOHEADER) + iColorTableSize, 1);;
    memcpy(bitmapInfo, pPackedDib, sizeof(BITMAPINFOHEADER) + iColorTableSize);
    bitmapInfo->biBitCount = m_iBitsPerPixel;
    bitmapInfo->biClrUsed = 0;
    bitmapInfo->biClrImportant = 0;
	*myBitmapInfo = bitmapInfo;
    void* pBits =
        ((char*)pPackedDib) + pPackedDib->bmiHeader.biSize + iColorTableSize;
	int widthBytes = (((bitmapInfo->biWidth * bitmapInfo->biBitCount) + 31) && ~31) >> 3;
	*bits =(char*) CDCCX::HugeAlloc(widthBytes * bitmapInfo->biHeight, 1);
	memcpy(bits, pBits, widthBytes * bitmapInfo->biHeight);
    // done, clean up
	UnlockResource(hRes);
    BOOL bResult = FreeResource(hRes);
    
    return TRUE;
}

void CDCCX::DisplayIcon(int32 x0, int32 y0, int icon_number)
{
    unsigned int bitmapID;    // resource ID of bitmap to load
    unsigned int maskID = 0;  // resource ID of mask (if any)

    if (icon_number < 0)
        return;

    int x, y;
	LTRB Rect;

    for (int i = 0; i < ICONMAPSIZE ; i++) {
        if (iconMap[i].iIconNum == icon_number) {
            x = iconMap[i].x;
            y = iconMap[i].y;
            bitmapID = iconMap[i].bitmapID;
            maskID = iconMap[i].maskID;
            break;
        }
    }

    if (i == ICONMAPSIZE) { // used default icon here.
        x = GOPHER_ICON_SIZE;
        y = GOPHER_ICON_SIZE + 1;
        bitmapID = IDB_FILE;
        maskID = IDB_GOPHER_AUDIO_MASK;
    }

    int width = CASTINT(Pix2TwipsX(x));
    int height = CASTINT(Pix2TwipsY(y));

	if (ResolveElement(Rect, x0, y0, 0, 0, width, height)) {
		SafeSixteen(Rect);
        
		HBITMAP hBitmap = NULL;
		HDC hdc = GetContextDC();    

#ifdef XP_WIN32
		if (icon_number == IL_IMAGE_DELAYED) {
			static HICON	hIcon=NULL;

			// The icon is represented as a small icon resource which is 16x16 pixels
			if(!hIcon)
				hIcon = (HICON)::LoadImage(AfxGetResourceHandle(),
					MAKEINTRESOURCE(IDI_IMAGE_DELAYED), IMAGE_ICON, 16, 16, LR_DEFAULTCOLOR);

			VERIFY(::DrawIconEx(hdc, CASTINT(Rect.left), CASTINT(Rect.top),
				hIcon, Pix2TwipsX(16), Pix2TwipsY(16), 0, NULL, DI_NORMAL));

			/* don't destroy hIcon because it's static */

//			return;
		}
		else
#endif
		{
			// load the bitmap out of the resource file
			HBITMAP mask;
			if (!IsPrintContext()) {
				hBitmap = LOADBITMAP(bitmapID);
				if(maskID) 
					mask = LOADBITMAP(maskID);
				HBITMAP hOldBitmap = NULL;                                       

				if(maskID) {

					// load the mask out of the resource file
						StretchMaskBlt(hdc, hBitmap, mask, 
									Rect.left, Rect.top, width, height,
									0, 0, x, y);
 					VERIFY(::DeleteObject(mask));
				} 
				else {
    				// load the bitmap into the cached image CDC                                                   
					hOldBitmap = (HBITMAP) ::SelectObject(m_pImageDC, hBitmap);

					::StretchBlt(hdc,
								CASTINT(Rect.left), 
    							CASTINT(Rect.top),
    							CASTINT(width), 
    							CASTINT(height), 
    							m_pImageDC,
    							CASTINT(0), 
    							CASTINT(0), 
    							CASTINT(x),
    							CASTINT(y), 
    							SRCCOPY);
					::SelectObject(m_pImageDC, hOldBitmap);
				}

				// restore the old bitmap
				VERIFY(::DeleteObject(hBitmap));
			}
			else {	// printing icon
				char** image_bits;
				BITMAPINFOHEADER* imageInfo;
				char** mask_bits;
				BITMAPINFOHEADER* maskInfo;
				if (cxLoadBitmap(MAKEINTRESOURCE(bitmapID), image_bits, &imageInfo)) {
					if(maskID) {
						BOOL fillBack = TRUE;
#ifdef XP_WIN32
						CPrintCX* pPrintCx = (CPrintCX*)this;
						fillBack = pPrintCx->IsPrintingBackground() ? FALSE : TRUE;
#endif
						cxLoadBitmap(MAKEINTRESOURCE(maskID), mask_bits, &maskInfo);
						WFE_StretchDIBitsWithMask(hdc,TRUE, m_pImageDC,
											CASTINT(Rect.left), 
    										CASTINT(Rect.top),
    										CASTINT(width), 
    										CASTINT(height), 
    										CASTINT(0), 
    										CASTINT(0), 
    										CASTINT(x),
    										CASTINT(y), 
											image_bits,
											(BITMAPINFO*)imageInfo,
											mask_bits,
											m_bUseDibPalColors,
											fillBack);
					}
					else {
						::StretchDIBits(hdc,
											CASTINT(Rect.left), 
    										CASTINT(Rect.top),
    										CASTINT(width), 
    										CASTINT(height), 
    										CASTINT(0), 
    										CASTINT(0), 
    										CASTINT(x),
    										CASTINT(y), 
											image_bits,
											(BITMAPINFO*)imageInfo,
											DIB_RGB_COLORS,
											SRCCOPY);
					}
				}

				if (image_bits)
					delete *image_bits;
				if (imageInfo)
					delete imageInfo;
				if(maskID) {
					if (mask_bits)
						delete *mask_bits;
					if (maskInfo)
						delete maskInfo;
				}
			}
		}
		ReleaseContextDC(hdc);
	}
}
	
int CDCCX::GetUrl(URL_Struct *pUrl, FO_Present_Types iFormatOut, BOOL bReallyLoading, BOOL bForceNew)	{
	//	Save the location of the current document, if not at the very top.
    //  Reset to top, then see if we need to change more....
    SHIST_SetPositionOfCurrentDoc(&(GetContext()->hist), 0);
    if(GetOriginX() || GetOriginY())    {
#ifdef LAYERS
	    LO_Any *pAny = (LO_Any *)LO_XYToNearestElement(GetDocumentContext(), GetOriginX(), GetOriginY(), NULL);
#else
	    LO_Any *pAny = (LO_Any *)LO_XYToNearestElement(GetDocumentContext(), GetOriginX(), GetOriginY());
#endif  /* LAYERS */
	    if(pAny != NULL)	{
		    TRACE("Remembering document position at element id %ld\n", pAny->ele_id);
		    SHIST_SetPositionOfCurrentDoc(&(GetContext()->hist), pAny->ele_id);
	    }
    }

	//	Handle forced image loading.
	m_csForceLoadImage = m_csNexttimeForceLoadImage;
	m_csNexttimeForceLoadImage.Empty();
	m_bLoadImagesNow = m_bNexttimeLoadImagesNow;
	m_bNexttimeLoadImagesNow = FALSE;

	//	Call the base.
	return(CStubsCX::GetUrl(pUrl, iFormatOut, bReallyLoading, bForceNew));
}

//	rewrite the BULLET_BASIC and BULLET_DISC part
//	the origional "o" approach cause a lot of problem in non-LATIN page
void CDCCX::DisplayBullet(MWContext *pContext, int iLocation, LO_BullettStruct *pBullet)	{
	//	Figure the coordinates.
	LTRB Rect;
	int		reduce;
//	if(ResolveElement(Rect, pBullet, iLocation) == TRUE)	{
	if (ResolveElement(Rect, pBullet->x, pBullet->y, 
				pBullet->x_offset, pBullet->y_offset,
				pBullet->width, pBullet->height) == TRUE) {
		SafeSixteen(Rect);

		COLORREF rgbBullet = ResolveTextColor(pBullet->text_attr);
		HDC hdc = GetContextDC();

		int w;
		if( pBullet->bullet_type == BULLET_MQUOTE 
			|| pBullet->bullet_type == BULLET_SQUARE ) {
			w = 1;
		} else {
			w = CASTINT( (Rect.bottom - Rect.top) / 10);
			if(w < 1)
				w = 1;
		}

		HPEN hpen = ::CreatePen(PS_SOLID,w,rgbBullet);
		HPEN oldPen = (HPEN)::SelectObject(hdc,hpen);      

		// draw_bullet_with_Ellipse
		HBRUSH hBrush = ::CreateSolidBrush(rgbBullet);
		HBRUSH hOldBrush = (HBRUSH)::SelectObject(hdc, hBrush);

		switch(pBullet->bullet_type)	{
		
		case BULLET_MQUOTE:
			// BUG#61210 draw quote as one pixel bar on the left
#if defined (WIN32)
			::MoveToEx(hdc, CASTINT(Rect.left), CASTINT(Rect.top), NULL);
#else
			::MoveTo(hdc, CASTINT(Rect.left), CASTINT(Rect.top));
#endif
			::LineTo(hdc,CASTINT(Rect.left), CASTINT(Rect.bottom));
			break;
		case BULLET_SQUARE:	
			// Size of square is too large relative to solid and open circle,
			//  so reduce a little
			Rect.top++;
			Rect.bottom--;
			Rect.left++;
			Rect.right--;
			::Rectangle(hdc, CASTINT(Rect.left), CASTINT(Rect.top), CASTINT(Rect.right), CASTINT(Rect.bottom));
			break;

		case BULLET_NONE:
			// Do nothing
			break;

		case BULLET_BASIC:		// solid bullet
		case BULLET_ROUND :		// todo ::RoundRect()?
		default :				// Circle
			if( BULLET_BASIC != pBullet->bullet_type )  {   // Circle
				// don't touch hOldBrush, put hOldBrush back after draw.
				::SelectObject(hdc, ::GetStockObject(NULL_BRUSH));
			}
			reduce = (Rect.bottom - Rect.top ) / 4;
			::Ellipse(hdc, CASTINT(Rect.left+reduce), CASTINT(Rect.top+reduce),
				           CASTINT(Rect.right-reduce), CASTINT(Rect.bottom-reduce));
			break;
		}
		::SelectObject(hdc, hOldBrush);
		VERIFY(::DeleteObject( hBrush ));

		::SelectObject(hdc,oldPen);      
       ::DeleteObject(hpen);
		// end of draw_bullet_with_Ellipse

		ReleaseContextDC(hdc);
	}
}

#ifdef Frank_code
void CDCCX::DisplayBullet(MWContext *pContext, int iLocation, LO_BullettStruct *pBullet)	{
	//	Figure the coordinates.
	LTRB Rect;
//	if(ResolveElement(Rect, pBullet, iLocation) == TRUE)	{
	if (ResolveElement(Rect, pBullet->x, pBullet->y, 
				pBullet->x_offset, pBullet->y_offset,
				pBullet->width, pBullet->height) == TRUE) {
		SafeSixteen(Rect);

		COLORREF rgbBullet = ResolveTextColor(pBullet->text_attr);
		HDC hdc = GetContextDC();


        Rect.top++;
        Rect.bottom--;
        Rect.left++;
        Rect.right--;

		switch(pBullet->bullet_type)	{
		
        case BULLET_MQUOTE:
		case BULLET_SQUARE:	{
			HBRUSH hBrush = ::CreateSolidBrush(rgbBullet);
			HBRUSH hOldBrush = (HBRUSH)::SelectObject(hdc, hBrush);

			::Rectangle(hdc, CASTINT(Rect.left), CASTINT(Rect.top), CASTINT(Rect.right), CASTINT(Rect.bottom));
			::SelectObject(hdc, hOldBrush);
			VERIFY(::DeleteObject( hBrush ));
			break;
		}

		case BULLET_BASIC:	{
			HBRUSH hBrush = ::CreateSolidBrush(rgbBullet);
			HBRUSH hOldBrush = (HBRUSH)::SelectObject(hdc, hBrush);

			::Ellipse(hdc, CASTINT(Rect.left), CASTINT(Rect.top), CASTINT(Rect.right), CASTINT(Rect.bottom));
			::SelectObject(hdc, hOldBrush);
			VERIFY(::DeleteObject( hBrush ));
			break;

        }

		default:	{
			int w = CASTINT( (Rect.bottom - Rect.top) / 10);
			if(w < 1)
				w = 1;
			HBRUSH hBrush = (HBRUSH)::GetStockObject(NULL_BRUSH);
			HBRUSH hOldBrush = (HBRUSH)::SelectObject(hdc, hBrush);
			HPEN hStrike = ::CreatePen(PS_SOLID, CASTINT( w ), rgbBullet);
			HPEN hOldStrike = (HPEN)::SelectObject(hdc, hStrike);

			::Ellipse(hdc, CASTINT(Rect.left), CASTINT(Rect.top), CASTINT(Rect.right), CASTINT(Rect.bottom));
			::SelectObject(hdc, hOldBrush);
			// Don't delete hBrush since it is a stock object

			::SelectObject(hdc, hOldStrike);
			VERIFY(::DeleteObject( hStrike ));
			break;

			}
		}

		ReleaseContextDC(hdc);
	}
}
#endif

// Display a border of the specified size and color.  x, y, width and height
// refer to the outside perimeter of the border.
void CDCCX::DisplayBorder(MWContext *pContext, int iLocation, int x, int y, int width, int height, int bw, LO_Color *color, LO_LineStyle style)
{
    LTRB Rect;
    
    if (bw) {
        // Adjust the input parameters so that they describe the inside
        // perimeter of the border.  Don't do this for 3D borders since
        // Draw3DBox does this for us.
        if (style != LO_BEVEL) {
            x += bw;
            y += bw;
            width -= 2 * bw;
            height -= 2 * bw;
        }

        if (ResolveElement(Rect, x, y, 0, 0, width, height)) {
            SafeSixteen(Rect);

            // Call the method which really draws the border.
            switch(style) {
            case LO_SOLID:
                DrawRectBorder(Rect, ResolveLOColor(color), bw);
                break;

            case LO_BEVEL:
                Display3DBox(Rect, ResolveDarkLineColor(),
                             ResolveLightLineColor(), Pix2TwipsX(bw), FALSE);
                break;

            default:
                break;
            }
        }
    }
}

void CDCCX::DisplayImageFeedback(MWContext *pContext, int iLocation, LO_Element *pElement, lo_MapAreaRec * theArea, uint32 drawFlag )
{
	if (pElement->lo_any.type == LO_IMAGE) {
		LO_ImageStruct *pImage = (LO_ImageStruct *)pElement;
		LTRB Rect;
		int borderWidth = CASTINT(pImage->border_width);
		int x = CASTINT(pImage->x + pImage->x_offset + borderWidth);
		int y = CASTINT(pImage->y + pImage->y_offset + borderWidth);

		if (ResolveElement(Rect, x, y, 0, 0, pImage->width, pImage->height)) {
			SafeSixteen(Rect);

            DisplaySelectionFeedback(pImage->ele_attrmask, Rect);

//#ifndef NO_TAB_NAVIGATION
            if((FE_DRAW_TAB_FOCUS & drawFlag) &&
               pImage->suppress_mode != LO_SUPPRESS) {
			
                // use the Rect from code above.
                if( theArea != NULL) {
                    //  It is a focused area in map, draw a focus border.
					DrawMapAreaBorder( CASTINT(Rect.left), CASTINT(Rect.top), theArea );
                } else {
                    // draw a focus border for the whole image
                    lo_MapAreaRec	area;
                    int32			coord[4];
                    area.coords		= coord;
                    area.type = AREA_SHAPE_RECT ;
                    area.coord_cnt = 4;
                    area.coords[0] = Rect.left;
                    area.coords[1] = Rect.top;
                    area.coords[2] = Rect.right;
                    area.coords[3] = Rect.bottom;
                    DrawMapAreaBorder( 0, 0, &area );
                }		
            }
//#endif	/* NO_TAB_NAVIGATION */
        }
    }
}


BOOL CDCCX::IsPluginFullPage(LO_EmbedStruct *pLayoutData)
{
    // 1x1 size is signal that plugin is full page, not embedded
    if((pLayoutData->width == Pix2TwipsX(1))
        && (pLayoutData->height == Pix2TwipsX(1)))
        return TRUE;
    return FALSE;
}

// returns TRUE if there is a plugin on the page and that plugin
// is of pluginType == NPWFE_FULL_PAGE.  There can be only one
// plugin on a page that contains a NPWFE_FULL_PAGE plugin.
BOOL CDCCX::ContainsFullPagePlugin()
{
    NPEmbeddedApp* pEmbeddedApp = GetContext()->pluginList;
    if(pEmbeddedApp) {
        if(pEmbeddedApp->pagePluginType == NP_FullPage)
            return TRUE;
    }
    return FALSE;
}

//  Determine location of plugin rect, convert from TWIPS to PIXELS
void CDCCX::GetPluginRect(MWContext *pContext,
                          LO_EmbedStruct *pLayoutData,
                          RECT &rect, int iLocation,
                          BOOL windowed)
{
    if(IsPluginFullPage(pLayoutData))
    {
		 ::GetClientRect(PANECX(pContext)->GetPane(), &rect);
    }
    else // plugin embedded in page
    {
        // get the display area and clamp it
        LTRB Rect;
        ResolveElement(Rect, pLayoutData, iLocation, windowed);

		SafeSixteen(Rect);
        rect.left   = (int)Rect.left;
        rect.top    = (int)Rect.top;
        rect.right  = (int)Rect.right;
        rect.bottom = (int)Rect.bottom;
    }
}

void CDCCX::DisplayWindowlessPlugin(MWContext *pContext, 
                                    LO_EmbedStruct *pEmbed,
                                    NPEmbeddedApp *pEmbeddedApp,
                                    int iLocation)
{
    RECT 		rect;
    NPWindow* 	pAppWin = pEmbeddedApp->wdata;
    HDC         hDC = GetContextDC();
    NPEvent event;
    FE_Region clip;
    
    // Get the coordinates of where it should be positioned
    GetPluginRect(pContext, pEmbed, rect, iLocation, FALSE);
    
    if ((pAppWin->window	!= (void *)hDC) ||
        (pAppWin->x			!= (uint32) rect.left) ||
        (pAppWin->y			!= (uint32) rect.top) ||
        (pAppWin->width		!= (uint32) (rect.right - rect.left)) ||
        (pAppWin->height	!= (uint32) (rect.bottom - rect.top))) 
    {
        pAppWin->window = (void *)hDC;
        pAppWin->x = rect.left;
        pAppWin->y = rect.top;
        pAppWin->width = rect.right - rect.left;
        pAppWin->height = rect.bottom - rect.top;
        pAppWin->type = NPWindowTypeDrawable;
        
        NPL_EmbedSize(pEmbeddedApp);
    }
    
#ifdef LAYERS
    clip = GetDrawingClip();
    if (clip) 
    {
        XP_Rect xprect;
        
        FE_GetRegionBoundingBox(clip, &xprect);
        rect.left = CASTINT(xprect.left);
        rect.top = CASTINT(xprect.top);
        rect.right = CASTINT(xprect.right);
        rect.bottom = CASTINT(xprect.bottom);
    }
#endif /* LAYERS */        
    
    event.event = WM_PAINT;
    event.wParam = (uint32)hDC;
    event.lParam = (uint32)&rect;
    
    NPL_HandleEvent(pEmbeddedApp, (void *)&event, pAppWin->window);

    ReleaseContextDC(hDC);
}


// create a window and pass its offset/size to the plugin
void CDCCX::DisplayPlugin(MWContext *pContext, LO_EmbedStruct *pEmbed,
					      NPEmbeddedApp* pEmbeddedApp, int iLocation)
{
    RECT 		rect;
    NPWindow* 	pAppWin = pEmbeddedApp->wdata;

   	if(pAppWin->window == NULL)
        return;

    if (::IsWindowVisible((HWND)pAppWin->window) && 
        (pEmbed->ele_attrmask & LO_ELE_INVISIBLE))
        ::ShowWindow((HWND)pAppWin->window, SW_HIDE);

    // If the plugin is embedded we need to make sure the window is
    // positioned properly
    if (!IsPluginFullPage(pEmbed)) {
        RECT	curRect;
            
        // Get the coordinates of where it should be positioned
        GetPluginRect(pContext, pEmbed, rect, iLocation, TRUE);

        // Get the current coordinates relative to the parent window's
        // client area
        ::GetWindowRect((HWND)pAppWin->window, &curRect);
        MapWindowPoints(NULL, ::GetParent((HWND)pAppWin->window),
                        (POINT FAR *)&curRect, 2);
                
        // Only move/size the window if necessary
        if ((rect.left != curRect.left) ||
            (rect.right != curRect.right) ||
            (rect.top != curRect.top) ||
            (rect.bottom != curRect.bottom)){
            ::SetWindowPos((HWND)pAppWin->window, NULL, rect.left, rect.top,
                           rect.right - rect.left, rect.bottom - rect.top, SWP_NOZORDER | SWP_NOACTIVATE);
                    
        }
         
        // Update the NPWindow rect
        pAppWin->x = rect.left;
        pAppWin->y = rect.top;
        pAppWin->width = rect.right - rect.left;
        pAppWin->height = rect.bottom - rect.top;
    }
        
    if (!::IsWindowVisible((HWND)pAppWin->window) &&
        !(pEmbed->ele_attrmask & LO_ELE_INVISIBLE))
        ::ShowWindow((HWND)pAppWin->window, SW_SHOW);
       
}

void CDCCX::DisplayEmbed(MWContext *pContext, int iLocation, LO_EmbedStruct *pEmbed)
{
    NPEmbeddedApp* pEmbeddedApp = (NPEmbeddedApp*)pEmbed->FE_Data;

    if(pEmbeddedApp == NULL)
        return;

	if(wfe_IsTypePlugin(pEmbeddedApp)) {
        if (NPL_IsEmbedWindowed(pEmbeddedApp)) {
            DisplayPlugin(pContext, pEmbed, pEmbeddedApp, iLocation);
            (void)NPL_EmbedSize(pEmbeddedApp);
        }
        else
            DisplayWindowlessPlugin(pContext, pEmbed, pEmbeddedApp, iLocation);

        if(IsPluginFullPage(pEmbed))
            pEmbeddedApp->pagePluginType = NP_FullPage;
        else
            pEmbeddedApp->pagePluginType = NP_Embedded;
        return;
    }

	// else must be an OLE display
	LTRB Rect;
	if(ResolveElement(Rect, pEmbed, iLocation, FALSE) == TRUE)	{
        int32 lOrgX, lOrgY;
        
        GetDrawingOrigin(&lOrgX, &lOrgY);
        SafeSixteen(Rect);

		//	Draw a border around the embed if needed.
		if(pEmbed->border_width != 0)	{
			DrawRectBorder(Rect, ResolveBorderColor(NULL), pEmbed->border_width);
		}

		//	Get the embedded item
        CNetscapeCntrItem *pItem = (CNetscapeCntrItem *)pEmbeddedApp->fe_data;
		if(pItem == NULL)	{
			DisplayIcon(Rect.left, Rect.top, IL_IMAGE_BAD_DATA);
			return;
		}

		//	Handle delayed, broken, and currently loading items.
		else if(pItem->m_bDelayed == TRUE)	{
			DisplayIcon(Rect.left - lOrgX, Rect.top - lOrgY, IL_IMAGE_DELAYED);
			return;
		}
		else if(pItem->m_bBroken == TRUE)	{
			DisplayIcon(Rect.left - lOrgX, Rect.top - lOrgY, IL_IMAGE_BAD_DATA);
		}
		else if(pItem->m_bLoading == TRUE)	{
			//	Can't draw if still loading.
			return;			
		}

		//	Okay to draw.
		HDC hdc = GetContextDC();
		RECT crRect;
		::SetRect(&crRect, (int)Rect.left,(int)Rect.top,(int)Rect.right,(int)Rect.bottom);
		CDC dc;
		dc.Attach(hdc);
		COLORREF backgroundColor = (COLORREF)GetSysColor(COLOR_WINDOW);
		HBRUSH tempBrush = ::CreateSolidBrush(backgroundColor);
		::FillRect(dc.GetSafeHdc(), &crRect,tempBrush);
		::DeleteObject(tempBrush);
		if (pItem->IsInPlaceActive())  {
			if (!pItem->m_bSetExtents) {
				pItem->m_bSetExtents = TRUE;
				SIZEL temp1;
				temp1.cx = Twips2MetricX(crRect.right - crRect.left);
				temp1.cy = Twips2MetricY(crRect.bottom - crRect.top);
				HRESULT sc = pItem->m_lpObject->SetExtent(DVASPECT_CONTENT, &temp1);
				sc = pItem->m_lpObject->Update();
			}
			crRect.left += sysInfo.m_iScrollWidth + sysInfo.m_iBorderWidth;
			crRect.top += sysInfo.m_iScrollHeight + sysInfo.m_iBorderHeight;
			crRect.right -=  sysInfo.m_iScrollWidth + sysInfo.m_iBorderWidth;
			crRect.bottom -= sysInfo.m_iScrollHeight + sysInfo.m_iBorderHeight;
			pItem->SetItemRects(&crRect);
		}
		pItem->Draw(&dc, &crRect);
		dc.Detach();
		ReleaseContextDC(hdc);
	}
}

void CDCCX::DisplayHR(MWContext *pContext, int iLocation, LO_HorizRuleStruct *pHorizRule)	
{
	//	Figure out the coordinates of where to draw the HR.
	LTRB Rect;
//	if(ResolveElement(Rect, pHorizRule, iLocation) == TRUE)	{
	if(ResolveElement(Rect, pHorizRule->x,pHorizRule->y,
					pHorizRule->x_offset, pHorizRule->y_offset,
					pHorizRule->width, pHorizRule->height) == TRUE)	{
		SafeSixteen(Rect);

#ifdef EDITOR
        // Don't draw the editor's end-of-document hrule unless we're
        // displaying paragraph marks.
        if ( pHorizRule->edit_offset < 0 && ! EDT_DISPLAY_PARAGRAPH_MARKS(pContext) ) {
            return;
        }

        // Increase height of selection rect if it is very small
        LTRB SelRect = Rect;
        if( SelRect.Height() < 6 )
        {
            SelRect.top -= (6 - SelRect.Height())/2;
            SelRect.bottom = SelRect.top + 6;
        }
//        EraseToBackground(SelRect);
#endif /* EDITOR */

		//	Find out if we are doing a solid or 3D HR.
		if(ResolveHRSolid(pHorizRule) == TRUE)	{
			HDC hdc = GetContextDC();

			//	Draw a solid HR.
			//	We'll be using the darker color to do this.
			COLORREF rgbColor = ResolveDarkLineColor();

			HPEN cpHR = ::CreatePen(PS_SOLID, CASTINT(Pix2TwipsY(pHorizRule->thickness)), rgbColor);
			HPEN pOldPen = (HPEN)::SelectObject(hdc, cpHR);
			if(MMIsText() == TRUE)	{
				::MoveToEx(hdc, CASTINT(Rect.left), CASTINT(Rect.top + Rect.Height() / 2), NULL);
				::LineTo(hdc, CASTINT(Rect.right), CASTINT(Rect.top + Rect.Height() / 2));	//	use top, or diagonal.
			}
			else	{
				::MoveToEx(hdc, CASTINT(Rect.left), CASTINT(Rect.top), NULL);
				::LineTo(hdc, CASTINT(Rect.right), CASTINT(Rect.top));	//	use top, or diagonal.
			}
			::SelectObject(hdc, pOldPen);
			VERIFY(::DeleteObject(cpHR));
	
			ReleaseContextDC(hdc);
		}
		else	{
			Display3DBox(Rect, ResolveDarkLineColor(), ResolveLightLineColor(),
				Pix2TwipsX(1), TRUE);
		}
#ifdef EDITOR
        DisplaySelectionFeedback(pHorizRule->ele_attrmask, SelRect);
#endif //EDITOR
	}
}

// Common algorithm for setting contrasting background and text colors
void wfe_GetSelectionColors( COLORREF rgbBackgroundColor, 
                             COLORREF* pTextColor, COLORREF* pBackColor)
{
    //CLM: Always use Blue text on white or white text on blue if selecting
    // Test intensity of real background so entire selection uses same colors
    // This algorithm favors using dark
    // Possible problem: If we have relatively bright text on a dark background image
    BOOL bDarkBackground = (GetRValue(rgbBackgroundColor) + 
                            GetGValue(rgbBackgroundColor) + 
                            GetBValue(rgbBackgroundColor)) < 192;

    if( pTextColor ){
        *pTextColor = bDarkBackground ? RGB(0,0,128) : RGB(255,255,255);
    }
    if( pBackColor ){
        *pBackColor = bDarkBackground ?  RGB(255,255,255) : RGB(0,0,128);
    }
}

               
void CDCCX::DisplayLineFeed(MWContext *pContext, int iLocation, LO_LinefeedStruct *pLineFeed, XP_Bool clear)
{
    LTRB Rect;
    Bool bElementResolved;
    Bool bSpecialDrawing = EDT_IS_EDITOR(pContext) && pLineFeed->break_type;

#ifdef EDITOR
    // Allow selection feedback and display of end-of-paragraph marks in the editor.
    // We do nothing if we're not in the editor.
    // We do nothing if this isn't an end-of-paragraph or hard break.
    // If we're displaying the marks, then we display them as little squares.
    // Otherwise we just do the selection feedback.
    // The selection feedback is a rectangle the height of the linefeed 1/2 of the rectangle's height.
    // located at the left edge of the linefeed's range.

    // We need to expand the linefeed's width here so that ResolveElement thinks it's at least as wide
    // as we're going to draw it.
    Bool bExpanded = FALSE;
    int32 expandedWidth;
    int32 expandedHeight;
    if ( bSpecialDrawing ) {
        const int32 kMinimumWidth = 7;
        const int32 kMinimumHeight = 12;

        int32 originalWidth = pLineFeed->width;
        int32 originalHeight= pLineFeed->height;
        expandedWidth = originalWidth;
        expandedHeight = originalHeight;

        if ( expandedWidth < kMinimumWidth ) {
            expandedWidth = kMinimumWidth;
            bExpanded = TRUE;
        }
        if ( expandedHeight < kMinimumHeight ) {
            expandedHeight = kMinimumHeight;
            bExpanded = TRUE;
        }
        pLineFeed->width = expandedWidth;
        pLineFeed->height = expandedHeight;
//        bElementResolved = ResolveElement(Rect, pLineFeed, iLocation);
        bElementResolved = ResolveElement(Rect, pLineFeed->x, pLineFeed->y,
									pLineFeed->x_offset,pLineFeed->y_offset,
									pLineFeed->width, pLineFeed->height);
        pLineFeed->width = originalWidth;
        pLineFeed->height = originalHeight;
    }
    else
    {
//        bElementResolved = ResolveElement(Rect, pLineFeed, iLocation);
        bElementResolved = ResolveElement(Rect, pLineFeed->x, pLineFeed->y,
								pLineFeed->x_offset, pLineFeed->y_offset,
								pLineFeed->width, pLineFeed->height);
    }
#else
//    bElementResolved = ResolveElement(Rect, pLineFeed, iLocation);
        bElementResolved = ResolveElement(Rect, pLineFeed->x, pLineFeed->y,
								pLineFeed->x_offset, pLineFeed->y_offset,
								pLineFeed->width, pLineFeed->height);
#endif

    if (bElementResolved) {
		SafeSixteen(Rect);

        if ( ! EDT_IS_EDITOR(pContext) || ! pLineFeed->break_type ) {
            // If the linefeed has a solid background color, then use it.
            // To Be Done: If we're selected, use the fg color instead of the bg color.
#ifndef LAYERS
	  // For layers, we don't want to draw the background 
		    if (pLineFeed->text_attr->no_background == FALSE && !IsPrintContext()) {
			    HBRUSH	 hBrush;
			    CRect	 cRect(CASTINT(Rect.left), CASTINT(Rect.top), CASTINT(Rect.right), CASTINT(Rect.bottom));
			    HDC hdc = GetContextDC(iLocation);

			    if (m_iBitsPerPixel == 16)
				    // We don't want a dithered brush
					hBrush = ::CreateSolidBrush(::GetNearestColor(hdc, RGB(pLineFeed->text_attr->bg.red,
					    pLineFeed->text_attr->bg.green, pLineFeed->text_attr->bg.blue)));
			    else
        		    hBrush = ::CreateSolidBrush(0x02000000L | ResolveBGColor(pLineFeed->text_attr->bg.red,
        			    pLineFeed->text_attr->bg.green, pLineFeed->text_attr->bg.blue));
				HBRUSH hOldBrush;
				hOldBrush = ::SelectObject(hdc, hBrush);
        	    ::FillRect(hdc, &cRect, hBrush);
				::SelectObject(hdc, hOldBrush);
        	    VERIFY(::DeleteObject(hBrush));

			    ReleaseContextDC(hdc, iLocation);
		    }
#endif // LAYERS
            return;
        }

		HDC hdc = GetContextDC();
        RECT r;
		::SetRect(&r, CASTINT(Rect.left), CASTINT(Rect.top), CASTINT(Rect.right), CASTINT(Rect.bottom));
        // Need to look up the text color.
        LO_TextAttr * attr = pLineFeed->text_attr;

		//	Determine the color.
		COLORREF rgbColor = ResolveTextColor(attr);
        COLORREF textBackColor;
        Bool selected = pLineFeed->ele_attrmask & LO_ELE_SELECTED;

        if ( selected ) {
            wfe_GetSelectionColors(m_rgbBackgroundColor, &rgbColor, &textBackColor);
        }

        if (clear & ! selected) {
#ifdef EDITOR
            // If the linefeed has a solid background color, then use it
		    if (pLineFeed->text_attr->no_background == FALSE && !IsPrintContext()) {
			    HBRUSH	 hBrush;
			    RECT	 cRect;
				::SetRect(&cRect, CASTINT(Rect.left), CASTINT(Rect.top), CASTINT(Rect.right), CASTINT(Rect.bottom));

			    if (m_iBitsPerPixel == 16)
				    // We don't want a dithered brush
					hBrush = ::CreateSolidBrush(::GetNearestColor(hdc, RGB(pLineFeed->text_attr->bg.red,
					    pLineFeed->text_attr->bg.green, pLineFeed->text_attr->bg.blue)));
			    else
        		    hBrush = ::CreateSolidBrush(0x02000000L | ResolveBGColor(pLineFeed->text_attr->bg.red,
        			    pLineFeed->text_attr->bg.green, pLineFeed->text_attr->bg.blue));
        	    ::FillRect(hdc, &cRect, hBrush);
        	    VERIFY(::DeleteObject(hBrush));
		    }
            else {
                EraseToBackground(Rect);
            }
            // If this linefeed draws outside it bounds, then
            // EraseToBackground could have
            // smashed a nearby element.
            // So invalidate this portion. (The main examples of this are
            // linefeeds in tables.)
            if ( bExpanded && IsWindowContext()) {
                ::InvalidateRect(PANECX(pContext)->GetPane(), &r, FALSE);
            }
#endif
        }

#ifdef EDITOR
        // Limit the size of the drawn paragraph marker.
        const int32 kMaxHeight = 30;
        if ( expandedHeight > kMaxHeight ){
            expandedHeight = kMaxHeight;
        }
        int32 desiredWidth = expandedHeight / 2;
        if ( expandedWidth > desiredWidth ) {
            expandedWidth = desiredWidth;
        }

        r.right = CASTINT(r.left + expandedWidth);
        r.bottom = CASTINT(r.top + expandedHeight);

#endif        
        if (selected) {
			HBRUSH cbBrush = ::CreateSolidBrush(textBackColor);
			::FillRect(hdc, &r, cbBrush);
			VERIFY(::DeleteObject(cbBrush));
        }
        if ( EDT_DISPLAY_PARAGRAPH_MARKS(pContext)
            && (! pLineFeed->prev // Don't draw mark after end-of-doc mark
                || pLineFeed->prev->lo_any.edit_offset >= 0 ) ) {
			HBRUSH cbBrush = ::CreateSolidBrush(rgbColor);
			if ( r.right - r.left > 5 ) {
			    r.left += 2;
                r.right -= 2;
            }
            if ( r.bottom - r.top > 5 ) {
                r.top += 2;
                r.bottom -= 2;
            }
            // draw line breaks at 1/3 height of paragraph marks
            if ( pLineFeed->break_type == LO_LINEFEED_BREAK_HARD ){
                r.top += (r.bottom - r.top) * 2 / 3;
            }
			::FillRect(hdc, &r, cbBrush);
			VERIFY(::DeleteObject(cbBrush));
        }
		ReleaseContextDC(hdc);
    }
}

void CDCCX::DisplaySubDoc(MWContext *pContext, int iLocation, LO_SubDocStruct *pSubDoc)	{
	LTRB Rect;
//	if(ResolveElement(Rect, pSubDoc, iLocation) == TRUE)	{
	if(ResolveElement(Rect, pSubDoc->x, pSubDoc->y, pSubDoc->x_offset,
						pSubDoc->y_offset, pSubDoc->width, pSubDoc->height) == TRUE)	{
		SafeSixteen(Rect);

		if(pSubDoc->border_width > 0)	{
			Display3DBox(Rect, ResolveLightLineColor(), ResolveDarkLineColor(), pSubDoc->border_width);
		}
	}
}

void CDCCX::DisplayCell(MWContext *pContext, int iLocation, LO_CellStruct *pCell)	{
	LTRB Rect;
//	if(ResolveElement(Rect, pCell, iLocation) == TRUE)	{
	if(ResolveElement(Rect, pCell->x, pCell->y, pCell->x_offset,
						pCell->y_offset, pCell->width, pCell->height) == TRUE)	{
		SafeSixteen(Rect);

#ifndef LAYERS
		// With layers, the background color is done with a layer

		// If the cell has a background color, then use it
		if (pCell->bg_color && !IsPrintContext()) {
			HBRUSH	 hBrush;
			RECT	 cRect;
			::SetRect(&cRect, CASTINT(Rect.left), CASTINT(Rect.top), CASTINT(Rect.right), CASTINT(Rect.bottom));
			HDC hdc = GetContextDC(iLocation);

			if (m_iBitsPerPixel == 16)
				// We don't want a dithered brush
				hBrush = ::CreateSolidBrush(::GetNearestColor(hdc, RGB(pCell->bg_color->red,
					pCell->bg_color->green, pCell->bg_color->blue)));
			else
        		hBrush = ::CreateSolidBrush(0x02000000L | ResolveBGColor(pCell->bg_color->red,
        			pCell->bg_color->green, pCell->bg_color->blue));

        	::FillRect(hdc, &cRect, hBrush);
        	VERIFY(::DeleteObject(hBrush));

			ReleaseContextDC(pDC, iLocation);
		}

		// If we decide to allow nested table cells to have the
		// background show through then we need this code
#endif /* LAYERS */
#ifdef EDITOR
        if( EDT_IS_EDITOR(pContext) )
        {
            int32 iExtraSpace = 0;
            int32 iBorder = pCell->border_width;
            // Cell highlightin is thicker
            int32 iMaxWidth = 2 * ED_SELECTION_BORDER;
            BOOL bSelected = pCell->ele_attrmask & LO_ELE_SELECTED;
            BOOL bSelectedSpecial = pCell->ele_attrmask & LO_ELE_SELECTED_SPECIAL;
            COLORREF rgbBorder;
            HDC hDC = 0;

            if( bSelected || bSelectedSpecial )
            {
                // Use the selection background color to draw a solid border
                wfe_GetSelectionColors(m_rgbBackgroundColor, NULL, &rgbBorder);
		        hDC = GetContextDC();
			    RECT r;
			    ::SetRect(&r, CASTINT(Rect.left), CASTINT(Rect.top), CASTINT(Rect.right), CASTINT(Rect.bottom));

                // If there is inter-cell spacing and 
                // draw selection in that region as much as possible
                if( pCell->inter_cell_space > 0 && iBorder < iMaxWidth )
                {
                    iExtraSpace = min(iMaxWidth - iBorder, pCell->inter_cell_space / 2);
                    iBorder += iExtraSpace;
                    ::InflateRect(&r, iExtraSpace, iExtraSpace);
                }

	            LTRB borderWidths(iBorder, iBorder, iBorder, iBorder);

                if( bSelectedSpecial )
                {
	                // Show a solid DASHED border as the special selection feedback
                    DisplaySpecialBorder(hDC, r, rgbBorder, iBorder, TRUE);
                } else {
	                // Show a solid border as the selection feedback
                    DisplaySolidBorder(hDC, r, rgbBorder, borderWidths);
                }
            }

            if( pCell->border_width == 0 || LO_IsEmptyCell(pCell) )
            {
    		    // Draw zero-border and empty cells with the dotted line
                //   (Navigator will not display borders of empty cells)
                // Don't bother testing (EDT_DISPLAY_TABLE_BORDERS)
                //  since we don't support turning borders off now
                EditorDisplayZeroWidthBorder(Rect, pCell->ele_attrmask & LO_ELE_SELECTED);

		    }
            else if( !bSelected )
            {
    			Display3DBox(Rect, ResolveDarkLineColor(), ResolveLightLineColor(), pCell->border_width);
            }

            // If directly-drawn selection border is narrower than minimum selection width (ED_SELECTION_BORDER)
            //  add inverse highlighting whose width is ED_SELECTION_BORDER
            // Thus total selection effect will always be between 
            //      ED_SELECTION_BORDER and (2*ED_SELECTION_BORDER) in thickness
            if( hDC && (bSelected || bSelectedSpecial) &&
                iBorder < ED_SELECTION_BORDER )
            {
                //  TODO: IMAGES THAT FILL CELL WILL OVERWRITE THIS SELECTION - Especially bad when iBorder = 0
                LTRB CellRect = Rect;
                // Draw inside the border rect
                CellRect.Inflate(-1);
                if( bSelectedSpecial )
                {
			        RECT r;
			        ::SetRect(&r, CASTINT(CellRect.left), CASTINT(CellRect.top), 
                              CASTINT(CellRect.right), CASTINT(CellRect.bottom));
	                // Show an inverted DASHED border as the special selection feedback
                    DisplaySpecialBorder(hDC, r, rgbBorder, iBorder, FALSE);
                } else {
                    DisplaySelectionFeedback(LO_ELE_SELECTED, CellRect);
                }
            }
            
            if( hDC )
                ReleaseContextDC(hDC);
        } 
        else
#endif // EDITOR
        // Normal border drawing for Navigator
        if( pCell->border_width > 0 ) {
			Display3DBox(Rect, ResolveDarkLineColor(), ResolveLightLineColor(), pCell->border_width);
		}
	}
}

VOID CALLBACK EXPORT LineDDAProcTabFocus(
    int x,	// x-coordinate of point being evaluated  
    int y,	// y-coordinate of point being evaluated  
    LPARAM lpData 	// address of application-defined data 
   )
{
	static BOOL flip = FALSE;
	// HDC hdc = (HDC) lpData;
	flip = ! flip;
#ifdef _WIN32
	SetPixelV((HDC)lpData, x, y, flip? COLORREF(RGB(0,0,0)) : COLORREF(RGB(255,255,255)) ); 
#else
	SetPixel((HDC)lpData, x, y, flip? COLORREF(RGB(0,0,0)) : COLORREF(RGB(255,255,255)) ); 
#endif
	return;
}	

void CDCCX::DrawTabFocusLine( HDC hdc, BOOL supportPixel, int x, int y, int x2, int y2)
{
	if( supportPixel ) {
		// support SetPixel()
		LineDDA( x, y, x2, y2, (LINEDDAPROC)LineDDAProcTabFocus, (LPARAM)hdc );
	} else {
		// SetPixel is not supported
#ifdef _WIN32
		::MoveToEx(hdc, x,  y, NULL);
#else
		::MoveTo(hdc, x,  y );
#endif
		::LineTo(hdc, x2, y2);
	}

}

// Monochrome brush with every other pixel set
struct CAlternateBrush {
	HBRUSH	hBrush;

	CAlternateBrush();
   ~CAlternateBrush();
} alternateBrush;

CAlternateBrush::CAlternateBrush()
{
	// Monochrome pattern brush we use for drawing horizontal and vertical alternate
	// lines (lines with every other pixel set)
    static const WORD gray50 [] = {0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55};
	HBITMAP	hBitmap = ::CreateBitmap(8, 8, 1, 1, gray50);

	hBrush = ::CreatePatternBrush(hBitmap);
	::DeleteObject(hBitmap);
}

CAlternateBrush::~CAlternateBrush()
{
	::DeleteObject(hBrush);
}

void CDCCX::DrawTabFocusRect( HDC hdc, BOOL supportPixel, int left, int top, int right, int bottom)
{
	RECT	rect = {left, top, right, bottom};
	DWORD	dwOldTextColor, dwOldBkColor;

	ASSERT(alternateBrush.hBrush);

	dwOldTextColor = ::SetTextColor(hdc, RGB(0,0,0));
	dwOldBkColor = ::SetBkColor(hdc, RGB(255,255,255));

	::FrameRect(hdc, &rect, alternateBrush.hBrush);

	::SetTextColor(hdc, dwOldTextColor);
	::SetBkColor(hdc, dwOldBkColor);
}

//#ifndef NO_TAB_NAVIGATION 
// see function lo_is_location_in_area() in file ns\lib\layout\laymap.c for area types.
void CDCCX::DrawMapAreaBorder( int baseX, int baseY, lo_MapAreaRec * theArea )
{
	int 	centerX, centerY, radius;
	int		left, top, right, bottom;
	int		oldDrawingMode;
	int		ii;
	HDC		hdc = GetContextDC();
	HPEN	pTabFocusPen;
	HPEN	pOldPen;
	HBRUSH	hOldBrush;
	BOOL	supportPixel = ::GetDeviceCaps(  hdc, RASTERCAPS ) & RC_BITBLT ;

	if( ! supportPixel || theArea->type == AREA_SHAPE_CIRCLE ) {
		// todo get color for hi-light
		oldDrawingMode	= SetROP2( hdc, R2_NOT);		// R2_NOT reverse the screen color
		pTabFocusPen	= ::CreatePen(PS_DOT, 1, COLORREF( RGB(0,0,0)) );
		pOldPen			= (HPEN)::SelectObject(hdc, pTabFocusPen);
		hOldBrush		= (HBRUSH) ::SelectObject(hdc, ::GetStockObject(NULL_BRUSH));
	}
	
	switch( theArea->type )
	{
		case AREA_SHAPE_RECT:
			if (theArea->coord_cnt >= 4)
			{
				left	= (int)(baseX + theArea->coords[0]);		// Pix2TwipsY()?
				top		= (int)(baseY + theArea->coords[1]);
				right	= (int)(baseX + theArea->coords[2]);
				bottom	= (int)(baseY + theArea->coords[3]);
			    DrawTabFocusRect(hdc, supportPixel, left, top, right, bottom);
				if( supportPixel )
					DrawTabFocusRect(hdc, supportPixel, left+1, top+1, right-1, bottom-1);  // double line
			}
			break;

		case AREA_SHAPE_CIRCLE:
			if ( theArea->coord_cnt >= 3)
			{
				centerX = (int)theArea->coords[0] + baseX;
				centerY = (int)theArea->coords[1] + baseY;
				radius	= (int)theArea->coords[2];
				
				left	= centerX - radius ;
				top		= centerY - radius ;
				right	= centerX + radius ;
				bottom	= centerY + radius ;
				//todo the NULL_BRUSH may cause problems on some platforms(win3.1, win95).
				::Ellipse(hdc, left, top, right, bottom);
				::Ellipse(hdc, left+1, top+1, right-1, bottom-1);  // double line
			}
			break;

		case AREA_SHAPE_POLY:
			if (theArea->coord_cnt >= 6)
			{
				for( ii=0; ii<= theArea->coord_cnt-4; ii+=2) {
					DrawTabFocusLine( hdc, supportPixel, 
						(int)theArea->coords[ii]   + baseX, (int)theArea->coords[ii+1] + baseY,
						(int)theArea->coords[ii+2] + baseX, (int)theArea->coords[ii+3] + baseY);
				}
				// make it close
				// work around: for 6 edges, theArea->coord_cnt is 13 !! 
				// Cannot use theArea->coord_cnt-2 for last x.
				// use ii, which stoped at the last point.
				DrawTabFocusLine( hdc, supportPixel, 
					(int)theArea->coords[ii]   + baseX, (int)theArea->coords[ii+1] + baseY,
						(int)theArea->coords[0] + baseX, (int)theArea->coords[1] + baseY);

			}
			break;

		case AREA_SHAPE_DEFAULT:
			// TODO ??????
			break;

		case AREA_SHAPE_UNKNOWN:
		default:
			break;
	}

	if( ! supportPixel || theArea->type == AREA_SHAPE_CIRCLE ) {
		::SelectObject(hdc, hOldBrush);
		::SelectObject(hdc, pOldPen);
		VERIFY(::DeleteObject(pTabFocusPen));
		::SetROP2( hdc, oldDrawingMode );
	}

	ReleaseContextDC(hdc);

}
//#endif	/* NO_TAB_NAVIGATION */



void CDCCX::DisplaySubtext(MWContext *pContext, int iLocation, LO_TextStruct *pText, int32 lStartPos, int32 lEndPos, XP_Bool iClear)    
{
	//	Figure the coordinates of where to draw the text.
	LTRB Rect;
	if(ResolveElement(Rect, pText, iLocation, lStartPos, lEndPos, iClear) == TRUE)	{
		SafeSixteen(Rect);

		HDC hdc = GetContextDC();

        // cache the attribute pointer
        LO_TextAttr * attr = pText->text_attr;

        BOOL display_background_color = !attr->no_background;

		//	Determine the color.
		COLORREF rgbColor = ResolveTextColor(attr);
		
		//	If the color is the same as the background color, then we are selecting.
		//	Go into opaque mode.
		COLORREF rgbOldBackgroundColor;

        // what color does layout think our background color is?
        COLORREF textBackColor = RGB(attr->bg.red, attr->bg.green, attr->bg.blue);

        //IMPORTANT! Note that we will get called to draw a sub-part of a text line
        //   with LO_ELE_SELECTED flag set and the selected start-end is 
        //   outside of range to be drawn, thus we are really drawing the UNSELECTED
        //   portion of the text. So be sure to test that drawing and selectd start positions match

        // [ = lStartPos
        // ] = lEndPos
        // ( = sel_start
        // ) = sel_end
        // selection calls one of these two:
        //     subtext           [ (    ) ]
        //     subtext [        ]  (    )
        // drawtext calls subtext three times: [       ] [(     )] [      ]

        BOOL bSelected = (pText->ele_attrmask & LO_ELE_SELECTED) && 
                         (lStartPos >= (int32)pText->sel_start) &&
                         ((int32)pText->sel_end >= lEndPos) ;

#if 0
        XP_TRACE(("DisplaySubtext args: lStartPos(%d) lEndPos(%d)"
            " iClear(%d) element: selected(%d) sel_start(%d) sel_end(%d) bSelected(%d)\n",
            lStartPos, lEndPos,
            iClear,
            (pText->ele_attrmask & LO_ELE_SELECTED),
            (int32)pText->sel_start,  (int32)pText->sel_end, bSelected
            ));
#endif
		if (bSelected) {
            // Note that we do NOT have the "real" text color if selected,
            //  making it impossible to preview new colors in Character Properties dialog
            wfe_GetSelectionColors(m_rgbBackgroundColor, &rgbColor, &textBackColor);
            display_background_color = TRUE;
        }

        if(display_background_color)
        {
            rgbOldBackgroundColor = ::SetBkColor(hdc, textBackColor);
            ::SetBkMode(hdc, OPAQUE);
        }

		//	Select the font.
		CyaFont	*pMyFont;
		SelectNetscapeFontWithCache( hdc, attr, pMyFont);

		//	Set the text color.
		COLORREF rgbOldColor = ::SetTextColor(hdc, rgbColor);

        // Originally, we drew just the substring of characters
        // that we were asked to. But this did not handle kerning
        // correctly, since kerned characters could intrude into the
        // area of the substring. Worse, when selecting, the reverse-
        // video characters were drawn outside their boundaries, which
        // caused thin vertical strips of selection to remain when the
        // selection was erased.
        //
        // Now we draw the whole string, clipped to the bounds of the
        // substring. -- jhp

        LTRB fullRect;
        ResolveElement(fullRect, pText->x, pText->y, pText->x_offset,
						pText->y_offset, pText->width, pText->height);
		SafeSixteen(fullRect);
		//	Output

        int iOldDC = ::SaveDC(hdc);
        ::IntersectClipRect(hdc, (int)Rect.left, (int)Rect.top, (int)Rect.right, (int)Rect.bottom);
		CIntlWin::TextOutWithCyaFont(
			pMyFont,
			INTL_GetCSIWinCSID(LO_GetDocumentCharacterSetInfo(pContext)),
			hdc, 
			CASTINT(fullRect.left),
			CASTINT(fullRect.top),
			(const char *)pText->text,
		    CASTINT(pText->text_len));

        ::RestoreDC(hdc, iOldDC);

		::SetTextColor(hdc, rgbOldColor);


		//	Handle strike, under_line, Spell and INLINEINPUT manually
        DrawTextPostDecoration(hdc, attr, &Rect, rgbColor );

		//	Normalize our selection if present.
		if (display_background_color) {
			::SetBkColor(hdc, rgbOldBackgroundColor);
			::SetBkMode(hdc, TRANSPARENT);
		}

		ReleaseNetscapeFontWithCache( hdc, pMyFont );
	
		ReleaseContextDC(hdc);
	}
}	// void CDCCX::DisplaySubtext()

#define TABLE_HAS_BORDER(pTable) \
	((pTable)->border_top_width > 0 || (pTable)->border_right_width > 0 || \
	 (pTable)->border_bottom_width > 0 || (pTable)->border_left_width > 0)

void CDCCX::DisplayTable(MWContext *pContext, int iLocation, LO_TableStruct *pTable)	{
	LTRB Rect;
    int32 iSelectionBorder = 0;
    BOOL bHaveBorder = TABLE_HAS_BORDER(pTable);

	if(ResolveElement(Rect, pTable->x, pTable->y, pTable->x_offset,
						pTable->y_offset, pTable->width, pTable->height) == TRUE)	{
		SafeSixteen(Rect);
        LTRB TableRect = Rect;
 
        //TRACE0("DisplayTable\n");

		if( bHaveBorder ) {
            iSelectionBorder = DisplayTableBorder(Rect, pTable);
		} 
#ifdef EDITOR
        else if ( EDT_DISPLAY_TABLE_BORDERS(pContext) )
        {
            if( 0 == pTable->inter_cell_space )
            {
                // When no cell spacing, Table border is on top of cell borders,
                //   so increase by 1 pixel so we always have a distinquishable table border
                TableRect.Inflate(1);
                iSelectionBorder = 1;
            }
            EditorDisplayZeroWidthBorder(TableRect, pTable->ele_attrmask & LO_ELE_SELECTED);
        }

        // Show extra selection if border was not wide enough for clear selection feedback
        if( EDT_IS_EDITOR(pContext) && (pTable->ele_attrmask & LO_ELE_SELECTED) &&
            iSelectionBorder < ED_SELECTION_BORDER )
        {
            // If directly-drawn selection border is too narrow (or none),
            //  add Inverse-Video highlighting to the maximum thickness allowed
            // Decrease size by amount of solid border used,
            if( iSelectionBorder )
                TableRect.Inflate(-(iSelectionBorder));

            DisplaySelectionFeedback(LO_ELE_SELECTED, TableRect);
        }
#endif //EDITOR
	}
}

// handle strike , under_line, Spell and INLINEINPUT after text is drawn.
void CDCCX::DrawTextPostDecoration( HDC hdc, LO_TextAttr * attr, LTRB *pRect, COLORREF rgbColor )
{
#ifdef font_do_it  // font handles underline, strikeOut 
		//	Handle strike manually
		if(attr->attrmask & LO_ATTR_STRIKEOUT)	{
			HPEN cpStrike = ::CreatePen(PS_SOLID, CASTINT(pRect->Height() / 10), rgbColor);
			HPEN pOldPen = (HPEN)::SelectObject(hdc, cpStrike);
			::MoveToEx(hdc, CASTINT(pRect->left), CASTINT(pRect->top + pRect->Height() / 2), NULL);
			::LineTo(hdc, CASTINT(pRect->right), CASTINT(pRect->top + pRect->Height() / 2));
			::SelectObject(hdc, pOldPen);
			VERIFY(::DeleteObject(cpStrike));
		}

		// because netscape font module doesn't support under_list, it is handled manually
		BOOL bUnderline = FALSE;
		if(attr->attrmask & LO_ATTR_ANCHOR) { 
			/*
			 * if (prefInfo.m_bUnderlineAnchors)
			 *   bUnderline = TRUE;
			 */
		}
		if(attr->attrmask & LO_ATTR_UNDERLINE)	{
			bUnderline = TRUE;
		}
		if( bUnderline ) {
			HPEN cpStrike = ::CreatePen(PS_SOLID, CASTINT(pRect->Height() / 10), rgbColor);
			HPEN pOldPen = (HPEN)::SelectObject(hdc, cpStrike);
			::MoveToEx(hdc, CASTINT(pRect->left), CASTINT(pRect->top + pRect->Height()-1 ), NULL);
			::LineTo(hdc, CASTINT(pRect->right), CASTINT(pRect->top + pRect->Height()-1 ));
			::SelectObject(hdc, pOldPen);
			VERIFY(::DeleteObject(cpStrike));
		}
#endif  // font handles underline, strikeOut 
		//	Handle Spell and INLINEINPUT  manually
		if(attr->attrmask & (LO_ATTR_SPELL | LO_ATTR_INLINEINPUT)  )	{
			HPEN cpStrike = ::CreatePen(PS_DOT, CASTINT(pRect->Height() / 10), 
			            RGB(attr->attrmask & LO_ATTR_SPELL ? 255 : 0, 
			                0,
			                attr->attrmask & LO_ATTR_SPELL ? 255 : 0 ) );
			HPEN pOldPen = (HPEN)::SelectObject(hdc, cpStrike);
			::MoveToEx(hdc, CASTINT(pRect->left), CASTINT(pRect->top + pRect->Height()-1 ), NULL);
			::LineTo(hdc, CASTINT(pRect->right), CASTINT(pRect->top + pRect->Height()-1 ));
			::SelectObject(hdc, pOldPen);
			VERIFY(::DeleteObject(cpStrike));
		}

} // DrawTextPostDecoration()

//TODO add uint32 drawFalg to the interface, check all caller to pass in the drawFlag, 
// C++ default mechanism doesn't work for calling from C.
void CDCCX::DisplayText(MWContext *pContext, int iLocation, LO_TextStruct *pText, XP_Bool iClear)	
{
		DisplayText(pContext, iLocation, pText, iClear, 0);			// use default if calling grom C.
}

/* cannot use default drawFlag = 0, if this function is called from C */
// an old interface  gateway for caller in C.
void CDCCX::DisplayText(MWContext *pContext, int iLocation, LO_TextStruct *pText, XP_Bool iClear, uint32 drawFlag )	
{
	//	Figure out the coordinates of where to draw the text.
	LTRB Rect;
	if(ResolveElement(Rect, pText->x, pText->y, pText->x_offset,
						pText->y_offset, pText->width, pText->height) == TRUE)	{
		SafeSixteen(Rect);

        // cache the attribute pointer
        LO_TextAttr * attr = pText->text_attr;
	
		if (attr)	// dmb 11/21/96 - w/o this line, we crash on blinking things like the phonebook.
		{
            BOOL display_background_color = !attr->no_background;
			HDC hdc;
			hdc = GetContextDC();

			//	Determine the color.
			COLORREF rgbColor = ResolveTextColor(attr);

			// what does layout think the background color is?
			COLORREF textBackColor = RGB(attr->bg.red, attr->bg.green, attr->bg.blue);

			// If the text is the same color as the background we are selecting text
			//   and need to go into OPAQUE mode so the text will show up on the screen
			COLORREF rgbOldBackgroundColor;
			if (pText->ele_attrmask & LO_ELE_SELECTED) {
                display_background_color = TRUE;
				wfe_GetSelectionColors(m_rgbBackgroundColor, &rgbColor, &textBackColor);
			}

            if(display_background_color)
            {
                rgbOldBackgroundColor = ::SetBkColor(hdc, textBackColor);
			    ::SetBkMode(hdc, OPAQUE);
            }
			else {
			    ::SetBkMode(hdc, TRANSPARENT);
			}

			//	Select the font.
			// CNetscapeFont *pFont;
			// HFONT pOldFont = SelectFont(hdc, attr, pFont);

			//	Set the text color.
			COLORREF rgbOldColor = ::SetTextColor(hdc, rgbColor);

//	#ifndef NO_TAB_NAVIGATION
			// draw a focus box if pText is current  TabFocus
			if( drawFlag & FE_DRAW_TAB_FOCUS ) {
				HPEN pTabFocusPen;
				HPEN pOldPen;
				BOOL	supportPixel = ::GetDeviceCaps(  hdc, RASTERCAPS ) & RC_BITBLT ;
				if( ! supportPixel ) {
					pTabFocusPen = ::CreatePen(PS_DOT, 1, rgbColor);
					pOldPen = (HPEN)::SelectObject(hdc, pTabFocusPen);
				}
				
				DrawTabFocusRect(hdc, supportPixel, CASTINT(Rect.left), CASTINT(Rect.top),
					                            CASTINT(Rect.right), CASTINT(Rect.bottom));
				
				if( ! supportPixel ) {
					::SelectObject(hdc, pOldPen);
					VERIFY(::DeleteObject(pTabFocusPen));
				}
			}
//	#endif	/* NO_TAB_NAVIGATION */

			CyaFont			*pMyFont;
			SelectNetscapeFontWithCache( hdc, attr, pMyFont);
		
#ifdef DEBUG_aliu
			ASSERT( pMyFont );
#endif

			if( pMyFont ) {
				CIntlWin::TextOutWithCyaFont(
					pMyFont,
					INTL_GetCSIWinCSID(LO_GetDocumentCharacterSetInfo(pContext)),
					hdc, 
					CASTINT(Rect.left),	
					CASTINT(Rect.top),
					(char *)pText->text,
					CASTINT(pText->text_len) 
				);

			}
			::SetTextColor(hdc, rgbOldColor);
			
		//	Handle strike, under_line, Spell and INLINEINPUT manually
            DrawTextPostDecoration(hdc, attr, &Rect, rgbColor );

#if 0
moved into DrawTextPostDecoration()
			//	Handle Spell and INLINEINPUT  manually
			if(attr->attrmask & (LO_ATTR_SPELL | LO_ATTR_INLINEINPUT)  )	{
				HPEN cpStrike = ::CreatePen(PS_DOT, CASTINT(Rect.Height() / 10), 
							RGB(attr->attrmask & LO_ATTR_SPELL ? 255 : 0, 
								0,
								attr->attrmask & LO_ATTR_INLINEINPUT ? 255 : 0 ) );
				HPEN pOldPen = (HPEN)::SelectObject(hdc, cpStrike);
				::MoveToEx(hdc, CASTINT(Rect.left), CASTINT(Rect.top + Rect.Height()-1 ), NULL);
				::LineTo(hdc, CASTINT(Rect.right), CASTINT(Rect.top + Rect.Height()-1 ));
				::SelectObject(hdc, pOldPen);
				VERIFY(::DeleteObject(cpStrike));
			}
#endif

			//	Normalize our selection if present.
			if (display_background_color) {
				::SetBkColor(hdc, rgbOldBackgroundColor);
				::SetBkMode(hdc, TRANSPARENT);
			}

			// ReleaseFont(hdc, pOldFont);
			ReleaseNetscapeFontWithCache(hdc, pMyFont);

			ReleaseContextDC(hdc);
		}
	}
}	// void CDCCX::DisplayText()

void CDCCX::FreeEmbedElement(MWContext *pContext, LO_EmbedStruct *pEmbed)	{
	//	We have our OLE document handle this.
	GetDocument()->FreeEmbedElement(pContext, pEmbed);
}

void CDCCX::GetEmbedSize(MWContext *pContext, LO_EmbedStruct *pEmbed, NET_ReloadMethod bReload)	
{
	//	We have our OLE document handle this.
	GetDocument()->GetEmbedSize(pContext, pEmbed, bReload);
}

#ifdef LAYERS
void CDCCX::GetTextFrame(MWContext *pContext, LO_TextStruct *pText,
			 int32 lStartPos, int32 lEndPos, XP_Rect *frame)
{
    frame->left = pText->x + pText->x_offset;
    frame->top = pText->y + pText->y_offset;

    HDC pDC = GetContextDC();
		
    CyaFont	*pMyFont;
    SelectNetscapeFontWithCache( pDC, pText->text_attr, pMyFont );
    CSize sz;
    ResolveTextExtent(pDC, (const char *)pText->text, CASTINT(lStartPos), &sz, pMyFont);
    frame->left += sz.cx;
    ResolveTextExtent(pDC, (const char *)pText->text + lStartPos, CASTINT(lEndPos - lStartPos + 1), &sz, pMyFont);
    frame->right = frame->left + sz.cx;	
		
    frame->bottom = frame->top + sz.cy;   

    ReleaseNetscapeFontWithCache( pDC, pMyFont );

    ReleaseContextDC(pDC);
}
#endif  /* LAYERS */

int CDCCX::GetTextInfo(MWContext *pContext, LO_TextStruct *pText, LO_TextInfo *pTextInfo)	{
	HDC hdc = GetAttribDC();

	//	Determine and select the font.
	CyaFont	*pMyFont;
	SelectNetscapeFontWithCache( hdc, pText->text_attr, pMyFont );

	//	Get the information regarding the size of the font for layout.
	SIZE sExtent;
	ResolveTextExtent(
		INTL_GetCSIWinCSID(LO_GetDocumentCharacterSetInfo(pContext))
		, hdc, (const char *)pText->text, pText->text_len, &sExtent, pMyFont);

	pTextInfo->max_width = sExtent.cx;

	pTextInfo->ascent = pMyFont->GetAscent();
	pTextInfo->descent = pMyFont->GetDescent();
	pTextInfo->lbearing = pTextInfo->rbearing = 0;

	ReleaseNetscapeFontWithCache( hdc, pMyFont );
	ReleaseContextDC(hdc);
	return(TRUE);
}

BOOL CDCCX::ResolveTextExtent(int16 wincsid, HDC pDC, LPCTSTR pString, int iLength, LPSIZE pSize, CyaFont *pMyFont)	
{
	// Always measure it because the bytes * mean width algorithm 
	// won't work for many code point. Expecially UTF8 which 3 byte 
	// could be one character which takes 1 or 2 columns.
	return CIntlWin::GetTextExtentPointWithCyaFont(pMyFont, wincsid, pDC, pString, iLength, pSize);
#if 0
	BOOL bRetval;

	// if(pMyFont->GetMeanWidth() == 0 )	{
	if( ! pMyFont->IsFixedFont() ) {
		bRetval = CIntlWin::GetTextExtentPointWithCyaFont(pMyFont, wincsid, pDC, pString, iLength, pSize);
		return(bRetval);
	}
	else	{
		//	fixed size.
		pSize->cx = (int) ((long)pMyFont->GetMeanWidth() * (long)iLength);
		pSize->cy = pMyFont->GetHeight();
		bRetval = TRUE;
	}
	return(bRetval);
#endif
}


// 
// This function is called only when applet are windowless and force a
// paint on the java side
//
void CDCCX::DrawJavaApp(MWContext *pContext, int iLocation, LO_JavaAppStruct *pJava)
{
#ifdef JAVA

    RECT        rect;
    HDC         hDC = GetContextDC();
    NPEvent     event;
    FE_Region   clip;
    
#ifdef LAYERS
    clip = GetDrawingClip();
    if (clip) 
    {
        XP_Rect xprect;
        
        FE_GetRegionBoundingBox(clip, &xprect);
        rect.left = CASTINT(xprect.left);
        rect.top = CASTINT(xprect.top);
        rect.right = CASTINT(xprect.right);
        rect.bottom = CASTINT(xprect.bottom);
    }
#endif /* LAYERS */        
    
    event.event = WM_PAINT;
    event.wParam = (uint32)hDC;
    event.lParam = (uint32)&rect;
    
    LJ_HandleEvent(pContext, pJava, (void *)&event);

    ReleaseContextDC(hDC);
#endif
}

