GRenderBrush Class Reference

A GDraw render region that uses normal DIBs for the bitmap. It serves a particularly special purpose in that it provides a number of functions that allow us to blit to the screen very quickly without getting tangled up in the render loop. This is so that we can draw brush strokes and have them appear on the screen in real time. This is achieved by maintaining not one but four static bitmaps. These work in the following way:. More...

#include <grndbrsh.h>

Inheritance diagram for GRenderBrush:

List of all members.

Public Member Functions
	GRenderBrush (DocRect ClipRegion, Matrix ConvertMatrix, FIXED16 ViewScale, UINT32 Depth, double dpi)
	GRenderBrush constructor. Doesn't do anything actually, just calls base class. INT32 dpi changed to double dpi (12/12/95) to improve the range of values allowed at the < 1000dpi settings that we will be using.
	~GRenderBrush ()
	GRenderBrush destructor. Frees up the bitmaps.
void	DrawToScreenNow ()
	This is a bit of a bodge function so that we could get the brush to draw itself to the screen ASAP. It bypasses all the regular rendering rubbish and gets straight down to blitting.
void	SetChangedBBox (DocRect Rect)
	For some reason when drawing brush steps into a render region there was a problem with having the bbox set itself, so this is a way to do it manually.
BOOL	InitialiseBrushBitmaps (DocRect BrushRect)
	Public interface to the initialisation function, you only need to pass in the size of the brush and the rest is taken care of for you.
void	SetupMainBitmap ()
	Public interface which sets up our main bitmap for GDraw to use. Note that the compression flag must be set to false or else things go wrong.
BOOL	PlotBrushIntoBigBitmap (DocRect BrushRect)
	Plots the brush bitmap into the view bitmap, just like rendering really but quicker.
BOOL	CaptureView (Spread *pSpread)
	Captures the screen (or rather the part of the screen that holds the View) as a bitmap.
BOOL	MoveWindowToFront ()
BOOL	ResetMatrix ()
void	Blackout ()
UINT32	GetScreenDepth ()
virtual void	SetOffscreen (OffscreenAttrValue *)
	Create a new bitmap into which, the subtree rooted at this attributes parent, will be rendered. Then call base version to push the current OffscreenAttr onto the context stack.
virtual void	RestoreOffscreen (OffscreenAttrValue *)
void	SetView (View *v)
void	SetCamView (CCamView *v)
void	SetCDC (CDC *cdc)
void	SetHDC (HDC hdc)
Static Public Member Functions
static BOOL	Convert16to32 (LPBITMAPINFO pSourceInfo, LPBYTE pSourceBits, RGBQUAD *pPalette, LPBITMAPINFO pDestInfo, LPBYTE pDestBits)
Protected Member Functions
BOOL	ConvertBrushBitmap ()
	Takes the contents of lppreconvertbrushbits which will be 32BPP, and calls GDraw to convert the contents and put it into lppostconvertbrushbits which has the same BPP as the screen.
BOOL	TestConvertBitmap ()
BOOL	ClipBrushBitmaps (RECT *pUsedRect, INT32 *pHeight)
	When we come to blit at the edge of the view we will end up access violating if we simply proceed regardless. This function checks to see how close we are to the edge and 'pretends' that the bitmap is only big enough to go up up to the edge and not beyond.
void	SetupBitmap (LPBITMAPINFO pBitmapInfo, LPBYTE pBits)
	Similar to GRenderRegion;;StartRender, initialises the bitmap for GDraw to render into it.
BOOL	InitialiseBrushBitmaps (INT32 Width, INT32 Height, INT32 RenderDepth, INT32 DeviceDepth)
	allocates bitmaps of the correct size, depth etc.
BOOL	CaptureViewByRendering ()
	Renders the view into this render region.
BOOL	Blit (HDC DestDC, HDC SourceDC, INT32 Height, INT32 Width, INT32 Left, INT32 Top)
BOOL	GetBits (HDC hDC, HBITMAP hBitmap, INT32 Height, LPBYTE lpbits, LPBITMAPINFO lpInfo)
virtual void	FreeLPBits (LPBITMAPINFO, LPBYTE)
	Frees up a bitmap allocated with GetLPBits.
Protected Attributes
LPBITMAPINFO	lpPreConvertBrushBitmapInfo
LPBYTE	lpPreConvertBrushBits
LPBITMAPINFO	lpPostConvertBrushBitmapInfo
LPBYTE	lpPostConvertBrushBits
LPBITMAPINFO	lpBrushBitmapInfo
LPBYTE	lpBrushBits
LPBITMAPINFO	lpTestInfo
LPBYTE	lpTestBits
RGBQUAD *	m_pPalette
View *	m_pView
CCamView *	m_pCCamView
CDC *	m_pDevContext
HDC	m_DeviceHdc

---

Detailed Description

A GDraw render region that uses normal DIBs for the bitmap. It serves a particularly special purpose in that it provides a number of functions that allow us to blit to the screen very quickly without getting tangled up in the render loop. This is so that we can draw brush strokes and have them appear on the screen in real time. This is achieved by maintaining not one but four static bitmaps. These work in the following way:.

Author:

Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com>

Date:

20/12/99

The main bitmap (lpbits) needs to have the current view rendered into it before beginning the brush stroke. lpbrushbits - bitmap which has the brush rendered into it.

What we do instead of rendering is to simply combine the brush bitmap with the view bitmap, copy the results to lppreconvertbits and either blit it or convert it(if we are on a <24bit device).

Definition at line 137 of file grndbrsh.h.

---

Constructor & Destructor Documentation

GRenderBrush::GRenderBrush (  DocRect  ClipRegion, Matrix  ConvertMatrix, FIXED16  ViewScale, UINT32  Depth, double  dpi )

GRenderBrush constructor. Doesn't do anything actually, just calls base class. INT32 dpi changed to double dpi (12/12/95) to improve the range of values allowed at the < 1000dpi settings that we will be using. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 20/12/99 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: GRenderRegion::GRenderRegion Definition at line 163 of file grndbrsh.cpp. : GRenderDIB( ClipRegion, ConvertMatrix, ViewScale, Depth, dpi) { lpPreConvertBrushBitmapInfo = NULL; lpPostConvertBrushBitmapInfo = NULL; lpPreConvertBrushBits = NULL; lpPostConvertBrushBits = NULL; lpBrushBitmapInfo = NULL; lpBrushBits = NULL; m_pPalette = NULL; //#ifdef NEWFASTBRUSHES m_pView = NULL; m_pCCamView = NULL; PORTNOTE("other", "Disable HDC stuff") #ifndef EXCLUDE_FROM_XARALX m_pDevContext = NULL; m_DeviceHdc = NULL; #endif //#endif }

GRenderBrush::~GRenderBrush (   )

