5125 lines
112 KiB
C++
5125 lines
112 KiB
C++
//
|
||
// 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;
|
||
}
|
||
|
||
|