зеркало из https://github.com/mozilla/gecko-dev.git
3926 строки
126 KiB
C++
3926 строки
126 KiB
C++
/* -*- 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"
|
|
#include "edt.h"
|
|
|
|
#if defined(OJI)
|
|
#include "jvmmgr.h"
|
|
#elif defined(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;
|
|
|
|
}
|
|
|
|
#ifdef MOZ_NGLAYOUT
|
|
XP_ASSERT(0);
|
|
#else
|
|
// Tell layout to get rid of all of it's cached FE font data
|
|
// in the LO_TextAttr.
|
|
LO_InvalidateFontData(GetDocumentContext());
|
|
#endif
|
|
|
|
|
|
// 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 )
|
|
{
|
|
#ifdef MOZ_NGLAYOUT
|
|
XP_ASSERT(0);
|
|
return 0;
|
|
#else
|
|
// 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 )) {
|
|
// 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 );
|
|
#endif /* MOZ_NGLAYOUT */
|
|
} // 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)
|
|
{
|
|
#ifdef MOZ_NGLAYOUT
|
|
XP_ASSERT(0);
|
|
#else
|
|
pNetscapeFont->EndDrawText( hdc ); // restore the old font.
|
|
#endif /* MOZ_NGLAYOUT */
|
|
}
|
|
|
|
// 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()){
|
|
#ifdef MOZ_NGLAYOUT
|
|
XP_ASSERT(0);
|
|
#else
|
|
GetContext()->fontScalingPercentage = LO_GetScalingFactor(m_iOffset);
|
|
#endif
|
|
}
|
|
|
|
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) {
|
|
#ifdef MOZ_NGLAYOUT
|
|
XP_ASSERT(0);
|
|
return FALSE;
|
|
#else
|
|
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);
|
|
#endif /* MOZ_NGLAYOUT */
|
|
}
|
|
|
|
/*
|
|
* 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,
|
|
int32 lScaleWidth, int32 lScaleHeight)
|
|
{
|
|
BOOL bRetval = TRUE;
|
|
|
|
/* Use the size of the image if size not provided. */
|
|
if(ulWidth == 0) {
|
|
ulWidth = pImage->header.width;
|
|
}
|
|
|
|
if(ulHeight == 0) {
|
|
ulHeight = pImage->header.height;
|
|
}
|
|
|
|
/* Scaled size overrides further if this is a print context.*/
|
|
if(IsPrintContext()) {
|
|
if(lScaleWidth) {
|
|
ulWidth = (uint32)lScaleWidth;
|
|
}
|
|
if(lScaleHeight) {
|
|
ulHeight = (uint32)lScaleHeight;
|
|
}
|
|
}
|
|
|
|
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->objTag.x + pEmbed->objTag.x_offset + pEmbed->objTag.border_width;
|
|
Rect.top += pEmbed->objTag.y + pEmbed->objTag.y_offset + pEmbed->objTag.border_width;
|
|
}
|
|
|
|
Rect.right = Rect.left + pEmbed->objTag.width;
|
|
Rect.bottom = Rect.top + pEmbed->objTag.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;
|
|
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);
|
|
HBRUSH hOldBrush = (HBRUSH) ::SelectObject(hdc, ::GetStockObject(NULL_BRUSH));
|
|
::Rectangle(hdc, Rect.left, Rect.top, Rect.right, Rect.bottom);
|
|
::SelectObject(hdc, hOldBrush);
|
|
::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)
|
|
{
|
|
#ifdef EDITOR
|
|
if( EDT_IS_EDITOR(pContext) )
|
|
WFE_HideEditCaret(pContext);
|
|
#endif
|
|
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);
|
|
#ifdef EDITOR
|
|
if( EDT_IS_EDITOR(pContext) )
|
|
WFE_ShowEditCaret(pContext);
|
|
#endif
|
|
}
|
|
#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)
|
|
{
|
|
HINSTANCE hResHandle = AfxGetResourceHandle();
|
|
|
|
// get the resource from the file
|
|
HBITMAP hBmp = (HBITMAP)FindResource(hResHandle, pszBmName, RT_BITMAP);
|
|
if(NULL == hBmp) {
|
|
ASSERT(0);
|
|
return FALSE;
|
|
}
|
|
|
|
HGLOBAL hRes = LoadResource(hResHandle, (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) {
|
|
if (IsPrintContext()) {
|
|
HBITMAP hOldBitmap = (HBITMAP)::SelectObject(m_pImageDC, hBitmap);
|
|
// filled in the background color for transparent bitmap.
|
|
AlterBackgroundColor(m_pImageDC, x, y, mask,
|
|
(HBRUSH)::GetStockObject(WHITE_BRUSH));
|
|
::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);
|
|
}
|
|
else {
|
|
// 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 = NULL;
|
|
BITMAPINFOHEADER* imageInfo = NULL;
|
|
char* mask_bits = NULL;
|
|
BITMAPINFOHEADER* maskInfo = NULL;
|
|
if (cxLoadBitmap(MAKEINTRESOURCE(bitmapID), &image_bits, &imageInfo)) {
|
|
if(maskID) {
|
|
BOOL fillBack = TRUE;
|
|
#ifdef MOZ_NGLAYOUT
|
|
XP_ASSERT(0);
|
|
#else
|
|
#ifdef XP_WIN32
|
|
CPrintCX* pPrintCx = (CPrintCX*)this;
|
|
fillBack = pPrintCx->IsPrintingBackground() ? FALSE : TRUE;
|
|
#endif
|
|
#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);
|
|
|
|
#ifdef MOZ_NGLAYOUT
|
|
XP_ASSERT(0);
|
|
#else
|
|
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);
|
|
}
|
|
}
|
|
#endif /* MOZ_NGLAYOUT */
|
|
|
|
// 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->objTag.width == Pix2TwipsX(1))
|
|
&& (pLayoutData->objTag.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;
|
|
|
|
#ifdef MOZ_NGLAYOUT
|
|
XP_ASSERT(0);
|
|
#else
|
|
NPL_EmbedSize(pEmbeddedApp);
|
|
#endif
|
|
}
|
|
|
|
#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)▭
|
|
|
|
#ifdef MOZ_NGLAYOUT
|
|
XP_ASSERT(0);
|
|
#else
|
|
NPL_HandleEvent(pEmbeddedApp, (void *)&event, pAppWin->window);
|
|
#endif
|
|
|
|
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->objTag.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->objTag.ele_attrmask & LO_ELE_INVISIBLE))
|
|
::ShowWindow((HWND)pAppWin->window, SW_SHOW);
|
|
|
|
}
|
|
|
|
#ifndef MOZ_NGLAYOUT
|
|
|
|
void CDCCX::DisplayEmbed(MWContext *pContext, int iLocation, LO_EmbedStruct *pEmbed)
|
|
{
|
|
NPEmbeddedApp* pEmbeddedApp = (NPEmbeddedApp*)pEmbed->objTag.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->objTag.border_width != 0) {
|
|
DrawRectBorder(Rect, ResolveBorderColor(NULL), pEmbed->objTag.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);
|
|
}
|
|
}
|
|
#endif /* MOZ_NGLAYOUT */
|
|
|
|
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->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) )
|
|
{
|
|
if( pCell->border_width == 0 || LO_IsEmptyCell(pCell) )
|
|
{
|
|
// If we do this, image background doesn't show up
|
|
//EraseToBackground(Rect);
|
|
}
|
|
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( iBorder > 0 )
|
|
{
|
|
// If there is inter-cell spacing,
|
|
// 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, bSelected | bSelectedSpecial );
|
|
|
|
}
|
|
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, ED_SELECTION_BORDER, 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);
|
|
BOOL bSelected = pTable->ele_attrmask & LO_ELE_SELECTED;
|
|
|
|
if(ResolveElement(Rect, pTable->x, pTable->y, pTable->x_offset,
|
|
pTable->y_offset, pTable->width, pTable->height) == TRUE) {
|
|
SafeSixteen(Rect);
|
|
LTRB TableRect = Rect;
|
|
|
|
#ifdef EDITOR
|
|
if( EDT_IS_EDITOR(pContext) && bSelected )
|
|
{
|
|
// Adjust the top or bottom of the rect if table is selected
|
|
// so the selection encloses area with the caption
|
|
XP_Rect xpRect;
|
|
xpRect.left = Rect.left;
|
|
xpRect.top = Rect.top;
|
|
xpRect.right = Rect.right;
|
|
xpRect.bottom = Rect.bottom;
|
|
if( EDT_AdjustTableRectForCaption(pTable, &xpRect) )
|
|
{
|
|
// Note: we don't change the left and right
|
|
Rect.top = xpRect.top;
|
|
Rect.bottom = xpRect.bottom;
|
|
}
|
|
// We use the larger rect including caption if selected
|
|
TableRect = Rect;
|
|
}
|
|
#endif
|
|
//TRACE0("DisplayTable\n");
|
|
|
|
if( bHaveBorder ) {
|
|
iSelectionBorder = DisplayTableBorder(Rect, pTable);
|
|
}
|
|
#ifdef EDITOR
|
|
else if( EDT_IS_EDITOR(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, bSelected);
|
|
}
|
|
|
|
// Show extra selection if border was not wide enough for clear selection feedback
|
|
if( EDT_IS_EDITOR(pContext) && bSelected && 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()
|
|
|
|
#ifndef MOZ_NGLAYOUT
|
|
|
|
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);
|
|
}
|
|
#endif /* MOZ_NGLAYOUT */
|
|
|
|
#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) {
|
|
#ifdef MOZ_NGLAYOUT
|
|
XP_ASSERT(0);
|
|
return FALSE;
|
|
#else
|
|
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);
|
|
#endif /* MOZ_NGLAYOUT */
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
#ifdef TRANSPARENT_APPLET
|
|
//
|
|
// 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)
|
|
{
|
|
#if defined(OJI) || defined(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)▭
|
|
|
|
#if defined(OJI)
|
|
// XXX help
|
|
#elif defined(JAVA)
|
|
LJ_HandleEvent(pContext, pJava, (void *)&event);
|
|
#endif
|
|
|
|
ReleaseContextDC(hDC);
|
|
#endif
|
|
}
|
|
|
|
#endif
|