|
|
//
// GROBJ.CPP
// Graphic Objects
//
// Copyright Microsoft 1998-
//
// PRECOMP
#include "precomp.h"
#define DECIMAL_PRECISION 10000
//
// Local macros
//
#define min4(x1,x2,x3,x4) min((min((x1),(x2))),(min((x3),(x4))))
#define max4(x1,x2,x3,x4) max((max((x1),(x2))),(max((x3),(x4))))
//
// CircleHit()
//
// Checks for overlap between circle at PcxPcy with uRadius and
// lpHitRect. If overlap TRUE is returned, otherwise FALSE.
//
BOOL CircleHit( LONG Pcx, LONG Pcy, UINT uRadius, LPCRECT lpHitRect, BOOL bCheckPt ){ RECT hr = *lpHitRect; RECT ellipse; ellipse.left = Pcx - uRadius; ellipse.right= Pcx + uRadius; ellipse.bottom = Pcy + uRadius; ellipse.top = Pcy - uRadius;
// check the easy thing first (don't use PtInRect)
if( bCheckPt &&(lpHitRect->left >= ellipse.left)&&(ellipse.right >= lpHitRect->right)&& (lpHitRect->top >= ellipse.top)&&(ellipse.bottom >= lpHitRect->bottom)) { return( TRUE ); }
//
// The circle is just a boring ellipse
//
return EllipseHit(&ellipse, bCheckPt, uRadius, lpHitRect );}
//
// EllipseHit()
//
// Checks for overlap between ellipse defined by lpEllipseRect and
// lpHitRect. If overlap TRUE is returned, otherwise FALSE.
//
BOOL EllipseHit(LPCRECT lpEllipseRect, BOOL bBorderHit, UINT uPenWidth, LPCRECT lpHitRect ){ RECT hr = *lpHitRect;
// Check easy thing first. If lpEllipseRect is inside lpHitRect
// then we have a hit (no duh...)
if( (hr.left <= lpEllipseRect->left)&&(hr.right >= lpEllipseRect->right)&& (hr.top <= lpEllipseRect->top)&&(hr.bottom >= lpEllipseRect->bottom) ) return( TRUE );
// If this is an ellipse....
//
// * * ^
// * | b | Y
// * | a +-------> X
// *-------+--------
// |
//
//
// Look for the ellipse hit. (x/a)^2 + (y/b)^2 = 1
// If it is > 1 than the point is outside the ellipse
// If it is < 1 it is inside
//
LONG a,b,aOuter, bOuter, x, y, xCenter, yCenter; BOOL bInsideOuter = FALSE; BOOL bOutsideInner = FALSE;
//
// Calculate a and b
//
a = (lpEllipseRect->right - lpEllipseRect->left)/2; b = (lpEllipseRect->bottom - lpEllipseRect->top)/2;
//
// Get the center of the ellipse
//
xCenter = lpEllipseRect->left + a; yCenter = lpEllipseRect->top + b;
//
// a and b generates a inner ellipse
// aOuter and bOuter generates a outer ellipse
//
aOuter = a + uPenWidth + 1; bOuter = b + uPenWidth + 1; a = a - 1; b = b - 1;
//
// Make our coordinates relative to the center of the ellipse
//
y = abs(hr.bottom - yCenter); x = abs(hr.right - xCenter);
//
// Be carefull not to divide by 0
//
if((a && b && aOuter && bOuter) == 0) { return FALSE; }
//
// We are using LONG instead of double and we need to have some precision
// that is why we multiply the equation of the ellipse
// ((x/a)^2 + (y/b)^2 = 1) by DECIMAL_PRECISION
// Note that the multiplication has to be done before the division, if we didn't do that
// we will always get 0 or 1 for x/a
//
if(x*x*DECIMAL_PRECISION/(aOuter*aOuter) + y*y*DECIMAL_PRECISION/(bOuter*bOuter) <= DECIMAL_PRECISION) { bInsideOuter = TRUE; }
if(x*x*DECIMAL_PRECISION/(a*a)+ y*y*DECIMAL_PRECISION/(b*b) >= DECIMAL_PRECISION) { bOutsideInner = TRUE; } //
// If we are checking for border hit,
// we need to be inside the outer ellipse and inside the inner
//
if( bBorderHit ) { return( bInsideOuter & bOutsideInner ); } // just need to be inside the outer ellipse
else { return( bInsideOuter ); }
}//
// LineHit()
//
// Checks for overlap (a "hit") between lpHitRect and the line
// P1P2 accounting for line width. If bCheckP1End or bCheckP2End is
// TRUE then a circle of radius 0.5 * uPenWidth is also checked for
// a hit to account for the rounded ends of wide lines.
//
// If a hit is found TRUE is returned, otherwise FALSE.
//
BOOL LineHit( LONG P1x, LONG P1y, LONG P2x, LONG P2y, UINT uPenWidth, BOOL bCheckP1End, BOOL bCheckP2End, LPCRECT lpHitRect ){
LONG uHalfPenWidth = uPenWidth/2;
LONG a,b,x,y;
x = lpHitRect->left + (lpHitRect->right - lpHitRect->left)/2; y = lpHitRect->bottom + (lpHitRect->top - lpHitRect->bottom)/2;
if( (P1x == P2x)&&(P1y == P2y) ) { // just check one end point's circle
return( CircleHit( P1x, P1y, uHalfPenWidth, lpHitRect, TRUE ) ); }
// check rounded end at P1
if( bCheckP1End && CircleHit( P1x, P1y, uHalfPenWidth, lpHitRect, FALSE ) ) return( TRUE );
// check rounded end at P2
if( bCheckP2End && CircleHit( P2x, P2y, uHalfPenWidth, lpHitRect, FALSE ) ) return( TRUE ); //
// The function of a line is Y = a.X + b
//
// a = (Y1-Y2)/(X1 -X2)
// if we found a we get b = y1 -a.X1
//
if(P1x == P2x) { a=0; b = DECIMAL_PRECISION*P1x;
} else { a = (P1y - P2y)*DECIMAL_PRECISION/(P1x - P2x); b = DECIMAL_PRECISION*P1y - a*P1x; }
//
// Paralel to Y
//
if(P1x == P2x && ((x >= P1x - uHalfPenWidth) && x <= P1x + uHalfPenWidth)) { return TRUE; }
//
// Paralel to X
//
if(P1y == P2y && ((y >= P1y - uHalfPenWidth) && y <= P1y + uHalfPenWidth)) { return TRUE; }
//
// General line
//
return(( y*DECIMAL_PRECISION <= a*x + b + DECIMAL_PRECISION*uHalfPenWidth) & ( y*DECIMAL_PRECISION >= a*x + b - DECIMAL_PRECISION*uHalfPenWidth));}
//
//
// Function: ConstructGraphic
//
// Purpose: Construct a graphic from a page and handle
//
//
DCWbGraphic* DCWbGraphic::ConstructGraphic(WB_PAGE_HANDLE hPage, WB_GRAPHIC_HANDLE hGraphic){ PWB_GRAPHIC pHeader; DCWbGraphic* pGraphic;
MLZ_EntryOut(ZONE_FUNCTION, "DCWbGraphic::ConstructGraphic(page, handle)");
// Get a pointer to the external graphic data
// (Throws an exception if any errors occur)
pHeader = PG_GetData(hPage, hGraphic);
// Construct the graphic
pGraphic = DCWbGraphic::ConstructGraphic(pHeader);
// If we got the graphic, set its page and handle
if (pGraphic != NULL) { pGraphic->m_hPage = hPage; pGraphic->m_hGraphic = hGraphic; }
g_pwbCore->WBP_GraphicRelease(hPage, hGraphic, pHeader);
return pGraphic;}
DCWbGraphic* DCWbGraphic::ConstructGraphic(WB_PAGE_HANDLE hPage, WB_GRAPHIC_HANDLE hGraphic, PWB_GRAPHIC pHeader){ DCWbGraphic* pGraphic;
MLZ_EntryOut(ZONE_FUNCTION, "DCWbGraphic::ConstructGraphic(page, pHeader)");
pGraphic = DCWbGraphic::ConstructGraphic(pHeader);
// If we got the graphic, set its page and handle
if (pGraphic != NULL) { pGraphic->m_hPage = hPage; pGraphic->m_hGraphic = hGraphic; } return pGraphic;}
DCWbGraphic* DCWbGraphic::ConstructGraphic(PWB_GRAPHIC pHeader){ MLZ_EntryOut(ZONE_FUNCTION, "DCWbGraphic::ConstructGraphic(data)");
TRACE_DEBUG(("Constructing graphic of type %hd", pHeader->type)); TRACE_DEBUG(("Length of graphic = %ld", pHeader->length)); TRACE_DEBUG(("Data offset = %hd", pHeader->dataOffset));
// Construct the internal representation of the graphic
DCWbGraphic* pGraphic = NULL;
if (pHeader == NULL) { return NULL; }
switch (pHeader->type) { case TYPE_GRAPHIC_LINE: pGraphic = new DCWbGraphicLine(pHeader); break;
case TYPE_GRAPHIC_FREEHAND: pGraphic = new DCWbGraphicFreehand(pHeader); break;
case TYPE_GRAPHIC_RECTANGLE: pGraphic = new DCWbGraphicRectangle(pHeader); break;
case TYPE_GRAPHIC_FILLED_RECTANGLE: pGraphic = new DCWbGraphicFilledRectangle(pHeader); break;
case TYPE_GRAPHIC_ELLIPSE: pGraphic = new DCWbGraphicEllipse(pHeader); break;
case TYPE_GRAPHIC_FILLED_ELLIPSE: pGraphic = new DCWbGraphicFilledEllipse(pHeader); break;
case TYPE_GRAPHIC_TEXT: pGraphic = new DCWbGraphicText(pHeader); break;
case TYPE_GRAPHIC_DIB: pGraphic = new DCWbGraphicDIB(pHeader); break;
default: // Do nothing, the object pointer is already set to NULL
break; }
if (!pGraphic) { ERROR_OUT(("ConstructGraphic failing; can't allocate object of type %d", pHeader->type)); }
return pGraphic;}
//
//
// Function: CopyGraphic
//
// Purpose: Construct a graphic from a pointer. This function makes a
// complete internal copy of the graphic data.
//
//
DCWbGraphic* DCWbGraphic::CopyGraphic(PWB_GRAPHIC pHeader){ MLZ_EntryOut(ZONE_FUNCTION, "DCWbGraphic::CopyGraphic(PWB_GRAPHIC)");
// Construct the graphic
DCWbGraphic* pGraphic = DCWbGraphic::ConstructGraphic(pHeader);
// Copy the extra data
if (pGraphic != NULL) { pGraphic->CopyExtra(pHeader); }
return pGraphic;}
//
//
// Function: DCWbGraphic constructor
//
// Purpose: Construct a new graphic object.
//
//
DCWbGraphic::DCWbGraphic(PWB_GRAPHIC pHeader){ MLZ_EntryOut(ZONE_FUNCTION, "DCWbGraphic::DCWbGraphic");
// Do basic initialization
Initialize();
// Convert the external data header to the internal member variables
if (pHeader != NULL) { ReadHeader(pHeader);
// Convert the extra data for the specific object
// (not all objects have extra data).
ReadExtra(pHeader); }}
DCWbGraphic::DCWbGraphic(WB_PAGE_HANDLE hPage, WB_GRAPHIC_HANDLE hGraphic){ MLZ_EntryOut(ZONE_FUNCTION, "DCWbGraphic::DCWbGraphic");
// Do the basic initialization
Initialize();
ASSERT(hPage != WB_PAGE_HANDLE_NULL); m_hPage = hPage;
ASSERT(hGraphic != NULL); m_hGraphic = hGraphic;
// Read the header data
ReadExternal();}
DCWbGraphic::~DCWbGraphic( void ){ // don't know if we are selected or not so just delete anyway
if(g_pDraw != NULL && g_pDraw->m_pMarker != NULL) { g_pDraw->m_pMarker->DeleteMarker( this ); }}
//
//
// Function: DCWbGraphic::ReadExternal
//
// Purpose: Read the graphic data from an externally stored graphic.
// The external graphic to be used is specified by the
// hGraphic member.
//
//
void DCWbGraphic::ReadExternal(void){ MLZ_EntryOut(ZONE_FUNCTION, "DCWbGraphic::ReadExternal");
ASSERT(m_hPage != WB_PAGE_HANDLE_NULL); ASSERT(m_hGraphic != NULL);
// Lock the object data in the page
PWB_GRAPHIC pHeader = PG_GetData(m_hPage, m_hGraphic);
// Convert the external data header to the internal member variables
ReadHeader(pHeader);
// Convert the extra data for the specific object
// (not all objects have extra data).
ReadExtra(pHeader);
// Release the data in the page
g_pwbCore->WBP_GraphicRelease(m_hPage, m_hGraphic, pHeader);
// Show that we are no longer changed since last read/write
m_bChanged = FALSE;}
//
//
// Function: DCWbGraphic::ReadHeader
//
// Purpose: Convert the external representation of the graphic's header
// to the internal format.
//
//
void DCWbGraphic::ReadHeader(PWB_GRAPHIC pHeader){ MLZ_EntryOut(ZONE_FUNCTION, "DCWbGraphic::ReadHeader");
// Get the length of the object
m_dwExternalLength = pHeader->length;
// Convert the external data header to the internal member variables
// Bounding rectangle
m_boundsRect.left = pHeader->rectBounds.left; m_boundsRect.top = pHeader->rectBounds.top; m_boundsRect.right = pHeader->rectBounds.right; m_boundsRect.bottom = pHeader->rectBounds.bottom;
// Defining rectangle
m_rect.left = pHeader->rect.left; m_rect.top = pHeader->rect.top; m_rect.right = pHeader->rect.right; m_rect.bottom = pHeader->rect.bottom;
// Pen color
m_clrPenColor = RGB(pHeader->color.red, pHeader->color.green, pHeader->color.blue); m_clrPenColor = SET_PALETTERGB( m_clrPenColor ); // make it do color matching
// Pen width
m_uiPenWidth = pHeader->penWidth;
// Pen style
m_iPenStyle = pHeader->penStyle;
// Raster operation
m_iPenROP = pHeader->rasterOp;
// Get the lock indication
m_uiLockState = pHeader->locked;
// Get the drawing tool type
if (pHeader->toolType == WBTOOL_TEXT) m_toolType = TOOLTYPE_TEXT; else m_toolType = TOOLTYPE_PEN;}
//
//
// Function: DCWbGraphic::WriteExternal
//
// Purpose: Write the graphic's details to a flat WB_GRAPHIC structure
//
//
void DCWbGraphic::WriteExternal(PWB_GRAPHIC pHeader){ MLZ_EntryOut(ZONE_FUNCTION, "DCWbGraphic::WriteExternal");
// Write the header
WriteHeader(pHeader);
// Write the extra data
WriteExtra(pHeader);}
//
//
// Function: DCWbGraphic::WriteHeader
//
// Purpose: Write the graphic's header details to a flat WB_GRAPHIC
// structure.
//
//
void DCWbGraphic::WriteHeader(PWB_GRAPHIC pHeader){ MLZ_EntryOut(ZONE_FUNCTION, "DCWbGraphic::WriteHeader");
// Convert the internal data to the external header format
// Init struct
FillMemory(pHeader, sizeof (WB_GRAPHIC), 0 );
// Calculate the external length
pHeader->length = CalculateExternalLength();
// Set the type of graphic
pHeader->type = (TSHR_UINT16)Type();
// Assume that there is no extra data
pHeader->dataOffset = sizeof(WB_GRAPHIC);
// Bounding rectangle
pHeader->rectBounds.left = (short)m_boundsRect.left; pHeader->rectBounds.top = (short)m_boundsRect.top; pHeader->rectBounds.right = (short)m_boundsRect.right; pHeader->rectBounds.bottom = (short)m_boundsRect.bottom;
// Defining rectangle
pHeader->rect.left = (short)m_rect.left; pHeader->rect.top = (short)m_rect.top; pHeader->rect.right = (short)m_rect.right; pHeader->rect.bottom = (short)m_rect.bottom;
// Pen color
pHeader->color.red = GetRValue(m_clrPenColor); pHeader->color.green = GetGValue(m_clrPenColor); pHeader->color.blue = GetBValue(m_clrPenColor);
// Pen width
pHeader->penWidth = (TSHR_UINT16)m_uiPenWidth;
// Pen style
pHeader->penStyle = (TSHR_UINT16)m_iPenStyle;
// Raster operation
pHeader->rasterOp = (TSHR_UINT16)m_iPenROP;
// Set the lock indicator
pHeader->locked = (BYTE) m_uiLockState;
// Set the drawing method
pHeader->smoothed = FALSE;
// Set the drawing tool type
if (m_toolType == TOOLTYPE_TEXT) pHeader->toolType = WBTOOL_TEXT; else pHeader->toolType = WBTOOL_PEN;}
//
//
// Function: Initialize
//
// Purpose: Initialize the member variables
//
//
void DCWbGraphic::Initialize(void){ m_hPage = WB_PAGE_HANDLE_NULL; m_hGraphic = NULL;
m_bChanged = TRUE;
m_uiLockState = WB_GRAPHIC_LOCK_NONE;
//
// Set default graphic attributes
//
::SetRectEmpty(&m_boundsRect); ::SetRectEmpty(&m_rect); m_clrPenColor = RGB(0, 0, 0); // Black pen color
m_uiPenWidth = 1; // One unit width
m_iPenROP = R2_COPYPEN; // Standard drawing ROP
m_iPenStyle = PS_INSIDEFRAME; // Solid pen to be used
m_toolType = TOOLTYPE_PEN;}
//
//
// Function: Copy
//
// Purpose: Return a copy of the graphic. The graphic returned has all
// its data read into local memory. The returned graphic has
// the same page as the copied graphic, but a NULL handle.
//
//
DCWbGraphic* DCWbGraphic::Copy(void) const{ MLZ_EntryOut(ZONE_FUNCTION, "DCWbGraphic::Copy");
// Get a pointer to the external graphic data
// (Throws an exception if any errors occur)
PWB_GRAPHIC pHeader = PG_GetData(m_hPage, m_hGraphic);
// Construct the graphic
DCWbGraphic* pGraphic = DCWbGraphic::CopyGraphic(pHeader);
// If we got the graphic, set its page and handle
if (pGraphic != NULL) { pGraphic->m_hPage = m_hPage; pGraphic->m_hGraphic = NULL; }
// Release the data
g_pwbCore->WBP_GraphicRelease(m_hPage, m_hGraphic, pHeader);
return pGraphic;}
//
//
// Function: DCWbGraphic::SetBoundsRect
//
// Purpose: Set the bounding rectangle of the object
//
//
void DCWbGraphic::SetBoundsRect(LPCRECT lprc){ m_boundsRect = *lprc;}
//
//
// Function: DCWbGraphic::SetRect
//
// Purpose: Set the defining rectangle of the object
//
//
void DCWbGraphic::SetRect(LPCRECT lprc){ m_rect = *lprc;
NormalizeRect(&m_rect);
// Show that we have been changed
m_bChanged = TRUE;}
void DCWbGraphic::SetRectPts(POINT point1, POINT point2){ RECT rc;
rc.left = point1.x; rc.top = point1.y; rc.right = point2.x; rc.bottom = point2.y;
SetRect(&rc);}
//
//
// Function: DCWbGraphic::PointInBounds
//
// Purpose: Return TRUE if the specified point lies in the bounding
// rectangle of the graphic object.
//
//
BOOL DCWbGraphic::PointInBounds(POINT point){ return(::PtInRect(&m_boundsRect, point));}
//
//
// Function: DCWbGraphic::MoveBy
//
// Purpose: Translate the object by the offset specified
//
//
void DCWbGraphic::MoveBy(int cx, int cy){ // Move the bounding rectangle
::OffsetRect(&m_boundsRect, cx, cy);
// Show that we have been changed
m_bChanged = TRUE;}
//
//
// Function: DCWbGraphic::MoveTo
//
// Purpose: Move the object to an absolute position
//
//
void DCWbGraphic::MoveTo(int x, int y){ // Calculate the offset needed to translate the object from its current
// position to the required position.
x -= m_boundsRect.left; y -= m_boundsRect.top;
MoveBy(x, y);}
//
//
// Function: DCWbGraphic::GetPosition
//
// Purpose: Return the top left corner of the object's bounding
// rectangle
//
//
void DCWbGraphic::GetPosition(LPPOINT lppt){ lppt->x = m_boundsRect.left; lppt->y = m_boundsRect.top;}
//
//
// Function: DCWbGraphic::NormalizeRect
//
// Purpose: Normalize a rectangle ensuring that the top left is above
// and to the left of the bottom right.
//
//
void DCWbGraphic::NormalizeRect(LPRECT lprc){ int tmp;
if (lprc->right < lprc->left) { tmp = lprc->left; lprc->left = lprc->right; lprc->right = tmp; }
if (lprc->bottom < lprc->top) { tmp = lprc->top; lprc->top = lprc->bottom; lprc->bottom = tmp; }}
//
//
// Function: DCWbGraphic::SetColor
//
// Purpose: Set the object color.
//
//
void DCWbGraphic::SetColor(COLORREF color){ color = SET_PALETTERGB( color ); // make it use color matching
if (m_clrPenColor != color) { // Save the new color
m_clrPenColor = color;
// Show that we have been changed
m_bChanged = TRUE; }}
//
//
// Function: DCWbGraphic::SetROP
//
// Purpose: Set the object raster operation
//
//
void DCWbGraphic::SetROP(int iPenROP){ // If the new ROP is different
if (m_iPenROP != iPenROP) { // Save the new ROP
m_iPenROP = iPenROP;
// Show that we have been changed
m_bChanged = TRUE; }}
//
//
// Function: DCWbGraphic::SetPenStyle
//
// Purpose: Set the object pen style
//
//
void DCWbGraphic::SetPenStyle(int iPenStyle){ // If the new style is different
if (m_iPenStyle != iPenStyle) { // Save the new pen style
m_iPenStyle = iPenStyle;
// Show that the graphic has been changed
m_bChanged = TRUE; }}
//
//
// Function: DCWbGraphic::SetPenWidth
//
// Purpose: Set the pen width for the object.
//
//
void DCWbGraphic::SetPenWidth(UINT uiWidth){ // If the new width is different
if (m_uiPenWidth != uiWidth) { // Save the width given
m_uiPenWidth = uiWidth;
// Update the bounding rectangle
CalculateBoundsRect();
// Show that we have been changed
m_bChanged = TRUE; }}
//
//
// Function: IsTopmost
//
// Purpose: Return TRUE if this graphic is topmost on its page
//
//
BOOL DCWbGraphic::IsTopmost(void){ MLZ_EntryOut(ZONE_FUNCTION, "DCWbGraphic::IsTopmost"); ASSERT(m_hGraphic != NULL);
return PG_IsTopmost(m_hPage, this);}
//
//
// Function: AddToPageLast
//
// Purpose: Add the graphic to the specified page
//
//
void DCWbGraphic::AddToPageLast(WB_PAGE_HANDLE hPage){ MLZ_EntryOut(ZONE_FUNCTION, "DCWbGraphic::AddToPageLast"); ASSERT(m_hGraphic == NULL);
// Get the length of the flat representation
DWORD length = CalculateExternalLength();
// Allocate memory for the graphic
PWB_GRAPHIC pHeader = PG_AllocateGraphic(hPage, length);
if(pHeader == NULL) { return; }
// Write the graphic details to the memory
WriteExternal(pHeader);
// Add the flat representation to the page
WB_GRAPHIC_HANDLE hGraphic = NULL; UINT uiReturn;
uiReturn = g_pwbCore->WBP_GraphicAddLast(hPage, pHeader, &hGraphic); if (uiReturn != 0) { DefaultExceptionHandler(WBFE_RC_WB, uiReturn); return; }
// Show that we have not changed since the last write
m_bChanged = FALSE;
// Save the page to which this graphic now belongs
m_hPage = hPage; m_hGraphic = hGraphic;}
//
//
// Function: ForceReplace
//
// Purpose: Write the object to external storage, replacing what is
// already there, even if the object hasn't changed.
//
//
void DCWbGraphic::ForceReplace(void) { if( Type() != 0 ) { m_bChanged = TRUE; this->Replace(); } }
//
//
// Function: Replace
//
// Purpose: Write the object to external storage, replacing what is
// already there.
//
//
void DCWbGraphic::Replace(void){ MLZ_EntryOut(ZONE_FUNCTION, "DCWbGraphic::Replace"); ASSERT(m_hGraphic != NULL);
// Only do the replace if we have been changed
if (m_bChanged == TRUE) { TRACE_MSG(("Replacing the graphic in the page")); // Get the length of the flat representation
DWORD length = CalculateExternalLength();
// Allocate memory for the graphic
PWB_GRAPHIC pHeader = PG_AllocateGraphic(m_hPage, length); if(pHeader == NULL) { return; }
// Write the graphic details to the memory
WriteExternal(pHeader);
// Replace the graphic
PG_GraphicReplace(m_hPage, &m_hGraphic, pHeader);
// Show that we have not changed since the last update
m_bChanged = FALSE; }}
//
//
// Function: ReplaceConfirm
//
// Purpose: Confirm the replace of the graphic
//
//
void DCWbGraphic::ReplaceConfirm(void){ MLZ_EntryOut(ZONE_FUNCTION, "DCWbGraphic::ReplaceConfirm"); ASSERT(m_hGraphic != NULL);
// Confirm the update
g_pwbCore->WBP_GraphicReplaceConfirm(m_hPage, m_hGraphic);
// Read the new details
ReadExternal();}
void DCWbGraphic::ForceUpdate(void){ if ((Type() != 0) && m_hGraphic) { m_bChanged = TRUE; this->Update(); }}
//
//
// Function: Update
//
// Purpose: Write the header of the graphic to external storage
//
//
void DCWbGraphic::Update(void){ MLZ_EntryOut(ZONE_FUNCTION, "DCWbGraphic::Update");
ASSERT(m_hGraphic != NULL);
// Only make the update if the graphic has changed
if (m_bChanged) { // Allocate memory for the update graphic
TRACE_MSG(("Graphic has changed")); DWORD length = sizeof(WB_GRAPHIC); PWB_GRAPHIC pHeader;
if( (pHeader = PG_AllocateGraphic(m_hPage, length)) != NULL ) { // Write the header details to the allocated memory
pHeader->type = (TSHR_UINT16)Type(); WriteHeader(pHeader);
// Update the header in the page
PG_GraphicUpdate(m_hPage, &m_hGraphic, pHeader); }
// Show that we have not changed since the last update
m_bChanged = FALSE; }}
//
//
// Function: UpdateConfirm
//
// Purpose: Confirm the update of the graphic
//
//
void DCWbGraphic::UpdateConfirm(void){ MLZ_EntryOut(ZONE_FUNCTION, "DCWbGraphic::UpdateConfirm"); ASSERT(m_hGraphic != NULL);
// Confirm the update
g_pwbCore->WBP_GraphicUpdateConfirm(m_hPage, m_hGraphic);
// Read the new details
ReadExternal();}
//
//
// Function: Delete
//
// Purpose: Remove the graphic from its page
//
//
void DCWbGraphic::Delete(void){ MLZ_EntryOut(ZONE_FUNCTION, "DCWbGraphic::Delete");
ASSERT(m_hPage != WB_PAGE_HANDLE_NULL); ASSERT(m_hGraphic != NULL);
// Delete the graphic
PG_GraphicDelete(m_hPage, *this);
// Reset the handles for this graphic - it is now deleted
m_hPage = WB_PAGE_HANDLE_NULL; m_hGraphic = NULL;
// Show that we have changed (an add is required to save the graphic)
m_bChanged = TRUE;}
//
//
// Function: DeleteConfirm
//
// Purpose: Confirm the delete of the graphic
//
//
void DCWbGraphic::DeleteConfirm(void){ MLZ_EntryOut(ZONE_FUNCTION, "DCWbGraphic::DeleteConfirm"); ASSERT(m_hGraphic != NULL);
// Confirm the update
g_pwbCore->WBP_GraphicDeleteConfirm(m_hPage, m_hGraphic);
// Reset the graphic page and handle (they are no longer useful)
m_hPage = WB_PAGE_HANDLE_NULL; m_hGraphic = NULL;}
//
//
// Function: Lock
//
// Purpose: Lock the graphic
//
//
void DCWbGraphic::Lock(void){ MLZ_EntryOut(ZONE_FUNCTION, "DCWbGraphic::Lock");
// If we are not already locked
if( Type() != 0 ) { if (m_uiLockState == WB_GRAPHIC_LOCK_NONE) { m_bChanged = TRUE; m_uiLockState = WB_GRAPHIC_LOCK_LOCAL; } } }
//
//
// Function: Unlock
//
// Purpose: Unlock the graphic
//
//
void DCWbGraphic::Unlock(void){ MLZ_EntryOut(ZONE_FUNCTION, "DCWbGraphic::Unlock");
// If we are currently locked
if( Type() != 0 ) { if (m_uiLockState == WB_GRAPHIC_LOCK_LOCAL) { // Lock & release
PWB_GRAPHIC pHeader = PG_GetData(m_hPage, m_hGraphic); g_pwbCore->WBP_GraphicRelease(m_hPage, m_hGraphic, pHeader);
m_uiLockState = WB_GRAPHIC_LOCK_NONE; g_pwbCore->WBP_GraphicUnlock(m_hPage, m_hGraphic); } } }
//
//
// Function: DCWbGraphicMarker::DCWbGraphicMarker
//
// Purpose: Constructors for marker objects
//
//
DCWbGraphicMarker::DCWbGraphicMarker(){ HBITMAP hBmpMarker; // Set up a checked pattern to draw the marker rect with
WORD bits[] = {204, 204, 51, 51, 204, 204, 51, 51};
// Create the brush to be used to draw the marker rectangle
hBmpMarker = ::CreateBitmap(8, 8, 1, 1, bits); m_hMarkerBrush = ::CreatePatternBrush(hBmpMarker); ::DeleteBitmap(hBmpMarker);
MarkerList.EmptyList(); ::SetRectEmpty(&m_rect); m_bMarkerPresent = FALSE;}
DCWbGraphicMarker::~DCWbGraphicMarker(){ if (m_hMarkerBrush != NULL) { DeleteBrush(m_hMarkerBrush); m_hMarkerBrush = NULL; }}
//
//
// Function: DCWbGraphicMarker::SetRect
//
// Purpose: Set the rectangle for the object
//
//
BOOL DCWbGraphicMarker::SetRect(LPCRECT lprc, DCWbGraphic *pGraphic, BOOL bRedraw, BOOL bLockObject ){ DCWbGraphic *pMarker; BOOL bGraphicAdded = FALSE; LPRECT pmMarker;
// Save the new rectangle
m_rect = *lprc; NormalizeRect(&m_rect);
// Calculate the new bounding rectangle of the entire marker
CalculateBoundsRect();
// Calculate the marker rectangles
CalculateMarkerRectangles();
if( (pMarker = HasAMarker( pGraphic )) != NULL ) delete pMarker;
// allow select only if object is not locked - bug 2185
if( !pGraphic->Locked()) { // add/replace pGraphic|markerrect pair to list
pmMarker = new RECT; if (!pmMarker) { ERROR_OUT(("Failed to create RECT object")); } else { *pmMarker = m_markerRect;
MarkerList.SetAt( (void *)pGraphic, pmMarker);
ASSERT(g_pDraw); DrawRect(g_pDraw->GetCachedDC(), pmMarker, FALSE, NULL ); bGraphicAdded = TRUE; }
if( bLockObject ) { // lock the object if we don't already have it locked
// to keep anybody else from selecting it
if( !pGraphic->GotLock() ) { pGraphic->Lock(); if( pGraphic->Handle() != NULL ) pGraphic->ForceUpdate(); // if valid object force lock NOW
} } }
if( bRedraw && m_bMarkerPresent ) { ASSERT(g_pDraw); ::UpdateWindow(g_pDraw->m_hwnd); }
// set m_boundsRect to real bounds
GetBoundsRect(&m_boundsRect);
return( bGraphicAdded );}
//
//
// Function: DCWbGraphicMarker::CalculateBoundsRect
//
// Purpose: Calculate the bounding rectangle of the object
//
//
void DCWbGraphicMarker::CalculateBoundsRect(void){ // Generate the new bounding rectangle
m_boundsRect = m_rect; NormalizeRect(&m_boundsRect);
::InflateRect(&m_boundsRect, m_uiPenWidth, m_uiPenWidth);}
//
//
// Function: DCWbGraphicMarker::CalculateMarkerRectangles
//
// Purpose: Calculate the rectangles for the marker handles
//
//
void DCWbGraphicMarker::CalculateMarkerRectangles(void){ m_markerRect = m_boundsRect; ::InflateRect(&m_markerRect, 1-m_uiPenWidth, 1-m_uiPenWidth);}
//
//
// Function: DCWbGraphicMarker::PointInMarker
//
// Purpose: Calculate whether the given point is in one of the marker
// rectangles.
//
//
int DCWbGraphicMarker::PointInMarker(POINT point){ return(NO_HANDLE);}
void DCWbGraphicMarker::DrawRect( HDC hDC, LPCRECT pMarkerRect, BOOL bDrawObject, DCWbGraphic * pGraphic){ int nOldROP; COLORREF crOldTextColor; COLORREF crOldBkColor;
nOldROP = ::SetROP2(hDC, R2_COPYPEN); crOldTextColor = ::SetTextColor(hDC, RGB(0, 0, 0));
ASSERT(g_pDraw); crOldBkColor = ::SetBkColor(hDC, ::GetSysColor(COLOR_WINDOW));
if (pMarkerRect != NULL) { if( bDrawObject ) pGraphic->Draw(hDC ); // draw object instead of rect
else ::FrameRect(hDC, pMarkerRect, m_hMarkerBrush); // draw rect
}
::SetROP2(hDC, nOldROP); ::SetTextColor(hDC, crOldTextColor); ::SetBkColor(hDC, crOldBkColor);}
//
//
// Function: DCWbGraphicMarker::Draw
//
// Purpose: Draw the marker object
//
//
void DCWbGraphicMarker::Draw(HDC hDC, BOOL bDrawObjects){ POSITION posNext; DCWbGraphic *pGraphic; LPRECT pMarkerRect;
// if marker is not up, do nuthin
if( !m_bMarkerPresent ) return;
posNext = MarkerList.GetHeadPosition(); while( posNext != NULL ) { MarkerList.GetNextAssoc( posNext, (void *&)pGraphic, (void *&)pMarkerRect ); DrawRect(hDC, pMarkerRect, bDrawObjects, pGraphic ); }}
void DCWbGraphicMarker::UndrawRect( HDC hDC, WbDrawingArea * pDrawingArea, LPCRECT pMarkerRect){ int nOldROP; COLORREF crOldTextColor; COLORREF crOldBkColor;
if (pMarkerRect != NULL) { // set up context to erase marker rect
nOldROP = ::SetROP2(hDC, R2_COPYPEN);
ASSERT(g_pDraw); crOldTextColor = ::SetTextColor(hDC, ::GetSysColor(COLOR_WINDOW)); crOldBkColor = ::SetBkColor(hDC, ::GetSysColor(COLOR_WINDOW));
::FrameRect(hDC, pMarkerRect, m_hMarkerBrush); UndrawMarker( pMarkerRect ); // invalidate so underlying objects will repair window
::SetROP2(hDC, nOldROP); ::SetTextColor(hDC, crOldTextColor); ::SetBkColor(hDC, crOldBkColor); }}
//
//
// Function: DCWbGraphicMarker::Undraw
//
// Purpose: Undraw the marker object
//
//
void DCWbGraphicMarker::Undraw(HDC hDC, WbDrawingArea * pDrawingArea){ POSITION posNext; DCWbGraphic *pGraphic; LPRECT pMarkerRect;
posNext = MarkerList.GetHeadPosition(); while( posNext != NULL ) { MarkerList.GetNextAssoc( posNext, (void *&)pGraphic, (void *&)pMarkerRect ); UndrawRect(hDC, pDrawingArea, pMarkerRect); }}
void DCWbGraphicMarker::DeleteAllMarkers( DCWbGraphic *pLastSelectedGraphic, BOOL bLockLastSelectedGraphic ) { POSITION posFirst; DCWbGraphic *pGraphic; LPRECT pMarkerRect; BOOL bAddLastBack = FALSE;
if( MarkerList.IsEmpty() ) return; // nuthin to do
// let each object clean itself up
posFirst = MarkerList.GetHeadPosition(); while( posFirst != NULL ) { MarkerList.GetNextAssoc( posFirst, (void *&)pGraphic, (void *&)pMarkerRect );
if( pGraphic != NULL ) { if( pGraphic == pLastSelectedGraphic ) { // have to put this one back since somebody up there needs it
bAddLastBack = TRUE;
// delete key but don't delete object
DeleteMarker( pGraphic ); } else { // obj will call DeleteMarker()
delete pGraphic; } } else { // nobody home, remove key ourselves
DeleteMarker( pGraphic ); } }
// put last selected object back if needed
if( bAddLastBack && (pLastSelectedGraphic != NULL) ) { RECT rcT;
pLastSelectedGraphic->GetBoundsRect(&rcT); SetRect(&rcT, pLastSelectedGraphic, FALSE, bLockLastSelectedGraphic ); }
// if marker is not up, don't redraw immediately
if( !m_bMarkerPresent ) return;
ASSERT(g_pDraw); if (g_pDraw->m_hwnd != NULL ) ::UpdateWindow(g_pDraw->m_hwnd);}
//
// Deletes DCWbGraphic/LPRECT pair corresponding to pGraphic
//
void DCWbGraphicMarker::DeleteMarker( DCWbGraphic *pGraphic ){ LPRECT pMarkerRect; if( MarkerList.IsEmpty() ) return;
if( MarkerList.Lookup( (void *)pGraphic, (void *&)pMarkerRect ) ) { if( pMarkerRect != NULL ) { ASSERT(g_pDraw); UndrawRect(g_pDraw->GetCachedDC(), g_pDraw, pMarkerRect ); delete pMarkerRect; }
MarkerList.RemoveKey( (void *)pGraphic );
// set m_boundsRect to real bounds
GetBoundsRect(&m_boundsRect);
// pGraphic should be locked by us since it was selected
// but check to be sure since this might be coming from
// another user that beat us to the lock.
if( pGraphic->GotLock() ) { pGraphic->Unlock(); if( pGraphic->Handle() != NULL ) pGraphic->ForceUpdate(); } }
// if marker is not up, don't redraw immediately
if( !m_bMarkerPresent ) return; }
//
// Sees if pGraphic->Handle() is in marker list and returns obj
//
DCWbGraphic *DCWbGraphicMarker::HasAMarker( DCWbGraphic *pGraphic ){ POSITION posNext; DCWbGraphic *pSearchGraphic; LPRECT pMarkerRect;
if( MarkerList.IsEmpty() ) return( NULL );
posNext = MarkerList.GetHeadPosition(); while( posNext != NULL ) { MarkerList.GetNextAssoc( posNext, (void *&)pSearchGraphic, (void *&)pMarkerRect );
if( (pSearchGraphic != NULL)&& (pSearchGraphic->Handle() == pGraphic->Handle()) ) { return( pSearchGraphic ); } }
return( NULL );
}
//
// Gets last marker
//
DCWbGraphic *DCWbGraphicMarker::LastMarker( void ){ POSITION posNext; DCWbGraphic *pGraphic; LPRECT pMarkerRect;
pGraphic = NULL;
if( !MarkerList.IsEmpty() ) { // this isn't eactly right, just return head of list for now
posNext = MarkerList.GetHeadPosition(); if( posNext != NULL ) MarkerList.GetNextAssoc( posNext, (void *&)pGraphic, (void *&)pMarkerRect ); }
return( pGraphic ); }
void DCWbGraphicMarker::UndrawMarker(LPCRECT pMarkerRect ){ RECT rect;
ASSERT(g_pDraw); if( (pMarkerRect != NULL) && (g_pDraw->m_hwnd != NULL) ) { rect = *pMarkerRect; g_pDraw->SurfaceToClient(&rect);
::InvalidateRect(g_pDraw->m_hwnd, &rect, FALSE); }}
int DCWbGraphicMarker::GetNumMarkers( void ){ int count = 0; POSITION pos; pos = MarkerList.GetHeadPosition(); while(pos) { count ++; MarkerList.GetNext(pos); }
return count;}
void DCWbGraphicMarker::MoveBy(int cx, int cy){ POSITION posNext; DCWbGraphic *pGraphic; LPRECT pMarkerRect;
if( !MarkerList.IsEmpty() ) { // Call MoveBy for each selected obj
posNext = MarkerList.GetHeadPosition(); while( posNext != NULL ) { MarkerList.GetNextAssoc( posNext, (void *&)pGraphic, (void *&)pMarkerRect );
if( pGraphic != NULL ) { pGraphic->MoveBy(cx, cy); } } }
DCWbGraphic::MoveBy(cx, cy); // move marker too
}
void DCWbGraphicMarker::Update( void ){ POSITION posNext; DCWbGraphic *pGraphic; LPRECT pMarkerRect;
if( !MarkerList.IsEmpty() ) { // Call Update for each selected obj
posNext = MarkerList.GetHeadPosition(); while( posNext != NULL ) { MarkerList.GetNextAssoc( posNext, (void *&)pGraphic, (void *&)pMarkerRect );
if( pGraphic != NULL ) pGraphic->Update(); } } }
BOOL DCWbGraphicMarker::PointInBounds(POINT pt){ POSITION posNext; DCWbGraphic *pGraphic; LPRECT pMarkerRect; RECT rectHit;
if( !MarkerList.IsEmpty() ) { // Call Update for each selected obj
posNext = MarkerList.GetHeadPosition(); while( posNext != NULL ) { MarkerList.GetNextAssoc( posNext, (void *&)pGraphic, (void *&)pMarkerRect );
if( pGraphic != NULL ) { MAKE_HIT_RECT(rectHit, pt );
if( pGraphic->PointInBounds(pt)&& pGraphic->CheckReallyHit( &rectHit ) ) return( TRUE ); } } }
return( FALSE );}
//
// Returns a rect that is the union of all the items in the marker
//
void DCWbGraphicMarker::GetBoundsRect(LPRECT lprc){ POSITION posNext; DCWbGraphic *pGraphic; LPRECT pMarkerRect; RECT rc;
::SetRectEmpty(lprc);
if( !MarkerList.IsEmpty()) { posNext = MarkerList.GetHeadPosition(); while( posNext != NULL ) { MarkerList.GetNextAssoc( posNext, (void *&)pGraphic, (void *&)pMarkerRect );
if( pGraphic != NULL ) { pGraphic->GetBoundsRect(&rc); ::UnionRect(lprc, lprc, &rc); } } }}
void DCWbGraphicMarker::SetColor(COLORREF color){ POSITION posNext; DCWbGraphic *pGraphic; LPRECT pMarkerRect;
if( !MarkerList.IsEmpty() ) { // Call Update for each selected obj
posNext = MarkerList.GetHeadPosition(); while( posNext != NULL ) { MarkerList.GetNextAssoc( posNext, (void *&)pGraphic, (void *&)pMarkerRect );
if( pGraphic != NULL ) pGraphic->SetColor( color ); } } }
void DCWbGraphicMarker::SetPenWidth(UINT uiWidth){ POSITION posNext; DCWbGraphic *pGraphic; LPRECT pMarkerRect;
if( !MarkerList.IsEmpty() ) { // Call Update for each selected obj
posNext = MarkerList.GetHeadPosition(); while( posNext != NULL ) { MarkerList.GetNextAssoc( posNext, (void *&)pGraphic, (void *&)pMarkerRect );
if( pGraphic != NULL ) pGraphic->SetPenWidth(uiWidth); } } }
void DCWbGraphicMarker::SetSelectionFont(HFONT hFont){ POSITION posNext; DCWbGraphic *pGraphic; LPRECT pMarkerRect;
if( !MarkerList.IsEmpty() ) { // Call Update for each selected obj
posNext = MarkerList.GetHeadPosition(); while( posNext != NULL ) { MarkerList.GetNextAssoc( posNext, (void *&)pGraphic, (void *&)pMarkerRect );
if( (pGraphic != NULL)&& pGraphic->IsGraphicTool() == enumGraphicText) { // Change the font of the object
((DCWbGraphicText*)pGraphic)->SetFont(hFont);
// Replace the object
pGraphic->Replace(); } } } }
//
// Deletes each marker obj for all connections
//
void DCWbGraphicMarker::DeleteSelection( void ){ POSITION posNext; DCWbGraphic *pGraphic; DCWbGraphic *pGraphicCopy; LPRECT pMarkerRect;
if( !MarkerList.IsEmpty() ) { // Call Update for each selected obj
posNext = MarkerList.GetHeadPosition(); while( posNext != NULL ) { MarkerList.GetNextAssoc( posNext, (void *&)pGraphic, (void *&)pMarkerRect );
if( pGraphic != NULL ) { // make a copy for trash can
pGraphicCopy = pGraphic->Copy();
// throw in trash
if( pGraphicCopy != NULL ) { g_pMain->m_LastDeletedGraphic.CollectTrash( pGraphicCopy ); }
// delete obj
g_pDraw->DeleteGraphic( pGraphic ); } }
DeleteAllMarkers( NULL ); } }
//
// Brings eaach marker obj to top
//
void DCWbGraphicMarker::BringToTopSelection( void ){ POSITION posNext; DCWbGraphic *pGraphic; LPRECT pMarkerRect;
if( !MarkerList.IsEmpty() ) { // Call Update for each selected obj
posNext = MarkerList.GetHeadPosition(); while( posNext != NULL ) { MarkerList.GetNextAssoc( posNext, (void *&)pGraphic, (void *&)pMarkerRect );
if( pGraphic != NULL ) { // move obj to top
UINT uiReturn;
uiReturn = g_pwbCore->WBP_GraphicMove(g_pDraw->Page(), pGraphic->Handle(), LAST); if (uiReturn != 0) { DefaultExceptionHandler(WBFE_RC_WB, uiReturn); return; } } } } }
//
// Sends each marker object to back
//
void DCWbGraphicMarker::SendToBackSelection( void ){ POSITION posNext; DCWbGraphic *pGraphic; LPRECT pMarkerRect;
if( !MarkerList.IsEmpty() ) { // Call Update for each selected obj
posNext = MarkerList.GetHeadPosition(); while( posNext != NULL ) { MarkerList.GetNextAssoc( posNext, (void *&)pGraphic, (void *&)pMarkerRect );
if( pGraphic != NULL ) { UINT uiReturn;
// move obj to top
uiReturn = g_pwbCore->WBP_GraphicMove(g_pDraw->Page(), pGraphic->Handle(), FIRST); if (uiReturn != 0) { DefaultExceptionHandler(WBFE_RC_WB, uiReturn); return; } } } } }
//
// Copy marker to clipboard using CLIPBOARD_PRIVATE_MULTI_OBJ format:
// [ RECT : marker rect ]
// [ DWORD : number of objects ]
// [ DWORD : byte length of 1st object ]
// [ WB_GRAPHIC : header data for first object ]
// [ DWORD : byte length of 2nd object ]
// [ WB_GRAPHIC : header data for 2nd object ]
// :
// :
// [ DWORD : byte length of last object ]
// [ WB_GRAPHIC : header data for last object ]
// [ DWORD : 0 (marks end of object data) ]
//
BOOL DCWbGraphicMarker::RenderPrivateMarkerFormat( void ){ POSITION posNext; DCWbGraphic *pGraphic; LPRECT pMarkerRect; DWORD nBufSize; DWORD nObjSize; DWORD nNumObjs; BYTE *buf; BYTE *pbuf; HANDLE hbuf; PWB_GRAPHIC pHeader; WB_GRAPHIC_HANDLE hGraphic;
if( MarkerList.IsEmpty() ) return( TRUE ); // nuthin to do
// Have to make two passes. The first one figures out how much
// data we have, the second copies the data.
// figure out how much data we've got
nBufSize = sizeof (RECT) + sizeof (DWORD); // marker rect and object
// count are first
nNumObjs = 0; posNext = MarkerList.GetHeadPosition(); while( posNext != NULL ) { MarkerList.GetNextAssoc( posNext, (void *&)pGraphic, (void *&)pMarkerRect );
if( (pGraphic != NULL)&& ((hGraphic = pGraphic->Handle()) != NULL)&& ((pHeader = PG_GetData(pGraphic->Page(), hGraphic )) != NULL) ) { nBufSize += (DWORD)(pHeader->length + sizeof(DWORD)); g_pwbCore->WBP_GraphicRelease(pGraphic->Page(), hGraphic, pHeader);
// count objects instead of using MarkerList.GetCount()
// in case we have an error or something (bad object,
// leaky core, who knows...)
nNumObjs++; } }
// Add one more DWORD at end. This will be set to 0 below
// to mark the end of the buffer.
nBufSize += sizeof(DWORD);
// Make object buffer. Use GlobalDiddle instead of new so we
// can pass a mem handle to the clipboard later.
hbuf = ::GlobalAlloc( GHND, nBufSize ); if( hbuf == NULL ) return( FALSE ); // couldn't make room
buf = (BYTE *)::GlobalLock( hbuf ); if( buf == NULL ) { ::GlobalFree( hbuf ); return( FALSE ); // couldn't find the room
}
pbuf = buf;
// set marker rect
CopyMemory(pbuf, &m_boundsRect, sizeof(RECT)); pbuf += sizeof (RECT);
// set number of objects
*((DWORD *)pbuf) = nNumObjs; pbuf += sizeof (DWORD);
// copy each obj to buf + a length DWORD
posNext = MarkerList.GetHeadPosition(); while( posNext != NULL ) { MarkerList.GetNextAssoc( posNext, (void *&)pGraphic, (void *&)pMarkerRect );
if( (pGraphic != NULL)&& ((hGraphic = pGraphic->Handle()) != NULL)&& ((pHeader = PG_GetData(pGraphic->Page(), hGraphic )) != NULL) ) { // save length of this obj first
nObjSize = (DWORD)pHeader->length; *((DWORD *)pbuf) = nObjSize; pbuf += sizeof (DWORD);
// copy obj to buf
CopyMemory( pbuf, (CONST VOID *)pHeader, nObjSize );
// make sure copy isn't "locked" (bug 474)
((PWB_GRAPHIC)pbuf)->locked = WB_GRAPHIC_LOCK_NONE;
// set up for next obj
pbuf += nObjSize;
g_pwbCore->WBP_GraphicRelease(pGraphic->Page(), hGraphic, pHeader ); } }
// cork it up
*((DWORD *)pbuf) = 0;
// give it to the clipboard
::GlobalUnlock( hbuf ); if( ::SetClipboardData( g_ClipboardFormats[ CLIPBOARD_PRIVATE_MULTI_OBJ ], hbuf ) == NULL ) { // clipboard choked, clean up mess
::GlobalFree( hbuf ); return( FALSE ); }
// zillions of shared clipboards all over the planet are receiving this
// thing about now...
return( TRUE ); }
//
// Decodes CLIPBOARD_PRIVATE_MULTI_OBJ format and pastes objects
// to Whiteboard. See DCWbGraphicMarker::RenderPrivateMarkerFormat
// for details of format.
//
void DCWbGraphicMarker::Paste( HANDLE handle ){ BYTE *pbuf; DWORD nNumObjs; DWORD nObjSize; DCWbGraphic *pGraphic; DCWbGraphic *pSelectedGraphic; SIZE PasteOffset; RECT rectMarker;
// blow off current selection
g_pMain->m_drawingArea.RemoveMarker(NULL); DeleteAllMarkers( NULL ); pSelectedGraphic = NULL;
// get data
pbuf = (BYTE *)::GlobalLock( handle ); if( pbuf == NULL ) return; // can't get the door open
// get marker's original coords and figure offset
CopyMemory( &rectMarker, (CONST VOID *)pbuf, sizeof (RECT) ); pbuf += sizeof (RECT);
RECT rcVis; g_pMain->m_drawingArea.GetVisibleRect(&rcVis); PasteOffset.cx = rcVis.left - rectMarker.left; PasteOffset.cy = rcVis.top - rectMarker.top;
// get num objects
nNumObjs = *((DWORD *)pbuf); pbuf += sizeof (DWORD);
// get each object
while( (nObjSize = *((DWORD *)pbuf)) != 0 ) { pbuf += sizeof (DWORD);
// Add the object to the page and current selection
pGraphic = DCWbGraphic::CopyGraphic( (PWB_GRAPHIC)pbuf ); pbuf += nObjSize;
if( pGraphic != NULL ) { pGraphic->MoveBy( PasteOffset.cx, PasteOffset.cy ); pGraphic->AddToPageLast( g_pMain->GetCurrentPage() ); g_pMain->m_drawingArea.SelectGraphic( pGraphic, TRUE, TRUE ); } }
::GlobalUnlock( handle );
GetBoundsRect(&m_boundsRect);}
DCWbGraphicLine::~DCWbGraphicLine( void ){ // Have to make sure marker is cleaned up before we vanish
// don't know if we are selected or not so just delete anyway
if(g_pDraw != NULL && g_pDraw->m_pMarker != NULL) { g_pDraw->m_pMarker->DeleteMarker( this ); }}
//
//
// Function: DCWbGraphicLine::CalculateBoundsRect
//
// Purpose: Calculate the bounding rectangle of the line
//
//
void DCWbGraphicLine::CalculateBoundsRect(){ // Create the basic bounding rectangle from the start and end points
m_boundsRect = m_rect; NormalizeRect(&m_boundsRect);
// Expand the rectangle by the pen width used for drawing
int iInflate = (m_uiPenWidth + 1) / 2; ::InflateRect(&m_boundsRect, iInflate, iInflate);}
//
//
// Function: DCWbGraphicLine::SetStart
//
// Purpose: Set the start point of the line
//
//
void DCWbGraphicLine::SetStart(POINT pointFrom){ // Only do anything if the start point has changed
if (!EqualPoint(*((LPPOINT)&m_rect.left), pointFrom)) { // Save the new start point
m_rect.left = pointFrom.x; m_rect.top = pointFrom.y;
// Show that the graphic has changed
m_bChanged = TRUE; }
// Update the bounding rectangle
CalculateBoundsRect();}
//
//
// Function: DCWbGraphicLine::SetEnd
//
// Purpose: Set the start point of the line
//
//
void DCWbGraphicLine::SetEnd(POINT pointTo){ // Only do anything if the end point has changed
if (!EqualPoint(*((LPPOINT)&m_rect.right), pointTo)) { // Save the new end point
m_rect.right = pointTo.x; m_rect.bottom = pointTo.y;
// Show that the graphic has changed
m_bChanged = TRUE; }
// Update the bounding rectangle
CalculateBoundsRect();}
//
//
// Function: DCWbGraphicLine::Draw
//
// Purpose: Draw the line.
//
//
void DCWbGraphicLine::Draw(HDC hDC){ HPEN hPen; HPEN hOldPen;
MLZ_EntryOut(ZONE_FUNCTION, "DCWbGraphicLine::Draw");
// Select the required pen
hPen = ::CreatePen(m_iPenStyle, m_uiPenWidth, m_clrPenColor); hOldPen = SelectPen(hDC, hPen);
if (hOldPen != NULL) { // Select the raster operation
int iOldROP = ::SetROP2(hDC, m_iPenROP);
// Draw the line
::MoveToEx(hDC, m_rect.left, m_rect.top, NULL); ::LineTo(hDC, m_rect.right, m_rect.bottom);
// De-select the pen and ROP
::SetROP2(hDC, iOldROP); SelectPen(hDC, hOldPen); }
if (hPen != NULL) { ::DeletePen(hPen); }}
//
//
// Function: DCWbGraphicLine::MoveBy
//
// Purpose: Move the line.
//
//
void DCWbGraphicLine::MoveBy(int cx, int cy){ // Move the start and end points
::OffsetRect(&m_rect, cx, cy);
// Move the other object attributes
DCWbGraphic::MoveBy(cx, cy);}
//
// Checks object for an actual overlap with pRectHit. Assumes m_boundsRect
// has already been compared.
//
BOOL DCWbGraphicLine::CheckReallyHit(LPCRECT pRectHit){ return(LineHit(m_rect.left, m_rect.top, m_rect.right, m_rect.bottom, m_uiPenWidth, TRUE, TRUE, pRectHit));}
//
//
// Function: DCWbGraphicFreehand::DCWbGraphicFreehand
//
// Purpose: Constructor
//
//
DCWbGraphicFreehand::DCWbGraphicFreehand(void) : DCWbGraphic(){}
DCWbGraphicFreehand::DCWbGraphicFreehand(PWB_GRAPHIC pHeader) : DCWbGraphic()
{ MLZ_EntryOut(ZONE_FUNCTION, "DCWbGraphicFreehand::DCWbGraphicFreehand");
// Note that we do everything in this constructor because of the
// call to ReadExternal. If we let the DCWbGraphic base constructor
// do it the wrong version of ReadExtra will be called (the one
// in DCWbGraphic instead of the one in DCWbGraphicFreehand);
// Do the basic initialization
Initialize();
// Set up the page and graphic handle
ASSERT(pHeader != NULL);
// Read the header data
ReadHeader(pHeader);
// Read the extra data
ReadExtra(pHeader);
}
DCWbGraphicFreehand::DCWbGraphicFreehand( WB_PAGE_HANDLE hPage, WB_GRAPHIC_HANDLE hGraphic) : DCWbGraphic()
{ MLZ_EntryOut(ZONE_FUNCTION, "DCWbGraphicFreehand::DCWbGraphicFreehand");
// Note that we do everything in this constructor because of the
// call to ReadExternal. If we let the DCWbGraphic base constructor
// do it the wrong version of ReadExtra will be called (the one
// in DCWbGraphic instead of the one in DCWbGraphicFreehand);
// Do the basic initialization
Initialize();
ASSERT(hPage != WB_PAGE_HANDLE_NULL); m_hPage = hPage;
ASSERT(hGraphic != NULL); m_hGraphic = hGraphic;
// Read the header data
ReadExternal();}
DCWbGraphicFreehand::~DCWbGraphicFreehand( void ){ // don't know if we are selected or not so just delete anyway
if(g_pDraw != NULL && g_pDraw->m_pMarker != NULL) { g_pDraw->m_pMarker->DeleteMarker( this ); }}
//
//
// Function: DCWbGraphicFreehand::MoveBy
//
// Purpose: Move the polyline.
//
//
void DCWbGraphicFreehand::MoveBy(int cx, int cy){ // Move the base point of the freehand object
m_rect.left += cx; m_rect.top += cy;
// Move the other object attributes
DCWbGraphic::MoveBy(cx, cy);}
//
//
// Function: DCWbGraphicFreehand::Draw
//
// Purpose: Draw the polyline.
//
//
void DCWbGraphicFreehand::Draw(HDC hDC){ RECT clipBox; int iOldROP; HPEN hPen; HPEN hOldPen;
MLZ_EntryOut(ZONE_FUNCTION, "DCWbGraphicFreehand:Draw");
// NFC, SFR 5922. Check the return code from GetClipBox.
// If we fail to get it, just draw everything
if (::GetClipBox(hDC, &clipBox) == ERROR) { WARNING_OUT(("Failed to get clip box")); } else if (!::IntersectRect(&clipBox, &clipBox, &m_boundsRect)) { TRACE_MSG(("No clip/bounds intersection")); return; }
// Select the required pen
hPen = ::CreatePen(m_iPenStyle, m_uiPenWidth, m_clrPenColor); hOldPen = SelectPen(hDC, hPen);
// Select the raster operation
iOldROP = ::SetROP2(hDC, m_iPenROP);
if (hOldPen != NULL) { // All points are relative to the first point in the list.
// We update the origin of the DC temporarily to account for this.
POINT origin;
::GetWindowOrgEx(hDC, &origin); ::SetWindowOrgEx(hDC, origin.x - m_rect.left, origin.y - m_rect.top, NULL);
// Call the appropriate drawing function, according to whether
// we're smooth or not
DrawUnsmoothed(hDC);
// Restore the origin
::SetWindowOrgEx(hDC, origin.x, origin.y, NULL);
::SetROP2(hDC, iOldROP); SelectPen(hDC, hOldPen); }
if (hPen != NULL) { ::DeletePen(hPen); }}
//
//
// Function: DCWbGraphicFreehand::DrawUnsmoothed
//
// Purpose: Draw the complete graphic, not using smoothing.
//
//
void DCWbGraphicFreehand::DrawUnsmoothed(HDC hDC){ MLZ_EntryOut(ZONE_FUNCTION, "DCWbGraphicFreehandDrawUnsmoothed");
// Set up the count and pointer to the points data. We use the
// external data if we have a handle, otherwise internal data is used.
int iCount = points.GetSize(); if (iCount < 2) { POINT point; point.x = points[0]->x; point.y = points[0]->y; points.Add(point);
iCount = points.GetSize(); }
RECT clipBox;
if (::GetClipBox(hDC, &clipBox) == ERROR) { WARNING_OUT(("Failed to get clip box")); }
// Draw all the line segments stored
::MoveToEx(hDC, points[0]->x, points[0]->y, NULL); for ( int iIndex = 1; iIndex < iCount; iIndex++) { // Draw the line
::LineTo(hDC, points[iIndex]->x, points[iIndex]->y); }}
//
//
// Function: DCWbGraphicFreehand::CalculateBoundsRect
//
// Purpose: Calculate the bounding rectangle of the line
//
//
void DCWbGraphicFreehand::CalculateBoundsRect(void){ // Reset the bounds rectangle
::SetRectEmpty(&m_boundsRect);
// Add each of the points in the line to the bounding rectangle
int iCount = points.GetSize(); for ( int iIndex = 0; iIndex < iCount; iIndex++) { AddPointToBounds(points[iIndex]->x, points[iIndex]->y); }
//
// Since the points are inclusive, we need to add one to the top &
// bottom sides.
//
::InflateRect(&m_boundsRect, 0, 1); ::OffsetRect(&m_boundsRect, m_rect.left, m_rect.top);}
//
//
// Function: DCWbGraphicFreehand::AddPointToBounds
//
// Purpose: Add a single point into the bounding rectangle. The point is
// expected to be in surface co-ordinates.
//
//
void DCWbGraphicFreehand::AddPointToBounds(int x, int y){ // Create a rectangle containing the point just added (expanded
// by the width of the pen being used).
RECT rect;
int iInflate = (m_uiPenWidth + 1) / 2; rect.left = x - iInflate; rect.top = y - iInflate; rect.right = x + iInflate; rect.bottom = y + iInflate;
::UnionRect(&m_boundsRect, &m_boundsRect, &rect);}
//
//
// Function: DCWbGraphicFreehand::AddPoint
//
// Purpose: Add a point to the poly line, returning BOOL indicating
// success.
//
//
BOOL DCWbGraphicFreehand::AddPoint(POINT point){ BOOL bSuccess = TRUE;
MLZ_EntryOut(ZONE_FUNCTION, "DCWbGraphicFreehand::AddPoint");
// if we've reached the maximum number of points then quit with failure
if (points.GetSize() >= MAX_FREEHAND_POINTS) { bSuccess = FALSE; TRACE_MSG(("Maximum number of points for freehand object reached.")); return(bSuccess); }
// If this is the first point - all others are taken relative to it.
if (points.GetSize() == 0) { // Save the first point here.
m_rect.left = point.x; m_rect.top = point.y; }
// Add the new point to the array - surround with exception handler
// to catch memory errors
POINT newpoint; newpoint.x = point.x - m_rect.left; newpoint.y = point.y - m_rect.top;
points.Add((newpoint));
// Add the new point into the accumulated bounds rectangle.
AddPointToBounds(point.x, point.y);
// Show that the graphic has changed
m_bChanged = TRUE;
return(bSuccess);}
//
//
// Function: DCWbGraphicFreehand::CalculateExternalLength
//
// Purpose: Return the length of the external representation of the
// graphic.
//
//
DWORD DCWbGraphicFreehand::CalculateExternalLength(void){ MLZ_EntryOut(ZONE_FUNCTION, "DCWbGraphicFreehand::CalculateExternalLength");
// Calculate the total length of the flat representation of the graphic
return (DWORD) ( sizeof(WB_GRAPHIC_FREEHAND) + (points.GetSize() * sizeof(POINT)));}
//
//
// Function: DCWbGraphicFreehand::WriteExtra
//
// Purpose: Write the extra (non-header) data to the flat representation
// of the graphic.
//
//
void DCWbGraphicFreehand::WriteExtra(PWB_GRAPHIC pHeader){ // Allocate the memory
PWB_GRAPHIC_FREEHAND pFreehand = (PWB_GRAPHIC_FREEHAND) pHeader;
// Copy the extra details into place
pFreehand->pointCount = (TSHR_UINT16)points.GetSize(); for ( int iIndex = 0; iIndex < pFreehand->pointCount; iIndex++) { pFreehand->points[iIndex].x = (short)points[iIndex]->x; pFreehand->points[iIndex].y = (short)points[iIndex]->y; }}
//
//
// Function: DCWbGraphicFreehand::ReadExtra
//
// Purpose: Read the extra (non-header) data from the flat
// representation of the graphic.
//
//
void DCWbGraphicFreehand::ReadExtra(PWB_GRAPHIC pHeader){ // Allocate the memory
PWB_GRAPHIC_FREEHAND pFreehand = (PWB_GRAPHIC_FREEHAND) pHeader;
// Get the number of points
int iCount = pFreehand->pointCount;
// Set the size of the points array
points.SetSize(iCount);
// Copy the points from the external memory to internal
int iPointIndex = 0; while (iPointIndex < iCount) { points[iPointIndex]->x = pFreehand->points[iPointIndex].x; points[iPointIndex]->y = pFreehand->points[iPointIndex].y;
iPointIndex++; }}
//
// Checks object for an actual overlap with pRectHit. This
// function assumes that the boundingRect has already been
// compared with pRectHit.
//
BOOL DCWbGraphicFreehand::CheckReallyHit(LPCRECT pRectHit){ POINT *lpPoints; int iCount; int i; POINT ptLast; UINT uRadius; RECT rectHit;
iCount = points.GetSize(); lpPoints = (POINT *)points.GetBuffer();
if( iCount == 0 ) return( FALSE );
// addjust hit rect to lpPoints coord space.
rectHit = *pRectHit; ::OffsetRect(&rectHit, -m_rect.left, -m_rect.top);
if( (iCount > 0)&&(iCount < 2) ) { // only one point, just hit check it
uRadius = m_uiPenWidth >> 1; // m_uiPenWidth/2
return( CircleHit( lpPoints->x, lpPoints->y, uRadius, &rectHit, TRUE ) ); }
// look for a hit on each line segment body
ptLast = *lpPoints++; for( i=1; i<iCount; i++ ) { if( LineHit( ptLast.x, ptLast.y, lpPoints->x, lpPoints->y, m_uiPenWidth, FALSE, FALSE, &rectHit ) ) return( TRUE ); // got a hit
ptLast = *lpPoints++; }
// now, look for a hit on the line endpoints if m_uiPenWidth > 1
if( m_uiPenWidth > 1 ) { uRadius = m_uiPenWidth >> 1; // m_uiPenWidth/2
lpPoints = (POINT *)points.GetBuffer(); for( i=0; i<iCount; i++, lpPoints++ ) { if( CircleHit( lpPoints->x, lpPoints->y, uRadius, &rectHit, FALSE ) ) return( TRUE ); // got a hit
} }
return( FALSE ); // no hits
}
DCWbGraphicRectangle::~DCWbGraphicRectangle( void ){ // don't know if we are selected or not so just delete anyway
if(g_pDraw != NULL && g_pDraw->m_pMarker != NULL) { g_pDraw->m_pMarker->DeleteMarker( this ); }}
//
//
// Function: DCWbGraphicRectangle::SetRect
//
// Purpose: Set the rectangle size/position
//
//
void DCWbGraphicRectangle::SetRect(LPCRECT lprect){ DCWbGraphic::SetRect(lprect);
// Generate the new bounding rectangle
CalculateBoundsRect();}
//
//
// Function: DCWbGraphicRectangle::MoveBy
//
// Purpose: Move the rectangle
//
//
void DCWbGraphicRectangle::MoveBy(int cx, int cy){ // Move the rectangle
::OffsetRect(&m_rect, cx, cy);
// Move the other object attributes
DCWbGraphic::MoveBy(cx, cy);}
//
//
// Function: DCWbGraphicRectangle::CalculateBoundsRect
//
// Purpose: Calculate the bounding rectangle of the object
//
//
void DCWbGraphicRectangle::CalculateBoundsRect(void){ // Generate the new bounding rectangle
m_boundsRect = m_rect;
NormalizeRect(&m_boundsRect); ::InflateRect(&m_boundsRect, m_uiPenWidth, m_uiPenWidth);}
//
//
// Function: DCWbGraphicRectangle::Draw
//
// Purpose: Draw the rectangle
//
//
void DCWbGraphicRectangle::Draw(HDC hDC){ int iOldROP; RECT clipBox; HPEN hPen; HPEN hOldPen; HBRUSH hOldBrush;
MLZ_EntryOut(ZONE_FUNCTION, "DCWbGraphicRectangle::Draw");
// Only draw anything if the bounding rectangle intersects
// the current clip box.
if (::GetClipBox(hDC, &clipBox) == ERROR) { WARNING_OUT(("Failed to get clip box")); } else if (!::IntersectRect(&clipBox, &clipBox, &m_boundsRect)) { TRACE_MSG(("No clip/bounds intersection")); return; }
// Select the pen
hPen = ::CreatePen(m_iPenStyle, m_uiPenWidth, m_clrPenColor); hOldPen = SelectPen(hDC, hPen); hOldBrush = SelectBrush(hDC, ::GetStockObject(NULL_BRUSH));
// Select the raster operation
iOldROP = ::SetROP2(hDC, m_iPenROP);
// Draw the rectangle
::Rectangle(hDC, m_boundsRect.left, m_boundsRect.top, m_boundsRect.right, m_boundsRect.bottom);
::SetROP2(hDC, iOldROP); SelectPen(hDC, hOldPen);
if (hPen != NULL) { ::DeletePen(hPen); }}
//
// Checks object for an actual overlap with pRectHit. This
// function assumes that the boundingRect has already been
// compared with pRectHit.
//
BOOL DCWbGraphicRectangle::CheckReallyHit(LPCRECT pRectHit){ RECT rectEdge; RECT rectHit;
// check left edge
rectEdge.left = m_rect.left - m_uiPenWidth; rectEdge.top = m_rect.top - m_uiPenWidth; rectEdge.right = m_rect.left; rectEdge.bottom = m_rect.bottom + m_uiPenWidth;
if (::IntersectRect(&rectHit, &rectEdge, pRectHit)) return( TRUE );
// check right edge
rectEdge.left = m_rect.right; rectEdge.right = m_rect.right + m_uiPenWidth;
if (::IntersectRect(&rectHit, &rectEdge, pRectHit)) return( TRUE );
// check top edge
rectEdge.left = m_rect.left; rectEdge.right = m_rect.right; rectEdge.bottom = m_rect.top;
if (::IntersectRect(&rectHit, &rectEdge, pRectHit)) return( TRUE );
// check bottom edge
rectEdge.top = m_rect.bottom; rectEdge.bottom = m_rect.bottom + m_uiPenWidth;
if (::IntersectRect(&rectHit, &rectEdge, pRectHit)) return( TRUE );
return( FALSE );}
DCWbGraphicFilledRectangle::~DCWbGraphicFilledRectangle( void ){ // don't know if we are selected or not so just delete anyway
if(g_pDraw != NULL && g_pDraw->m_pMarker != NULL) { g_pDraw->m_pMarker->DeleteMarker( this ); }}
//
//
// Function: DCWbGraphicFilledRectangle::CalculateBoundsRect
//
// Purpose: Calculate the bounding rectangle of the object
//
//
void DCWbGraphicFilledRectangle::CalculateBoundsRect(void){ // Generate the new bounding rectangle
// This is one greater than the rectangle to include the drawing rectangle
m_boundsRect = m_rect;
NormalizeRect(&m_boundsRect); ::InflateRect(&m_boundsRect, 1, 1);}
//
//
// Function: DCWbGraphicFilledRectangle::Draw
//
// Purpose: Draw the rectangle
//
//
void DCWbGraphicFilledRectangle::Draw(HDC hDC){ HPEN hPen; HPEN hOldPen; HBRUSH hBrush; HBRUSH hOldBrush; int iOldROP; RECT clipBox;
MLZ_EntryOut(ZONE_FUNCTION, "DCWbGraphicFilledRectangle::Draw");
// Only draw anything if the bounding rectangle intersects
// the current clip box.
if (::GetClipBox(hDC, &clipBox) == ERROR) { WARNING_OUT(("Failed to get clip box")); } else if (!::IntersectRect(&clipBox, &clipBox, &m_boundsRect)) { TRACE_MSG(("No clip/bounds intersection")); return; }
// Select the pen
hPen = ::CreatePen(m_iPenStyle, 2, m_clrPenColor); hOldPen = SelectPen(hDC, hPen);
hBrush = ::CreateSolidBrush(m_clrPenColor); hOldBrush = SelectBrush(hDC, hBrush);
// Select the raster operation
iOldROP = ::SetROP2(hDC, m_iPenROP);
// Draw the rectangle
::Rectangle(hDC, m_boundsRect.left, m_boundsRect.top, m_boundsRect.right, m_boundsRect.bottom);
// Restore the ROP mode
::SetROP2(hDC, iOldROP);
SelectBrush(hDC, hOldBrush); if (hBrush != NULL) { ::DeleteBrush(hBrush); }
SelectPen(hDC, hOldPen); if (hPen != NULL) { ::DeletePen(hPen); }}
//
// Checks object for an actual overlap with pRectHit. This
// function assumes that the boundingRect has already been
// compared with pRectHit.
//
BOOL DCWbGraphicFilledRectangle::CheckReallyHit(LPCRECT pRectHit){ return( TRUE );}
//
// Draws a tracking rect for every marker obj in marker
// (DCWbGraphicSelectTrackingRectangle is a friend of DCWbGraphicMarker
// and WbDrawingArea)
//
void DCWbGraphicSelectTrackingRectangle::Draw(HDC hDC){ POSITION posNext; DCWbGraphic *pGraphic; LPRECT pMarkerRect; RECT rectTracker; CPtrToPtrList *pMList;
// don't draw at start point or XOR will get out of sync
if( (m_Offset.cx == 0)&&(m_Offset.cy == 0) ) return;
ASSERT(g_pDraw); pMList = &(g_pDraw->m_pMarker->MarkerList);
if( pMList->IsEmpty() ) return;
posNext = pMList->GetHeadPosition(); while( posNext != NULL ) { pMList->GetNextAssoc( posNext, (void *&)pGraphic, (void *&)pMarkerRect );
if( pMarkerRect != NULL ) { rectTracker = *pMarkerRect; ::OffsetRect(&rectTracker, m_Offset.cx, m_Offset.cy);
SetRect(&rectTracker); DCWbGraphicRectangle::Draw(hDC); } }}
void DCWbGraphicSelectTrackingRectangle::MoveBy(int cx, int cy){ m_Offset.cx += cx; m_Offset.cy += cy;}
DCWbGraphicEllipse::~DCWbGraphicEllipse( void ){ // don't know if we are selected or not so just delete anyway
if(g_pDraw != NULL && g_pDraw->m_pMarker != NULL) { g_pDraw->m_pMarker->DeleteMarker( this ); }}
//
//
// Function: DCWbGraphicEllipse::SetRect
//
// Purpose: Set the ellipse size/position
//
//
void DCWbGraphicEllipse::SetRect(LPCRECT lprc){ DCWbGraphic::SetRect(lprc);
// Generate the new bounding rectangle
CalculateBoundsRect();}
//
//
// Function: DCWbGraphicEllipse::CalculateBoundsRect
//
// Purpose: Calculate the bounding rectangle of the object
//
//
void DCWbGraphicEllipse::CalculateBoundsRect(void){ // Generate the new bounding rectangle
// This includes all the line, since we draw inside the bounds
m_boundsRect = m_rect;
NormalizeRect(&m_boundsRect); ::InflateRect(&m_boundsRect, m_uiPenWidth, m_uiPenWidth);}
//
//
// Function: DCWbGraphicEllipse::MoveBy
//
// Purpose: Move the ellipse
//
//
void DCWbGraphicEllipse::MoveBy(int cx, int cy){ // Move the ellipse
::OffsetRect(&m_rect, cx, cy);
// Move the other object attributes
DCWbGraphic::MoveBy(cx, cy);}
//
//
// Function: DCWbGraphicEllipse::Draw
//
// Purpose: Draw the ellipse
//
//
void DCWbGraphicEllipse::Draw(HDC hDC){ HPEN hPen; HPEN hOldPen; HBRUSH hOldBrush; int iOldROP; RECT clipBox;
MLZ_EntryOut(ZONE_FUNCTION, "DCWbGraphicEllipse::Draw");
// Only draw anything if the bounding rectangle intersects
// the current clip box.
if (::GetClipBox(hDC, &clipBox) == ERROR) { WARNING_OUT(("Failed to get clip box")); } else if (!::IntersectRect(&clipBox, &clipBox, &m_boundsRect)) { TRACE_MSG(("No clip/bounds intersection")); return; }
// Select the pen
hPen = ::CreatePen(m_iPenStyle, m_uiPenWidth, m_clrPenColor); hOldPen = SelectPen(hDC, hPen); hOldBrush = SelectBrush(hDC, ::GetStockObject(NULL_BRUSH));
// Select the raster operation
iOldROP = ::SetROP2(hDC, m_iPenROP);
// Draw the rectangle
::Ellipse(hDC, m_boundsRect.left, m_boundsRect.top, m_boundsRect.right, m_boundsRect.bottom);
::SetROP2(hDC, iOldROP);
SelectBrush(hDC, hOldBrush);
SelectPen(hDC, hOldPen); if (hPen != NULL) { ::DeletePen(hPen); }}
//
// Checks object for an actual overlap with pRectHit. This
// function assumes that the boundingRect has already been
// compared with pRectHit.
//
BOOL DCWbGraphicEllipse::CheckReallyHit(LPCRECT pRectHit){ return( EllipseHit( &m_rect, TRUE, m_uiPenWidth, pRectHit ) );}
DCWbGraphicFilledEllipse::~DCWbGraphicFilledEllipse( void ){ // don't know if we are selected or not so just delete anyway
if(g_pDraw != NULL && g_pDraw->m_pMarker != NULL) { g_pDraw->m_pMarker->DeleteMarker( this ); }}
//
//
// Function: DCWbGraphicFilledEllipse::CalculateBoundsRect
//
// Purpose: Calculate the bounding rectangle of the object
//
//
void DCWbGraphicFilledEllipse::CalculateBoundsRect(void){ // Generate the new bounding rectangle
// This is one greater than the rectangle to include the drawing rectangle
m_boundsRect = m_rect;
NormalizeRect(&m_boundsRect); ::InflateRect(&m_boundsRect, 1, 1);}
//
//
// Function: DCWbGraphicFilledEllipse::Draw
//
// Purpose: Draw the ellipse
//
//
void DCWbGraphicFilledEllipse::Draw(HDC hDC){ RECT clipBox; HPEN hPen; HPEN hOldPen; HBRUSH hBrush; HBRUSH hOldBrush; int iOldROP;
MLZ_EntryOut(ZONE_FUNCTION, "DCWbGraphicFilledEllipse::Draw");
// Only draw anything if the bounding rectangle intersects
// the current clip box.
if (::GetClipBox(hDC, &clipBox) == ERROR) { WARNING_OUT(("Failed to get clip box")); } else if (!::IntersectRect(&clipBox, &clipBox, &m_boundsRect)) { TRACE_MSG(("No clip/bounds intersection")); return; }
// Select the pen
hPen = ::CreatePen(m_iPenStyle, 2, m_clrPenColor); hOldPen = SelectPen(hDC, hPen);
hBrush = ::CreateSolidBrush(m_clrPenColor); hOldBrush = SelectBrush(hDC, hBrush);
// Select the raster operation
iOldROP = ::SetROP2(hDC, m_iPenROP);
// Draw the rectangle
::Ellipse(hDC, m_boundsRect.left, m_boundsRect.top, m_boundsRect.right, m_boundsRect.bottom);
::SetROP2(hDC, iOldROP);
SelectBrush(hDC, hOldBrush); if (hBrush != NULL) { ::DeleteBrush(hBrush); }
SelectPen(hDC, hOldPen); if (hPen != NULL) { ::DeletePen(hPen); }
}
//
// Checks object for an actual overlap with pRectHit. This
// function assumes that the boundingRect has already been
// compared with pRectHit.
//
BOOL DCWbGraphicFilledEllipse::CheckReallyHit(LPCRECT pRectHit){ return( EllipseHit( &m_rect, FALSE, 0, pRectHit ) );}
//
//
// Function: DCWbGraphicText::DCWbGraphicText
//
// Purpose: Initialize a new drawn text object.
//
//
DCWbGraphicText::DCWbGraphicText(void){ MLZ_EntryOut(ZONE_FUNCTION, "DCWbGraphicText::DCWbGraphicText");
m_hFontThumb = NULL;
m_hFont = ::CreateFont(0,0,0,0,FW_NORMAL,0,0,0,0,OUT_TT_PRECIS, CLIP_DFA_OVERRIDE, DRAFT_QUALITY, FF_SWISS,NULL);
// Add an empty line to the text array
strTextArray.Add(_T(""));
// Show that the graphic has not changed
m_bChanged = FALSE;
m_nKerningOffset = 0; // added for bug 469
}
DCWbGraphicText::DCWbGraphicText(PWB_GRAPHIC pHeader) : DCWbGraphic(){ MLZ_EntryOut(ZONE_FUNCTION, "DCWbGraphicText::DCWbGraphicText");
ASSERT(pHeader != NULL);
m_hFont = NULL; m_hFontThumb = NULL;
// Note that we do everything in this constructor because of the
// calls to ReadHeader and ReadExtra. If we let the DCWbGraphic base
// constructor do it the wrong version of ReadExtra will be called
// (the one in DCWbGraphic instead of the one in DCWbGraphicText).
// Add an empty line to the text array
strTextArray.Add(_T(""));
// Read the data
ReadHeader(pHeader); ReadExtra(pHeader);
// Show that the graphic has not changed
m_bChanged = FALSE;}
DCWbGraphicText::DCWbGraphicText( WB_PAGE_HANDLE hPage, WB_GRAPHIC_HANDLE hGraphic) : DCWbGraphic(){ MLZ_EntryOut(ZONE_FUNCTION, "DCWbGraphicText::DCWbGraphicText");
// Note that we do everything in this constructor because of the
// call to ReadExternal. If we let the DCWbGraphic base constructor
// do it the wrong version of ReadExtra will be called (the one
// in DCWbGraphic instead of the one in DCWbGraphicText);
// Set up the page and graphic handle
ASSERT(hPage != WB_PAGE_HANDLE_NULL); m_hPage = hPage;
ASSERT(hGraphic != NULL); m_hGraphic = hGraphic;
m_hFont = NULL; m_hFontThumb = NULL;
// Add an empty line to the text array
strTextArray.Add(_T(""));
// Read the data
ReadExternal();
// Show that the graphic has not changed
m_bChanged = FALSE;}
//
//
// Function: DCWbGraphicText:: ~DCWbGraphicText
//
// Purpose: Destruct a text object
//
//
DCWbGraphicText::~DCWbGraphicText(){ MLZ_EntryOut(ZONE_FUNCTION, "DCWbGraphicText::~DCWbGraphicText");
// don't know if we are selected or not so just delete anyway
if(g_pDraw != NULL && g_pDraw->m_pMarker != NULL) { g_pDraw->m_pMarker->DeleteMarker( this ); }
// Ensure that the DC does not contain our fonts
if(g_pDraw != NULL) { g_pDraw->UnPrimeFont(g_pDraw->GetCachedDC()); }
if (m_hFontThumb != NULL) { ::DeleteFont(m_hFontThumb); m_hFontThumb = NULL; }
if (m_hFont != NULL) { ::DeleteFont(m_hFont); m_hFont = NULL; }}
StrCspn(char * string, char * control){ char *str = string; char *ctrl = control;
unsigned char map[32]; int count;
/* Clear out bit map */ for (count=0; count<32; count++) map[count] = 0;
/* Set bits in control map */ while (*ctrl) { map[*ctrl >> 3] |= (1 << (*ctrl & 7)); ctrl++; } count=0; map[0] |= 1; /* null chars not considered */ while (!(map[*str >> 3] & (1 << (*str & 7)))) { count++; str++; } return(count);}
//
//
// Function: DCWbGraphicText::SetText
//
// Purpose: Set the text of the object
//
//
void DCWbGraphicText::SetText(TCHAR * strText){ // Remove all the current stored text
strTextArray.RemoveAll();
// Scan the text for carriage return and new-line characters
int iNext = 0; int iLast = 0; int textSize = lstrlen(strText); TCHAR savedChar[1];
//
// In this case, we don't know how many lines there will be. So we
// use Add() from the StrArray class.
//
while (iNext < textSize) { // Find the next carriage return or line feed
iNext += StrCspn(strText + iNext, "\r\n");
// Extract the text before the terminator
// and add it to the current list of text lines.
savedChar[0] = strText[iNext]; strText[iNext] = 0; strTextArray.Add((strText+iLast)); strText[iNext] = savedChar[0];
if (iNext < textSize) { // Skip the carriage return
if (strText[iNext] == '\r') iNext++;
// Skip a following new line (if there is one)
if (strText[iNext] == '\n') iNext++;
// Update the index of the start of the next line
iLast = iNext; } }
// Calculate the bounding rectangle for the new text
CalculateBoundsRect();
// Show that the graphic has not changed
m_bChanged = TRUE;}
//
//
// Function: DCWbGraphicText::SetText
//
// Purpose: Set the text of the object
//
//
void DCWbGraphicText::SetText(const StrArray& _strTextArray){ // Scan the text for carriage return and new-line characters
int iSize = _strTextArray.GetSize();
//
// In this case we know how many lines, so set that # then use SetAt()
// to stick text there.
//
strTextArray.RemoveAll(); strTextArray.SetSize(iSize);
int iNext = 0; for ( ; iNext < iSize; iNext++) { strTextArray.SetAt(iNext, _strTextArray[iNext]); }
// Calculate the new bounding rectangle
CalculateBoundsRect();
// Show that the graphic has changed
m_bChanged = TRUE;}
//
//
// Function: DCWbGraphicText::SetFont
//
// Purpose: Set the font to be used for drawing
//
//
void DCWbGraphicText::SetFont(HFONT hFont){ MLZ_EntryOut(ZONE_FUNCTION, "DCWbGraphicText::SetFont");
// Get the font details
LOGFONT lfont; ::GetObject(hFont, sizeof(LOGFONT), &lfont);
//
// Pass the logical font into the SetFont() function
//
SetFont(&lfont);}
//
//
// Function: DCWbGraphicText::SetFont(metrics)
//
// Purpose: Set the font to be used for drawing
//
//
void DCWbGraphicText::SetFont(LOGFONT *pLogFont, BOOL bReCalc ){ HFONT hOldFont;
MLZ_EntryOut(ZONE_FUNCTION, "DCWbGraphicText::SetFont");
// Ensure that the font can be resized by the zoom function
// (proof quality prevents font scaling).
pLogFont->lfQuality = DRAFT_QUALITY;
//zap FontAssociation mode (bug 3258)
pLogFont->lfClipPrecision |= CLIP_DFA_OVERRIDE;
// Always work in cell coordinates to get scaling right
TRACE_MSG(("Setting font height %d, width %d, face %s, family %d, precis %d", pLogFont->lfHeight,pLogFont->lfWidth,pLogFont->lfFaceName, pLogFont->lfPitchAndFamily, pLogFont->lfOutPrecision));
hOldFont = m_hFont;
m_hFont = ::CreateFontIndirect(pLogFont); if (!m_hFont) { // Could not create the font
ERROR_OUT(("Failed to create font")); DefaultExceptionHandler(WBFE_RC_WINDOWS, 0); return; }
// Calculate the line height for this font
if(g_pDraw != NULL) { HDC hDC = g_pDraw->GetCachedDC();
g_pDraw->PrimeFont(hDC, m_hFont, &m_textMetrics); }
// We are now guaranteed to be able to delete the old font
if (hOldFont != NULL) { ::DeleteFont(hOldFont); }
// Set up the thumbnail font, forcing truetype if not currently TT
if (!(m_textMetrics.tmPitchAndFamily & TMPF_TRUETYPE)) { pLogFont->lfFaceName[0] = 0; pLogFont->lfOutPrecision = OUT_TT_PRECIS; TRACE_MSG(("Non-True type font")); }
if (m_hFontThumb != NULL) { ::DeleteFont(m_hFontThumb); } m_hFontThumb = ::CreateFontIndirect(pLogFont); if (!m_hFontThumb) { // Could not create the font
ERROR_OUT(("Failed to create thumbnail font")); DefaultExceptionHandler(WBFE_RC_WINDOWS, 0); return; }
// Calculate the bounding rectangle, accounting for the new font
if( bReCalc ) CalculateBoundsRect();
// Show that the graphic has changed
m_bChanged = TRUE;}
//
//
// Function: DCWbGraphicText::GetTextABC
//
// Purpose: Calculate the ABC numbers for a string of text
//
// COMMENT BY RAND: The abc returned is for the whole string, not just one
// char. I.e, ABC.abcA is the offset to the first glyph in
// the string, ABC.abcB is the sum of all of the glyphs and
// ABC.abcC is the trailing space after the last glyph.
// ABC.abcA + ABC.abcB + ABC.abcC is the total rendered
// length including overhangs.
//
// Note - we never use the A spacing so it is always 0
//
ABC DCWbGraphicText::GetTextABC( LPCTSTR pText, int iStartX, int iStopX){ MLZ_EntryOut(ZONE_FUNCTION, "DCWbGraphicText::GetTextABC"); ABC abcResult; HDC hDC; BOOL rc = FALSE; ABC abcFirst; ABC abcLast; BOOL zoomed = g_pDraw->Zoomed(); int nCharLast; int i; LPCTSTR pScanStr; ZeroMemory( (PVOID)&abcResult, sizeof abcResult ); ZeroMemory( (PVOID)&abcFirst, sizeof abcFirst ); ZeroMemory( (PVOID)&abcLast, sizeof abcLast );
// Get the standard size measure of the text
LPCTSTR pABC = (pText + iStartX); int pABCLength = iStopX - iStartX; hDC = g_pDraw->GetCachedDC(); g_pDraw->PrimeFont(hDC, m_hFont, &m_textMetrics);
//
// We must temporarily unzoom if we are currently zoomed since the
// weird Windows font handling will not give us the same answer for
// the text extent in zoomed mode for some TrueType fonts
//
if (zoomed) { ::ScaleViewportExtEx(hDC, 1, g_pDraw->ZoomFactor(), 1, g_pDraw->ZoomFactor(), NULL); }
DWORD size = ::GetTabbedTextExtent(hDC, pABC, pABCLength, 0, NULL);
// We now have the advance width of the text
abcResult.abcB = LOWORD(size); TRACE_MSG(("Basic text width is %d",abcResult.abcB));
// Allow for C space (or overhang)
if (iStopX > iStartX) { if (m_textMetrics.tmPitchAndFamily & TMPF_TRUETYPE) { if(GetSystemMetrics( SM_DBCSENABLED )) { // have to handle DBCS on both ends
if( IsDBCSLeadByte( (BYTE)pABC[0] ) ) { // pack multi byte char into a WORD for GetCharABCWidths
WORD wMultiChar = MAKEWORD( pABC[1], pABC[0] ); rc = ::GetCharABCWidths(hDC, wMultiChar, wMultiChar, &abcFirst); } else { // first char is SBCS
rc = ::GetCharABCWidths(hDC, pABC[0], pABC[0], &abcFirst ); }
// Check for DBCS as last char. Have to scan whole string to be sure
pScanStr = pABC; nCharLast = 0; for( i=0; i<pABCLength; i++, pScanStr++ ) { nCharLast = i; if( IsDBCSLeadByte( (BYTE)*pScanStr ) ) { i++; pScanStr++; } }
if( IsDBCSLeadByte( (BYTE)pABC[nCharLast] ) ) { // pack multi byte char into a WORD for GetCharABCWidths
ASSERT( (nCharLast+1) < pABCLength ); WORD wMultiChar = MAKEWORD( pABC[nCharLast+1], pABC[nCharLast] ); rc = ::GetCharABCWidths(hDC, wMultiChar, wMultiChar, &abcLast); } else { // last char is SBCS
rc = ::GetCharABCWidths(hDC, pABC[nCharLast], pABC[nCharLast], &abcLast ); } } else { // SBCS, no special fiddling, just call GetCharABCWidths()
rc = ::GetCharABCWidths(hDC, pABC[0], pABC[0], &abcFirst );
nCharLast = pABCLength-1; rc = rc && ::GetCharABCWidths(hDC, pABC[nCharLast], pABC[nCharLast], &abcLast ); }
TRACE_MSG(("abcFirst: rc=%d, a=%d, b=%d, c=%d", rc, abcFirst.abcA, abcFirst.abcB, abcFirst.abcC) ); TRACE_MSG(("abcLast: rc=%d, a=%d, b=%d, c=%d", rc, abcLast.abcA, abcLast.abcB, abcLast.abcC) ); }
if( rc ) { // The text was trutype and we got good abcwidths
// Give the C space of the last characters from
// the string as the C space of the text.
abcResult.abcA = abcFirst.abcA; abcResult.abcC = abcLast.abcC; } else { //
// Mock up C value for a non TT font by taking some of overhang as
// the negative C value.
//
//TRACE_MSG(("Using overhang -%d as C space",m_textMetrics.tmOverhang/2));
// Adjust B by -overhang to make update rect schoot
// far enough to the left so that the toes of italic cap A's
// don't get clipped. Ignore comment above.
abcResult.abcB -= m_textMetrics.tmOverhang; } }
//
// If we temporarily unzoomed then restore it now
//
if (zoomed) { ::ScaleViewportExtEx(hDC, g_pDraw->ZoomFactor(), 1, g_pDraw->ZoomFactor(), 1, NULL); }
TRACE_MSG(("Final text width is %d, C space %d",abcResult.abcB,abcResult.abcC));
return abcResult; }
//
//
// Function: DCWbGraphicText::GetTextRectangle
//
// Purpose: Calculate the bounding rectangle of a portion of the object
//
//
void DCWbGraphicText::GetTextRectangle(int iStartY, int iStartX, int iStopX, LPRECT lprc){ // ABC structures for text sizing
ABC abcText1; ABC abcText2; int iLeftOffset = 0; MLZ_EntryOut(ZONE_FUNCTION, "DCWbGraphicText::GetTextRect");
// Here we calculate the width of the text glyphs in which we
// are interested. In case there are tabs involved we must start
// with position 0 and get two lengths then subtract them
abcText1 = GetTextABC(strTextArray[iStartY], 0, iStopX);
if (iStartX > 0) { // The third param used to be iStartX-1 which is WRONG. It
// has to point to the first char pos past the string
// we are using.
abcText2 = GetTextABC(strTextArray[iStartY], 0, iStartX);
// Just use B part for offset. Adding A snd/or C to it moves the update
// rectangle too far to the right and clips the char
iLeftOffset = abcText2.abcB; } else { ZeroMemory( &abcText2, sizeof abcText2 ); }
//
// We need to allow for A and C space in the bounding rectangle. Use
// ABS function just to make sure we get a large enough rectangle.
//
// Move A and C from original offset calc to here for width of update
// rectangle. Add in tmOverhang (non zero for non-tt fonts) to compensate
// for the kludge in GetTextABC()....THIS EDITBOX CODE HAS GOT TO GO...
abcText1.abcB = abcText1.abcB - iLeftOffset + abs(abcText2.abcA) + abs(abcText2.abcC) + abs(abcText1.abcA) + abs(abcText1.abcC) + m_textMetrics.tmOverhang;
TRACE_DEBUG(("Left offset %d",iLeftOffset)); TRACE_DEBUG(("B width now %d",abcText1.abcB));
// Build the result rectangle.
// Note that we never return an empty rectangle. This allows for the
// fact that the Windows rectangle functions will ignore empty
// rectangles completely. This would cause the bounding rectangle
// calculation (for instance) to go wrong if the top or bottom lines
// in a text object were empty.
int iLineHeight = m_textMetrics.tmHeight + m_textMetrics.tmExternalLeading;
lprc->left = 0; lprc->top = 0; lprc->right = max(1, abcText1.abcB); lprc->bottom = iLineHeight; ::OffsetRect(lprc, iLeftOffset, iLineHeight * iStartY);
// rect is the correct width at this point but it might need to be schooted to
// the left a bit to allow for kerning of 1st letter (bug 469)
if( abcText1.abcA < 0 ) { ::OffsetRect(lprc, abcText1.abcA, 0); m_nKerningOffset = -abcText1.abcA; } else m_nKerningOffset = 0;
POINT pt; GetPosition(&pt); ::OffsetRect(lprc, pt.x, pt.y);}
//
//
// Function: DCWbGraphicText::CalculateRect
//
// Purpose: Calculate the bounding rectangle of a portion of the object
//
//
void DCWbGraphicText::CalculateRect(int iStartX, int iStartY, int iStopX, int iStopY, LPRECT lprcResult){ RECT rcResult; RECT rcT;
MLZ_EntryOut(ZONE_FUNCTION, "DCWbGraphicText::CalculateRect");
//
// NOTE:
// We must use an intermediate rectangle, so as not to disturb the
// contents of the passed-in one until done. lprcResult may be pointing
// to the current bounds rect, and we call functions from here that
// may need its current value.
//
// Initialize the result rectangle
::SetRectEmpty(&rcResult);
// Allow for special limit values and ensure that the start and stop
// character positions are in range.
if (iStopY == LAST_LINE) { iStopY = strTextArray.GetSize() - 1; } iStopY = min(iStopY, strTextArray.GetSize() - 1); iStopY = max(iStopY, 0);
if (iStopX == LAST_CHAR) { iStopX = lstrlen(strTextArray[iStopY]); } iStopX = min(iStopX, lstrlen(strTextArray[iStopY])); iStopX = max(iStopX, 0);
// Loop through the text strings, adding each to the rectangle
for (int iIndex = iStartY; iIndex <= iStopY; iIndex++) { int iLeftX = ((iIndex == iStartY) ? iStartX : 0); int iRightX = ((iIndex == iStopY) ? iStopX : lstrlen(strTextArray[iIndex]));
GetTextRectangle(iIndex, iLeftX, iRightX, &rcT); ::UnionRect(&rcResult, &rcResult, &rcT); }
*lprcResult = rcResult;}
//
//
// Function: DCWbGraphicText::CalculateBoundsRect
//
// Purpose: Calculate the bounding rectangle of the object
//
//
void DCWbGraphicText::CalculateBoundsRect(void){ // Set the new bounding rectangle
CalculateRect(0, 0, LAST_CHAR, LAST_LINE, &m_boundsRect);}
//
//
// Function: DCWbGraphicText::Draw
//
// Purpose : Draw the object onto the specified DC
//
//
void DCWbGraphicText::Draw(HDC hDC, BOOL thumbNail){ RECT clipBox; BOOL dbcsEnabled = GetSystemMetrics(SM_DBCSENABLED); INT *tabArray; UINT ch; int i,j; BOOL zoomed = g_pDraw->Zoomed(); int oldBkMode = 0; int iIndex = 0; POINT pointPos; int nLastTab; ABC abc; int iLength; TCHAR * strLine;
MLZ_EntryOut(ZONE_FUNCTION, "DCWbGraphicText::Draw");
//
// Only draw anything if the bounding rectangle intersects the current
// clip box.
//
if (::GetClipBox(hDC, &clipBox) == ERROR) { WARNING_OUT(("Failed to get clip box")); } else if (!::IntersectRect(&clipBox, &clipBox, &m_boundsRect)) { TRACE_MSG(("No clip/bounds intersection")); return; }
//
// Select the font.
//
if (thumbNail) { TRACE_MSG(("Using thumbnail font")); g_pDraw->PrimeFont(hDC, m_hFontThumb, &m_textMetrics); } else { TRACE_MSG(("Using standard font")); g_pDraw->PrimeFont(hDC, m_hFont, &m_textMetrics); }
//
// Set the color and mode for drawing.
//
::SetTextColor(hDC, m_clrPenColor);
//
// Set the background to be transparent
//
oldBkMode = ::SetBkMode(hDC, TRANSPARENT);
//
// Calculate the bounding rectangle, accounting for the new font.
//
CalculateBoundsRect();
//
// Get the start point for the text.
//
pointPos.x = m_boundsRect.left + m_nKerningOffset; pointPos.y = m_boundsRect.top;
//
// Loop through the text strings drawing each as we go.
//
for (iIndex = 0; iIndex < strTextArray.GetSize(); iIndex++) { //
// Get a reference to the line to be printed for convenience.
//
strLine = (LPTSTR)strTextArray[iIndex]; iLength = lstrlen(strLine);
//
// Only draw the line if there are any characters in it.
//
if (iLength > 0) { if (zoomed) { // if new fails just skip it
tabArray = new INT[iLength+1]; if( tabArray == NULL ) { ERROR_OUT(("Failed to allocate tabArray")); continue; }
// We are zoomed. Must calculate char spacings
// ourselfs so that they end up proportionally
// in the right places. TabbedTextOut will not
// do this right so we have to use ExtTextOut with
// a tab array.
// figure out tab array
j = 0; nLastTab = 0; for (i=0; i < iLength; i++) { ch = strLine[(int)i]; //Don't worry about DBCS here...
abc = GetTextABC(strLine, 0, i);
if( j > 0 ) tabArray[j-1] = abc.abcB - nLastTab;
nLastTab = abc.abcB; j++; }
// Now, strip out any tab chars so they don't interact
// in an obnoxious manner with the tab array we just
// made and so they don't make ugly little
// blocks when they are drawn.
for (i=0; i < iLength; i++) { ch = strLine[(int)i]; if ((dbcsEnabled) && (IsDBCSLeadByte((BYTE)ch))) i++; else if(strLine[(int)i] == '\t') strLine[i] = ' '; // blow off tab, tab array
// will compensate for this
}
// do it
::ExtTextOut(hDC, pointPos.x, pointPos.y, 0, NULL, strLine, iLength, tabArray);
delete [] tabArray; } else { POINT ptPos;
GetPosition(&ptPos);
// Not zoomed, just do it
::TabbedTextOut(hDC, pointPos.x, pointPos.y, strLine, iLength, 0, NULL, ptPos.x); } }
//
// Move to the next line.
//
pointPos.y += (m_textMetrics.tmHeight); }
//
// Restore the old background mode.
//
::SetBkMode(hDC, oldBkMode); g_pDraw->UnPrimeFont(hDC);}
//
//
// Function: DCWbGraphicText::CalculateExternalLength
//
// Purpose: Return the length of the external representation of the
// graphic.
//
//
DWORD DCWbGraphicText::CalculateExternalLength(void){ MLZ_EntryOut(ZONE_FUNCTION, "DCWbGraphicText::CalculateExternalLength");
// Loop through the text strings, adding the size of each as we go
DWORD length = sizeof(WB_GRAPHIC_TEXT); int iCount = strTextArray.GetSize(); for (int iIndex = 0; iIndex < iCount; iIndex++) { // Allow extra bytes per string for NULL term
length += lstrlen(strTextArray[iIndex]) + 2; }
return length;}
//
//
// Function: DCWbGraphicText::WriteExtra
//
// Purpose: Write the extra (non-header) data to the flat representation
// of the graphic.
//
//
void DCWbGraphicText::WriteExtra(PWB_GRAPHIC pHeader){ MLZ_EntryOut(ZONE_FUNCTION, "DCWbGraphicText::WriteExtra");
// Allocate the memory
PWB_GRAPHIC_TEXT pText = (PWB_GRAPHIC_TEXT) pHeader;
// Get the font face name
LOGFONT lfont;
::GetObject(m_hFont, sizeof(LOGFONT), &lfont);
// Copy the face name into the flat object representation
// The other information comes from the logical font details
TRACE_MSG(("Font details height %d, avwidth %d, family %d, face %s", lfont.lfHeight, lfont.lfWidth, lfont.lfPitchAndFamily, lfont.lfFaceName)); _tcscpy(pText->faceName, lfont.lfFaceName);
pText->charHeight = (short)lfont.lfHeight; pText->averageCharWidth = (short)lfont.lfWidth; pText->strokeWeight = (short)lfont.lfWeight; pText->italic = lfont.lfItalic; pText->underline = lfont.lfUnderline; pText->strikeout = lfont.lfStrikeOut; pText->pitch = lfont.lfPitchAndFamily;
//COMMENT BY RAND
// Original DCL apps ignore WB_GRAPHIC_TEXT::codePage. I am using it here
// to pass around the fonts script (character set). This might change later.
// Apps that ignore this have set it to 0 which will be interpreted as an
// ANSI_CHARSET.
pText->codePage = lfont.lfCharSet;
// Loop through the text strings, adding each as we go
char* pDest = pText->text; int iCount = strTextArray.GetSize(); for (int iIndex = 0; iIndex < iCount; iIndex++) { _tcscpy(pDest, strTextArray[iIndex]); pDest += lstrlen(strTextArray[iIndex]);
// Add the null terminator
*pDest++ = '\0'; }
// Save the number of strings
pText->stringCount = (TSHR_UINT16)iCount;}
//
//
// Function: DCWbGraphicText::ReadExtra
//
// Purpose: Read the extra (non-header) data from the flat
// representation of the graphic.
//
//
void DCWbGraphicText::ReadExtra(PWB_GRAPHIC pHeader){ MLZ_EntryOut(ZONE_FUNCTION, "DCWbGraphicText::ReadExtra");
// Allocate the memory
PWB_GRAPHIC_TEXT pText = (PWB_GRAPHIC_TEXT) pHeader;
// Get the font details
LOGFONT lfont;
lfont.lfHeight = (short)pText->charHeight;//
lfont.lfWidth = pText->averageCharWidth; lfont.lfEscapement = 0; lfont.lfOrientation = 0; lfont.lfWeight = pText->strokeWeight; lfont.lfItalic = pText->italic; lfont.lfUnderline = pText->underline; lfont.lfStrikeOut = pText->strikeout;
//COMMENT BY RAND
// Original DCL apps ignore WB_GRAPHIC_TEXT::codePage. I am using it here
// to pass around the fonts script (character set). This might change later.
// Apps that ignore this have set it to 0 which will be interpreted as an
// ANSI_CHARSET.
lfont.lfCharSet = (BYTE)pText->codePage;
lfont.lfOutPrecision = OUT_DEFAULT_PRECIS; lfont.lfClipPrecision = CLIP_DEFAULT_PRECIS | CLIP_DFA_OVERRIDE; lfont.lfQuality = DRAFT_QUALITY; lfont.lfPitchAndFamily = pText->pitch; _tcscpy(lfont.lfFaceName, pText->faceName); TRACE_MSG(("Setting height to %d, width %d, pitch %d, face %s", pText->charHeight, pText->averageCharWidth, pText->pitch, pText->faceName));
// Loop through the text strings, retrieving each as we go
TCHAR* pString = pText->text; int iCount = pText->stringCount;
// Remove all the current stored text
strTextArray.RemoveAll(); strTextArray.SetSize(iCount);
for (int iIndex = 0; iIndex < iCount; iIndex++) { strTextArray.SetAt(iIndex, pString); pString += lstrlen(pString);
// Skip the null terminator
pString++; }
// Set the current font
SetFont(&lfont);
}
//
//
// Function: InvalidateMetrics
//
// Purpose: Mark the metrics need retrieving again
//
//
void DCWbGraphicText::InvalidateMetrics(void){}
//
// Checks object for an actual overlap with pRectHit. This
// function assumes that the boundingRect has already been
// compared with pRectHit.
//
BOOL DCWbGraphicText::CheckReallyHit(LPCRECT pRectHit ){ return( TRUE );}
// version of Position() that compensates for kerning (bug 469)
void DCWbGraphicText::GetPosition(LPPOINT lppt){ lppt->x = m_boundsRect.left + m_nKerningOffset; lppt->y = m_boundsRect.top;}
//
//
// Function: DCWbGraphicDIB::DCWbGraphicDIB
//
// Purpose: Initialize a new drawn bitmap object.
//
//
DCWbGraphicDIB::DCWbGraphicDIB(void){ // Show that we have no internal image
m_lpbiImage = NULL;}
DCWbGraphicDIB::DCWbGraphicDIB(PWB_GRAPHIC pHeader) : DCWbGraphic(pHeader){ // Show that we have no internal image
m_lpbiImage = NULL;}
DCWbGraphicDIB::DCWbGraphicDIB( WB_PAGE_HANDLE hPage, WB_GRAPHIC_HANDLE hGraphic) : DCWbGraphic(hPage, hGraphic){ // Show that we have no internal image
m_lpbiImage = NULL;}
//
//
// Function: DCWbGraphicDIB::~DCWbGraphicDIB
//
// Purpose: Destruct a drawn bitmap object.
//
//
DCWbGraphicDIB::~DCWbGraphicDIB(void){ MLZ_EntryOut(ZONE_FUNCTION, "DCWbGraphicDIB::~DCWbGraphicDIB");
// don't know if we are selected or not so just delete anyway
if(g_pDraw->m_pMarker != NULL) { g_pDraw->m_pMarker->DeleteMarker( this ); }
DeleteImage();}
//
//
// Function: DCWbGraphicDIB::SetImage
//
// Purpose: Set the image of the object
//
//
void DCWbGraphicDIB::SetImage(LPBITMAPINFOHEADER lpbi){ // Delete any current bits
DeleteImage();
// Save the DIB bits--this is a COPY we now own
m_lpbiImage = lpbi;
// Update the bounds rectangle
CalculateBoundsRect();
// Show that the graphic has changed
m_bChanged = TRUE;}
//
//
// Function: DCWbGraphicDIB::CalculateBoundsRect
//
// Purpose: Calculate the bounding rectangle of the bitmap
//
//
void DCWbGraphicDIB::CalculateBoundsRect(){ // If there is no bitmap set up, the bounding rectangle is empty
if (m_lpbiImage == NULL) { ::SetRectEmpty(&m_boundsRect); } else { // Calculate the bounding rectangle from the size of the bitmap
m_boundsRect.right = m_boundsRect.left + m_lpbiImage->biWidth; m_boundsRect.bottom = m_boundsRect.top + m_lpbiImage->biHeight; }}
//
//
// Function: DCWbGraphicDIB::CalculateExternalLength
//
// Purpose: Return the length of the external representation of the
// graphic.
//
//
DWORD DCWbGraphicDIB::CalculateExternalLength(void){ MLZ_EntryOut(ZONE_FUNCTION, "DCWbGraphicDIB::CalculateExternalLength");
// Use the internal representation to calculate the external length.
DWORD dwLength = sizeof(WB_GRAPHIC_DIB);
if (m_lpbiImage != NULL) { dwLength += DIB_TotalLength(m_lpbiImage); } else { // If we have got an external form already, use its length
if (m_hGraphic != NULL) { dwLength = m_dwExternalLength; } }
return dwLength;}
//
//
// Function: DCWbGraphicDIB::WriteExtra
//
// Purpose: Write the data above and beyond the header to the pointer
// passed.
//
//
void DCWbGraphicDIB::WriteExtra(PWB_GRAPHIC pHeader){ MLZ_EntryOut(ZONE_FUNCTION, "DCWbGraphicDIB::WriteExtra");
// Nothing more to do if we do not have an image
if (m_lpbiImage != NULL) { // Copy the data into place
memcpy(((BYTE *) pHeader) + pHeader->dataOffset, m_lpbiImage, DIB_TotalLength(m_lpbiImage)); }}
//
//
// Function: DCWbGraphicDIB::ReadExtra
//
// Purpose: Read the data above and beyond the header to the pointer
// passed.
//
//
//
// DCWbGraphicDIB does not have a ReadExtra function. The Draw function
// uses the external data (if there is any) and the local data if there is
// not.
//
//
//
// Function: DCWbGraphicDIB::CopyExtra
//
// Purpose: Copy the data above and beyond the header into this object.
//
//
void DCWbGraphicDIB::CopyExtra(PWB_GRAPHIC pHeader){ MLZ_EntryOut(ZONE_FUNCTION, "DCWbGraphicDIB::CopyExtra");
// Get a pointer to the DIB data
LPBITMAPINFOHEADER lpbi; lpbi = (LPBITMAPINFOHEADER) (((BYTE *) pHeader) + pHeader->dataOffset);
// Make a DIB copy
ASSERT(m_lpbiImage == NULL); m_lpbiImage = DIB_Copy(lpbi);
// Show that the graphic has changed
m_bChanged = TRUE;}
//
//
// Function: DCWbGraphicDIB::FromScreenArea
//
// Purpose: Set the content of the object from an area of the screen
//
//
void DCWbGraphicDIB::FromScreenArea(LPCRECT lprcScreen){ LPBITMAPINFOHEADER lpbiNew;
lpbiNew = DIB_FromScreenArea(lprcScreen); if (lpbiNew != NULL) { // Set this as our current bits
SetImage(lpbiNew); } else { ::Message(NULL, (UINT)IDS_MSG_CAPTION, (UINT)IDS_CANTGETBMP, (UINT)MB_OK ); }}
//
//
// Function: DCWbGraphicDIB::DeleteImage
//
// Purpose: Delete the internal image
//
//
void DCWbGraphicDIB::DeleteImage(void){ // If we have DIB bits, delete
if (m_lpbiImage != NULL) { ::GlobalFree((HGLOBAL)m_lpbiImage); m_lpbiImage = NULL; }
// Show our contents have changed
m_bChanged = TRUE;}
//
//
// Function: DCWbGraphicDIB::GetDIBData
//
// Purpose: Return a pointer to the DIB data
//
//
BOOL DCWbGraphicDIB::GetDIBData(HOLD_DATA& hold){ MLZ_EntryOut(ZONE_FUNCTION, "DCWbGraphicDIB::GetDIBData");
// Pointer to image data (set up below depending on whether
// we have an internal or external image).
hold.lpbi = NULL; hold.pHeader = NULL;
// Draw depending on whether the DIB data is internal or external
if (m_hGraphic == NULL) { // Do nothing if we do not have an image at all
if (m_lpbiImage != NULL) { hold.lpbi = m_lpbiImage; } } else { // Lock the object data in the page
hold.pHeader = (PWB_GRAPHIC) PG_GetData(m_hPage, m_hGraphic); if (hold.pHeader != NULL) { hold.lpbi = (LPBITMAPINFOHEADER) (((BYTE *) hold.pHeader) + hold.pHeader->dataOffset); } }
return (hold.lpbi != NULL);}
//
//
// Function: DCWbGraphicDIB::ReleaseDIBData
//
// Purpose: Release DIB data previously obtained with GetDIBData
//
//
void DCWbGraphicDIB::ReleaseDIBData(HOLD_DATA& hold){ if ((m_hGraphic != NULL) && (hold.pHeader != NULL)) { // Release external memory
g_pwbCore->WBP_GraphicRelease(m_hPage, m_hGraphic, hold.pHeader); hold.pHeader = NULL; }
// Reset the hold bitmap info pointer
hold.lpbi = NULL;}
//
//
// Function: DCWbGraphicDIB::Draw
//
// Purpose: Draw the object onto the specified DC
//
//
void DCWbGraphicDIB::Draw(HDC hDC){ RECT clipBox;
MLZ_EntryOut(ZONE_FUNCTION, "DCWbGraphicDIB::Draw");
// Only draw anything if the bounding rectangle intersects
// the current clip box.
if (::GetClipBox(hDC, &clipBox) == ERROR) { WARNING_OUT(("Failed to get clip box")); } else if (!::IntersectRect(&clipBox, &clipBox, &m_boundsRect)) { TRACE_MSG(("No clip/bounds intersection")); return; }
// Pointer to image data (set up below depending on whether
// we have an internal or external image.
HOLD_DATA hold; if (GetDIBData(hold)) { // Set the stretch mode to be used so that scan lines are deleted
// rather than combined. This will tend to preserve color better.
int iOldStretchMode = ::SetStretchBltMode(hDC, STRETCH_DELETESCANS);
// Draw the bitmap
BOOL bResult = ::StretchDIBits(hDC, m_boundsRect.left, m_boundsRect.top, m_boundsRect.right - m_boundsRect.left, m_boundsRect.bottom - m_boundsRect.top, 0, 0, (UINT) hold.lpbi->biWidth, (UINT) hold.lpbi->biHeight, (VOID FAR *) DIB_Bits(hold.lpbi), (LPBITMAPINFO)hold.lpbi, DIB_RGB_COLORS, SRCCOPY);
// Restore the stretch mode
::SetStretchBltMode(hDC, iOldStretchMode);
// Release external memory
ReleaseDIBData(hold); }
}
//
// Checks object for an actual overlap with pRectHit. This
// function assumes that the boundingRect has already been
// compared with pRectHit.
//
BOOL DCWbGraphicDIB::CheckReallyHit(LPCRECT pRectHit){ return( TRUE );}
ObjectTrashCan::~ObjectTrashCan(void){ MLZ_EntryOut(ZONE_FUNCTION, "ObjectTrashCan::~ObjectTrashCan");
BurnTrash();}
BOOL ObjectTrashCan::GotTrash( void ){ MLZ_EntryOut(ZONE_FUNCTION, "ObjectTrashCan::GotTrash");
return(!Trash.IsEmpty());}
void ObjectTrashCan::BurnTrash( void ){ MLZ_EntryOut(ZONE_FUNCTION, "ObjectTrashCan::BurnTrash");
int nObjects; int i;
// zap objects
POSITION pos = Trash.GetHeadPosition(); while (pos != NULL) { delete Trash.GetNext(pos); }
// zap pointers
EmptyTrash();
}
void ObjectTrashCan::CollectTrash( DCWbGraphic *pGObj ){ MLZ_EntryOut(ZONE_FUNCTION, "ObjectTrashCan::CollectTrash");
Trash.AddTail(pGObj); // stuff it in the sack
m_hPage = pGObj->Page();}
void ObjectTrashCan::EmptyTrash( void ) { MLZ_EntryOut(ZONE_FUNCTION, "ObjectTrashCan::EmptyTrash");
// zap pointers but leave objects scattered about the room
Trash.EmptyList();
}
void ObjectTrashCan::AddToPageLast( WB_PAGE_HANDLE hPage){ MLZ_EntryOut(ZONE_FUNCTION, "ObjectTrashCan::AddToPageLast");
int nObjects; int i;
POSITION posNext = Trash.GetHeadPosition(); while( posNext != NULL ) { ((DCWbGraphic *)(Trash.GetNext(posNext)))->AddToPageLast(hPage); }}
void ObjectTrashCan::SelectTrash( void ) { MLZ_EntryOut(ZONE_FUNCTION, "ObjectTrashCan::SelectTrash");
int nObjects; int i; BOOL bForceAdd; DCWbGraphic *pGObj;
// Zap current selection with first object and then add remaining
// objects to current selection
bForceAdd = FALSE; POSITION posNext = Trash.GetHeadPosition(); while( posNext != NULL ) { pGObj = (DCWbGraphic *)(Trash.GetNext(posNext)); g_pMain->m_drawingArea.SelectGraphic( pGObj, TRUE, bForceAdd );
bForceAdd = TRUE; }
}
CPtrToPtrList::CPtrToPtrList( void ) { MLZ_EntryOut(ZONE_FUNCTION, "CPtrToPtrList::CPtrToPtrList");
}// CPtrToPtrList::CPtrToPtrList
CPtrToPtrList::~CPtrToPtrList( void ){ MLZ_EntryOut(ZONE_FUNCTION, "CPtrToPtrList::~CPtrToPtrList");
RemoveAll();
}// CPtrToPtrList::~CPtrToPtrList
void CPtrToPtrList::RemoveAll( void ) { MLZ_EntryOut(ZONE_FUNCTION, "CPtrToPtrList::RemoveAll");
POSITION pos; stPtrPair *pPp;
// clean up pairs
pos = GetHeadPosition(); while( pos != NULL ) { pPp = (stPtrPair *)GetNext( pos ); if( pPp != NULL ) delete pPp; } COBLIST::EmptyList(); }// CPtrToPtrList::~CPtrToPtrList
void CPtrToPtrList::SetAt( void *key, void *newValue ) { MLZ_EntryOut(ZONE_FUNCTION, "CPtrToPtrList::SetAt");
stPtrPair *pPp;
// see if key is already there
pPp = FindMainThingPair( key, NULL ); if( pPp != NULL ) { // it's there, we're just updating its value
pPp->pRelatedThing = newValue; } else { // this is a new entry
pPp = new stPtrPair; if( pPp != NULL ) { pPp->pMainThing = key; pPp->pRelatedThing = newValue;
AddTail(pPp); } else { ERROR_OUT( ("CPtrToPtrList: can't alloc stPtrPair") ); } }
}// CPtrToPtrList::SetAt
BOOL CPtrToPtrList::RemoveKey( void *key ) { MLZ_EntryOut(ZONE_FUNCTION, "CPtrToPtrList::RemoveKey");
POSITION pos; stPtrPair *pPp;
pPp = FindMainThingPair( key, &pos ); if( pPp != NULL ) { RemoveAt( pos ); delete pPp; return( TRUE ); } else return( FALSE );
}// CPtrToPtrList::RemoveKey
void CPtrToPtrList::GetNextAssoc( POSITION &rNextPosition, void *&rKey, void *&rValue ) { MLZ_EntryOut(ZONE_FUNCTION, "CPtrToPtrList::GetNextAssoc");
stPtrPair *pPp;
pPp = (stPtrPair *)GetNext( rNextPosition ); if( pPp != NULL ) { rKey = pPp->pMainThing; rValue = pPp->pRelatedThing; } else { rKey = NULL; rValue = NULL; }
}// CPtrToPtrList::GetNextAssoc
BOOL CPtrToPtrList::Lookup( void *key, void *&rValue ) { MLZ_EntryOut(ZONE_FUNCTION, "CPtrToPtrList::Lookup");
stPtrPair *pPp;
pPp = FindMainThingPair( key, NULL ); if( pPp != NULL ) { rValue = pPp->pRelatedThing; return( TRUE ); } else { rValue = NULL; return( FALSE ); }
}// CPtrToPtrList::Lookup
CPtrToPtrList::stPtrPair * CPtrToPtrList::FindMainThingPair( void *pMainThing, POSITION *pPos ) { MLZ_EntryOut(ZONE_FUNCTION, "CPtrToPtrList::FindMainThingPair");
POSITION pos; POSITION lastpos; stPtrPair *pPp;
if( pPos != NULL ) *pPos = NULL;
// look for pair containing pMainThing
pos = GetHeadPosition(); while( pos != NULL ) { lastpos = pos; pPp = (stPtrPair *)GetNext( pos ); if( pPp->pMainThing == pMainThing ) { if( pPos != NULL ) *pPos = lastpos;
return( pPp ); } }
// didn't find it
return( NULL );
}// CPtrToPtrList::FindMainThingPair
#define ARRAY_INCREMENT 0x200
DCDWordArray::DCDWordArray(){ MLZ_EntryOut(ZONE_FUNCTION, "DCDWordArray::DCDWordArray"); m_Size = 0; m_MaxSize = ARRAY_INCREMENT; m_pData = new POINT[ARRAY_INCREMENT]; if (!m_pData) { ERROR_OUT(("Failed to allocate m_pData POINT array")); }}
DCDWordArray::~DCDWordArray(){ MLZ_EntryOut(ZONE_FUNCTION, "DCDWordArray::~DCDWordArray");
delete[] m_pData;}
//
// We need to increase the size of the array
//
BOOL DCDWordArray::ReallocateArray(void){ POINT *pOldArray = m_pData; m_pData = new POINT[m_MaxSize]; if(m_pData) { TRACE_DEBUG((">>>>>Increasing size of array to hold %d points", m_MaxSize)); // copy new data from old
memcpy( m_pData, pOldArray, (m_Size) * sizeof(POINT));
TRACE_DEBUG(("Deleting array of points %x", pOldArray)); delete[] pOldArray; return TRUE; } else { ERROR_OUT(("Failed to allocate new POINT array of size %d", m_MaxSize)); m_pData = pOldArray; return FALSE; }}
//
// Add a new point to the array
//
void DCDWordArray::Add(POINT point){
MLZ_EntryOut(ZONE_FUNCTION, "DCDWordArray::Add"); TRACE_DEBUG(("Adding point(%d,%d) at %d", point.x, point.y, m_Size)); TRACE_DEBUG(("Adding point at %x", &m_pData[m_Size]));
if(m_pData == NULL) { return; } m_pData[m_Size].x = point.x; m_pData[m_Size].y = point.y; m_Size++;
//
// if we want more points, we need to re allocate the array
//
if(m_Size == m_MaxSize) { m_MaxSize +=ARRAY_INCREMENT; if(ReallocateArray() == FALSE) { m_Size--; } }}
//
// Return the number of points in the array
//
UINT DCDWordArray::GetSize(void){ return m_Size;}
//
// Sets the size of the array
//
void DCDWordArray::SetSize(UINT size){ int newSize; //
// if we want more points, we need to re allocate the array
//
if (size > m_MaxSize) { m_MaxSize= ((size/ARRAY_INCREMENT)+1)*ARRAY_INCREMENT; if(ReallocateArray() == FALSE) { return; } } m_Size = size;}
|
