/* AbiWord
* Copyright (C) 1998 AbiSource, Inc.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
* 02111-1307, USA.
*/
#ifndef GR_WIN32GRAPHICS_H
#define GR_WIN32GRAPHICS_H
#include <windows.h>
#include "ut_misc.h"
#include "gr_Graphics.h"
#include "gr_Win32CharWidths.h"
#include "ut_vector.h"
#include "ut_stack.h"
#include <wchar.h>
#include <winuser.h>
class UT_ByteBuf;
#define _MAX_CACHE_PENS 64
//////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////
class ABI_EXPORT GR_Win32Font : public GR_Font
{
public:
static GR_Win32Font * newFont(LOGFONTW & lf, double fPoints, HDC hdc, HDC printDC);
virtual ~GR_Win32Font();
// need these to allow for adjustements in response to changes of device
void setAscent(UT_uint32 n) { m_tm.tmAscent = n; }
void setDescent(UT_uint32 n) { m_tm.tmDescent = n; }
void setHeight(UT_uint32 n) { m_tm.tmHeight = n; }
UT_uint32 getAscent(HDC hdc, HDC printHDC);
UT_uint32 getDescent(HDC hdc, HDC printHDC);
UT_uint32 getHeight(HDC hdc, HDC printHDC);
UT_uint32 getUnscaledHeight() const { return m_iHeight;}
HFONT getDisplayFont(GR_Graphics * pGr);
virtual UT_sint32 measureUnremappedCharForCache(UT_UCSChar cChar) const;
UT_sint32 measureUnRemappedChar(UT_UCSChar c, UT_uint32 * height = 0);
virtual GR_CharWidths* newFontWidths(void) const;
//
// UT_Rect of glyph in Logical units.
// rec.left = bearing Left (distance from origin to start)
// rec.width = width of the glyph
// rec.top = distance from the origin to the top of the glyph
// rec.height = total height of the glyph
virtual bool glyphBox(UT_UCS4Char g, UT_Rect & rec, GR_Graphics * pG);
void selectFontIntoDC(GR_Graphics * pGr, HDC hdc);
void markGUIFont() {m_bGUIFont = true;}
bool isFontGUI() const {return m_bGUIFont;}
const HDC getPrimaryHDC() const {return m_hdc;}
const HDC getXHDC() const {return m_xhdc;}
const HDC getYHDC() const {return m_yhdc;}
void setPrimaryHDC(const HDC hdc) {m_hdc = hdc;}
void setXHDC(const HDC hdc) {m_xhdc = hdc;}
void setYHDC(const HDC hdc) {m_yhdc = hdc;}
// NB: the font handle is one which was associated with this font when it was
// origianlly created; however, it is not necessarily one that is to be used for
// drawing as that has to reflect zoom factor and has to be obtained using
// GR_Win32Font::Acq::getDisplayFont()
// (The handle returned by getFontHandle() can be used for things that are not
// affected by zoom, such as retrieving face names, etc.)
HFONT getFontHandle() const {return m_layoutFont;}
double getPointSize() const {return m_fPointSize;}
protected:
// all construction has to be done via the graphics class
GR_Win32Font(LOGFONTW & lf, double fPoints, HDC hdc, HDC printHDC);
GR_Win32CharWidths * _getCharWidths() const
{
#ifndef ABI_GRAPHICS_PLUGIN_NO_WIDTHS
return reinterpret_cast<GR_Win32CharWidths *>(GR_Font::_getCharWidths());
#else
UT_return_val_if_fail(UT_NOT_IMPLEMENTED,NULL);
#endif
}
// this function should clear any cached information the font might cary
// it is prinicipally intened to be used when we share fonts between screen and
// printer
virtual void _clearAnyCachedInfo() {};
void _updateFontYMetrics(HDC hdc, HDC printHDC);
public:
HFONT getFontFromCache(UT_uint32 pixelsize, bool bIsLayout,
UT_uint32 zoomPercentage) const;
void fetchFont(UT_uint32 pixelsize) const;
const TEXTMETRICW & getTextMetric() const {return m_tm;}
private:
struct allocFont
{
UT_uint32 pixelSize;
HFONT hFont;
};
void insertFontInCache(UT_uint32 pixelsize, HFONT pFont) const;
// we will store three different HDC values
// m_hdc is handle to the device on which we are meant to draw
// m_xhdc is handle to the device which was used for obtaining x-axis metrics
// m_yhdc is handle to the device which was used for obtaining y-axis metrics
// we have no control over the lifetime of any of
// these dc's -- we only use these to check that the metrics and other font info is
// uptodate -- they should NEVER be passed to any win32 API
HDC m_hdc;
HDC m_xhdc;
HDC m_yhdc;
UT_uint32 m_defaultCharWidth;
HFONT m_layoutFont;
TEXTMETRICW m_tm;
UT_uint32 m_iHeight; // unscaled height
// a cache of 'allocFont *' at a given size
mutable UT_Vector m_allocFonts;
bool m_bGUIFont;
double m_fPointSize;
};
//////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////
class ABI_EXPORT GR_Win32AllocInfo : public GR_AllocInfo
{
public:
GR_Win32AllocInfo():
m_hdc(0), m_hwnd(0), m_pDocInfo(NULL), m_hDevMode(NULL) {};
GR_Win32AllocInfo(HDC hdc, HWND hwnd):
m_hdc(hdc), m_hwnd(hwnd), m_pDocInfo(NULL), m_hDevMode(NULL) {};
GR_Win32AllocInfo(HDC hdc, const DOCINFOW* pDoc, HGLOBAL devmode):
m_hdc(hdc), m_hwnd(0), m_pDocInfo(pDoc), m_hDevMode(devmode) {};
virtual GR_GraphicsId getType() const {return GRID_WIN32;}
virtual bool isPrinterGraphics() const {return (m_pDocInfo != 0);}
HDC m_hdc;
HWND m_hwnd;
const DOCINFOW * m_pDocInfo;
HGLOBAL m_hDevMode;
};
class ABI_EXPORT GR_Win32Graphics : public GR_Graphics
{
// all constructors are protected; instances must be created via
// GR_GraphicsFactory
public:
virtual ~GR_Win32Graphics();
static UT_uint32 s_getClassId() {return GRID_WIN32;}
virtual UT_uint32 getClassId() {return s_getClassId();}
virtual GR_Capability getCapability() {return GRCAP_SCREEN_AND_PRINTER;}
static const char * graphicsDescriptor(){return "Win32 Default";}
static GR_Graphics * graphicsAllocator(GR_AllocInfo&);
static GR_Graphics * getPrinterGraphics(const wchar_t * pPrinterName,
const wchar_t * pDocName);
virtual void drawGlyph(UT_uint32 glyph_idx, UT_sint32 xoff, UT_sint32 yoff);
virtual void drawChar(UT_UCSChar Char, UT_sint32 xoff, UT_sint32 yoff);
virtual void drawChars(const UT_UCSChar* pChars,
int iCharOffset, int iLength,
UT_sint32 xoff, UT_sint32 yoff,
int * pCharWidth);
virtual void setFont(const GR_Font* pFont);
virtual void clearFont(void) { m_pFont = NULL;}
virtual UT_uint32 getFontHeight();
virtual UT_sint32 measureUnRemappedChar(const UT_UCSChar c, UT_uint32 * height = 0);
virtual void setColor(const UT_RGBColor& clr);
virtual void getColor(UT_RGBColor& clr);
virtual GR_Font* getGUIFont();
virtual UT_uint32 getFontAscent();
virtual UT_uint32 getFontDescent();
virtual void getCoverage(UT_NumberVector& coverage);
virtual void drawLine(UT_sint32, UT_sint32, UT_sint32, UT_sint32);
virtual void xorLine(UT_sint32, UT_sint32, UT_sint32, UT_sint32);
virtual void setLineWidth(UT_sint32);
virtual void setLineProperties ( double inWidthPixels,
JoinStyle inJoinStyle = JOIN_MITER,
CapStyle inCapStyle = CAP_BUTT,
LineStyle inLineStyle = LINE_SOLID );
virtual void polyLine(UT_Point * pts, UT_uint32 nPoints);
virtual void fillRect(const UT_RGBColor& c,
UT_sint32 x, UT_sint32 y,
UT_sint32 w, UT_sint32 h);
virtual void invertRect(const UT_Rect* pRect);
virtual void setClipRect(const UT_Rect* pRect);
virtual void scroll(UT_sint32 dx, UT_sint32 dy);
virtual void scroll(UT_sint32 x_dest, UT_sint32 y_dest,
UT_sint32 x_src, UT_sint32 y_src,
UT_sint32 width, UT_sint32 height);
virtual void clearArea(UT_sint32, UT_sint32, UT_sint32, UT_sint32);
virtual void drawImage(GR_Image* pImg, UT_sint32 xDest, UT_sint32 yDest);
virtual GR_Image* createNewImage(const char* pszName, const UT_ByteBuf* pBB, const std::string& mimetype,
UT_sint32 iDisplayWidth, UT_sint32 iDisplayHeight, GR_Image::GRType iType = GR_Image::GRT_Raster);
virtual bool queryProperties(GR_Graphics::Properties gp) const;
virtual bool startPrint(void);
virtual bool startPage(const char * szPageLabel, UT_uint32 pageNumber,
bool bPortrait, UT_uint32 iWidth, UT_uint32 iHeight);
virtual bool endPrint(void);
virtual HWND getHwnd(void) const;
virtual void setColorSpace(GR_Graphics::ColorSpace c);
virtual GR_Graphics::ColorSpace getColorSpace(void) const;
virtual void setCursor(GR_Graphics::Cursor c);
virtual GR_Graphics::Cursor getCursor(void) const;
virtual void handleSetCursorMessage(void);
virtual void setColor3D(GR_Color3D c);
void init3dColors(void);
virtual void fillRect(GR_Color3D c,
UT_sint32 x, UT_sint32 y,
UT_sint32 w, UT_sint32 h);
virtual void fillRect(GR_Color3D c, UT_Rect &r);
virtual void polygon(UT_RGBColor& c,UT_Point *pts,UT_uint32 nPoints);
virtual UT_uint32 getFontAscent(const GR_Font *);
virtual UT_uint32 getFontDescent(const GR_Font *);
virtual UT_uint32 getFontHeight(const GR_Font *);
virtual GR_Image * genImageFromRectangle(const UT_Rect & r);
virtual void saveRectangle(UT_Rect & r, UT_uint32 iIndx);
virtual void restoreRectangle(UT_uint32 iIndx);
virtual void flush(void);
void setBrush(HBRUSH hBrush){ m_hClearBrush = hBrush;};
virtual void setPrintDC(HDC dc);
HDC getPrintDC() const {return m_printHDC;}
HDC getPrimaryDC() const {return m_hdc;}
void setPrintDCFontAllocNo(UT_uint32 i){m_iPrintDCFontAllocNo = i;}
void setDCFontAllocNo(UT_uint32 i){m_iDCFontAllocNo = i;}
double getXYRatio() const {return m_fXYRatio;}
double getXYRatioPrint() const {return m_fXYRatioPrint;}
static bool fixDevMode(HGLOBAL hModDev);
static DOCINFOW *getDocInfo();
static HDC createbestmetafilehdc();
protected:
// all instances have to be created via GR_GraphicsFactory; see gr_Graphics.h
GR_Win32Graphics(HDC, HWND); /* for screen */
GR_Win32Graphics(HDC, const DOCINFOW *, HGLOBAL hDevMode = NULL); /* for printing */
BITMAPINFO * ConvertDDBToDIB(HBITMAP bitmap, HPALETTE hPal, DWORD dwCompression);
virtual GR_Font* _findFont(const char* pszFontFamily,
const char* pszFontStyle,
const char* pszFontVariant,
const char* pszFontWeight,
const char* pszFontStretch,
const char* pszFontSize,
const char* pszLang);
virtual UT_uint32 getDeviceResolution(void) const;
void _setColor(DWORD clrRef);
HDC m_bufferHdc;
HDC m_dummyHdc;
void _DeviceContext_MeasureBitBltCopySpeed(HDC source, HDC dest, int width, int height);
void getWidthAndHeightFromHWND(HWND h, int &width, int &height);
void _DeviceContext_SwitchToBuffer();
void _DeviceContext_SwitchToScreen();
void _DeviceContext_DrawBufferToScreen();
void _DeviceContext_SuspendDrawing();
void _DeviceContext_ResumeDrawing();
void _DoubleBuffering_SetUpDummyBuffer();
void _DoubleBuffering_ReleaseDummyBuffer();
HDC _DoubleBuffering_CreateBuffer(HDC, int, int);
void _DoubleBuffering_ReleaseBuffer(HDC);
struct _HDCSwitchRecord
{
HDC oldHdc;
_HDCSwitchRecord(HDC h) : oldHdc(h) { }
};
UT_Stack _HDCSwitchStack;
void _DeviceContext_RestorePrevHDCFromStack();
private:
virtual GR_Win32Font * _newFont(LOGFONTW & lf, double fPointSize, HDC hdc, HDC printDC);
protected:
UT_uint32 m_iDCFontAllocNo;
UT_uint32 m_iPrintDCFontAllocNo;
HDC m_hdc;
HDC m_printHDC;
static HDC m_defPrintHDC;
static UT_uint32 s_iInstanceCount;
HWND m_hwnd;
const DOCINFOW * m_pDocInfo;
bool m_bPrint;
bool m_bStartPrint;
bool m_bStartPage;
GR_Win32Font* m_pFont;
GR_Win32Font* m_pFontGUI;
UT_sint32 m_iLineWidth;
JoinStyle m_eJoinStyle;
CapStyle m_eCapStyle;
LineStyle m_eLineStyle;
GR_Graphics::ColorSpace m_cs;
GR_Graphics::Cursor m_cursor;
DWORD m_clrCurrent;
DWORD m_3dColors[COUNT_3D_COLORS];
int m_nPrintLogPixelsY;
double m_fXYRatio;
double m_fXYRatioPrint;
private:
void _constructorCommonCode(HDC);
UT_uint16* _remapGlyphs(const UT_UCSChar* pChars, int iCharOffset, int &iLength);
virtual bool _setTransform(const GR_Transform & tr);
DWORD m_clrXorPen;
HPEN m_hXorPen;
UT_UCS2Char* m_remapBuffer;
UT_uint32 m_remapBufferSize;
UT_UCS2Char* m_remapIndices;
UT_RGBColor m_curColor;
UT_Vector m_vSaveRect;
UT_Vector m_vSaveRectBuf;
HBRUSH m_hClearBrush;
int m_nLogPixelsY;
HGLOBAL m_hDevMode;
typedef struct
{
HPEN hPen;
int nStyle;
int nWidth;
DWORD dwColour;
} CACHE_PEN;
CACHE_PEN* m_pArPens;
int m_nArPenPos;
bool m_bIsPreview;
};
#endif /* GR_WIN32GRAPHICS_H */