1225 lines
27 KiB
C++
1225 lines
27 KiB
C++
//
|
|
// GROBJ.CPP
|
|
// Graphic Object Classes
|
|
//
|
|
// Copyright Microsoft 1998-
|
|
//
|
|
#ifndef __GROBJ_HPP_
|
|
#define __GROBJ_HPP_
|
|
|
|
|
|
#define HIT_WINDOW 1
|
|
#define MAKE_HIT_RECT(r, p ) \
|
|
::SetRect(&r, p.x-HIT_WINDOW, p.y-HIT_WINDOW, p.x+HIT_WINDOW, p.y+HIT_WINDOW);
|
|
|
|
|
|
//
|
|
// Marker definitions
|
|
//
|
|
#define NO_HANDLE -1
|
|
#define TOP_LEFT 0
|
|
#define TOP_MIDDLE 1
|
|
#define TOP_RIGHT 2
|
|
#define RIGHT_MIDDLE 3
|
|
#define BOTTOM_RIGHT 4
|
|
#define BOTTOM_MIDDLE 5
|
|
#define BOTTOM_LEFT 6
|
|
#define LEFT_MIDDLE 7
|
|
|
|
//
|
|
// Definitions for text objects
|
|
//
|
|
#define LAST_LINE -1
|
|
#define LAST_CHAR -2
|
|
|
|
//
|
|
// Maximum number of points in a freehand object - determined by the fact
|
|
// that pointCount is held in a TSHR_UINT16 in WB_GRAPHIC_FREEHAND (awbdef.h)
|
|
//
|
|
#define MAX_FREEHAND_POINTS 65535
|
|
|
|
|
|
BOOL EllipseHit(LPCRECT lpEllipseRect, BOOL bBorderHit, UINT uPenWidth, LPCRECT lpHitRect );
|
|
|
|
|
|
// Class to simulate CMapPtrToPtr but based on a linked list instead of the order-jumbling
|
|
// hashing method. This is the major cause of bug 354. I'm doing this instead of just replacing
|
|
// CMapPtrToPtr because it is used in a zillion places and I want to minimize changes to the
|
|
// multi-object select logic so that I don't break it.
|
|
class CPtrToPtrList : public COBLIST
|
|
{
|
|
|
|
public:
|
|
CPtrToPtrList( void );
|
|
~CPtrToPtrList(void);
|
|
|
|
void SetAt( void *key, void *newValue );
|
|
BOOL RemoveKey( void *key );
|
|
void RemoveAll( void );
|
|
|
|
void GetNextAssoc( POSITION &rNextPosition, void *&rKey, void *&rValue ) ;
|
|
BOOL Lookup( void *key, void *&rValue );
|
|
|
|
|
|
protected:
|
|
struct stPtrPair
|
|
{
|
|
void *pMainThing;
|
|
void *pRelatedThing;
|
|
};
|
|
|
|
stPtrPair *FindMainThingPair( void *pMainThing, POSITION *pPos );
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Class: DCWbGraphic
|
|
//
|
|
// Purpose: Base graphic object class
|
|
//
|
|
//
|
|
class WbDrawingArea;
|
|
|
|
enum
|
|
{
|
|
enumGraphicMarker,
|
|
enumGraphicFreeHand,
|
|
enumGraphicFilledRectangle,
|
|
enumGraphicFilledEllipse,
|
|
enumGraphicText,
|
|
enumGraphicDIB,
|
|
enumGraphicPointer,
|
|
enumNoGraphicTool
|
|
};
|
|
|
|
|
|
|
|
class DCWbGraphic
|
|
{
|
|
public:
|
|
//
|
|
// Static graphic construction routines - return a pointer to a graphic
|
|
// of the relevant type given a page and graphic handle or a pointer to
|
|
// a flat graphic representation.
|
|
//
|
|
static DCWbGraphic* ConstructGraphic(WB_PAGE_HANDLE hPage,
|
|
WB_GRAPHIC_HANDLE hGraphic);
|
|
|
|
static DCWbGraphic* ConstructGraphic(PWB_GRAPHIC pHeader);
|
|
|
|
static DCWbGraphic* ConstructGraphic(WB_PAGE_HANDLE hPage,
|
|
WB_GRAPHIC_HANDLE hGraphic,
|
|
PWB_GRAPHIC pHeader);
|
|
|
|
static DCWbGraphic* CopyGraphic(PWB_GRAPHIC pHeader);
|
|
|
|
|
|
//
|
|
// Constructor.
|
|
//
|
|
DCWbGraphic(PWB_GRAPHIC pHeader = NULL);
|
|
DCWbGraphic(WB_PAGE_HANDLE hPage, WB_GRAPHIC_HANDLE _hGraphic);
|
|
virtual ~DCWbGraphic( void );
|
|
|
|
|
|
virtual UINT IsGraphicTool(void) = 0;
|
|
|
|
//
|
|
// Get/set the bounding rectangle of the graphic object (in logical
|
|
// co-ordinates).
|
|
//
|
|
virtual void GetBoundsRect(LPRECT lprc) { *lprc = m_boundsRect; }
|
|
virtual void SetBoundsRect(LPCRECT lprc);
|
|
|
|
//
|
|
// Get the size of the object
|
|
//
|
|
virtual int Width(void) { return(m_boundsRect.right - m_boundsRect.left); }
|
|
virtual int Height(void) { return(m_boundsRect.bottom - m_boundsRect.top); }
|
|
|
|
//
|
|
// Get/set the defining rectangle of the graphic - this is only set up
|
|
// for some object types e.g. rectangles and ellipses.
|
|
//
|
|
virtual LPCRECT GetRect(void) const { return(&m_rect); }
|
|
virtual void SetRect(LPCRECT lprc);
|
|
virtual void SetRectPts(POINT ptStart, POINT ptEnd);
|
|
|
|
//
|
|
// Get/set the color the object will be drawn in
|
|
//
|
|
virtual void SetColor(COLORREF clr);
|
|
virtual COLORREF GetColor(void) //CHANGED BY RAND for PALETTERGB
|
|
{ return( SET_PALETTERGB(m_clrPenColor ) ); }
|
|
|
|
//
|
|
// Get/set the width of the pen used to draw the object
|
|
//
|
|
virtual void SetPenWidth(UINT uiWidth);
|
|
virtual UINT GetPenWidth(void) { return m_uiPenWidth; }
|
|
|
|
//
|
|
// Get/set the raster op to be used to draw the object
|
|
//
|
|
virtual void SetROP(int iPenROP);
|
|
virtual int GetROP(void) { return m_iPenROP; }
|
|
|
|
//
|
|
// Get/set the pen style
|
|
//
|
|
virtual void SetPenStyle(int iPenStyle);
|
|
virtual int GetPenStyle(void) { return m_iPenStyle; }
|
|
|
|
//
|
|
// Translates the graphic object by the x and y values of the point
|
|
// parameter.
|
|
//
|
|
virtual void MoveBy(int cx, int cy);
|
|
|
|
//
|
|
// Set the top left corner of the object's bounding rectangle to the
|
|
// point specified as parameter.
|
|
//
|
|
virtual void MoveTo(int x, int y);
|
|
|
|
//
|
|
// Return the top left corner of the objects bounding rectangle.
|
|
//
|
|
virtual void GetPosition(LPPOINT lpt);
|
|
|
|
//
|
|
// Return TRUE if the specified point is inside the bounding rectangle
|
|
// of the graphic object.
|
|
//
|
|
virtual BOOL PointInBounds(POINT pt);
|
|
|
|
//
|
|
// Draw the graphic object into the device context specified.
|
|
//
|
|
virtual void Draw(HDC hDC)
|
|
{return;}
|
|
virtual void Draw(HDC hDC, WbDrawingArea * pDrawingArea)
|
|
{ Draw(hDC); }
|
|
virtual void Draw(HDC hDC, BOOL thumbNail)
|
|
{ Draw(hDC); }
|
|
|
|
//
|
|
// Return the page of the graphic object
|
|
//
|
|
virtual WB_PAGE_HANDLE Page(void) const { return m_hPage; }
|
|
|
|
//
|
|
// Return the handle of the graphic object
|
|
//
|
|
virtual WB_GRAPHIC_HANDLE Handle(void) const { return m_hGraphic; }
|
|
virtual void ZapHandle(void) {m_hGraphic = NULL;}
|
|
|
|
//
|
|
// Return TRUE if the graphic is topmost on its page
|
|
//
|
|
virtual BOOL IsTopmost(void);
|
|
|
|
//
|
|
// Update the external version of the graphic
|
|
//
|
|
virtual void ForceReplace(void);
|
|
virtual void Replace(void);
|
|
virtual void ForceUpdate(void);
|
|
virtual void Update(void);
|
|
virtual void Delete(void);
|
|
|
|
//
|
|
// Confirm an update or delete of the graphic
|
|
//
|
|
virtual void ReplaceConfirm(void);
|
|
virtual void UpdateConfirm(void);
|
|
virtual void DeleteConfirm(void);
|
|
|
|
|
|
|
|
virtual BOOL CheckReallyHit(LPCRECT pRectHit)
|
|
{
|
|
RECT rcT;
|
|
return(!IntersectRect(&rcT, &m_boundsRect, pRectHit));
|
|
}
|
|
|
|
|
|
//
|
|
// Lock and unlock the graphic - the lock or unlock will only take
|
|
// effect the next time the graphic is updated or replaced.
|
|
//
|
|
void Lock(void);
|
|
void Unlock(void);
|
|
BOOL Locked(void) { return (m_uiLockState == WB_GRAPHIC_LOCK_REMOTE); }
|
|
BOOL GotLock(void) { return (m_uiLockState == WB_GRAPHIC_LOCK_LOCAL); }
|
|
void ClearLockFlag(void) {m_uiLockState = WB_GRAPHIC_LOCK_NONE;}
|
|
|
|
UINT GetLockState( void )
|
|
{return( m_uiLockState );}
|
|
|
|
void SetLockState( UINT uLock )
|
|
{m_uiLockState = uLock;}
|
|
|
|
//
|
|
// Add this graphic to the specified page. This member must only be
|
|
// called if the graphic does not yet belong to a page (i.e. if
|
|
// hGraphic is NULL).
|
|
//
|
|
virtual void AddToPageLast(WB_PAGE_HANDLE hPage);
|
|
|
|
//
|
|
// Return a copy of the graphic - this is a complete copy with all
|
|
// data read into internal memory.
|
|
//
|
|
virtual DCWbGraphic* Copy(void) const;
|
|
|
|
//
|
|
// Return TRUE if the graphic has changed since it was last read/written
|
|
// from external storage.
|
|
//
|
|
virtual BOOL Changed(void) const { return m_bChanged; }
|
|
|
|
//
|
|
// Get/set the type of tool which drew the graphic, or at least one
|
|
// which can be used to manipulate it.
|
|
//
|
|
void GraphicTool(int toolType)
|
|
{ m_toolType = toolType; m_bChanged = TRUE; }
|
|
int GraphicTool(void) { return m_toolType; }
|
|
|
|
//
|
|
// Return the length of the external representation of the object
|
|
//
|
|
DWORD ExternalLength(void)
|
|
{return(m_dwExternalLength );}
|
|
|
|
protected:
|
|
//
|
|
// Initialize the member variables
|
|
//
|
|
virtual void Initialize(void);
|
|
|
|
//
|
|
// Bounding rectangle calculation
|
|
//
|
|
virtual void CalculateBoundsRect(void) { m_boundsRect = m_rect; }
|
|
|
|
//
|
|
// Ensure that a rectangle has top left to the left of and above bottom
|
|
// right.
|
|
//
|
|
void NormalizeRect(LPRECT lprc);
|
|
|
|
//
|
|
// Type of the graphic (used in the external representation)
|
|
//
|
|
virtual UINT Type(void) const { return 0; }
|
|
|
|
//
|
|
// Length of the external representation of the graphic
|
|
//
|
|
virtual DWORD CalculateExternalLength(void)
|
|
{ return sizeof(WB_GRAPHIC); }
|
|
|
|
//
|
|
// Convert between internal and external representations
|
|
//
|
|
virtual void ReadExternal(void);
|
|
virtual void ReadHeader(PWB_GRAPHIC pHeader);
|
|
virtual void ReadExtra(PWB_GRAPHIC) {}
|
|
virtual void CopyExtra(PWB_GRAPHIC) {}
|
|
|
|
virtual void WriteExternal(PWB_GRAPHIC pHeader);
|
|
virtual void WriteHeader(PWB_GRAPHIC pHeader);
|
|
virtual void WriteExtra(PWB_GRAPHIC) {}
|
|
|
|
//
|
|
// Page on which this object belongs
|
|
//
|
|
WB_PAGE_HANDLE m_hPage;
|
|
|
|
//
|
|
// Whiteboard Core handle for the object
|
|
//
|
|
WB_GRAPHIC_HANDLE m_hGraphic;
|
|
|
|
//
|
|
// Flag indicating whether the graphic has changed since it was last
|
|
// read from external storage.
|
|
//
|
|
BOOL m_bChanged;
|
|
|
|
//
|
|
// Graphic header details
|
|
//
|
|
DWORD m_dwExternalLength; // Length of the object
|
|
RECT m_boundsRect; // Bounding
|
|
RECT m_rect; // Defining
|
|
COLORREF m_clrPenColor; // Color of pen as RGB
|
|
UINT m_uiPenWidth; // Width in logical units
|
|
int m_iPenROP; // Raster operation to be used for drawing
|
|
int m_iPenStyle; // Pen style to be used for drawing
|
|
UINT m_uiLockState; // Lock indicator
|
|
int m_toolType; // Type of tool used to create the graphic
|
|
};
|
|
|
|
//
|
|
//
|
|
// Class: DCWbGraphicMarker
|
|
//
|
|
// Purpose: Class representing an object marker. This is a set of eight
|
|
// handles drawn at intervals round the objects bounding rectangle.
|
|
//
|
|
// This is an internal object only - it is never passed to the
|
|
// Whiteboard Core DLL.
|
|
//
|
|
//
|
|
class DCWbGraphicMarker : public DCWbGraphic
|
|
{
|
|
|
|
friend class DCWbGraphicSelectTrackingRectangle;
|
|
|
|
public:
|
|
//
|
|
// Constructors
|
|
//
|
|
DCWbGraphicMarker(void);
|
|
~DCWbGraphicMarker(void);
|
|
|
|
UINT IsGraphicTool(void) { return enumGraphicMarker;}
|
|
|
|
|
|
// Rect that bounds all objs in RectList
|
|
virtual void GetBoundsRect(LPRECT lprc);
|
|
|
|
// Deletes all marker rects in RectList
|
|
void DeleteAllMarkers( DCWbGraphic *pLastSelectedGraphic,
|
|
BOOL bLockLastSelectedGraphic = FALSE );
|
|
|
|
// Deletes one marker
|
|
void DeleteMarker( DCWbGraphic *pGraphic );
|
|
|
|
// Sees if obj is already in marker
|
|
DCWbGraphic *HasAMarker( DCWbGraphic *pGraphic );
|
|
|
|
// Gets last marker
|
|
DCWbGraphic *LastMarker( void );
|
|
|
|
// Gets number of markers in marker list
|
|
int GetNumMarkers( void );
|
|
|
|
// Moves all selected objects by offset
|
|
virtual void MoveBy(int cx, int cy);
|
|
|
|
// Updates selected remote objects
|
|
void Update( void );
|
|
|
|
// Checks for point hitting any marker obj
|
|
BOOL PointInBounds(POINT pt);
|
|
|
|
// Changes color for selection
|
|
void SetColor(COLORREF color);
|
|
|
|
// Changes width of selection
|
|
void SetPenWidth(UINT uiWidth);
|
|
|
|
// Changes font of selection (text objs only)
|
|
void SetSelectionFont(HFONT hFont);
|
|
|
|
//Deletes all objs in selection
|
|
void DeleteSelection( void );
|
|
|
|
//Brings all objs in selection to top
|
|
void BringToTopSelection( void );
|
|
|
|
//Sends all objs to bottom
|
|
void SendToBackSelection( void );
|
|
|
|
//Renders marker objects to a multi-obj format and copies to the
|
|
// clipboard
|
|
BOOL RenderPrivateMarkerFormat( void );
|
|
|
|
//Pastes multi-obj clipboard data
|
|
void Paste( HANDLE handle );
|
|
|
|
|
|
//
|
|
// Set the object defining rectangle - this is only set up for some
|
|
// object types e.g. rectangles and ellipses.
|
|
//
|
|
BOOL SetRect(LPCRECT lprc, DCWbGraphic *pGraphic, BOOL bRedraw,
|
|
BOOL bLockObject = TRUE );
|
|
|
|
//
|
|
// Return an indication of which handle the specified point lies in.
|
|
//
|
|
int PointInMarker(POINT pt);
|
|
|
|
//
|
|
// Draw the marker
|
|
//
|
|
void Draw(HDC hDC, BOOL bDrawObjects = FALSE );
|
|
void Undraw(HDC hDC, WbDrawingArea * pDrawingArea);
|
|
|
|
void DrawRect( HDC hDC, LPCRECT pMarkerRect,
|
|
BOOL bDrawObject, DCWbGraphic *pGraphic );
|
|
void UndrawRect(HDC hDC, WbDrawingArea * pDrawingArea,
|
|
LPCRECT pMarkerRect );
|
|
|
|
//
|
|
// Override the base graphic object functions that are not appropriate
|
|
// for this graphic type. This prevents updates being made for changes
|
|
// to pen attributes (for instance).
|
|
//
|
|
|
|
void Present( BOOL bOn )
|
|
{m_bMarkerPresent = bOn;}
|
|
|
|
protected:
|
|
//
|
|
// Bounding rectangle calculation
|
|
//
|
|
void CalculateBoundsRect(void);
|
|
|
|
//
|
|
// Marker rectangle calculation
|
|
//
|
|
void CalculateMarkerRectangles(void);
|
|
|
|
//
|
|
// Marker rectangle
|
|
//
|
|
RECT m_markerRect;
|
|
CPtrToPtrList MarkerList; // keys are DCWbGraphic pointers,
|
|
// values are LPRECT pointers.
|
|
BOOL m_bMarkerPresent;
|
|
|
|
|
|
void UndrawMarker(LPCRECT pMarkerREct);
|
|
|
|
//
|
|
// Brush used to draw the marker rectangle
|
|
//
|
|
HBRUSH m_hMarkerBrush;
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Class: DCWbGraphicLine
|
|
//
|
|
// Purpose: Class representing straight line
|
|
//
|
|
//
|
|
class DCWbGraphicLine : public DCWbGraphic
|
|
{
|
|
|
|
public:
|
|
//
|
|
// Constructors
|
|
//
|
|
DCWbGraphicLine(void) { }
|
|
DCWbGraphicLine(PWB_GRAPHIC pHeader)
|
|
: DCWbGraphic(pHeader) { }
|
|
DCWbGraphicLine(WB_PAGE_HANDLE hPage, WB_GRAPHIC_HANDLE hGraphic)
|
|
: DCWbGraphic(hPage, hGraphic) { }
|
|
|
|
~DCWbGraphicLine(void);
|
|
|
|
//
|
|
// Set the object start and end points
|
|
//
|
|
void SetStart(POINT ptStart);
|
|
void SetEnd(POINT ptEnd);
|
|
|
|
UINT IsGraphicTool(void) {return enumNoGraphicTool;}
|
|
|
|
//
|
|
// Draw the object
|
|
//
|
|
void Draw(HDC hDC);
|
|
|
|
//
|
|
// Translate the graphic object by the x and y values of the point
|
|
// parameter.
|
|
//
|
|
virtual void MoveBy(int cx, int cy);
|
|
|
|
//
|
|
// Override the base graphic object functions that are not appropriate
|
|
// for this graphic type. This prevents updates being made for changes
|
|
// to pen attributes (for instance).
|
|
//
|
|
|
|
virtual BOOL CheckReallyHit( LPCRECT pRectHit );
|
|
|
|
protected:
|
|
//
|
|
// Type of the graphic (used for writing to external memory)
|
|
//
|
|
virtual UINT Type(void) const { return TYPE_GRAPHIC_LINE; }
|
|
|
|
//
|
|
// Bounding rectangle calculation
|
|
//
|
|
void CalculateBoundsRect(void);
|
|
};
|
|
|
|
//
|
|
//
|
|
// Class: DCWbGraphicTrackingLine
|
|
//
|
|
// Purpose: Class representing an XORed straight line (for rubber banding)
|
|
//
|
|
// This is an internal object only - it is never passed to the
|
|
// Whiteboard Core DLL.
|
|
//
|
|
//
|
|
class DCWbGraphicTrackingLine : public DCWbGraphicLine
|
|
{
|
|
|
|
public:
|
|
//
|
|
// Constructor
|
|
//
|
|
DCWbGraphicTrackingLine(void) { SetROP(R2_NOTXORPEN); };
|
|
};
|
|
|
|
//
|
|
//
|
|
// Class: DCWbGraphicFreehand
|
|
//
|
|
// Purpose: Class representing multiple line segments
|
|
//
|
|
//
|
|
|
|
|
|
class DCDWordArray
|
|
{
|
|
|
|
|
|
|
|
public:
|
|
DCDWordArray(void);
|
|
~DCDWordArray(void);
|
|
|
|
void Add(POINT point);
|
|
BOOL ReallocateArray(void);
|
|
POINT* GetBuffer(void) { return m_pData; }
|
|
void SetSize(UINT size);
|
|
UINT GetSize(void);
|
|
|
|
POINT* operator[](UINT index){return &(m_pData[index]);}
|
|
|
|
private:
|
|
|
|
POINT* m_pData;
|
|
UINT m_Size;
|
|
UINT m_MaxSize;
|
|
|
|
|
|
|
|
};
|
|
/////////////
|
|
|
|
class DCWbGraphicFreehand : public DCWbGraphic
|
|
{
|
|
|
|
public:
|
|
//
|
|
// Constructors
|
|
//
|
|
DCWbGraphicFreehand(void);
|
|
DCWbGraphicFreehand(PWB_GRAPHIC pHeader);
|
|
DCWbGraphicFreehand(WB_PAGE_HANDLE hPage, WB_GRAPHIC_HANDLE hGraphic);
|
|
|
|
~DCWbGraphicFreehand(void);
|
|
|
|
UINT IsGraphicTool(void) { return enumGraphicFreeHand;}
|
|
|
|
//
|
|
// Add a point to the list, returning success
|
|
//
|
|
BOOL AddPoint(POINT pt);
|
|
|
|
//
|
|
// Translate the graphic object by the x and y values of the point
|
|
// parameter.
|
|
//
|
|
virtual void MoveBy(int cx, int cy);
|
|
|
|
//
|
|
// Draw the object
|
|
//
|
|
void Draw(HDC hDC);
|
|
|
|
|
|
virtual BOOL CheckReallyHit( LPCRECT pRectHit );
|
|
|
|
protected:
|
|
//
|
|
// Type of the graphic (used for writing to external memory)
|
|
//
|
|
virtual UINT Type(void) const { return TYPE_GRAPHIC_FREEHAND; }
|
|
|
|
//
|
|
// Length of the external representation of the graphic
|
|
//
|
|
virtual DWORD CalculateExternalLength(void);
|
|
|
|
//
|
|
// Convert between internal and external representations
|
|
//
|
|
void WriteExtra(PWB_GRAPHIC pHeader);
|
|
void ReadExtra(PWB_GRAPHIC pHeader);
|
|
|
|
//
|
|
// Bounding rectangle calculation
|
|
//
|
|
void CalculateBoundsRect(void);
|
|
void AddPointToBounds(int x, int y);
|
|
|
|
|
|
//
|
|
// Array holding point information
|
|
//
|
|
DCDWordArray points; //CHANGED BY RAND
|
|
|
|
//
|
|
// Spline curve smoothing drawing functions
|
|
//
|
|
void DrawUnsmoothed(HDC hDC);
|
|
};
|
|
|
|
//
|
|
//
|
|
// Class: DCWbGraphicRectangle
|
|
//
|
|
// Purpose: Class representing a rectangle
|
|
//
|
|
//
|
|
class DCWbGraphicRectangle : public DCWbGraphic
|
|
{
|
|
|
|
public:
|
|
//
|
|
// Constructors
|
|
//
|
|
DCWbGraphicRectangle(void) { }
|
|
DCWbGraphicRectangle(PWB_GRAPHIC pHeader)
|
|
: DCWbGraphic(pHeader) { }
|
|
DCWbGraphicRectangle(WB_PAGE_HANDLE hPage, WB_GRAPHIC_HANDLE hGraphic)
|
|
: DCWbGraphic(hPage, hGraphic) { }
|
|
|
|
~DCWbGraphicRectangle(void);
|
|
|
|
UINT IsGraphicTool(void) {return enumNoGraphicTool;}
|
|
|
|
//
|
|
// Set the defining rectangle
|
|
//
|
|
void SetRect(LPCRECT lprc);
|
|
|
|
//
|
|
// Draw the object
|
|
//
|
|
void Draw(HDC hDC);
|
|
|
|
//
|
|
// Translate the graphic object by the x and y values of the point
|
|
// parameter.
|
|
//
|
|
virtual void MoveBy(int cx, int cy);
|
|
|
|
//
|
|
// Override the base graphic object functions that are not appropriate
|
|
// for this graphic type. This prevents updates being made for changes
|
|
// to pen attributes (for instance).
|
|
//
|
|
|
|
virtual BOOL CheckReallyHit( LPCRECT pRectHit );
|
|
|
|
protected:
|
|
//
|
|
// Type of the graphic (used for writing to external memory)
|
|
//
|
|
virtual UINT Type(void) const { return TYPE_GRAPHIC_RECTANGLE; }
|
|
|
|
//
|
|
// Bounding rectangle calculation
|
|
//
|
|
void CalculateBoundsRect(void);
|
|
};
|
|
|
|
//
|
|
//
|
|
// Class: DCWbGraphicTrackingRectangle
|
|
//
|
|
// Purpose: Class representing an XORed rectangle (for rubber banding)
|
|
//
|
|
// This is an internal object only - it is never passed to the
|
|
// Whiteboard Core DLL.
|
|
//
|
|
//
|
|
class DCWbGraphicTrackingRectangle : public DCWbGraphicRectangle
|
|
{
|
|
|
|
public:
|
|
//
|
|
// Constructor
|
|
//
|
|
DCWbGraphicTrackingRectangle(void) { SetROP(R2_NOTXORPEN); };
|
|
};
|
|
|
|
|
|
|
|
|
|
class DCWbGraphicSelectTrackingRectangle : public DCWbGraphicRectangle
|
|
{
|
|
|
|
public:
|
|
//
|
|
// Constructor
|
|
//
|
|
DCWbGraphicSelectTrackingRectangle(void)
|
|
{SetROP(R2_NOTXORPEN); m_Offset.cx = 0; m_Offset.cy = 0; }
|
|
|
|
void Draw( HDC hDC);
|
|
virtual void MoveBy(int cx, int cy);
|
|
|
|
protected:
|
|
SIZE m_Offset;
|
|
};
|
|
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Class: DCWbGraphicFilledRectangle
|
|
//
|
|
// Purpose: Class representing a filled rectangle
|
|
//
|
|
//
|
|
class DCWbGraphicFilledRectangle : public DCWbGraphicRectangle
|
|
{
|
|
|
|
public:
|
|
//
|
|
// Constructors
|
|
//
|
|
DCWbGraphicFilledRectangle(void) { }
|
|
DCWbGraphicFilledRectangle(PWB_GRAPHIC pHeader)
|
|
: DCWbGraphicRectangle(pHeader) { }
|
|
DCWbGraphicFilledRectangle(WB_PAGE_HANDLE hPage,
|
|
WB_GRAPHIC_HANDLE hGraphic)
|
|
: DCWbGraphicRectangle(hPage, hGraphic) { }
|
|
|
|
~DCWbGraphicFilledRectangle(void);
|
|
|
|
UINT IsGraphicTool(void) { return enumGraphicFilledRectangle;}
|
|
|
|
//
|
|
// Draw the object
|
|
//
|
|
void Draw(HDC hDC);
|
|
|
|
//
|
|
// Override the base graphic object functions that are not appropriate
|
|
// for this graphic type. This prevents updates being made for changes
|
|
// to pen attributes (for instance).
|
|
//
|
|
|
|
virtual BOOL CheckReallyHit( LPCRECT pRectHit );
|
|
|
|
protected:
|
|
//
|
|
// Type of the graphic (used for writing to external memory)
|
|
//
|
|
virtual UINT Type(void) const { return TYPE_GRAPHIC_FILLED_RECTANGLE; }
|
|
|
|
//
|
|
// Bounding rectangle calculation
|
|
//
|
|
void CalculateBoundsRect(void);
|
|
};
|
|
|
|
//
|
|
//
|
|
// Class: DCWbGraphicEllipse
|
|
//
|
|
// Purpose: Class representing an ellipse
|
|
//
|
|
//
|
|
class DCWbGraphicEllipse : public DCWbGraphic
|
|
{
|
|
|
|
public:
|
|
//
|
|
// Constructor
|
|
//
|
|
DCWbGraphicEllipse(void) { }
|
|
DCWbGraphicEllipse(PWB_GRAPHIC pHeader)
|
|
: DCWbGraphic(pHeader) { }
|
|
DCWbGraphicEllipse(WB_PAGE_HANDLE hPage, WB_GRAPHIC_HANDLE hGraphic)
|
|
: DCWbGraphic(hPage, hGraphic) { }
|
|
|
|
~DCWbGraphicEllipse(void);
|
|
|
|
UINT IsGraphicTool(void) {return enumNoGraphicTool;}
|
|
|
|
//
|
|
// Set the defining rectangle
|
|
//
|
|
void SetRect(LPCRECT lprc);
|
|
|
|
//
|
|
// Draw the object
|
|
//
|
|
void Draw(HDC hDC);
|
|
|
|
//
|
|
// Translate the graphic object by the x and y values of the point
|
|
// parameter.
|
|
//
|
|
virtual void MoveBy(int cx, int cy);
|
|
|
|
//
|
|
// Override the base graphic object functions that are not appropriate
|
|
// for this graphic type. This prevents updates being made for changes
|
|
// to pen attributes (for instance).
|
|
//
|
|
|
|
virtual BOOL CheckReallyHit(LPCRECT pRectHit );
|
|
|
|
protected:
|
|
//
|
|
// Type of the graphic (used for writing to external memory)
|
|
//
|
|
virtual UINT Type(void) const { return TYPE_GRAPHIC_ELLIPSE; }
|
|
|
|
//
|
|
// Bounding rectangle calculation
|
|
//
|
|
void CalculateBoundsRect(void);
|
|
};
|
|
|
|
//
|
|
//
|
|
// Class: DCWbGraphicTrackingEllipse
|
|
//
|
|
// Purpose: Class representing an XORed ellipse (for rubber banding)
|
|
//
|
|
// This is an internal object only - it is never passed to the
|
|
// Whiteboard Core DLL.
|
|
//
|
|
//
|
|
class DCWbGraphicTrackingEllipse : public DCWbGraphicEllipse
|
|
{
|
|
|
|
public:
|
|
//
|
|
// Constructors
|
|
//
|
|
DCWbGraphicTrackingEllipse(void) { SetROP(R2_NOTXORPEN); };
|
|
};
|
|
|
|
//
|
|
//
|
|
// Class: DCWbGraphicFilledEllipse
|
|
//
|
|
// Purpose: Class representing a filled ellipse
|
|
//
|
|
//
|
|
class DCWbGraphicFilledEllipse : public DCWbGraphicEllipse
|
|
{
|
|
|
|
public:
|
|
//
|
|
// Constructor
|
|
//
|
|
DCWbGraphicFilledEllipse(void) { }
|
|
DCWbGraphicFilledEllipse(PWB_GRAPHIC pHeader)
|
|
: DCWbGraphicEllipse(pHeader) { }
|
|
DCWbGraphicFilledEllipse(WB_PAGE_HANDLE hPage,
|
|
WB_GRAPHIC_HANDLE hGraphic)
|
|
: DCWbGraphicEllipse(hPage, hGraphic) { }
|
|
|
|
~DCWbGraphicFilledEllipse(void);
|
|
|
|
UINT IsGraphicTool(void) { return enumGraphicFilledEllipse;}
|
|
|
|
//
|
|
// Draw the object
|
|
//
|
|
void Draw(HDC hDC);
|
|
|
|
|
|
virtual BOOL CheckReallyHit(LPCRECT pRectHit );
|
|
|
|
protected:
|
|
//
|
|
// Type of the graphic (used for writing to external memory)
|
|
//
|
|
virtual UINT Type(void) const { return TYPE_GRAPHIC_FILLED_ELLIPSE; }
|
|
//
|
|
// Bounding rectangle calculation
|
|
//
|
|
void CalculateBoundsRect(void);
|
|
};
|
|
|
|
//
|
|
//
|
|
// Class: DCWbGraphicText
|
|
//
|
|
// Purpose: Class representing a text object
|
|
//
|
|
//
|
|
class DCWbGraphicText : public DCWbGraphic
|
|
{
|
|
|
|
// Friend declaration for text editing
|
|
friend class WbTextEditor;
|
|
|
|
// Friend declaration for copying to the clipboard
|
|
friend class WbMainWindow;
|
|
|
|
public:
|
|
//
|
|
// Constructors
|
|
//
|
|
DCWbGraphicText(void);
|
|
DCWbGraphicText(PWB_GRAPHIC pHeader);
|
|
DCWbGraphicText(WB_PAGE_HANDLE hPage, WB_GRAPHIC_HANDLE hGraphic);
|
|
|
|
//
|
|
// Destructor
|
|
//
|
|
~DCWbGraphicText(void);
|
|
|
|
UINT IsGraphicTool(void) { return enumGraphicText;}
|
|
//
|
|
// Set the text of the object
|
|
//
|
|
virtual void SetText(TCHAR * strText);
|
|
virtual void SetText(const StrArray& strTextArray);
|
|
|
|
//
|
|
// Get/Set the font for drawing the text
|
|
//
|
|
virtual void SetFont(HFONT hFont);
|
|
virtual void SetFont(LOGFONT *pLogFont, BOOL bReCalc=TRUE );
|
|
virtual HFONT GetFont(void) {return m_hFont;};
|
|
|
|
//
|
|
// Draw - draw the object
|
|
//
|
|
void Draw(HDC hDC) { Draw(hDC, FALSE); };
|
|
void Draw(HDC hDC, BOOL thumbNail);
|
|
|
|
//
|
|
// InvalidateMetrics - flag metrics need to be reread
|
|
//
|
|
void InvalidateMetrics(void);
|
|
|
|
//
|
|
// Override the base graphic object functions that are not appropriate
|
|
// for this graphic type. This prevents updates being made for changes
|
|
// to pen attributes (for instance).
|
|
//
|
|
void SetPenWidth(UINT) { };
|
|
void SetROP(int) { };
|
|
void SetPenStyle(int) { };
|
|
|
|
virtual BOOL CheckReallyHit( LPCRECT pRectHit );
|
|
|
|
virtual void GetPosition(LPPOINT lppt); // added for bug 469
|
|
|
|
protected:
|
|
//
|
|
// Type of the graphic (used for writing to external memory)
|
|
//
|
|
virtual UINT Type(void) const { return TYPE_GRAPHIC_TEXT; }
|
|
|
|
//
|
|
// Bounding rectangle calculation
|
|
//
|
|
void CalculateBoundsRect(void);
|
|
|
|
//
|
|
// Length of the external representation of the graphic
|
|
//
|
|
virtual DWORD CalculateExternalLength(void);
|
|
|
|
//
|
|
// Convert between internal and external representations
|
|
//
|
|
void WriteExtra(PWB_GRAPHIC pHeader);
|
|
void ReadExtra(PWB_GRAPHIC pHeader);
|
|
|
|
//
|
|
// Calculate the rectangle of a portion of a single line of text
|
|
//
|
|
ABC GetTextABC( LPCTSTR strText,
|
|
int iStartX,
|
|
int iStopX);
|
|
void GetTextRectangle(int iStartY,
|
|
int iStartX,
|
|
int iStopX,
|
|
LPRECT lprc);
|
|
void CalculateRect(int iStartX,
|
|
int iStartY,
|
|
int iStopX,
|
|
int iStopY,
|
|
LPRECT lprc);
|
|
|
|
//
|
|
// Array for storing text
|
|
//
|
|
StrArray strTextArray;
|
|
|
|
//
|
|
// Font details
|
|
//
|
|
HFONT m_hFont;
|
|
HFONT m_hFontThumb;
|
|
BOOL m_bFirstSetFontCall;
|
|
LONG m_nKerningOffset; // added for bug 469
|
|
|
|
public:
|
|
TEXTMETRIC m_textMetrics;
|
|
};
|
|
|
|
|
|
//
|
|
//
|
|
// Class: DCWbGraphicDIB
|
|
//
|
|
// Purpose: Class representing a drawn DI bitmap object
|
|
//
|
|
//
|
|
typedef struct tagHOLD_DATA
|
|
{
|
|
PWB_GRAPHIC pHeader;
|
|
LPBITMAPINFOHEADER lpbi;
|
|
}
|
|
HOLD_DATA;
|
|
|
|
class DCWbGraphicDIB : public DCWbGraphic
|
|
{
|
|
|
|
public:
|
|
//
|
|
// Constructors
|
|
//
|
|
DCWbGraphicDIB(void);
|
|
DCWbGraphicDIB(PWB_GRAPHIC pHeader);
|
|
DCWbGraphicDIB(WB_PAGE_HANDLE hPage, WB_GRAPHIC_HANDLE _hGraphic);
|
|
|
|
UINT IsGraphicTool(void) { return enumGraphicDIB; }
|
|
|
|
//
|
|
// Destructor
|
|
//
|
|
~DCWbGraphicDIB(void);
|
|
|
|
//
|
|
// Set the contents of the bitmap
|
|
//
|
|
void SetImage(LPBITMAPINFOHEADER lpbi);
|
|
|
|
//
|
|
// Set the contents of the bitmap from the screen
|
|
//
|
|
void FromScreenArea(LPCRECT lprcScreen);
|
|
|
|
//
|
|
// Draw the object
|
|
//
|
|
void Draw(HDC hDC);
|
|
|
|
//
|
|
// Delete the image currently held internally (if any)
|
|
//
|
|
void DeleteImage(void);
|
|
|
|
//
|
|
// Override the base graphic object functions that are not appropriate
|
|
// for this graphic type. This prevents updates being made for changes
|
|
// to pen attributes (for instance).
|
|
//
|
|
void SetPenWidth(UINT) { };
|
|
void SetColor(COLORREF) { };
|
|
void SetROP(int) { };
|
|
void SetPenStyle(int) { };
|
|
|
|
|
|
virtual BOOL CheckReallyHit( LPCRECT pRectHit );
|
|
|
|
protected:
|
|
//
|
|
// Type of the graphic (used for writing to external memory)
|
|
//
|
|
virtual UINT Type(void) const { return TYPE_GRAPHIC_DIB; }
|
|
|
|
//
|
|
// Bounding rectangle calculation
|
|
//
|
|
void CalculateBoundsRect(void);
|
|
|
|
//
|
|
// Length of the external representation of the graphic
|
|
//
|
|
virtual DWORD CalculateExternalLength(void);
|
|
|
|
//
|
|
// Convert between internal and external representations
|
|
//
|
|
void WriteExtra(PWB_GRAPHIC pHeader);
|
|
void CopyExtra(PWB_GRAPHIC pHeader);
|
|
|
|
//
|
|
// Get the DIB data
|
|
//
|
|
BOOL GetDIBData(HOLD_DATA& hold);
|
|
void ReleaseDIBData(HOLD_DATA& hold);
|
|
|
|
// Pointer to the DIB bits
|
|
LPBITMAPINFOHEADER m_lpbiImage;
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class ObjectTrashCan : public DCWbGraphic
|
|
{
|
|
|
|
public:
|
|
~ObjectTrashCan(void);
|
|
|
|
UINT IsGraphicTool(void) {return enumNoGraphicTool;}
|
|
|
|
BOOL GotTrash( void );
|
|
void CollectTrash( DCWbGraphic *pGObj );
|
|
void SelectTrash( void );
|
|
void EmptyTrash( void );
|
|
void BurnTrash( void );
|
|
virtual void AddToPageLast(WB_PAGE_HANDLE hPage);
|
|
|
|
protected:
|
|
COBLIST Trash;
|
|
|
|
};
|
|
|
|
|
|
#endif // __GROBJ_HPP_
|