GRenderBrush destructor. Frees up the bitmaps. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 20/12/99 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - Definition at line 201 of file grndbrsh.cpp. { if (lpPreConvertBrushBitmapInfo != NULL && lpPreConvertBrushBits != NULL) FreeLPBits(lpPreConvertBrushBitmapInfo, lpPreConvertBrushBits); if (lpPostConvertBrushBitmapInfo != NULL && lpPostConvertBrushBits != NULL) FreeLPBits(lpPostConvertBrushBitmapInfo, lpPostConvertBrushBits); if (lpBrushBitmapInfo != NULL && lpBrushBits != NULL) FreeLPBits(lpBrushBitmapInfo, lpBrushBits); if (pBits != NULL && pBitmapInfo != NULL) { FreeLPBits( pBitmapInfo, pBits ); SetBitmapPointers(NULL, NULL); } TRACEUSER( "Gavin", _T("GRenderBrush::~GRenderBrush - RenderFlags.Rendering = FALSE;\n")); RenderFlags.Rendering = FALSE; // will call GRenderDIBs destructor here }

---

Member Function Documentation

void GRenderBrush::Blackout (   )

BOOL GRenderBrush::Blit (  HDC  DestDC, HDC  SourceDC, INT32  Height, INT32  Width, INT32  Left, INT32  Top )  [protected]

Definition at line 1321 of file grndbrsh.cpp. { if (BitBlt(DestDC, 0, 0, Width, Height, SourceDC, Left , Top, SRCCOPY)) return TRUE; else return FALSE; }

BOOL GRenderBrush::CaptureView (  Spread *  pSpread  )

Captures the screen (or rather the part of the screen that holds the View) as a bitmap. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 29/10/99 Parameters: pSpread  - contains the view we wish to grab [INPUTS] [OUTPUTS]  Definition at line 980 of file grndbrsh.cpp. { ERROR3IF(!MasterCaptureIsCurrent() && GetCaptureDepth()>0, "Can't 'CaptureView' while Captures are running"); // TRACEUSER( "Diccon", _T("Entering CaptureView\n")); // put up an hour glass String_32 ProgString = "Preparing for brush stroke, please wait.."; Progress Prog(&ProgString, -1, FALSE); // make sure we're at the front ( we may still have a window on top though) BOOL DoCapture = MoveWindowToFront(); // If we have a bitmap then ditch it if (lpBitmapInfo!=NULL && lpBits != NULL) { FreeLPBits(lpBitmapInfo, lpBits); lpBitmapInfo = NULL; lpBits = NULL; } // get the current screen depth HDC hDCScreen = CreateDC("DISPLAY", NULL, NULL, NULL); ScreenDepth = GetDeviceCaps(hDCScreen, BITSPIXEL); // if we have an 8-bit screen or there is a window on top of us then // don't capture the screen, render the view normally. A bit slower, if the document is complex if (ScreenDepth == 8 || !DoCapture) { DeleteDC(hDCScreen); CaptureViewByRendering(); // TRACEUSER( "Diccon", _T("Rendered View\n")); return TRUE; } // Get a new one to replace it lpBitmapInfo = GetLPBits(WRect.right-WRect.left, WRect.bottom-WRect.top, 32, &lpBits); // See if we got it if (lpBitmapInfo==NULL) return FALSE; // make a compatible DC to put the bitmap in HDC hDCCompatible = CreateCompatibleDC(hDCScreen); // get the window so we can do client to screen to find out how big // the view is in pixels View* pView = View::GetCurrent(); if (pView == NULL) { ERROR3("No view in GRenderBrush::CaptureView"); DeleteDC(hDCScreen); DeleteDC(hDCCompatible); return FALSE; } CCamView *pRenderWindow = pView->GetConnectionToOilView(); if (pRenderWindow == NULL) { ERROR3("No window in GRenderBrush::CaptureView"); DeleteDC(hDCScreen); DeleteDC(hDCCompatible); return FALSE; } RECT Rect = CalculateWinRect(RenderMatrix, CurrentClipRect, PixelsPerInch ); pRenderWindow->ClientToScreen( &Rect ); // get some locals to store the dimensions - remember that DIBs are upside down INT32 ViewHeight = Rect.bottom - Rect.top ; INT32 ViewWidth = Rect.right - Rect.left; INT32 ViewTop = Rect.top; INT32 ViewLeft = Rect.left; // if the rulers are on then we must shift in a little bit DocView* pDocView = DocView::GetCurrent(); if (pDocView->AreRulersVisible()) { INT32 RulerSize = OILRuler::GetRenderWidth(); ViewTop += RulerSize+1; ViewLeft += RulerSize+1; } // allocate the bitmap HBITMAP hBMScreen = CreateCompatibleBitmap(hDCScreen, ViewWidth, ViewHeight); ERROR2IF(hBMScreen == NULL, FALSE, "unable to allocate bitmap for the view"); // select the bitmap into the DC if (!SelectObject(hDCCompatible, hBMScreen)) { ERROR3("Error selecting bitmap into DC"); DeleteDC(hDCScreen); DeleteDC(hDCCompatible); DeleteObject(hBMScreen); return FALSE; } hPrevPalette = PaletteManager::StartPaintPalette(hDCScreen); // blit it /*if (!BitBlt(hDCCompatible, 0, 0, ViewWidth, ViewHeight, hDCScreen, ViewLeft , ViewTop, SRCCOPY))*/ if (!Blit(hDCCompatible, hDCScreen, ViewHeight, ViewWidth, ViewLeft, ViewTop)) { ERROR3("Error selecting bitmap into DC"); DeleteDC(hDCScreen); DeleteDC(hDCCompatible); DeleteObject(hBMScreen); return FALSE; } // Now we have to convert it to 32bit and use it as our member bitmap // first get a pointer to the bitmap bits INT32 BitmapSize = ViewHeight * ViewWidth * ScreenDepth; LPBYTE lpScreenBits = NULL; //(LPBYTE)CCMalloc(BitmapSize);//(LPBYTE)malloc(BitmapSize); LPBITMAPINFO lpScreenInfo = GetLPBits(Rect.right-Rect.left, Rect.bottom-Rect.top, ScreenDepth, &lpScreenBits); if (lpScreenBits == NULL) { ERROR3("error getting screen bits"); DeleteDC(hDCScreen); DeleteDC(hDCCompatible); DeleteObject(hBMScreen); return FALSE; } // now setup a bitmapinfo //LPBITMAPINFO lpScreenInfo = (LPBITMAPINFO)CCMalloc(sizeof(BITMAPINFO)); if (lpScreenInfo == NULL) { ERROR3("error getting bitmapinfo"); CCFree((LPVOID)lpScreenBits); DeleteDC(hDCScreen); DeleteDC(hDCCompatible); DeleteObject(hBMScreen); return FALSE; } INT32 Colours = 0; switch (ScreenDepth) { case 1: Colours = 2; break; case 4: Colours = 16; break; case 8: Colours = 256; break; case 16: // for 16 bit and upwards we can pass in zero Colours = 0; break; case 24: Colours = 0; break; case 32: Colours = 0; break; default: ERROR3("Illegal screen depth"); break; } lpScreenInfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER); lpScreenInfo->bmiHeader.biWidth = ViewWidth; lpScreenInfo->bmiHeader.biHeight = ViewHeight; lpScreenInfo->bmiHeader.biPlanes = 1; lpScreenInfo->bmiHeader.biBitCount = ScreenDepth; lpScreenInfo->bmiHeader.biCompression = BI_RGB; lpScreenInfo->bmiHeader.biXPelsPerMeter = 3780; // Default to 96 dpi lpScreenInfo->bmiHeader.biYPelsPerMeter = 3780; lpScreenInfo->bmiHeader.biClrUsed = Colours; lpScreenInfo->bmiHeader.biClrImportant = 0; lpScreenInfo->bmiHeader.biSizeImage = BitmapSize; // now get the DIBits INT32 num = (GetDIBits(hDCCompatible, hBMScreen, 0, ViewHeight, lpScreenBits, lpScreenInfo, DIB_RGB_COLORS)); //if (!GetBits(hDCCompatible, hBMScreen, ViewHeight, lpScreenBits, lpScreenInfo)) if (num ==0 ) { ERROR3("Failed to get bitmap bits"); DeleteDC(hDCScreen); DeleteDC(hDCCompatible); DeleteObject(hBMScreen); delete lpScreenInfo; CCFree((LPVOID)lpScreenBits); return FALSE; } // quick sanity check if (lpBitmapInfo == NULL) ERROR3("What the *?!& is going on with my bitmaps!?"); GDrawContext *GDC = GetDrawContext(); // convert it to 32bit, using the already allocated bitmap and bitmapinfo INT32 result = 0; if (ScreenDepth == 8) { SetPaletteEntries(lpScreenInfo); /*result = DIBUtil::Convert8to32(lpScreenInfo, lpScreenBits, lpScreenInfo->bmiColors, lpBitmapInfo, lpBits); INT32 result = GDC->ConvertBitmap(&(lpBitmapInfo->bmiHeader), lpBits, &(lpScreenInfo->bmiHeader), lpScreenBits, DitherStyle8Bit); */ /* GDC->SetChangedBBox(&Rect); BitmapDepth = 8; DisplayBits(); BitmapDepth = 32; */ /* INT32 res = SetDIBitsToDevice( hDCScreen, 0, Rect.top, ViewWidth, ViewHeight, 0, 0, // lower left of DIB (upside down) 0, ViewHeight, // actual bitmap height in entirety lpScreenBits, lpScreenInfo, DIB_RGB_COLORS); */ result = DIBUtil::Convert8to32(lpScreenInfo, lpScreenBits, lpScreenInfo->bmiColors, lpBitmapInfo, lpBits); } if (ScreenDepth == 16) { RGBQUAD* pPalette = lpScreenInfo->bmiColors; result = Convert16to32(lpScreenInfo, lpScreenBits, pPalette, lpBitmapInfo, lpBits); SetupMainBitmap(); /* Test code for figuring out the bitmap shearing problem GDrawContext *GDC = GetDrawContext(); INT32 ColourFlag = DIB_RGB_COLORS; INT32 result = GDC->ConvertBitmap(&(lpBitmapInfo->bmiHeader), lpBits, &(lpScreenInfo->bmiHeader), lpScreenBits, DitherStyle8Bit); PatBlt( hDCScreen, 0, Rect.top, ViewWidth, ViewHeight, BLACKNESS ); // blit the post-converted bitmap INT32 res = SetDIBitsToDevice( hDCScreen, 0, Rect.top, ViewWidth, ViewHeight, 0, 0, // lower left of DIB (upside down) 0, ViewHeight, // actual bitmap height in entirety lpScreenBits, lpScreenInfo, DIB_RGB_COLORS); TRACEUSER( "Diccon", _T("Blitted post-converted bitmap\n")); */ } if (ScreenDepth == 24) { result = GDC->ConvertBitmap(&(lpScreenInfo->bmiHeader), lpScreenBits, &(lpBitmapInfo->bmiHeader), lpBits, DitherStyle8Bit); } if (ScreenDepth == 32) { // blit the post-converted bitmap /* INT32 res = SetDIBitsToDevice( hDCScreen, 0, Rect.top, ViewWidth, ViewHeight, 0, 0, // lower left of DIB (upside down) 0, ViewHeight, // actual bitmap height in entirety lpScreenBits, lpScreenInfo, DIB_RGB_COLORS); */ FreeLPBits(lpBitmapInfo, lpBits); lpBitmapInfo = lpScreenInfo; lpBits = lpScreenBits; lpScreenInfo = NULL; lpScreenBits = NULL; } // Update the master capture Capture* pMasterCapture = GetMasterCapture(); pMasterCapture->lpBitmapInfo = lpBitmapInfo; pMasterCapture->lpBits = lpBits; // free up all that lovely memory and stuff DeleteDC(hDCScreen); DeleteDC(hDCCompatible); DeleteObject(hBMScreen); if (lpScreenBits != NULL) FreeLPBits(lpScreenInfo, lpScreenBits); lpScreenInfo = NULL; lpScreenBits = NULL; if (hPrevPalette) PaletteManager::StopPaintPalette(hDCScreen, hPrevPalette); if (result == -1) { ERROR3("Failed to convert bitmap"); return FALSE; } else return TRUE; }

BOOL GRenderBrush::CaptureViewByRendering (   )  [protected]

Renders the view into this render region. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 2/6/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if successful, FALSE otherwise Notes: Due to the ongoing palette problems capturing the view from the screen in 8-bit mode this will serve to capture the background for the time being. Obviously it is not ideal as rendering the view can be very slow. Definition at line 1355 of file grndbrsh.cpp. { // first things first, we need the view, docview and spread DocView* pDocView = DocView::GetCurrent(); View* pView = View::GetCurrent(); Spread* pSpread = Document::GetSelectedSpread(); Document* pDoc = Document::GetCurrent(); if (pSpread == NULL || pDocView == NULL || pView == NULL || pDoc == NULL) { ERROR3("Invalid entry conditions to GRenderBrush::CaptureViewByRendering"); return FALSE; } ERROR3IF(!MasterCaptureIsCurrent() && GetCaptureDepth()>0, "Can't 'CaptureView' while Captures are running"); // Convert our window rect to doccoords because the concurrent render needs it WinRect WinRect(WRect.left, WRect.top, WRect.right, WRect.bottom); OilRect ORect = WinRect.ToOil(pView); DocRect ViewRect = ORect.ToDoc(pSpread, pView); pSpread->DocCoordToSpreadCoord(&ViewRect); // Setup a concurrent renderer. ConcurrentRenderer* pRendWrap = NULL; // The last argument to this call is a little odd, basically for some reason under a // 16bpp display the background paper is rendered incorrectly if our bitmap // gets initialised in GRenderRegion::InitBmpBits. Therefore we ask for it to // not be transparent, (although it is actually transparent, being 32 bit). pRendWrap = GRenderRegionWrapper::GetConcurrentRenderer(this, 1.0, ViewRect, 32, FALSE); if (pRendWrap == NULL) return FALSE; GRenderRegion* pOffscreenRR = pRendWrap->GetRenderRegion(); // we're saving the context for paranoia's sake, and 'cos it doesn't hurt. pOffscreenRR->SaveContext(); // ConcurrentRenderer created, now we need to render the entire view into it pDocView->RenderEntireView(pOffscreenRR, pSpread); // restore the context. pOffscreenRR->RestoreContext(); // extract the bitmap from the offscreen RR before the RR is closed down, // this is somewhat labourious KernelBitmap * pBitmap = pRendWrap->GetKernelBitmap(); if (pBitmap == NULL) { ERROR3("Bitmap is NULL in GRenderBrush::CaptureViewByRendering"); delete pOffscreenRR; return FALSE; } WinBitmap* pWinBitmap = (WinBitmap*)pBitmap->GetActualBitmap(); if (pWinBitmap == NULL) { ERROR3("Bitmap is NULL in GRenderBrush::CaptureViewByRendering"); delete pOffscreenRR; delete pBitmap; return FALSE; } LPBYTE pBits = NULL; //(LPBYTE)pWinBitmap->GetBitmapBits(); LPBITMAPINFO pBitmapInfo = NULL; //pWinBitmap->GetBitmapInfo(); pWinBitmap->ExtractBitsAndInfo(&pBits, &pBitmapInfo); if (pBits == NULL || pBitmapInfo == NULL) { ERROR3("Bitmap is NULL in GRenderBrush::CaptureViewByRendering"); delete pOffscreenRR; delete pBitmap; delete pWinBitmap; return FALSE; } // now delete our existing bitmap and assign the new on if (lpBitmapInfo!=NULL && lpBits != NULL) { FreeLPBits(lpBitmapInfo, lpBits); lpBitmapInfo = NULL; lpBits = NULL; } lpBits = pBits; lpBitmapInfo = pBitmapInfo; // Update the master capture Capture* pMasterCapture = GetMasterCapture(); pMasterCapture->lpBitmapInfo = lpBitmapInfo; pMasterCapture->lpBits = lpBits; // delete our bitmap container delete pBitmap; // restore gdraw pRendWrap->RestorePreviousRendererState(); return TRUE; }

BOOL GRenderBrush::ClipBrushBitmaps (  RECT *  pUsedRect, INT32 *  pHeight )  [protected]

When we come to blit at the edge of the view we will end up access violating if we simply proceed regardless. This function checks to see how close we are to the edge and 'pretends' that the bitmap is only big enough to go up up to the edge and not beyond. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 29/10/99 Parameters: pUsedRect  - the screen RECT that we are about to blit [INPUTS] pHeight  - pointer to an INT32 representing the new height of the bitmap, or rather [OUTPUTS] the maximum height that we will blit. Returns: TRUE if successful, FALSE if input params are wrong Definition at line 583 of file grndbrsh.cpp. { // first get the size of the big bitmap INT32 ViewWidth = WRect.right - WRect.left; INT32 ViewHeight= WRect.bottom - WRect.top; // if we've gone off the screen then just return now if (pUsedRect->top >= ViewHeight || pUsedRect->bottom <= 0 || pUsedRect->left >= ViewWidth || pUsedRect->right <= 0) return FALSE; INT32 TopAdjust = 0; INT32 BottomAdjust = 0; // otherwise clip the offscreen area if (pUsedRect->bottom > ViewHeight) { BottomAdjust = pUsedRect->bottom - ViewHeight; pUsedRect->bottom = ViewHeight; } if (pUsedRect->top < 0) { TopAdjust = pUsedRect->top; pUsedRect->top = 0; } if (pUsedRect->right > ViewWidth) pUsedRect->right = ViewWidth; if ( pUsedRect->left < 0) pUsedRect->left = 0; INT32 SourceY = ViewHeight - pUsedRect->bottom; // TRACEUSER( "Diccon", _T("Top = %d, SourceY = %d\n"), pUsedRect->top, SourceY); // going off the top of the screen is a bit of a special case for some reason if (SourceY + *pHeight >= ViewHeight) { //TRACEUSER( "Diccon", _T("SourceY = %d, Height = %d\n"), SourceY, Height); // Adjust the height of the bitmaps, we need to do the post-convert one as well // or else the convert will fail INT32 Adjuster = (ViewHeight - (SourceY+*pHeight)); TRACEUSER( "Diccon", _T("Adjust = %d\n"), Adjuster); *pHeight += Adjuster; lpPreConvertBrushBitmapInfo->bmiHeader.biHeight = *pHeight; lpPostConvertBrushBitmapInfo->bmiHeader.biHeight = *pHeight; // TRACEUSER( "Diccon", _T("Height = %d\n"), *pHeight); //TRACEUSER( "Diccon", _T("SourceY = %d\n"), SourceY); } else if (TopAdjust != 0) { *pHeight -= TopAdjust; lpPreConvertBrushBitmapInfo->bmiHeader.biHeight = *pHeight; lpPostConvertBrushBitmapInfo->bmiHeader.biHeight = *pHeight; } else if (BottomAdjust != 0) { *pHeight -= BottomAdjust; lpPreConvertBrushBitmapInfo->bmiHeader.biHeight = *pHeight; lpPostConvertBrushBitmapInfo->bmiHeader.biHeight = *pHeight; } return TRUE; }

BOOL GRenderBrush::Convert16to32 (  LPBITMAPINFO  pSourceInfo, LPBYTE  pSourceBits, RGBQUAD *  pPalette, LPBITMAPINFO  pDestInfo, LPBYTE  pDestBits )  [static]

Definition at line 1510 of file grndbrsh.cpp. { ERROR2IF(pSourceBits == NULL, FALSE, "NULL source bitmap"); ERROR2IF(pSourceInfo == NULL, FALSE, "NULL source info"); ERROR2IF(pDestInfo == NULL, FALSE, "NULL destination info"); ERROR2IF(pDestBits == NULL, FALSE, "Null destination bitmap"); // most info will be the same so memcpy is the quickest way //memcpy(pSourceInfo, pDestInfo, sizeof(BITMAPINFO)); // these will all be the same pDestInfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER); pDestInfo->bmiHeader.biWidth = pSourceInfo->bmiHeader.biWidth; pDestInfo->bmiHeader.biHeight = pSourceInfo->bmiHeader.biHeight; pDestInfo->bmiHeader.biPlanes = pSourceInfo->bmiHeader.biPlanes; pDestInfo->bmiHeader.biCompression = pSourceInfo->bmiHeader.biCompression; pDestInfo->bmiHeader.biXPelsPerMeter = pSourceInfo->bmiHeader.biXPelsPerMeter; pDestInfo->bmiHeader.biYPelsPerMeter = pSourceInfo->bmiHeader.biYPelsPerMeter; pDestInfo->bmiHeader.biClrImportant = 0; // get the size of the new bitmap INT32 size = pDestInfo->bmiHeader.biWidth * pDestInfo->bmiHeader.biHeight * 4; //these will be different from source pDestInfo->bmiHeader.biBitCount = 32; pDestInfo->bmiHeader.biSizeImage = size; pDestInfo->bmiHeader.biClrUsed = 0; // convert from 16 bit to 32 bit INT32 bmpsize = pSourceInfo->bmiHeader.biWidth * pSourceInfo->bmiHeader.biHeight; // we need some padding just in case we are not DWORD aligned INT32 padding = pSourceInfo->bmiHeader.biWidth % 2; if (padding) padding = 2 - padding; LPBYTE pSourceEnd = pSourceBits; LPBYTE pDestEnd = pDestBits; for (INT32 j = 0; j < bmpsize; j++) { pSourceEnd++; pDestEnd++; } LPWORD pSource = (LPWORD)pSourceBits; LPBYTE pDest = pDestBits; for (INT32 i = 0; i < bmpsize; i ++) { if (i && i % pSourceInfo->bmiHeader.biWidth == 0) pSource += padding; const WORD Data = *pSource; const BYTE Blue = Data & 0x1F; *pDest++ = EXPAND(Blue); const BYTE Green = (Data>>5) & 0x1F; *pDest++ = EXPAND(Green); const BYTE Red = (Data>>10) & 0x1F; *pDest++ = EXPAND(Red); *pDest = 0; pDest++; // *pSource +=1; pSource++; } return TRUE; }

BOOL GRenderBrush::ConvertBrushBitmap (   )  [protected]

Takes the contents of lppreconvertbrushbits which will be 32BPP, and calls GDraw to convert the contents and put it into lppostconvertbrushbits which has the same BPP as the screen. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 29/10/99 Parameters: [INPUTS]  [OUTPUTS]  Returns: TRUE if successful, FALSE otherwise Definition at line 719 of file grndbrsh.cpp. { if (lpPreConvertBrushBitmapInfo == NULL || lpPreConvertBrushBits == NULL || lpPostConvertBrushBitmapInfo == NULL || lpPostConvertBrushBits == NULL) { ERROR3("Bitmaps not initialised"); return FALSE; } GDrawContext *GDC = GetDrawContext(); INT32 ColourFlag = DIB_RGB_COLORS; INT32 result = GDC->ConvertBitmap(&(lpPreConvertBrushBitmapInfo->bmiHeader), lpPreConvertBrushBits, &(lpPostConvertBrushBitmapInfo->bmiHeader), lpPostConvertBrushBits, DitherStyle8Bit); // 16 bit bmps don't like having their palette entries set. if (ScreenDepth == 8) ColourFlag = SetPaletteEntries(lpPostConvertBrushBitmapInfo, RenderDC); else ColourFlag = DIB_RGB_COLORS; if (result == -1) { ERROR3("Failed to convert bitmap"); return FALSE; } return TRUE; }

void GRenderBrush::DrawToScreenNow (   )

This is a bit of a bodge function so that we could get the brush to draw itself to the screen ASAP. It bypasses all the regular rendering rubbish and gets straight down to blitting. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 29/10/99 Parameters: [INPUTS]  [OUTPUTS]  Definition at line 239 of file grndbrsh.cpp. { // this fn. basically blits to the screen, so we need to know, where on the source bitmap // we take our data, where on the destination bitmap we put it, and what size chunk we move INT32 DestX = WRect.GetLeft(); INT32 DestY = WRect.GetTop(); INT32 ViewWidth = WRect.GetWidth(); INT32 ViewHeight= WRect.GetHeight(); INT32 Width = 0; INT32 Height = 0; INT32 SourceX = WRect.GetLeft(); INT32 SourceY = WRect.GetTop(); // if ChangedBBox is set then we don't have to blit so much RECT UsedRect; if (GetDrawContext()->GetChangedBBox( &UsedRect )) { if ((UsedRect.right < UsedRect.left) || (UsedRect.bottom< UsedRect.top )) { // Changed box is illegal so exit return; } else { View* pView = NULL; CCamView* pCCamView = NULL; PORTNOTE("other", "Disable HDC stuff") #ifndef EXCLUDE_FROM_XARALX CDC* pDevContext = NULL; HDC DeviceHdc = NULL; #endif // find out about our device if (m_pView) pView = m_pView; else m_pView = View::GetCurrent(); if (m_pCCamView) pCCamView = m_pCCamView; else pCCamView = pView->GetConnectionToOilView(); PORTNOTE("other", "Disable HDC stuff") #ifndef EXCLUDE_FROM_XARALX if (m_pDevContext) pDevContext = m_pDevContext; else pDevContext = ((ScreenCamView*)pCCamView)->GetRenderDC(); if (m_DeviceHdc) DeviceHdc = m_DeviceHdc; else DeviceHdc = pDevContext->GetSafeHdc(); #endif if (ScreenDepth < 24) { INT32 OldHeight = -1; OldHeight = lpPreConvertBrushBitmapInfo->bmiHeader.biHeight; Width = UsedRect.right - UsedRect.left; Height = UsedRect.bottom - UsedRect.top; if (!ClipBrushBitmaps(&UsedRect, &Height)) return; SourceX = UsedRect.left; DestX = UsedRect.left; DestY = UsedRect.top; // bit of a hack because DIBs are stored upside down SourceY = ViewHeight - UsedRect.bottom; if (Height > 0) { // copy from the big bitmap to the small brush bitmap if (!DIBUtil::CopyBitmapSection(pBitmapInfo, pBits, lpPreConvertBrushBitmapInfo, lpPreConvertBrushBits, SourceY, SourceX)) { ERROR3("Failed to copy bitmap section"); return; } // convert it to screen depth ConvertBrushBitmap(); if (ScreenDepth == 8) SetPaletteEntries(lpPostConvertBrushBitmapInfo, RenderDC); // blit the post-converted bitmap INT32 res = SetDIBitsToDevice( DeviceHdc, /*RenderDC->m_hDC,*/ //hDCScreen, DestX , DestY, Width, Height, 0, 0, // lower left of DIB (upside down) 0, Height, // actual bitmap height in entirety lpPostConvertBrushBits, lpPostConvertBrushBitmapInfo, DIB_RGB_COLORS); /* TestConvertBitmap(); INT32 res = SetDIBitsToDevice( RenderDC->m_hDC, 0, ViewHeight, ViewWidth, ViewHeight, 0, 0, // lower left of DIB (upside down) 0, ViewHeight, // actual bitmap height in entirety lpTestBits, lpTestInfo, DIB_RGB_COLORS); */ if (!res) { TRACEUSER( "Diccon", _T("SetDIB Failed. DestY = %d, Height = %d\n"), DestY, Height); //ERROR3("SetDIB failed in GRenderRegion::DrawToScreenNow"); DWORD error = GetLastError(); TRACEUSER( "Diccon", _T("Failed to set Bits in DrawToScreen Now, Error %d\n"), error); } } else TRACEUSER( "Diccon", _T("SetDIB Failed. DestY = %d, Height = %d\n"), DestY, Height); // restore the old height //if (OldHeight != -1) lpPreConvertBrushBitmapInfo->bmiHeader.biHeight = OldHeight; lpPostConvertBrushBitmapInfo->bmiHeader.biHeight = OldHeight; return; } else { //we don't need to convert, just call the win32 function SourceX += UsedRect.left; DestX += UsedRect.left; SourceY += UsedRect.top; DestY += UsedRect.top; Width = UsedRect.right - UsedRect.left; Height = UsedRect.bottom - UsedRect.top; DWORD *rgb = (DWORD *)lpBitmapInfo->bmiColors ; *rgb++ = 0x00ff0000 ; *rgb++ = 0x0000ff00 ; *rgb++ = 0x000000ff ; CanDoDeepDIBs = TRUE; const UINT32 TotalHeight = (UINT32)lpBitmapInfo->bmiHeader.biHeight; // height of complete DIB const INT32 DIBSourceY = TotalHeight - (Height + SourceY); INT32 res = SetDIBitsToDevice( DeviceHdc, DestX, DestY, Width, Height, SourceX, DIBSourceY, // lower left of DIB (upside down) 0, TotalHeight, // actual bitmap height in entirety lpBits, lpBitmapInfo, DIB_RGB_COLORS); if (res == 0) { TRACEUSER( "Diccon", _T("SetDIB Failed. DestY = %d, Height = %d\n"), DestY, Height); //ERROR3("SetDIB failed in GRenderRegion::DrawToScreenNow"); DWORD error = GetLastError(); TRACEUSER( "Diccon", _T("Failed to set Bits in DrawToScreen Now, Error %d\n"), error); } #if 0 static DWORD startCount = 0; static INT32 fps = 0; if (startCount != 0) { if ((GetTickCount () - startCount) <= 100) { fps++; } else { TRACEUSER( "ChrisS", _T("%i, "), fps); //TextOut (DeviceHdc, 0, 0, data, camStrlen (data)); startCount = 0; fps = 0; } } else { startCount = GetTickCount (); } /*RECT bounds; bounds.left = DestX; bounds.top = DestY; bounds.right = DestX + Width; bounds.bottom = DestY + Height; FrameRect (DeviceHdc, &bounds, (HBRUSH) GetStockObject (BLACK_BRUSH));*/ #endif // PlotBitmap( RenderDC->m_hDC, DIB_RGB_COLORS, lpBitmapInfo, lpBits, DestX, DestY, // Width, Height, hPalette, SourceX, SourceY ); } // DeleteDC(hDCScreen); } } }

void GRenderBrush::FreeLPBits (  LPBITMAPINFO  lpBMI, LPBYTE  lpB )  [protected, virtual]

Frees up a bitmap allocated with GetLPBits. Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 2/6/94 Parameters: Bitmap  characteristics. [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: GRenderDIB::FreeLPBits Reimplemented from GRenderDIB. Definition at line 1478 of file grndbrsh.cpp. { // If we are banded, then free the memory from the limited heap FreeDIB(lpBMI, lpB, NULL, FALSE); }

BOOL GRenderBrush::GetBits (  HDC  hDC, HBITMAP  hBitmap, INT32  Height, LPBYTE  lpbits, LPBITMAPINFO  lpInfo )  [protected]

Definition at line 1311 of file grndbrsh.cpp. { // now get the DIBits INT32 num = (GetDIBits(hMemDC, hBitmap, 0, Height, lpBits, lpInfo, DIB_RGB_COLORS)); return (num != 0); }

UINT32 GRenderBrush::GetScreenDepth (   )  [inline]

Definition at line 173 of file grndbrsh.h. { return (UINT32)ScreenDepth; }

BOOL GRenderBrush::InitialiseBrushBitmaps (  INT32  Width, INT32  Height, INT32  RenderDepth, INT32  DeviceDepth )  [protected]

allocates bitmaps of the correct size, depth etc. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 29/10/99 Parameters: Width  = width of the brush object in pixels [INPUTS] Height - height of the brush object in pixels RenderDepth - required BPP of the bitmap (no reason for this to be < 32) DeviceDepth - BPP of the device we are drawing to [OUTPUTS]  Returns: TRUE if successful, FALSE if we fail (most likely memory) Definition at line 504 of file grndbrsh.cpp. { // quick check if (Width <=0 || Height <= 0) { ERROR3("illegal height or width value"); return FALSE; } // TRACE( _T("Initialising brush bitmaps\n")); // if the bitmaps already exist then delete them if ((lpPreConvertBrushBits != NULL) && (lpPreConvertBrushBitmapInfo != NULL)) FreeLPBits(lpPreConvertBrushBitmapInfo, lpPreConvertBrushBits); if ((lpPostConvertBrushBits != NULL) && (lpPostConvertBrushBitmapInfo != NULL)) FreeLPBits(lpPostConvertBrushBitmapInfo, lpPostConvertBrushBits); // get the pre-conversion bitmap lpPreConvertBrushBitmapInfo = GetLPBits(Width, Height, RenderDepth, &lpPreConvertBrushBits); if (lpPreConvertBrushBitmapInfo == NULL) { ERROR3("Unable to allocate pre-convert bitmap"); return FALSE; } // TRACEUSER( "Diccon", _T("Allocated bitmapinfo: 0x%x, bitmap: 0x%x\n"),lpPreConvertBrushBitmapInfo, lpPreConvertBrushBits); // get the post-conversion bitmap lpPostConvertBrushBitmapInfo = GetLPBits(Width, Height, DeviceDepth, &lpPostConvertBrushBits); if (lpPostConvertBrushBitmapInfo == NULL) { ERROR3("Unable to allocate post-convert bitmap"); return FALSE; } // TRACEUSER( "Diccon", _T("Allocated bitmapinfo: 0x%x, bitmap: 0x%x\n"),lpPostConvertBrushBitmapInfo, lpPostConvertBrushBits); // we're not using the brush bitmap any more /* lpBrushBitmapInfo = GetLPBits(Width, Height, RenderDepth, &lpBrushBits); if (lpBrushBitmapInfo == NULL) { ERROR3("Unable to allocate post-convert bitmap"); return FALSE; } */ // get the palette LPRGBQUAD pSourcePalette = &(lpBitmapInfo->bmiColors[0]); LPRGBQUAD pDestPalette = &(lpPreConvertBrushBitmapInfo->bmiColors[0]); if (!DIBUtil::CopyPalette(pSourcePalette, pDestPalette, lpBitmapInfo->bmiHeader.biClrUsed)) { ERROR3("Failed to copy palette"); FreeLPBits(lpPreConvertBrushBitmapInfo, lpPreConvertBrushBits); FreeLPBits(lpPostConvertBrushBitmapInfo, lpPostConvertBrushBits); return FALSE; } return TRUE; }

BOOL GRenderBrush::InitialiseBrushBitmaps (  DocRect  BrushRect  )

Public interface to the initialisation function, you only need to pass in the size of the brush and the rest is taken care of for you. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 29/10/99 Parameters: BrushRect  - the size of the brush [INPUTS] [OUTPUTS]  Returnd: TRUE if successful, FALSE otherwise Definition at line 467 of file grndbrsh.cpp. { if (BrushRect.IsEmpty()) { ERROR3("Rect is empty"); return FALSE; } RECT WinRect = OSRenderRegion::DocRectToWin(RenderMatrix, BrushRect, PixelsPerInch); INT32 Height = WinRect.bottom - WinRect.top; INT32 Width = WinRect.right - WinRect.left; INT32 RenderDepth = 32; INT32 DeviceDepth = ScreenDepth; return InitialiseBrushBitmaps(Width, Height, RenderDepth, DeviceDepth); }

BOOL GRenderBrush::MoveWindowToFront (   )

Definition at line 905 of file grndbrsh.cpp. { // move our main frame to the front CMainFrame* pMainFrame = GetMainFrame(); ERROR2IF(pMainFrame == NULL, FALSE, "Wheres our mainframe gone!!??"); HWND OurHWnd = pMainFrame->GetSafeHwnd(); SetWindowPos(OurHWnd, HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE); CWnd* pFirst = pMainFrame->GetWindow(GW_HWNDFIRST); HWND HWFirst = pFirst->GetSafeHwnd(); // there may be a window on top of us, check to see. // Basically we check downwards from the Desktop windo checking to see if there // is an on top window, if so we minimize it, unless it is the taskbar CWnd* pNextWnd = pFirst; UINT32 Counter = 0; HWND hTaskBar = FindWindow("Shell_TrayWnd", NULL); CWnd* pLast = pNextWnd; while (pNextWnd != NULL) { pLast = NULL; if (pNextWnd->GetExStyle() & WS_EX_TOPMOST) { if (pNextWnd->IsWindowVisible() && (pNextWnd->GetSafeHwnd() != hTaskBar)) { Counter++; pLast = pNextWnd; } } pNextWnd = pNextWnd->GetNextWindow(); // if (pLast != NULL) // pLast->ShowWindow(SW_MINIMIZE); } pMainFrame->SetActiveWindow(); pMainFrame->UpdateWindow(); // TRACEUSER( "Diccon", _T("Found %d on top windows\n"), Counter); if (Counter == 0) return TRUE; return FALSE; }

BOOL GRenderBrush::PlotBrushIntoBigBitmap (  DocRect  BrushRect  )

Plots the brush bitmap into the view bitmap, just like rendering really but quicker. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 29/10/99 Parameters: BrushRect  - the location in the view where we wish to plot the brush [INPUTS] [OUTPUTS]  Returnd: TRUE if successful, FALSE otherwise Definition at line 663 of file grndbrsh.cpp. { if (BrushRect.IsEmpty()) { ERROR3("Brush rect is empty"); return FALSE; } if (lpBitmapInfo == NULL || lpBits == NULL || lpBrushBitmapInfo == NULL || lpBrushBits == NULL) { ERROR3("Bitmaps not initialised"); return FALSE; } INT32 PixelSize = CalcPixelWidth(); // Get the Bitmap width and height in Millipoints INT32 Width = lpBrushBitmapInfo->bmiHeader.biWidth * PixelSize; INT32 Height = lpBrushBitmapInfo->bmiHeader.biHeight * PixelSize; POINT Plot[3]; Plot[0].x = BrushRect.lox; Plot[0].y = BrushRect.loy; Plot[1].x = BrushRect.lox + Width; Plot[1].y = BrushRect.loy; Plot[2].x = BrushRect.lox; Plot[2].y = BrushRect.loy + Height; INT32 Style = 1; LPRGBQUAD pRGB = &(lpBitmapInfo->bmiColors[0]); if (!GetDrawContext()->PlotBitmap(&(lpBrushBitmapInfo->bmiHeader), lpBrushBits, Style, Plot, pRGB, NULL, NULL, NULL, NoTransTable)) { ERROR3("Failed to plot bitmap"); return FALSE; } return TRUE; }

BOOL GRenderBrush::ResetMatrix (   )

Definition at line 952 of file grndbrsh.cpp. { View* pView = View::GetCurrent(); Spread* pSpread = Document::GetSelectedSpread(); if (pSpread != NULL) { Matrix RenderMat = pView->ConstructRenderingMatrix(pSpread); GMATRIX GMat; GMat = MakeGavinMatrix(RenderMat, CurrentClipRect, PixelsPerInch, FALSE); SetGavinMatrix(&GMat); } return TRUE; }

virtual void GRenderBrush::RestoreOffscreen (  OffscreenAttrValue *   )  [inline, virtual]

Reimplemented from GRenderRegion. Definition at line 200 of file grndbrsh.h. {}

void GRenderBrush::SetCamView (  CCamView *  v  )  [inline]

Definition at line 207 of file grndbrsh.h. { m_pCCamView = v; }

void GRenderBrush::SetCDC (  CDC *  cdc  )  [inline]

Definition at line 210 of file grndbrsh.h. { m_pDevContext = cdc; }

void GRenderBrush::SetChangedBBox (  DocRect  Rect  )

For some reason when drawing brush steps into a render region there was a problem with having the bbox set itself, so this is a way to do it manually. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 29/10/99 Parameters: Rect  - the area to specify as changed [INPUTS] [OUTPUTS]  Definition at line 1604 of file grndbrsh.cpp. { RECT WinRect = OSRenderRegion::DocRectToWin(RenderMatrix, Rect, PixelsPerInch); GetDrawContext()->SetChangedBBox(&WinRect); }

void GRenderBrush::SetHDC (  HDC  hdc  )  [inline]

Definition at line 211 of file grndbrsh.h. { m_DeviceHdc = hdc; }

virtual void GRenderBrush::SetOffscreen (  OffscreenAttrValue *   )  [inline, virtual]

Create a new bitmap into which, the subtree rooted at this attributes parent, will be rendered. Then call base version to push the current OffscreenAttr onto the context stack. Following only used by GRenderRegion version ** info pointer to bmp info struct which we will setup. bits pointer to bitmap bits which we'll setup. See also: GRenderRegion::RestoreOffscreen; GRenderRegion:: Reimplemented from GRenderRegion. Definition at line 199 of file grndbrsh.h. {}

void GRenderBrush::SetupBitmap (  LPBITMAPINFO  pBitmapInfo, LPBYTE  pBits )  [protected]

Similar to GRenderRegion;;StartRender, initialises the bitmap for GDraw to render into it. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 29/10/99 Parameters: pBitmapInfo  - info of the bitmap to be set up [INPUTS] pBits - pointer to the bits [OUTPUTS]  Definition at line 819 of file grndbrsh.cpp. { if (pBitmapInfo == NULL || pBits == NULL) { ERROR3("invalid parameters passed into GRenderBrush::SetupBitmap"); return; } // Determine the correct hinting value for the current output mode, and call gavin to // set up his offscreen bitmap. /* DWORD GavinHint = DIBUtil::GetGavinBlitFormat(ScreenDepth, BitmapDepth, ScreenHinting); //TRACEUSER( "Diccon", _T("About to setup bitmap\n")); GetDrawContext()->SetupBitmapNoInitialise( pBitmapInfo->bmiHeader.biWidth, pBitmapInfo->bmiHeader.biHeight, pBitmapInfo->bmiHeader.biBitCount, pBits, GavinHint, m_DoCompression ); */ GetDrawContext()->SetBitmap( &pBitmapInfo->bmiHeader, pBits ); // TRACEUSER( "Diccon", _T("Bitmap Setup OK\n")); if (RenderDC != NULL) { if (ScreenDepth == 8) { // use frame windows palette if desired if (PaletteManager::UsePalette()) hPalette = *(PaletteManager::GetPalette()); } if (hPalette != NULL) hPrevPalette = PaletteManager::StartPaintPalette(RenderDC->m_hDC); if (BitmapDepth == 8) { // If we are not error diffusing then set the dither style if ((DitherStyle8Bit != 0) && (DitherStyle8Bit != 3)) GetDrawContext()->SetDitherStyle((DitherStyle) DitherStyle8Bit); // Stupid prototype } if (ScreenDepth == 8) { // Whether we set a palette or not, we need this call on all 8-bit screens GRenderRegion::GColInit(RenderDC->m_hDC); } } // Work out our matrix and set it ResetMatrix(); Spread* pSpread = Document::GetSelectedSpread(); if (pSpread != NULL) { // get the bounding rect of the view and set it as the clip rect DocView* pDocView = DocView::GetCurrent(); DocRect ViewRect = pDocView->GetDocViewRect(pSpread); pSpread->DocCoordToSpreadCoord(&ViewRect); RECT WinRect = OSRenderRegion::DocRectToWin(RenderMatrix, ViewRect, PixelsPerInch); GetDrawContext()->DeviceClipRectangle(&WinRect); } // setup code borrowed from StartRender // set up anti-aliasing & flatness, using the SetQualityLevel function SetQualityLevel(); GetDrawContext()->SetHintingFlag(TRUE); // Always hint lines!!! GetDrawContext()->SetDashAdjustmentFlag(FALSE); // work out the brush alignment // algorithm based on code from OSRenderRegion::InitAttributes POINT DocOrigin, OSOrigin; DocOrigin.x = 0; DocOrigin.y = 0; // Then we transform it into OSCoords GetDrawContext()->TransformPath( &DocOrigin, &OSOrigin, 1, &CurrentGMatrix ); // Once we've shifted then right by FX, they're in pixel co-ords, which is what // SetHalftoneOrigin is expecting them to be in const INT32 BrushX = OSOrigin.x >> FX; const INT32 BrushY = -(OSOrigin.y >> FX); // has to be negated to work GetDrawContext()->SetHalftoneOrigin( BrushX, BrushY ); }

void GRenderBrush::SetupMainBitmap (   )

Public interface which sets up our main bitmap for GDraw to use. Note that the compression flag must be set to false or else things go wrong. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 29/10/99 Parameters: [INPUTS]  [OUTPUTS]  Definition at line 791 of file grndbrsh.cpp. { if (lpBitmapInfo == NULL || lpBits == NULL) { ERROR3("Bitmaps are unititialised in GRenderBrush::SetupMainBitmap"); return; } // we need to make sure the compression flag is off lpBitmapInfo->bmiHeader.biCompression = 0; SetupBitmap(lpBitmapInfo, lpBits); }

void GRenderBrush::SetView (  View *  v  )  [inline]

Definition at line 206 of file grndbrsh.h. { m_pView = v; }

BOOL GRenderBrush::TestConvertBitmap (   )  [protected]

Definition at line 749 of file grndbrsh.cpp. { if (lpTestInfo == NULL || lpTestBits == NULL || lpBitmapInfo == NULL || lpBits == NULL) { ERROR3("bitmaps not initialised"); return FALSE; } GDrawContext *GDC = GetDrawContext(); INT32 ColourFlag = DIB_RGB_COLORS; INT32 result = GDC->ConvertBitmap(&(lpBitmapInfo->bmiHeader), lpBits, &(lpTestInfo->bmiHeader), lpTestBits, DitherStyle8Bit); if (result == -1) { ERROR3("Failed to convert bitmap"); return FALSE; } return TRUE; }

---

Member Data Documentation

LPBITMAPINFO GRenderBrush::lpBrushBitmapInfo [protected]

Definition at line 221 of file grndbrsh.h.

LPBYTE GRenderBrush::lpBrushBits [protected]

Definition at line 222 of file grndbrsh.h.

LPBITMAPINFO GRenderBrush::lpPostConvertBrushBitmapInfo [protected]

Definition at line 219 of file grndbrsh.h.

LPBYTE GRenderBrush::lpPostConvertBrushBits [protected]

Definition at line 220 of file grndbrsh.h.

LPBITMAPINFO GRenderBrush::lpPreConvertBrushBitmapInfo [protected]

Definition at line 217 of file grndbrsh.h.

LPBYTE GRenderBrush::lpPreConvertBrushBits [protected]

Definition at line 218 of file grndbrsh.h.

LPBYTE GRenderBrush::lpTestBits [protected]

Definition at line 225 of file grndbrsh.h.

LPBITMAPINFO GRenderBrush::lpTestInfo [protected]

Definition at line 224 of file grndbrsh.h.

HDC GRenderBrush::m_DeviceHdc [protected]

Definition at line 238 of file grndbrsh.h.

CCamView* GRenderBrush::m_pCCamView [protected]

Definition at line 234 of file grndbrsh.h.

CDC* GRenderBrush::m_pDevContext [protected]

Definition at line 237 of file grndbrsh.h.

RGBQUAD* GRenderBrush::m_pPalette [protected]

Definition at line 227 of file grndbrsh.h.

View* GRenderBrush::m_pView [protected]

Definition at line 233 of file grndbrsh.h.

---

The documentation for this class was generated from the following files:

• wxOil/grndbrsh.h (r1785/r1755)
• wxOil/grndbrsh.cpp (r1785/r1755)

---