Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-12-02 18:08:58 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
c2ab2b2d05
gecko-dev/cmd/winfe/cxdc.h
mjudge%netscape.com fd42334be0 ender carpool
1998-10-14 20:24:50 +00:00

798 lines
25 KiB
C++
Raw Blame History

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
*
* 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.
*/
#ifndef __Context_Device_Context_H
// Avoid include redundancy
//
#define __Context_Device_Context_H
// Purpose: Implement a Context which holds the common code for
// contexts which draw information.
// Comments: Use for those contexts with actual windows to display,
// or for printing. Basically those with a CDC on
// which to display and which handle output formats
// that go through layout or other engines.
// Revision History:
// 05-26-95 created GAB
//
// Required Includes
//
#include "cxstubs.h"
#include "ni_pixmp.h"
#include "prtypes.h"
#include "il_types.h"
#include "il_util.h"
#include "libimg.h"
#ifdef XP_WIN32
//#define DDRAW
#endif
#ifdef DDRAW
#include "ddraw.h"
#endif
// Constants
//
#define HIMETRIC_INCH 2540 // HIMETRIC units per inch
#define TWIPS_INCH 1440
#define MAX_IMAGE_PALETTE_ENTRIES 216
// DIBSECTIONS are pretty slow on most platforms except NT3.51
// We can use them if they're sped up in a later version of Windows
#define USE_DIB_SECTIONS 0
// Use for selection highlighting of objects in Editor
#define ED_SELECTION_BORDER 3
//#ifndef NO_TAB_NAVIGATION
typedef enum {
FE_DRAW_NORMAL = 0x00000000,
FE_DRAW_TAB_FOCUS = 0x00000001,
} feDrawFlag_t ;
//#endif /* NO_TAB_NAVIGATION */
void WFE_StretchDIBitsWithMask(HDC hTargetDC,
BOOL isDeviceDC,
HDC hOffscreenDC,
int dx,
int dy,
int dw,
int dh,
int sx,
int sy,
int sw,
int sh,
void XP_HUGE *imageBit,
BITMAPINFO* lpImageInfo,
void XP_HUGE *maskBit,
BOOL bUseDibPalColors = FALSE,
COLORREF fillWithBackground = NULL
);
// Structures
//
class LTRB {
public:
union {
int32 m_lLeft;
int32 left;
};
union {
int32 m_lTop;
int32 top;
};
union {
int32 m_lRight;
int32 right;
};
union {
int32 m_lBottom;
int32 bottom;
};
LTRB( LTRB& theRect) {
m_lLeft = theRect.m_lLeft;
m_lTop = theRect.m_lTop;
m_lRight = theRect.m_lRight;
m_lBottom = theRect.m_lBottom;
}
LTRB& operator = (LTRB& theRect) {
m_lLeft = theRect.m_lLeft;
m_lTop = theRect.m_lTop;
m_lRight = theRect.m_lRight;
m_lBottom = theRect.m_lBottom;
return *this;
}
void MergeRect(LTRB& theRect) {
if ( m_lLeft >theRect.m_lLeft)
m_lLeft = theRect.m_lLeft;
if (m_lTop > theRect.m_lTop)
m_lTop = theRect.m_lTop;
if (m_lRight < theRect.m_lRight)
m_lRight = theRect.m_lRight;
if (m_lBottom < theRect.m_lBottom)
m_lBottom = theRect.m_lBottom;
}
void Empty() {
m_lLeft = 0;
m_lTop = 0;
m_lRight = 0;
m_lBottom = 0;
}
BOOL IsEmpty() {
return( m_lLeft == 0 &&
m_lTop == 0 &&
m_lRight == 0 &&
m_lBottom == 0);
}
LTRB(int32 lLeft, int32 lTop, int32 lRight, int32 lBottom) {
m_lLeft = lLeft;
m_lTop = lTop;
m_lRight = lRight;
m_lBottom = lBottom;
}
LTRB() {
m_lLeft = m_lTop = m_lRight = m_lBottom = 0L;
}
int32 Width() {
return(m_lRight - m_lLeft);
}
int32 Height() {
return(m_lBottom - m_lTop);
}
void Inflate(int32 lDelta) {
m_lLeft -= lDelta;
m_lTop -= lDelta;
m_lRight += lDelta;
m_lBottom += lDelta;
}
void Inflate(int32 lDeltaX, int32 lDeltaY) {
m_lLeft -= lDeltaX;
m_lTop -= lDeltaY;
m_lRight += lDeltaX;
m_lBottom += lDeltaY;
}
};
class XY {
public:
union {
int32 m_lX;
int32 x;
};
union {
int32 m_lY;
int32 y;
};
XY(int32 lX, int32 lY) {
m_lX = lX;
m_lY = lY;
}
XY() {
m_lX = m_lY = 0L;
}
};
class CDCCX : public CStubsCX {
// Construction/Destruction
public:
CDCCX();
~CDCCX();
virtual void DestroyContext();
// CDC Access
private:
BOOL m_bOwnDC;
BOOL m_bClassDC;
protected:
void SetOwnDC(BOOL bSet) { m_bOwnDC = bSet; }
void SetClassDC(BOOL bSet) { m_bClassDC = bSet; }
protected:
HDC m_pImageDC;
IL_IRGB rgbTransparentColor;
IL_ColorSpace* curColorSpace;
IL_ColorMap *curColorMap;
public:
virtual HDC GetContextDC() = 0;
virtual void ReleaseContextDC(HDC hDC) = 0;
virtual HDC GetAttribDC() { return GetContextDC(); }
virtual void ReleaseAttribDC(HDC hDC) { ReleaseContextDC(hDC); }
virtual HDC GetDispDC() { return GetContextDC(); }
virtual void ReleaseDispDC(HDC hDC) { ReleaseContextDC(hDC); }
virtual BOOL IsDeviceDC() { return TRUE; }
virtual int32 GetXConvertUnit() { return m_lConvertX;}
virtual int32 GetYConvertUnit() { return m_lConvertY;}
IL_ColorSpace* GetCurrentColorSpace() { return curColorSpace;}
virtual BOOL IsOwnDC() const {
return(m_bOwnDC);
}
virtual BOOL IsClassDC() const {
return(m_bClassDC);
}
HDC GetImageDC() {
// Use this, a compatible DC, to size things to the display or for bitmaps
// to blt on the screen.
// Don't use to actually attempt display of anything.
return(m_pImageDC);
}
// Post construction initialization.
// Variables should be set by those deriving from this class at
// the appropriate times.
public:
// MWH - The usage for bInitialPalette and bNewMemDC flags -
// if bInitialPalette is set to FALSE, we will use the default palette that is created when the App started.
// otherwise a palette will be created.
// if bNewMemDC = TRUE, the the cache memory DC(m_pImageDC) will be created. Otherwise, it will be
// NULL. If you set bNewMemDC = FALSE, you should call PrepareDraw() before any drawing happen, and
// call EndDraw() when you are done with this CDCCX. When I'm working on Aurora, I find out that
// I need this flag. In Aurora, every button has an associate view, it gets created when the button
// is created. If the view has HTML pane, it will create a CDCCX. I need to control when to cache
// memory DC and when to destroy memory DC in order to use GDI resource efficiently under WIN16.
virtual void Initialize(BOOL bOwnDC, RECT *pRect = NULL, BOOL bInitialPalette = TRUE, BOOL bNewMemDC = TRUE);
virtual void PrepareDraw();
virtual void EndDraw();
int32 m_lOrgX;
int32 m_lOrgY;
int32 m_lWidth;
int32 m_lHeight;
int32 m_lDocHeight;
int32 m_lDocWidth;
#ifdef DDRAW
virtual LPDDSURFACEDESC GetSurfDesc() {return 0;}
virtual LPDIRECTDRAWSURFACE GetPrimarySurface() {return 0;}
virtual LPDIRECTDRAW GetDrawObj() {return 0;}
virtual LPDIRECTDRAWSURFACE GetBackSurface(){return 0;}
virtual void ReleaseSurfDC(LPDIRECTDRAWSURFACE surf, HDC hdc){;}
virtual void RestoreAllDrawSurface() {;}
virtual void SetClipOnDrawSurface(LPDIRECTDRAWSURFACE surface, HRGN hClipRgn) {;}
virtual LPDIRECTDRAWSURFACE CreateOffscreenSurface(RECT& rect) {return NULL;}
virtual void BltToScreen(LTRB& rect) {;}
virtual void LockOffscreenSurfDC(){;}
virtual void ReleaseOffscreenSurfDC() {;}
#endif
// Drawing conversions, informational.
protected:
// Hacks for speedup.
int32 m_lConvertX;
int32 m_lConvertY;
// What mapping mode we're in.
int m_MM;
HRGN curClipRgn;
public:
virtual int GetLeftMargin() {return 0;}
virtual int GetTopMargin() {return 0;}
// How to set the mapping mode.
void SetMappingMode(HDC hdc) {
if(MMIsText() == TRUE) {
::SetMapMode(hdc, MM_TEXT);
}
else {
::SetMapMode(hdc, MM_ANISOTROPIC);
::SetWindowExtEx(hdc, 1440,1440, NULL);
::SetViewportExtEx(hdc, ::GetDeviceCaps(hdc, LOGPIXELSX), ::GetDeviceCaps(hdc, LOGPIXELSY), NULL);
}
}
// Can opt for 1 to 1 conversions.
BOOL MMIsText() const {
return(m_MM == MM_TEXT);
}
int32 Pix2TwipsX(int32 lPixX) {
return(GetXConvertUnit() * lPixX);
}
int32 Twips2PixX(int32 lTwipsX) {
return(lTwipsX / m_lConvertX);
}
int32 Pix2TwipsY(int32 lPixY) {
return(GetYConvertUnit() * lPixY);
}
int32 Twips2PixY(int32 lTwipsY) {
return(lTwipsY / m_lConvertY);
}
int32 Metric2TwipsX(int32 lMetricX) {
// We use a screen DC to get WYSIWYG
CDC *pTempDC = theApp.m_pMainWnd->GetDC();
float convertPixX = ((float)HIMETRIC_INCH / (float)pTempDC->GetDeviceCaps(LOGPIXELSX));
theApp.m_pMainWnd->ReleaseDC(pTempDC);
// Convert the Metrics to pixels first.
lMetricX = (int32)((float)lMetricX / convertPixX);
// Complete the conversion to twips.
return(Pix2TwipsX(lMetricX));
}
int32 Metric2TwipsY(int32 lMetricY) {
// We use a screen DC to get WYSIWYG
CDC *pTempDC = theApp.m_pMainWnd->GetDC();
float convertPixY = ((float)HIMETRIC_INCH / (float)pTempDC->GetDeviceCaps(LOGPIXELSY));
theApp.m_pMainWnd->ReleaseDC(pTempDC);
// Convert the Metrics to pixels first.
lMetricY = (int32)((float)lMetricY / convertPixY);
// Complete the conversion to twips.
return(Pix2TwipsY(lMetricY));
}
int32 Twips2MetricX(int32 lTwipsX) {
// Convert the twips to pixels first.
lTwipsX = Twips2PixX(lTwipsX);
// We use a screen DC to get WYSIWYG
CDC *pTempDC = theApp.m_pMainWnd->GetDC();
float convertPixX = ((float)HIMETRIC_INCH / (float)pTempDC->GetDeviceCaps(LOGPIXELSX));
theApp.m_pMainWnd->ReleaseDC(pTempDC);
// Go metric.
lTwipsX = (int32)((float)lTwipsX * convertPixX);
return(lTwipsX);
}
int32 Twips2MetricY(int32 lTwipsY) {
// Convert the twips to pixels first.
lTwipsY = Twips2PixY(lTwipsY);
// We use a screen DC to get WYSIWYG
CDC *pTempDC = theApp.m_pMainWnd->GetDC();
float convertPixY = ((float)HIMETRIC_INCH / (float)pTempDC->GetDeviceCaps(LOGPIXELSY));
theApp.m_pMainWnd->ReleaseDC(pTempDC);
// Go metric.
lTwipsY = (int32)((float)lTwipsY * convertPixY);
return(lTwipsY);
}
int32 GetOriginX() {
return(m_lOrgX);
}
int32 GetOriginY() {
return(m_lOrgY);
}
int32 GetWidth() {
return(m_lWidth);
}
int32 GetHeight() {
return(m_lHeight);
}
int32 GetDocumentWidth() {
return(m_lDocWidth);
}
int32 GetDocumentHeight() {
return(m_lDocHeight);
}
void SetTransparentColor(BYTE red, BYTE green, BYTE blue);
IL_IRGB &GetTransparentColor() {return rgbTransparentColor;}
// Turning on or off display blocking.
private:
BOOL m_bResolveElements;
protected:
BOOL CanBlockDisplay() const {
return(m_bResolveElements);
}
public:
void DisableDisplayBlocking() {
m_bResolveElements = FALSE;
}
void EnableDisplayBlocking() {
m_bResolveElements = TRUE;
}
// Coordinate resolution and display blocking.
public:
virtual BOOL ResolveElement(LTRB& Rect, NI_Pixmap *pImage, int32 lX, int32 lY,
int32 orgx, int32 orgy,
uint32 ulWidth, uint32 ulHeight,
int32 lScaleWidth, int32 lScaleHeight);
virtual BOOL ResolveElement(LTRB& Rect, int32 x, int32 y, int32 x_offset, int32 y_offset,
int32 width, int32 height);
virtual BOOL ResolveElement(LTRB& Rect, LO_SubDocStruct *pSubDoc, int iLocation);
virtual BOOL ResolveElement(LTRB& Rect, LO_LinefeedStruct *pLineFeed, int iLocation);
virtual BOOL ResolveElement(LTRB& Rect, LO_CellStruct *pCell, int iLocation);
virtual BOOL ResolveElement(LTRB& Rect, LO_TableStruct *pTable, int iLocation);
virtual BOOL ResolveElement(LTRB& Rect, LO_EmbedStruct *pEmbed, int iLocation, Bool bWindowed);
virtual BOOL ResolveElement(LTRB& Rect, LO_FormElementStruct *pFormElement);
virtual BOOL ResolveElement(LTRB& Rect, LO_TextStruct *pText, int iLocation, int32 lStartPos, int32 lEndPos, int iClear);
// How to make sure above functions work on windows 16.
public:
void SafeSixteen(LTRB& Rect) {
// This routine is called to make sure that drawing coords don't wrap
// with GDI functions which take short ints.
// Use some hard coded values to end this pain quickly.
// Leave some marginal values to allow for additional leeway of
// the result (2767 twips).
// Maximum display height known is 1200 pixels, which is about 24000
// twips, which is kinda close for the future of this product.
// This doesn't count those users which somehow get their app much
// larger than the screen size by using other means, and they
// are dead.
const int iMax = 30000;
const int iMin = -30000;
if(Rect.left > iMax) {
Rect.left = iMax;
}
else if(Rect.left < iMin) {
Rect.left = iMin;
}
if(Rect.top > iMax) {
Rect.top = iMax;
}
else if(Rect.top < iMin) {
Rect.top = iMin;
}
if(Rect.right > iMax) {
Rect.right = iMax;
}
else if(Rect.right < iMin) {
Rect.right = iMin;
}
if(Rect.bottom > iMax) {
Rect.bottom = iMax;
}
else if(Rect.bottom < iMin) {
Rect.bottom = iMin;
}
}
// Font selection, deselection, caching
private:
enum {
m_MaxFontSizes = 9,
m_MaxUnderline = 2,
m_MaxItalic = 2,
m_MaxBold = 2,
m_MaxFixed = 2
};
private :
CPtrList m_cplCachedFontList;
protected:
HDC m_lastDCWithCachedFont;
CyaFont *m_pSelectedCachedFont;
int m_iOffset;
public:
static void ClearAllFontCaches();
void ClearFontCache();
virtual int SelectNetscapeFont( HDC hdc, LO_TextAttr *pAttr, CyaFont *& pMyFont);
virtual int SelectNetscapeFontWithCache( HDC hdc, LO_TextAttr *pAttr, CyaFont *& pMyFont );
virtual void ReleaseNetscapeFont(HDC hdc, CyaFont * pNetscapeFont);
virtual void ReleaseNetscapeFontWithCache(HDC hdc, CyaFont * pNetscapeFont);
virtual void ChangeFontOffset(int iIncrementor);
// Context sensitive attribute mapping.
public:
virtual COLORREF ResolveTextColor(LO_TextAttr *pAttr);
virtual COLORREF ResolveBGColor(unsigned uRed, unsigned uGreen, unsigned uBlue);
virtual BOOL ResolveHRSolid(LO_HorizRuleStruct *pHorizRule);
virtual BOOL ResolveLineSolid();
virtual void ResolveTransparentColor(unsigned uRed, unsigned uGreen, unsigned uBlue);
virtual COLORREF ResolveDarkLineColor();
virtual COLORREF ResolveLightLineColor();
virtual COLORREF ResolveBorderColor(LO_TextAttr *pAttr);
COLORREF ResolveLOColor(LO_Color *color);
virtual PRBool ResolveIncrementalImages();
#ifdef XP_WIN16
static void HugeFree(void XP_HUGE *pFreeMe) {
#ifdef __WATCOMC__
hfree(pFreeMe);
#else
_hfree(pFreeMe);
#endif
}
void XP_HUGE *HugeAlloc(int32 iSize, int32 iNum) {
#ifdef __WATCOMC__
return(halloc( (long) iSize, (size_t) iNum));
#else
return(_halloc( (long) iSize, (size_t) iNum));
#endif
}
#else
static void HugeFree(void XP_HUGE *pFreeMe) {
free(pFreeMe);
}
void XP_HUGE *HugeAlloc(int32 iSize, int32 iNum) {
return(calloc(iNum, iSize));
}
#endif
BOOL ResolveTextExtent(int16 wincsid, HDC pDC, LPCTSTR pString, int iLength, LPSIZE pSize, CyaFont *pMyFont);
BOOL ResolveTextExtent(HDC pDC, LPCTSTR pString, int iLength, LPSIZE pSize, CyaFont *pMyFont );
BOOL ResolveTextExtent(HDC pDC, LPCTSTR pString, int iLength, LPSIZE pSize)
{
BOOL bRetval;
bRetval = CIntlWin::GetTextExtentPoint(0, pDC, pString, iLength, pSize);
return(bRetval);
}
// Color and palette.
protected:
COLORREF m_rgbLightColor;
COLORREF m_rgbDarkColor;
HPALETTE m_pPal;
BOOL m_bRGB565; // driver supports 565 mode for DIBs
public:
virtual HPALETTE GetPalette() const;
COLORREF m_rgbBackgroundColor; // let our view access this
// Misc draw helpers
public:
virtual double CalcFontPointSize(int size, int iBaseSize, int iOffset = 0);
void Display3DBox(LTRB& Rect, COLORREF rgbLight, COLORREF rgbDark, int32 lWidth, BOOL bAdjust = FALSE);
void EditorDisplayZeroWidthBorder(LTRB& Rect, BOOL bSelected);
void Compute3DColors(COLORREF rgbColor, COLORREF &rgbLight, COLORREF &rgbDark);
// Returns width of selection border (if any) - used only by Composer
int32 DisplayTableBorder(LTRB& Rect, LO_TableStruct *pTable);
void Display3DBorder(LTRB& Rect, COLORREF rgbLight, COLORREF rgbDark, LTRB &);
BOOL cxLoadBitmap(LPCSTR pszBmName, char** bits, BITMAPINFOHEADER** myBitmapInfo);
virtual void DisplayIcon(int32 x, int32 y, int icon_number);
virtual void GetIconDimensions(int32* width, int32* height, int iconNumber);
void FloodRect(LTRB& Rect, HBRUSH hColor);
BOOL WriteBitmapFile(LPCSTR lpszFileName, LO_ImageStruct*);
HANDLE WriteBitmapToMemory( IL_ImageReq *image_req, LO_Color* bgColor);
BOOL CanWriteBitmapFile(LO_ImageStruct*);
// Uses the document color/backdrop by default, but you can specify a color or backdrop image to be used instead
virtual BOOL _EraseBkgnd(HDC pDC, RECT&, int32 tileX, int32 tileY,
LO_Color* bg = NULL);
void DisplaySelectionFeedback(uint16 ele_attrmask, const LTRB& rect);
void EraseToBackground(const LTRB& rect, int32 borderWidth = 0);
protected:
int m_iBitsPerPixel;
BOOL m_bUseDibPalColors;
public:
BOOL GetUseDibPalColors() {
return m_bUseDibPalColors;
}
int GetBitsPerPixel() {
return m_iBitsPerPixel;
}
void SetUseDibPalColors(BOOL flag) {
m_bUseDibPalColors = flag;
}
// Preference representations needed per context.
protected:
public:
// OLE Embed implementation.
private:
BOOL m_bAutoDeleteDocument;
protected:
CGenericDoc *m_pDocument;
public:
CGenericDoc *GetDocument() const {
return(m_pDocument);
}
void ClearDoc() {
m_pDocument = NULL;
}
void GetPluginRect(MWContext *pContext,
LO_EmbedStruct *pLayoutData,
RECT &rect, int iLocation,
BOOL windowed);
BOOL IsPluginFullPage(LO_EmbedStruct *pLayoutData);
BOOL ContainsFullPagePlugin();
// Document helpers.
public:
virtual BOOL OnOpenDocumentCX(const char *pPathName);
// URL retrieval
public:
virtual int GetUrl(URL_Struct *pUrl, FO_Present_Types iFormatOut, BOOL bReallyLoad = TRUE, BOOL bForceNew = FALSE);
// Function for easy creation of a URL from the current history entry.
public:
virtual URL_Struct *CreateUrlFromHist(BOOL bClearStateData = FALSE, SHIST_SavedData *pSavedData = NULL, BOOL bWysiwyg = FALSE);
// Image conditional loading.
private:
CString m_csForceLoadImage;
CString m_csNexttimeForceLoadImage;
BOOL m_bLoadImagesNow;
BOOL m_bNexttimeLoadImagesNow;
public:
void ExplicitlyLoadThisImage(const char *pImageUrl) {
m_csNexttimeForceLoadImage = pImageUrl;
NiceReload();
}
void ExplicitlyLoadAllImages() {
m_bNexttimeLoadImagesNow = TRUE;
NiceReload();
}
// Wether or not we exist in an OLE server....
private:
BOOL m_bOleServer;
public:
BOOL IsOleServer() const {
return(m_bOleServer);
}
void EnableOleServer();
void DisableOleServer() {
m_bOleServer = FALSE;
}
// Font for Form Text Entry
private:
friend class CFormElement;
enum {
m_FixedFont,
m_ProportionalFont
};
#if 0 /* dp */
int m_DownloadedFontList; // for testing
#endif /* 0 */
HFONT m_pFormFixFont;
HFONT m_pFormPropFont;
int m_iFormFixCSID; // csid for current form.
int m_iFormPropCSID; // csid for current form.
void ExtendCoord(LTRB &Rect);
virtual void GetDrawingOrigin(int32 *plOrgX, int32 *plOrgY)
{ *plOrgX = 0; *plOrgY = 0; }
virtual FE_Region GetDrawingClip()
{ return NULL; }
private :
void CDCCX::DrawTabFocusLine( HDC hdc, BOOL supportPixel, int x, int y, int x2, int y2);
void CDCCX::DrawTabFocusRect( HDC hdc, BOOL supportPixel, int left, int top, int right, int bottom);
void CDCCX::DrawRectBorder(LTRB& Rect, COLORREF rgbColor, int32 lWidth);
void CDCCX::DrawMapAreaBorder( int baseX, int baseY, lo_MapAreaRec * theArea );
// MFC Helpers; abstraction away
public:
virtual void ViewImages();
virtual BOOL CanViewImages();
// Context Overrides
virtual void DisplayBullet(MWContext *pContext, int iLocation, LO_BullettStruct *pBullet);
#ifndef MOZ_NGLAYOUT
virtual void DisplayEmbed(MWContext *pContext, int iLocation, LO_EmbedStruct *pEmbed);
#endif
virtual void DisplayBorder(MWContext *pContext, int iLocation, int x, int y, int width, int height, int bw, LO_Color *color, LO_LineStyle style);
virtual void DisplayHR(MWContext *pContext, int iLocation, LO_HorizRuleStruct *pHorizRule);
virtual BITMAPINFO* NewPixmap(NI_Pixmap* pImage, BOOL mask = FALSE);
virtual int DisplayPixmap(NI_Pixmap* image, NI_Pixmap* mask, int32 x, int32 y, int32 x_offset, int32 y_offset, int32 width, int32 height, int32 lScaleWidth, int32 lScaleHeight, LTRB& Rect);
virtual void DisplayLineFeed(MWContext *pContext, int iLocation, LO_LinefeedStruct *pLineFeed, XP_Bool clear);
virtual void DisplaySubDoc(MWContext *pContext, int iLocation, LO_SubDocStruct *pSubDoc);
virtual void DisplayCell(MWContext *pContext, int iLocation, LO_CellStruct *pCell);
virtual void DisplaySubtext(MWContext *pContext, int iLocation, LO_TextStruct *pText, int32 lStartPos, int32 lEndPos, XP_Bool clear);
virtual void DisplayTable(MWContext *pContext, int iLocation, LO_TableStruct *pTable);
// need to keep the old interface for calling from C
virtual void DisplayText(MWContext *pContext, int iLocation, LO_TextStruct *pText, XP_Bool clear);
void CDCCX::DisplayImageFeedback(MWContext *pContext, int iLocation, LO_Element *pElement, lo_MapAreaRec * theArea, uint32 drawFlag );
// /* cannot use default drawFlag = 0, if this function is called from C */
virtual void DisplayText(MWContext *pContext, int iLocation, LO_TextStruct *pText, XP_Bool clear, uint32 drawFlag );
// handle strike and under-line, after text is drawn.
virtual void CDCCX::DrawTextPostDecoration(HDC hdc, LO_TextAttr * attr, LTRB * Rect, COLORREF rgbColor );
virtual void DisplayWindowlessPlugin(MWContext *pContext, LO_EmbedStruct *pEmbed, NPEmbeddedApp *pEmbeddedApp, int iLocation);
virtual void DisplayPlugin(MWContext *pContext, LO_EmbedStruct *pEmbed, NPEmbeddedApp* pEmbeddedApp, int iLocation);
#ifdef LAYERS
virtual void EraseBackground(MWContext *pContext, int iLocation, int32 x, int32 y, uint32 width, uint32 height, LO_Color *pColor);
#endif
#ifndef MOZ_NGLAYOUT
virtual void FreeEmbedElement(MWContext *pContext, LO_EmbedStruct *pEmbed);
virtual void GetEmbedSize(MWContext *pContext, LO_EmbedStruct *pEmbed, NET_ReloadMethod bReload);
#endif /* MOZ_NGLAYOUT */
#ifdef LAYERS
virtual void GetTextFrame(MWContext *pContext, LO_TextStruct *pText,
int32 start, int32 end, XP_Rect *frame);
#endif
virtual int GetTextInfo(MWContext *pContext, LO_TextStruct *pText, LO_TextInfo *pTextInfo);
virtual void ImageComplete(NI_Pixmap* image);
virtual void LayoutNewDocument(MWContext *pContext, URL_Struct *pURL, int32 *pWidth, int32 *pHeight, int32 *pmWidth, int32 *pmHeight);
virtual void SetBackgroundColor(MWContext *pContext, uint8 uRed, uint8 uGreen, uint8 uBlue);
virtual COLORREF GetBackgroundColor() {return m_rgbBackgroundColor;}
virtual void Set3DColors( COLORREF crBackground );
static HPALETTE InitPalette(HDC hdc);
static HPALETTE CreateColorPalette(HDC hdc, IL_IRGB& transparentColor, int bitsPerPixel);
static void SetColormap(HDC hdc, NI_ColorMap *pMap, IL_IRGB& transparentColor, HPALETTE hPal);
virtual void SetDocDimension(MWContext *pContext, int iLocation, int32 lWidth, int32 lLength);
virtual void GetDocPosition(MWContext *pContext, int iLocation, int32 *lX_p, int32 *lY_p);
#ifndef MOZ_NGLAYOUT
virtual void DisplayFormElement(MWContext *pContext, int iLocation, LO_FormElementStruct *pFormElement);
virtual void FormTextIsSubmit(MWContext *pContext, LO_FormElementStruct *pFormElement);
virtual void GetFormElementInfo(MWContext *pContext, LO_FormElementStruct *pFormElement);
virtual void GetFormElementValue(MWContext *pContext, LO_FormElementStruct *pFormElement, XP_Bool bTurnOff, XP_Bool bSubmit);
virtual void ResetFormElement(MWContext *pContext, LO_FormElementStruct *pFormElement);
virtual void SetFormElementToggle(MWContext *pContext, LO_FormElementStruct *pFormElement, XP_Bool iState);
#endif
#ifdef TRANSPARENT_APPLET
virtual void DrawJavaApp(MWContext *pContext, int iLocation, LO_JavaAppStruct *pJava);
#endif
protected:
void StretchMaskBlt(HDC hTargetDC, HBITMAP theBitmap, HBITMAP theMask,
int32 dx, int32 dy, int32 dw, int32 dh,
int32 sx, int32 sy, int32 sw, int32 sh);
void StretchPixmap(HDC hTargetDC, NI_Pixmap* pImage,
int32 dx, int32 dy, int32 dw, int32 dh,
int32 sx, int32 sy, int32 sw, int32 sh);
virtual void _StretchDIBitsWithMask(HDC pDC,
int iDestX,
int iDestY,
int iDestWidth,
int iDestHeight,
int iSrcX,
int iSrcY,
int iSrcWidth,
int iSrcHeight,
NI_Pixmap *image,
NI_Pixmap *mask);
#ifdef DDRAW
BOOL TransparentBlt(int iDestX,
int iDestY,
int iDestWidth,
int iDestHeight,
int iSrcX,
int iSrcY,
int iSrcWidth,
int iSrcHeight,
NI_Pixmap *image,
COLORREF transColor,
LPDIRECTDRAWSURFACE surf);
#endif
BITMAPINFO* FillBitmapInfoHeader(NI_Pixmap* pImage);
HBITMAP CreateBitmap(HDC hTargetDC, NI_Pixmap *image);
HBITMAP CreateMask(HDC hTargetDC, NI_Pixmap* mask);
void TileImage(HDC hdc, LTRB& Rect, NI_Pixmap* image, NI_Pixmap* mask, int32 x, int32 y);
};
// Global functions
// Calculate a contrastng text and background colors to use for selection
// given a background color
void wfe_GetSelectionColors( COLORREF rgbBackgroundColor,
COLORREF* pTextColor, COLORREF* pBackColor);
// Global variables
//
// Macros
//
#endif // __Context_Device_Context_H
Reference in New Issue View Git Blame Copy Permalink