Initial commit: ROW Client source code

Game client codebase including: - CharacterActionControl: Character and creature management - GlobalScript: Network, items, skills, quests, utilities - RYLClient: Main client application with GUI and event handlers - Engine: 3D rendering engine (RYLGL) - MemoryManager: Custom memory allocation - Library: Third-party dependencies (DirectX, boost, etc.) - Tools: Development utilities 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com>
2025-11-29 16:24:34 +09:00
commit e067522598
5135 changed files with 1745744 additions and 0 deletions
--- a/Library/dxx8/samples/Multimedia/Common/include/didcfgview.h
+++ b/Library/dxx8/samples/Multimedia/Common/include/didcfgview.h
@@ -0,0 +1,866 @@
+//-----------------------------------------------------------------------------
+// File: didcfgview.h
+//
+// Desc: Header file for DIDCfgView, a class that encapsulates a view of a
+//       DirectInput device.  The DIDCfgView class exists to make it easier 
+//       to make custom interfaces to view or configure action mappings for 
+//       input devices(instead of using IDirectInput8::ConfigureDevices).
+//
+//       To use the DIDCfgView class, you initialize it for a particular
+//       DirectInput device.  You then set up state information for how the
+//       image should be drawn: colors, fonts, and details for callouts(the
+//       lines drawn from each axis/button to a label).  Finally, you can 
+//       call RenderView, passing in a bitmap or HDC for DIDCfgView to draw
+//       the image to.
+//
+//       DIDCfgView is the only class in this file that you need to understand 
+//       or interface to.  The other classes shown here are only used to 
+//       implement the DIDCfgView class.
+//
+//
+// Copyright (c) 1999-2001 Microsoft Corporation. All rights reserved.
+//-----------------------------------------------------------------------------
+
+#ifndef __DIDCV_H__
+#define __DIDCV_H__
+
+
+
+
+#include <windows.h>
+#include <dinput.h>
+
+
+
+
+// invalid id, used for unique, signed identifiers
+#define DIDCV_INVALID_ID                            -1
+
+// flags for callout states
+#define DIDCV_DRAWCALLOUT                           0x1
+#define DIDCV_DRAWOVERLAY                           0x2
+#define DIDCV_DRAWHIGHLIGHT                         0x4
+#define DIDCV_DRAWEMPTYCALLOUT                      0x8
+#define DIDCV_DRAWFULLNAME                          0x10
+
+// all flags set
+#define DIDCV_ALL_CALLOUT_STATE_SET                 0xFFFFFFFF
+
+// default dimensions
+#define DIDCV_MAX_IMAGE_WIDTH                       512
+#define DIDCV_MAX_IMAGE_HEIGHT                      512
+#define DIDCV_CUSTOM_VIEW_WIDTH                     400
+#define DIDCV_CUSTOM_VIEW_HEIGHT                    300
+
+// DidcvCreateFont attribute flags
+#define DIDCV_FONT_BOLD                             0x1
+#define DIDCV_FONT_ITALIC                           0x2
+#define DIDCV_FONT_UNDERLINE                        0x4
+#define DIDCV_FONT_STRIKEOUT                        0x8
+
+// default font point width
+#define DIDCV_DEFAULT_FONT_SIZE                     90
+
+// default size of callout array in DidcvCalloutManager
+#define DIDCV_DEFAULT_CALLOUT_MANAGER_ARRAY_SIZE    0
+
+// default size of callout array in DidcvCalloutSet
+#define DIDCV_DEFAULT_CALLOUT_SET_ARRAY_SIZE        8
+
+
+
+
+// forward declarations
+class DidcvViewManager;
+class DidcvCalloutManager;
+class DidcvBitmap;
+class DidcvCallout;
+class DidcvCalloutSet;
+struct DIDCfgViewInfo;
+struct DidcvCalloutData;
+struct DidcvCalloutState;
+struct DidcvActionMap;
+struct DidcvCustomViewInfo;
+
+
+
+
+//-----------------------------------------------------------------------------
+// Name: class DIDCfgView
+// Desc: main interface for retrieving and rendering device configuration views
+//
+//       Init() - initializes the object for a particular DirectInputDevice
+//       SetActionFormat() - sets the action mapping for the device
+//       SetCalloutState() - specifies state for a given callout
+//       SetAllCalloutState() - sets the state for all callouts
+//       GetObjectIDByLocation() - gets object id at location of current view
+//       SetCurrentView() - sets the current view to be rendered
+//       RebuildViews() - collapses or expand the views for this device
+//       RenderView() - renders device configuration view with image,
+//                       callout information, action mapping.
+//-----------------------------------------------------------------------------
+class DIDCfgView
+{
+public:
+    DIDCfgView();
+    ~DIDCfgView();
+
+public:
+    // main device configuration view interface
+    HRESULT Init( LPDIRECTINPUTDEVICE8 pDevice );
+    HRESULT SetActionFormat( LPDIACTIONFORMAT pDiaf );
+    HRESULT SetCalloutState( DWORD dwFlags, DWORD dwObjID );
+    HRESULT SetAllCalloutState( DWORD dwFlags );
+    HRESULT GetObjectIDByLocation( LPDWORD pdwObjID, LPPOINT pPt );
+    HRESULT SetCurrentView( INT nView );
+    HRESULT RebuildViews( BOOL bCompact );
+    HRESULT RenderView( HBITMAP hBitmap, BOOL bIsDib );
+    HRESULT RenderView( HDC hdc );
+
+    // rendering options
+    HRESULT SetViewOrigin( const POINT* pPtOrg, POINT* pPtOldOrg );
+    HRESULT CalcCenterOrgForCurrentView( const SIZE* pImgSize, POINT* pPtOrg, BOOL bSetOrigin = FALSE );
+    VOID    SetDefaultText( const TCHAR* pctszDefaultText, DWORD length );
+    VOID    SetColors( COLORREF crFore, COLORREF crBack, COLORREF crHighlight, COLORREF crHighlightLine );
+    VOID    GetColors( COLORREF* pCrFore, COLORREF* pCrBack, COLORREF* pCrHighlight, COLORREF* pCrHighlightLine );
+    HRESULT SetFont( const TCHAR*  pctszFontName, DWORD dwAttributes );
+    HFONT   GetFont();
+
+    // information access functios
+    HRESULT GetInfo( DIDCfgViewInfo* pCfgViewInfo );
+    HRESULT GetCurrentView( LPINT lpnView );
+    HRESULT GetCalloutState( LPDWORD lpdwFlags, DWORD dwObjID );
+
+protected:
+    // protected helper functions
+    VOID    CleanUp();
+    HRESULT InitAlloc();
+    HRESULT InitImageInfoRetrieve( LPDIRECTINPUTDEVICE8 pDevice );
+    HRESULT InitImageInfoProcess();
+    VOID    CalcSizes( const DIDEVICEIMAGEINFO* prgImageInfoArray, DWORD dwNumElements, const LPDWORD pNumViews, LPDWORD pNumCallouts, LPDWORD pNumDistinctObjID );
+    HRESULT RenderView( HDC hdc, VOID* pBits, INT width, INT height );
+
+    HRESULT InitCustomViews( LPDIRECTINPUTDEVICE8 pDevice, BOOL bUseInternal = FALSE );
+    HRESULT BuildCustomViews();
+    VOID    RenderFullname( HDC hdc, const TCHAR* pctszFullname, const RECT* pRect );
+    BOOL    CopyActionMap( LPDIACTIONFORMAT pDiaf );
+
+protected:
+    // data structures for managing views and callouts
+    DidcvViewManager* m_lpViewManager;
+    DidcvCalloutManager* m_lpCalloutManager;
+
+    // keeps track of whether this has been initialized
+    BOOL m_bIsInit;
+    // the index of the next view to render
+    INT m_nView;
+    // pointer to the DIDEVICEIMAGEINFOHEADER
+    LPDIDEVICEIMAGEINFOHEADER m_lpDidImgHeader;
+    // custom device view data
+    DidcvCustomViewInfo* m_lpCustomViewInfo;
+
+    // device reference
+    LPDIRECTINPUTDEVICE8 m_lpDIDevice;
+    // action mapping copy
+    LPDIACTIONFORMAT m_lpDiaf;
+    // can this view be collapsed
+    BOOL m_bCanBeCollapsed;
+    // is this view compacted
+    BOOL m_bIsCollapsed;
+
+    // rendering options
+    COLORREF m_crFore;
+    COLORREF m_crBack;
+    COLORREF m_crHighlight;
+    COLORREF m_crHighlightLine;
+    POINT    m_ptOrigin;
+    HFONT    m_hFont;
+    TCHAR m_tszDefaultText [MAX_PATH];
+};
+
+
+
+
+//-----------------------------------------------------------------------------
+// Name: struct DIDCfgViewInfo
+// Desc: struct containing current information about DIDCfgView states
+//-----------------------------------------------------------------------------
+struct DIDCfgViewInfo
+{
+    BOOL  bIsInit;              // is the CfgView object initialized
+    INT   iCurrentViewID;       // the ID of the current view
+    INT   iNumTotalViews;       // total number of views
+    DWORD dwNumUniqueCallouts;  // number of unique
+    BOOL  bCanBeCollapsed;      // can views for this CfgView object be compacted
+    BOOL  bIsCollapsed;         // is the CfgView currently using collapsed views
+
+
+    DIDCfgViewInfo()
+        : bIsInit( FALSE ),
+          iCurrentViewID( DIDCV_INVALID_ID ),
+          iNumTotalViews( 0 ),
+          dwNumUniqueCallouts( 0 ),
+          bCanBeCollapsed( FALSE ),
+          bIsCollapsed( FALSE )
+    { }
+};
+
+
+
+
+//-----------------------------------------------------------------------------
+// Name: struct DidcvCustomViewInfo
+// Desc: object containing information about custom views
+//-----------------------------------------------------------------------------
+struct DidcvCustomViewInfo
+{
+    DWORD dwType;               // type of the operation(count or save)
+    DWORD dwCount;              // the total count of items
+    DWORD dwSize;               // number of items actually in array
+    LPDIDEVICEOBJECTINSTANCE* rgObjData;   // array of control info
+
+    DidcvCustomViewInfo()
+        : dwType( 0 ),
+          dwCount( 0 ),
+          dwSize( 0 ),
+          rgObjData( NULL )
+    { }
+
+    ~DidcvCustomViewInfo() { CleanUp(); }
+    
+    VOID CleanUp();
+};
+
+
+
+
+//-----------------------------------------------------------------------------
+// Name: class DidcvView
+// Desc: data structure for representing one view of a device
+//-----------------------------------------------------------------------------
+class DidcvView
+{
+public:
+    virtual ~DidcvView() { };
+
+    // DidcvView interface
+    void SetOffset( INT nOffset );
+    void SetID( INT nID );
+    INT  GetOffset() const;
+    INT  GetID() const;
+
+    // rendering
+    virtual BOOL GetViewSize( SIZE* pSize ) const = 0;
+    virtual void Render( HDC hdc, VOID* pBits, INT width, INT height, const POINT* pPtOrigin ) = 0;
+
+protected:
+    // constructor
+    DidcvView();
+    // the original offset in the array returned by DirectInputDevice8::GetImage
+    INT m_nOffset;
+    // the internally assigned unique identifier
+    INT m_nID;
+};
+
+
+
+
+//-----------------------------------------------------------------------------
+// Name: class DidcvBitmapView
+// Desc: subclass of DidcvView that renders a bitmap
+//-----------------------------------------------------------------------------
+class DidcvBitmapView : public DidcvView
+{
+public:
+    ~DidcvBitmapView();
+
+    // interface
+    virtual BOOL GetViewSize( SIZE* pSize ) const;
+    virtual void Render( HDC hdc, VOID* pBits, INT width, INT height, const POINT* pPtOrigin );
+
+public:
+    // function to instantiate a DidcvBitmapView
+    static DidcvBitmapView* Create( LPCTSTR ptszImagePath, DWORD dwFlags );
+
+private:
+    // constructor
+    DidcvBitmapView();
+
+protected:
+    // bitmap of the view
+    DidcvBitmap* m_lpBitmap;
+};
+
+
+
+
+//-----------------------------------------------------------------------------
+// Name: class DidcvCustomView
+// Desc: subclass of DidcvView that renders a view from custom data
+//-----------------------------------------------------------------------------
+class DidcvCustomView : public DidcvView
+{
+public:
+    ~DidcvCustomView() { }
+
+    // interface
+    virtual BOOL GetViewSize( SIZE* pSize ) const;
+    virtual void Render( HDC hdc, VOID* pBits, INT width, INT height, const POINT* pPtOrigin );
+
+public:
+    // static function to instantiate a DidcvCustomView
+    static DidcvCustomView* Create( const DidcvCustomViewInfo* pInfo, DWORD dwStartIndex, DWORD* pFinishIndex );
+    static BOOL CalcImageInfo( DWORD index, LPRECT rcOverlay, LPDWORD pNumPoints, LPPOINT rgptCalloutLine, LPRECT rcCalloutRect );
+    static DWORD CalcNumViews( DWORD dwCount );
+
+private:
+    // constructor
+    DidcvCustomView( const DidcvCustomViewInfo* pInfo, DWORD dwStartIndex, DWORD dwEndIndex );
+
+protected:
+    // returns coordinates for a given index
+    void CalcCoordinates( DWORD dwIndex, LPRECT lpRect );
+
+    // custom data from which to render the view
+    const DidcvCustomViewInfo* m_lpCustomViewInfoRef;
+    DWORD m_dwStartIndex;
+    DWORD m_dwEndIndex;
+};
+
+
+
+
+//-----------------------------------------------------------------------------
+// Name: class DidcvViewManager
+// Desc: stores and manages all the views for particular device
+//-----------------------------------------------------------------------------
+class DidcvViewManager
+{
+public:
+    DidcvViewManager();
+    ~DidcvViewManager();
+
+    // interface
+    BOOL SetCapacity( UINT uCapacity, BOOL bDeleteContent = TRUE );
+    BOOL AddImage( DidcvView* pView, INT nOffset = DIDCV_INVALID_ID );
+    DidcvView* GetImage( INT nID );
+    DidcvView* GetImageByOffset( INT nOffset );
+    UINT GetNumViews() const;
+    void CleanUp();
+
+protected:
+    // table holding references to views, indexed by the internal unique identifier
+    DidcvView ** m_ppViewTable;
+    UINT m_capacity;
+    UINT m_size;
+};
+
+
+
+
+//-----------------------------------------------------------------------------
+// Name: class DidcvCallout
+// Desc: data structure for representing one callout on a particular view
+//       A callout is the line drawn from each axis/button to a label
+//-----------------------------------------------------------------------------
+class DidcvCallout
+{
+public:
+    ~DidcvCallout();
+
+    // accessor functions to information retrieved from DirectInput
+    DWORD GetObjID() const;
+    const RECT & GetOverlayRect() const;
+    const RECT & GetCalloutRect() const;
+    const POINT* GetCalloutLine( DWORD* lpNumPts ) const;
+    DWORD GetTextAlign() const;
+    DWORD GetOverlayOffset() const;
+
+    // accessor functions to internal data
+    void  SetAssociatedViewID( INT nViewRef );
+    INT   GetAssociatedViewID() const;
+    void  SetDataRef( const DidcvCalloutData* lpData );
+    const DidcvCalloutData* GetDataRef() const;
+
+    // hit test for a given point
+    DWORD HitTest( LPPOINT lpPt ) const;
+
+    // draw the overlay
+    DWORD DrawOverlay( HDC hDC, VOID* lpBits, INT width, INT height, const POINT* pptOrigin );
+
+public:
+    // static functions to instantiate a callout object
+    static DidcvCallout* Create( LPDIDEVICEIMAGEINFO devImgInfo );
+
+private:
+    // private constructor
+    DidcvCallout();
+
+protected:
+    // copy of device information
+    DIDEVICEIMAGEINFO m_devImgInfo;
+    // the view that this particular callout is associated with
+    INT m_nViewRef;
+    // pointer to callout state/data
+    const DidcvCalloutData* m_lpDataRef;
+    // the bitmap of the overlay
+    DidcvBitmap* m_lpOverlayBitmap;
+};
+
+
+
+
+// default array size
+#define GW_ARRAY_DEFAULT_SIZE       4
+
+//-----------------------------------------------------------------------------
+// Name: class GwArray
+// Desc: templated c-style array class for PRIMITIVE data types only
+//-----------------------------------------------------------------------------
+template <class Item> 
+class GwArray
+{
+public:
+    // constructors
+    GwArray() { this->Alloc( GW_ARRAY_DEFAULT_SIZE ); m_size = 0; }
+    GwArray( UINT initCap ) { this->Alloc( initCap ); m_size = 0; }
+    ~GwArray() { this->DeAlloc(); m_size = 0; }
+
+public:
+    void SetSize( UINT newCap )
+    {
+        if( newCap == m_capacity )
+            return;
+
+        m_size =( newCap < m_size ? newCap : m_size );
+
+        UINT old_cap = m_capacity;
+        UINT numoverlap =( newCap > m_capacity ? m_capacity : newCap );
+
+        Item* oldList = m_list;
+        this->Alloc( newCap );
+
+        if( oldList )
+        {
+            memcpy( m_list, oldList, sizeof( Item )* numoverlap );
+
+            // free( oldList );
+            delete [] oldList;
+        }
+    }
+
+    Item & operator[]( UINT index )
+    {
+        if( index >= m_capacity )
+            assert( index >= 0 && index < m_capacity );
+
+        return m_list[index];
+    }
+
+    const Item & operator[]( UINT index ) const
+    {
+        if( index >= m_capacity )
+            assert( index >= 0 && index < m_capacity );
+
+        return m_list[index];
+    }
+
+    void PushBack( const Item & item )
+    {
+        if( m_capacity == 0 )
+            SetSize( 2 );
+        else if( m_size >= m_capacity )
+            SetSize( m_capacity* 2 );
+
+        m_list[m_size] = item;
+        m_size++;
+    }
+
+    void Resize( UINT newCap ) { SetSize( newCap ); }
+    void PopBack()        { if( m_size ) m_size--; }
+    void Clear()          { m_size = 0; }
+    void Trim()           { Resize( m_size ); }
+    UINT Capacity() const { return m_capacity; }
+    UINT Size() const     { return m_size; }
+
+protected:
+    inline void Alloc( UINT cap )
+    {
+        if( cap == 0 )
+            m_list = NULL;
+        else
+        {
+            m_list = new Item[cap];
+            assert( m_list );
+            memset( m_list, 0, sizeof( Item )* cap );
+        }
+
+        m_capacity = cap;
+    }
+
+    inline void DeAlloc()
+    {
+        if( m_list != NULL )
+        {
+            //free( m_list );
+            delete [] m_list;
+            m_list = NULL;
+        }
+
+        m_capacity = 0;
+    }
+
+protected:
+    // array
+    Item* m_list;
+    // number of entries the array can hold
+    UINT m_capacity;
+    // number of entries added using PushBack() minus # removed using PopBack()
+    UINT m_size;
+};
+
+
+
+
+//-----------------------------------------------------------------------------
+// Name: class DidcvCalloutApplicant
+// Desc: abstract base class for processing DidcvCallout
+//-----------------------------------------------------------------------------
+class DidcvCalloutApplicant
+{
+public:
+    virtual ~DidcvCalloutApplicant() { }
+    virtual BOOL Apply( DidcvCallout* pCallout ) = 0;
+};
+
+
+
+
+//-----------------------------------------------------------------------------
+// Name: class DidcvCalloutSet
+// Desc: a group of DidcvCallout references
+//       A callout is the line drawn from each axis/button to a label
+//-----------------------------------------------------------------------------
+class DidcvCalloutSet
+{
+public:
+    DidcvCalloutSet();
+    ~DidcvCalloutSet();
+
+public:
+    BOOL  AddCallout( DidcvCallout* pCallout );
+    void  Apply( DidcvCalloutApplicant* pCalloutApp );
+    void  SetIdentifier( DWORD dwID );
+    DWORD GetIdentifier() const;
+    void  SetData( void* pData );
+    void* GetData() const;
+
+    const GwArray <DidcvCallout*> & GetInternalArrayRef() const;
+    void  TrimArrays();  
+
+protected:
+    void CleanUp();
+
+protected:
+    GwArray <DidcvCallout*> m_calloutList;
+    DWORD m_dwSetID;
+    void* m_lpData;
+};
+
+
+
+
+//-----------------------------------------------------------------------------
+// Name: class DidcvCalloutManager
+// Desc: data structure for storing and managing callouts
+//       A callout is the line drawn from each axis/button to a label
+//-----------------------------------------------------------------------------
+class DidcvCalloutManager
+{
+public:
+    DidcvCalloutManager();
+    ~DidcvCalloutManager();
+
+    // main interface
+    BOOL  AddCallout( DidcvCallout* pCallout, INT nView );
+    BOOL  SetCalloutState( const DidcvCalloutState* pCalloutState, DWORD dwObjID );
+    BOOL  SetAllCalloutState( const DidcvCalloutState* pCalloutState );
+    BOOL  SetActionMap( const LPDIACTION pAction, DWORD dwObjID );
+    void  ClearAllActionMaps();
+
+    // information
+    DWORD GetObjectIDByLocation( const LPPOINT pPt, INT nView );
+    BOOL  GetCalloutState( DidcvCalloutState* pCalloutState, DWORD dwObjID );
+    BOOL  GetActionMap( DidcvActionMap* pActionMap, DWORD dwObjID );
+    const DidcvCalloutSet* GetCalloutSetByView( INT nView ) const;
+    const DidcvCalloutSet* GetCalloutSetByObjID( DWORD dwObjID ) const;
+    const DidcvCalloutData* GetCalloutDataRef( DWORD dwObjID ) const;
+    UINT  GetNumUniqueCallouts() const;
+
+    BOOL  EnumObjects( LPDIRECTINPUTDEVICE8 pDevice, LPDIENUMDEVICEOBJECTSCALLBACK pCallback, LPVOID pvRef, DWORD dwMapOnly );
+    BOOL  CalcCanBeCollapsed();
+
+    // allocation
+    BOOL  SetCapacity( DWORD dwNumCallouts, DWORD dwNumUniqueObjID, DWORD dwNumViews, BOOL bDeleteContent = TRUE );
+    void  TrimArrays();
+    void  CleanUp();
+
+protected:
+    // helper functions
+    DidcvCalloutSet*  Find( const GwArray <DidcvCalloutSet*> & array, DWORD dwIdentifier ) const;
+    DidcvCalloutData* GetCalloutData( DWORD dwObjID ) const;
+
+protected:
+    // list of all callouts added
+    GwArray <DidcvCallout*> m_calloutList;
+    // list of callout sets, one for each unique callout id
+    GwArray <DidcvCalloutSet*> m_calloutSetListByObjID;
+    // list of callout sets, one for each view
+    GwArray <DidcvCalloutSet*> m_calloutSetListByView;
+};
+
+
+
+
+//-----------------------------------------------------------------------------
+// Name: struct DidcvCalloutData
+// Desc: data structure holding references to callout data components
+//-----------------------------------------------------------------------------
+struct DidcvCalloutData
+{
+    DidcvCalloutState* lpState;    // callout state info
+    DidcvActionMap* lpActionMap;   // action mapped this callout
+
+    DidcvCalloutData( DidcvCalloutState* s, DidcvActionMap* a )
+        : lpState( s ), lpActionMap( a )
+    { }
+};
+
+
+
+
+//-----------------------------------------------------------------------------
+// Name: struct DidcvCalloutState
+// Desc: state information for a callout
+//-----------------------------------------------------------------------------
+struct DidcvCalloutState
+{
+    // whether to draw
+    BOOL bDrawCallout;
+    BOOL bDrawOverlay;
+    BOOL bDrawHighlight;
+    BOOL bDrawEmptyCallout;
+    BOOL bDrawFullname;
+
+    // specifies which state is valid
+    DWORD dwFlags;
+
+    // --- member functions ---
+    DidcvCalloutState( DWORD f = 0, BOOL c = FALSE, BOOL o = FALSE, 
+        BOOL h = FALSE, BOOL e = FALSE, BOOL d = FALSE )
+        : dwFlags( f ), bDrawCallout( c ), bDrawOverlay( o ), bDrawHighlight( h ), 
+          bDrawEmptyCallout( e ), bDrawFullname( d )
+    { }
+
+    void SmartSet( const DidcvCalloutState* other );
+    void Copy( const DidcvCalloutState* other ) { *this = *other; }
+    DWORD MakeFlag() const;
+    void SetFlag( DWORD dwExtFlags );
+};
+
+
+
+
+//-----------------------------------------------------------------------------
+// Name: struct DidcvActionMap
+// Desc: action mapping information for a callout
+//-----------------------------------------------------------------------------
+struct DidcvActionMap
+{
+    DIACTION dia;
+
+    DidcvActionMap() { ZeroMemory( &dia, sizeof( DIACTION ) ); }
+    void Copy( const DidcvActionMap* other ) { this->dia = other->dia; }
+
+    LPCSTR GetActionName() const { return dia.lptszActionName; }
+};
+
+
+
+
+// utility functions
+void  DidcvPolyLineArrow( HDC hDC, const POINT* rgpt, INT nPoints, BOOL bDoShadow = FALSE );
+HFONT DidcvCreateFont( HDC hdc, const TCHAR* szFaceName, int iDeciPtHeight, int iDeciPtWidth, int iAttributes, BOOL fLogRes);
+
+
+
+
+//-----------------------------------------------------------------------------
+// Name: struct rgref
+// Desc: templated lightweight c-style array
+//-----------------------------------------------------------------------------
+template <class T>
+struct rgref {
+    rgref( T* p ) : pt( p ) {}
+
+    T & operator []( int i ) { return pt[i]; }
+    const T & operator []( int i ) const { return pt[i]; }
+
+private:
+    T *pt;
+};
+
+
+
+
+//-----------------------------------------------------------------------------
+// Name: struct SPOINT
+// Desc: used by line drawing routine
+//-----------------------------------------------------------------------------
+struct SPOINT {
+    SPOINT()
+#define SPOINT_INITIALIZERS \
+        p( u.p ), \
+        s( u.s ), \
+        a((( int* )( void* ) u.a ) ), \
+        x( u.p.x ), \
+        y( u.p.y ), \
+        cx( u.s.cx ), \
+        cy( u.s.cy )
+        : SPOINT_INITIALIZERS
+        { x = y = 0; }
+
+    SPOINT( int, POINT *r ) 
+        : p( *r ),
+          s( *(( SIZE* )( void* ) r ) ),
+          a((( int* )( void* ) r ) ),
+          x( r->x ),
+          y( r->y ),
+          cx( r->x ),
+          cy( r->y )
+    { }
+
+    SPOINT( const SPOINT & sp ) 
+        : SPOINT_INITIALIZERS
+    { p = sp.p; }
+
+    SPOINT( int b, int c ) 
+        : SPOINT_INITIALIZERS
+    { x = b; y = c; }
+
+    SPOINT( const POINT &point )
+        : SPOINT_INITIALIZERS
+    { p = point; }
+
+    SPOINT( const SIZE &size )
+        : SPOINT_INITIALIZERS
+    { s = size; }
+
+#undef SPOINT_INITIALIZERS
+
+    SPOINT operator =( const SPOINT &sp ) { p = sp.p; return *this; }
+    SPOINT operator =( const POINT &_p ) { p = _p; return *this; }
+    SPOINT operator =( const SIZE &_s ) { s = _s; return *this; }
+
+    operator POINT() const { return p; }
+    operator SIZE() const { return s; }
+
+    long &x, &y, &cx, &cy;
+    POINT &p;
+    SIZE &s;
+    rgref<int> a;
+
+private:
+    union {
+        POINT p;
+        SIZE s;
+        int a[2];
+    } u;
+};
+
+
+
+
+//-----------------------------------------------------------------------------
+// Name: class DidcvBitmap
+// Desc: object containing a bitmap
+//-----------------------------------------------------------------------------
+class DidcvBitmap
+{
+public:
+    ~DidcvBitmap();
+
+    // drawing interface
+    BOOL Draw( HDC hDC, INT xStart, INT yStart);
+    BOOL Blend( HDC hDC, INT xStart, INT yStart );
+    BOOL Blend( VOID* lpBits, INT xStart, INT yStart, INT width, INT height );
+
+    // information
+    BOOL GetSize( SIZE* lpSize ) const;
+    HBITMAP GetHandle();
+    LPVOID GetBits();
+
+public:
+    // static function for instantiating a DidcvBitmap
+    static DidcvBitmap* Create( LPCTSTR tszFilename );
+    static DidcvBitmap* Create( INT width, INT height );
+
+private:
+    // private constructor
+    DidcvBitmap();
+
+protected:
+    // helper functions
+    void CleanUp();
+    void FigureSize();
+
+    static DidcvBitmap* CreateViaD3dx( LPCTSTR tszFilename );
+    static DidcvBitmap* CreateViaLoadImage( HINSTANCE hinst, LPCTSTR tszName, 
+        UINT uType, int cx, int cy, UINT fuLoad );
+
+protected:
+    // GDI handle to bitmap
+    HBITMAP m_hbitmap;
+    VOID* m_lpBits;
+    SIZE m_size;
+};
+
+
+
+
+// alpha blending information
+#define DIDCV_ALPHABLEND_DLL_NAME   TEXT( "MSIMG32.DLL" )
+#define DIDCV_ALPHABLEND_PROC_NAME  TEXT( "AlphaBlend" )
+
+#if( WINVER >= 0x400 )
+  typedef WINGDIAPI BOOL( WINAPI* DIDCV_ALPHABLEND )( HDC, int, int, int, int, HDC, int, int, int, int, BLENDFUNCTION );
+#else
+  typedef DIDCV_ALPHABLEND DWORD
+#endif
+
+//-----------------------------------------------------------------------------
+// Name: class DidcvAlphaBlend
+// Desc: utility class for alpha blending
+//-----------------------------------------------------------------------------
+class DidcvAlphaBlend
+{
+public:
+    // reference counting interface
+    static BOOL AddClient();
+    static BOOL ReleaseClient();
+
+    // functions to perform blending
+    static BOOL Blend( HDC hDC, INT xStart, INT yStart, INT width, INT height, HBITMAP hbitmap, const SIZE* lpSize );
+    static BOOL Blend( VOID* lpDestBits, INT xStart, INT yStart, INT destWidth, INT destHeight, VOID* lpSrcBits, INT srcWidth, INT srcHeight );
+
+protected:
+    static DIDCV_ALPHABLEND s_alphaBlendProc;
+    static HMODULE s_hDll;
+    static DWORD s_dwNumClients;
+
+};
+
+
+
+
+#endif // #ifndef __DIDCV_H__