home *** CD-ROM | disk | FTP | other *** search
/ Programming a Multiplayer FPS in DirectX / Programming a Multiplayer FPS in DirectX (Companion CD).iso / DirectX / dxsdk_oct2004.exe / dxsdk.exe / Samples / C++ / Common / DXUTgui.h < prev    next >
Encoding:
C/C++ Source or Header  |  2004-09-30  |  47.4 KB  |  1,114 lines
  1. //--------------------------------------------------------------------------------------
  2. // File: DXUTgui.h
  3. //
  4. // Desc: 
  5. //
  6. // Copyright (c) Microsoft Corporation. All rights reserved.
  7. //--------------------------------------------------------------------------------------
  8. #pragma once
  9. #ifndef DXUT_GUI_H
  10. #define DXUT_GUI_H
  11.  
  12. #include <usp10.h>
  13. #include <dimm.h>
  14.  
  15.  
  16. //--------------------------------------------------------------------------------------
  17. // Defines and macros 
  18. //--------------------------------------------------------------------------------------
  19. #define EVENT_BUTTON_CLICKED                0x0101
  20. #define EVENT_COMBOBOX_SELECTION_CHANGED    0x0201
  21. #define EVENT_RADIOBUTTON_CHANGED           0x0301
  22. #define EVENT_CHECKBOX_CHANGED              0x0401
  23. #define EVENT_SLIDER_VALUE_CHANGED          0x0501
  24. #define EVENT_EDITBOX_STRING                0x0601
  25. // EVENT_EDITBOX_CHANGE is sent when the listbox content changes
  26. // due to user input.
  27. #define EVENT_EDITBOX_CHANGE                0x0602
  28. #define EVENT_LISTBOX_ITEM_DBLCLK           0x0701
  29. // EVENT_LISTBOX_SELECTION is fired off when the selection changes in
  30. // a single selection list box.
  31. #define EVENT_LISTBOX_SELECTION             0x0702
  32.  
  33.  
  34. //--------------------------------------------------------------------------------------
  35. // Forward declarations
  36. //--------------------------------------------------------------------------------------
  37. class CDXUTControl;
  38. class CDXUTButton;
  39. class CDXUTStatic;
  40. class CDXUTCheckBox;
  41. class CDXUTRadioButton;
  42. class CDXUTComboBox;
  43. class CDXUTSlider;
  44. class CDXUTEditBox;
  45. class CDXUTIMEEditBox;
  46. class CDXUTListBox;
  47. class CDXUTScrollBar;
  48. class CDXUTElement;
  49. struct DXUTElementHolder;
  50. struct DXUTTextureNode;
  51. struct DXUTFontNode;
  52. typedef VOID (CALLBACK *PCALLBACKDXUTGUIEVENT) ( UINT nEvent, int nControlID, CDXUTControl* pControl );
  53.  
  54.  
  55. //--------------------------------------------------------------------------------------
  56. // Enums for pre-defined control types
  57. //--------------------------------------------------------------------------------------
  58. enum DXUT_CONTROL_TYPE 
  59. { 
  60.     DXUT_CONTROL_BUTTON, 
  61.     DXUT_CONTROL_STATIC, 
  62.     DXUT_CONTROL_CHECKBOX,
  63.     DXUT_CONTROL_RADIOBUTTON,
  64.     DXUT_CONTROL_COMBOBOX,
  65.     DXUT_CONTROL_SLIDER,
  66.     DXUT_CONTROL_EDITBOX,
  67.     DXUT_CONTROL_IMEEDITBOX,
  68.     DXUT_CONTROL_LISTBOX,
  69.     DXUT_CONTROL_SCROLLBAR,
  70. };
  71.  
  72. enum DXUT_CONTROL_STATE
  73. {
  74.     DXUT_STATE_NORMAL = 0,
  75.     DXUT_STATE_DISABLED,
  76.     DXUT_STATE_HIDDEN,
  77.     DXUT_STATE_FOCUS,
  78.     DXUT_STATE_MOUSEOVER,
  79.     DXUT_STATE_PRESSED,
  80. };
  81.  
  82. #define MAX_CONTROL_STATES 6
  83.  
  84. struct DXUTBlendColor
  85. {
  86.     void Init( D3DCOLOR defaultColor, D3DCOLOR disabledColor = D3DCOLOR_ARGB(200, 128, 128, 128), D3DCOLOR hiddenColor = 0 );
  87.     void Blend( UINT iState, float fElapsedTime, float fRate = 0.7f );
  88.     
  89.     D3DCOLOR  States[ MAX_CONTROL_STATES ]; // Modulate colors for all possible control states
  90.     D3DXCOLOR Current;
  91. };
  92.  
  93.  
  94. //-----------------------------------------------------------------------------
  95. // Contains all the display tweakables for a sub-control
  96. //-----------------------------------------------------------------------------
  97. class CDXUTElement
  98. {
  99. public:
  100.     void SetTexture( UINT iTexture, RECT* prcTexture, D3DCOLOR defaultTextureColor = D3DCOLOR_ARGB(255, 255, 255, 255) );
  101.     void SetFont( UINT iFont, D3DCOLOR defaultFontColor = D3DCOLOR_ARGB(255, 255, 255, 255), DWORD dwTextFormat = DT_CENTER | DT_VCENTER );
  102.     
  103.     void Refresh();
  104.     
  105.     UINT iTexture;          // Index of the texture for this Element 
  106.     UINT iFont;             // Index of the font for this Element
  107.     DWORD dwTextFormat;     // The format argument to DrawText 
  108.  
  109.     RECT rcTexture;         // Bounding rect of this element on the composite texture
  110.     
  111.     DXUTBlendColor TextureColor;
  112.     DXUTBlendColor FontColor;
  113. };
  114.  
  115.  
  116. //-----------------------------------------------------------------------------
  117. // All controls must be assigned to a dialog, which handles
  118. // input and rendering for the controls.
  119. //-----------------------------------------------------------------------------
  120. class CDXUTDialog
  121. {
  122. public:
  123.     CDXUTDialog();
  124.     ~CDXUTDialog();
  125.  
  126.     // Windows message handler
  127.     bool MsgProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam );
  128.  
  129.     // Control creation
  130.     HRESULT AddStatic( int ID, LPCWSTR strText, int x, int y, int width, int height, bool bIsDefault=false, CDXUTStatic** ppCreated=NULL );
  131.     HRESULT AddButton( int ID, LPCWSTR strText, int x, int y, int width, int height, UINT nHotkey=0, bool bIsDefault=false, CDXUTButton** ppCreated=NULL );
  132.     HRESULT AddCheckBox( int ID, LPCWSTR strText, int x, int y, int width, int height, bool bChecked=false, UINT nHotkey=0, bool bIsDefault=false, CDXUTCheckBox** ppCreated=NULL );
  133.     HRESULT AddRadioButton( int ID, UINT nButtonGroup, LPCWSTR strText, int x, int y, int width, int height, bool bChecked=false, UINT nHotkey=0, bool bIsDefault=false, CDXUTRadioButton** ppCreated=NULL );
  134.     HRESULT AddComboBox( int ID, int x, int y, int width, int height, UINT nHotKey=0, bool bIsDefault=false, CDXUTComboBox** ppCreated=NULL );
  135.     HRESULT AddSlider( int ID, int x, int y, int width, int height, int min=0, int max=100, int value=50, bool bIsDefault=false, CDXUTSlider** ppCreated=NULL );
  136.     HRESULT AddEditBox( int ID, LPCWSTR strText, int x, int y, int width, int height, bool bIsDefault=false, CDXUTEditBox** ppCreated=NULL );
  137.     HRESULT AddIMEEditBox( int ID, LPCWSTR strText, int x, int y, int width, int height, bool bIsDefault=false, CDXUTIMEEditBox** ppCreated=NULL );
  138.     HRESULT AddListBox( int ID, int x, int y, int width, int height, DWORD dwStyle=0, CDXUTListBox** ppCreated=NULL );
  139.     HRESULT AddControl( CDXUTControl* pControl );
  140.     HRESULT InitControl( CDXUTControl* pControl );
  141.  
  142.     // Control retrieval
  143.     CDXUTStatic*      GetStatic( int ID ) { return (CDXUTStatic*) GetControl( ID, DXUT_CONTROL_STATIC ); }
  144.     CDXUTButton*      GetButton( int ID ) { return (CDXUTButton*) GetControl( ID, DXUT_CONTROL_BUTTON ); }
  145.     CDXUTCheckBox*    GetCheckBox( int ID ) { return (CDXUTCheckBox*) GetControl( ID, DXUT_CONTROL_CHECKBOX ); }
  146.     CDXUTRadioButton* GetRadioButton( int ID ) { return (CDXUTRadioButton*) GetControl( ID, DXUT_CONTROL_RADIOBUTTON ); }
  147.     CDXUTComboBox*    GetComboBox( int ID ) { return (CDXUTComboBox*) GetControl( ID, DXUT_CONTROL_COMBOBOX ); }
  148.     CDXUTSlider*      GetSlider( int ID ) { return (CDXUTSlider*) GetControl( ID, DXUT_CONTROL_SLIDER ); }
  149.     CDXUTEditBox*     GetEditBox( int ID ) { return (CDXUTEditBox*) GetControl( ID, DXUT_CONTROL_EDITBOX ); }
  150.     CDXUTIMEEditBox*  GetIMEEditBox( int ID ) { return (CDXUTIMEEditBox*) GetControl( ID, DXUT_CONTROL_IMEEDITBOX ); }
  151.     CDXUTListBox*     GetListBox( int ID ) { return (CDXUTListBox*) GetControl( ID, DXUT_CONTROL_LISTBOX ); }
  152.  
  153.     CDXUTControl* GetControl( int ID );
  154.     CDXUTControl* GetControl( int ID, UINT nControlType );
  155.     CDXUTControl* GetControlAtPoint( POINT pt );
  156.  
  157.     bool GetControlEnabled( int ID );
  158.     void SetControlEnabled( int ID, bool bEnabled );
  159.  
  160.     void ClearRadioButtonGroup( UINT nGroup );
  161.     void ClearComboBox( int ID );
  162.  
  163.     // Access the default display Elements used when adding new controls
  164.     HRESULT       SetDefaultElement( UINT nControlType, UINT iElement, CDXUTElement* pElement );
  165.     CDXUTElement* GetDefaultElement( UINT nControlType, UINT iElement );
  166.  
  167.     // Methods called by controls
  168.     void SendEvent( UINT nEvent, bool bTriggeredByUser, CDXUTControl* pControl );
  169.     void RequestFocus( CDXUTControl* pControl );
  170.  
  171.     // Render helpers
  172.     HRESULT DrawRect( RECT* pRect, D3DCOLOR color );
  173.     HRESULT DrawPolyLine( POINT* apPoints, UINT nNumPoints, D3DCOLOR color );
  174.     HRESULT DrawSprite( CDXUTElement* pElement, RECT* prcDest );
  175.     HRESULT CalcTextRect( LPCWSTR strText, CDXUTElement* pElement, RECT* prcDest, int nCount = -1 );
  176.     HRESULT DrawText( LPCWSTR strText, CDXUTElement* pElement, RECT* prcDest, bool bShadow = false, int nCount = -1 );
  177.  
  178.     // Attributes
  179.     bool GetMinimized() { return m_bMinimized; }
  180.     void SetMinimized( bool bMinimized ) { m_bMinimized = bMinimized; }
  181.     void SetBackgroundColors( D3DCOLOR colorAllCorners ) { SetBackgroundColors( colorAllCorners, colorAllCorners, colorAllCorners, colorAllCorners ); }
  182.     void SetBackgroundColors( D3DCOLOR colorTopLeft, D3DCOLOR colorTopRight, D3DCOLOR colorBottomLeft, D3DCOLOR colorBottomRight );
  183.     void EnableCaption( bool bEnable ) { m_bCaption = bEnable; }
  184.     int GetCaptionHeight() const { return m_nCaptionHeight; }
  185.     void SetCaptionHeight( int nHeight ) { m_nCaptionHeight = nHeight; }
  186.     void SetCaptionText( const WCHAR *pwszText ) { wcsncpy( m_wszCaption, pwszText, sizeof(m_wszCaption)/sizeof(m_wszCaption[0]) ); m_wszCaption[sizeof(m_wszCaption)/sizeof(m_wszCaption[0])-1] = 0; }
  187.     void GetLocation( POINT &Pt ) const { Pt.x = m_x; Pt.y = m_y; }
  188.     void SetLocation( int x, int y ) { m_x = x; m_y = y; }
  189.     void SetSize( int width, int height ) { m_width = width; m_height = height;  }
  190.     int GetWidth() { return m_width; }
  191.     int GetHeight() { return m_height; }
  192.  
  193.     void SetNextDialog( CDXUTDialog* pNextDialog );
  194.  
  195.     static void SetRefreshTime( float fTime ){ s_fTimeRefresh = fTime; }
  196.  
  197.     static CDXUTControl* GetNextControl( CDXUTControl* pControl );
  198.     static CDXUTControl* GetPrevControl( CDXUTControl* pControl );
  199.  
  200.     void RemoveControl( int ID );
  201.     void RemoveAllControls();
  202.  
  203.     // Sets the callback used to notify the app of control events
  204.     void SetCallback( PCALLBACKDXUTGUIEVENT pCallback ) { m_pCallbackEvent = pCallback; }
  205.     void EnableNonUserEvents( bool bEnable ) { m_bNonUserEvents = bEnable; }
  206.     void EnableKeyboardInput( bool bEnable ) { m_bKeyboardInput = bEnable; }
  207.     void EnableMouseInput( bool bEnable ) { m_bMouseInput = bEnable; }
  208.  
  209.     // Device state notification
  210.     void Refresh();
  211.     HRESULT OnRender( float fElapsedTime );    
  212.  
  213.     // Shared resource access. Indexed fonts and textures are shared among
  214.     // all the controls.
  215.     HRESULT       SetFont( UINT index, LPCWSTR strFaceName, LONG height, LONG weight );
  216.     DXUTFontNode* GetFont( UINT index );
  217.  
  218.     HRESULT          SetTexture( UINT index, LPCWSTR strFilename );
  219.     DXUTTextureNode* GetTexture( UINT index );
  220.  
  221.     static void ClearFocus();
  222.     void FocusDefaultControl();
  223.  
  224.     bool m_bNonUserEvents;
  225.     bool m_bKeyboardInput;
  226.     bool m_bMouseInput;
  227.  
  228. private:
  229.     int m_nDefaultControlID;
  230.  
  231.     static double s_fTimeRefresh;
  232.     double m_fTimeLastRefresh;
  233.  
  234.     // Initialize default Elements
  235.     void InitDefaultElements();
  236.  
  237.     // Windows message handlers
  238.     void OnMouseMove( POINT pt );
  239.     void OnMouseUp( POINT pt );
  240.  
  241.     // Control events
  242.     void OnCycleFocus( bool bForward );
  243.     void OnMouseEnter( CDXUTControl* pControl );
  244.     void OnMouseLeave( CDXUTControl* pControl );
  245.  
  246.     static CDXUTControl* s_pControlFocus;        // The control which has focus
  247.     static CDXUTControl* s_pControlPressed;      // The control currently pressed
  248.  
  249.     CDXUTControl* m_pControlMouseOver;           // The control which is hovered over
  250.  
  251.     bool m_bCaption;
  252.     bool m_bMinimized;
  253.     WCHAR m_wszCaption[256];
  254.  
  255.     int m_x;
  256.     int m_y;
  257.     int m_width;
  258.     int m_height;
  259.     int m_nCaptionHeight;
  260.  
  261.     D3DCOLOR m_colorTopLeft;
  262.     D3DCOLOR m_colorTopRight;
  263.     D3DCOLOR m_colorBottomLeft;
  264.     D3DCOLOR m_colorBottomRight;
  265.  
  266.     PCALLBACKDXUTGUIEVENT m_pCallbackEvent;
  267.  
  268.     CGrowableArray< int > m_Textures;   // Index into m_TextureCache;
  269.     CGrowableArray< int > m_Fonts;      // Index into m_FontCache;
  270.  
  271.     CGrowableArray< CDXUTControl* > m_Controls;
  272.     CGrowableArray< DXUTElementHolder* > m_DefaultElements;
  273.  
  274.     CDXUTElement m_CapElement;  // Element for the caption
  275.  
  276.     CDXUTDialog* m_pNextDialog;
  277.     CDXUTDialog* m_pPrevDialog;
  278. };
  279.  
  280.  
  281. //--------------------------------------------------------------------------------------
  282. // Structs for shared resources
  283. //--------------------------------------------------------------------------------------
  284. struct DXUTTextureNode
  285. {
  286.     WCHAR strFilename[MAX_PATH];
  287.     IDirect3DTexture9* pTexture;
  288.     DWORD dwWidth;
  289.     DWORD dwHeight;
  290. };
  291.  
  292. struct DXUTFontNode
  293. {
  294.     WCHAR strFace[MAX_PATH];
  295.     ID3DXFont* pFont;
  296.     LONG  nHeight;
  297.     LONG  nWeight;
  298. };
  299.  
  300.  
  301. //-----------------------------------------------------------------------------
  302. // Manages shared resources of dialogs
  303. // Use DXUTGetGlobalDialogResourceManager() to get access to the global instance
  304. //-----------------------------------------------------------------------------
  305. class CDXUTDialogResourceManager
  306. {
  307. public:
  308.     int AddFont( LPCWSTR strFaceName, LONG height, LONG weight );
  309.     int AddTexture( LPCWSTR strFilename );
  310.  
  311.     DXUTFontNode*     GetFontNode( int iIndex )     { return m_FontCache.GetAt( iIndex ); };
  312.     DXUTTextureNode*  GetTextureNode( int iIndex )  { return m_TextureCache.GetAt( iIndex ); };    
  313.     IDirect3DDevice9* GetD3DDevice()                { return m_pd3dDevice; }
  314.  
  315.     // Shared between all dialogs
  316.     IDirect3DStateBlock9* m_pStateBlock;
  317.     ID3DXSprite*          m_pSprite;          // Sprite used for drawing
  318.  
  319.     ~CDXUTDialogResourceManager();
  320.  
  321. protected:
  322.     friend CDXUTDialogResourceManager* DXUTGetGlobalDialogResourceManager();
  323.     friend HRESULT DXUTInitialize3DEnvironment();
  324.     friend HRESULT DXUTReset3DEnvironment();
  325.     friend void DXUTCleanup3DEnvironment( bool bReleaseSettings );
  326.  
  327.     // Use DXUTGetGlobalDialogResourceManager() to get access to the global instance
  328.     CDXUTDialogResourceManager();
  329.  
  330.     // The sample framework uses the global instance and automatically calls the device events
  331.     HRESULT     OnCreateDevice( LPDIRECT3DDEVICE9 pd3dDevice );
  332.     HRESULT     OnResetDevice();
  333.     void        OnLostDevice();
  334.     void        OnDestroyDevice();
  335.  
  336.     CGrowableArray< DXUTTextureNode* > m_TextureCache;   // Shared textures
  337.     CGrowableArray< DXUTFontNode* > m_FontCache;         // Shared fonts
  338.     
  339.     IDirect3DDevice9* m_pd3dDevice;
  340.  
  341.     // Resource creation helpers
  342.     HRESULT CreateFont( UINT index );
  343.     HRESULT CreateTexture( UINT index );
  344. };
  345.  
  346. CDXUTDialogResourceManager* DXUTGetGlobalDialogResourceManager();
  347.  
  348.  
  349. //-----------------------------------------------------------------------------
  350. // Base class for controls
  351. //-----------------------------------------------------------------------------
  352. class CDXUTControl
  353. {
  354. public:
  355.     CDXUTControl( CDXUTDialog *pDialog = NULL );
  356.     virtual ~CDXUTControl();
  357.  
  358.     virtual HRESULT OnInit() { return S_OK; }
  359.     virtual void Refresh();
  360.     virtual void Render( IDirect3DDevice9* pd3dDevice, float fElapsedTime ) { };
  361.  
  362.     // Windows message handler
  363.     virtual bool MsgProc( UINT uMsg, WPARAM wParam, LPARAM lParam ) { return false; }
  364.  
  365.     virtual bool HandleKeyboard( UINT uMsg, WPARAM wParam, LPARAM lParam ) { return false; }
  366.     virtual bool HandleMouse( UINT uMsg, POINT pt, WPARAM wParam, LPARAM lParam ) { return false; }
  367.  
  368.     virtual bool CanHaveFocus() { return false; }
  369.     virtual void OnFocusIn() { m_bHasFocus = true; }
  370.     virtual void OnFocusOut() { m_bHasFocus = false; }
  371.     virtual void OnMouseEnter() { m_bMouseOver = true; }
  372.     virtual void OnMouseLeave() { m_bMouseOver = false; }
  373.     virtual void OnHotkey() {}
  374.  
  375.     virtual BOOL ContainsPoint( POINT pt ) { return PtInRect( &m_rcBoundingBox, pt ); }
  376.  
  377.     virtual void SetEnabled( bool bEnabled ) { m_bEnabled = bEnabled; }
  378.     virtual bool GetEnabled() { return m_bEnabled; }
  379.     virtual void SetVisible( bool bVisible ) { m_bVisible = bVisible; }
  380.     virtual bool GetVisible() { return m_bVisible; }
  381.  
  382.     UINT GetType() const { return m_Type; }
  383.  
  384.     int  GetID() const { return m_ID; }
  385.     void SetID( int ID ) { m_ID = ID; }
  386.  
  387.     void SetLocation( int x, int y ) { m_x = x; m_y = y; UpdateRects(); }
  388.     void SetSize( int width, int height ) { m_width = width; m_height = height; UpdateRects(); }
  389.  
  390.     void SetHotkey( UINT nHotkey ) { m_nHotkey = nHotkey; }
  391.     UINT GetHotkey() { return m_nHotkey; }
  392.  
  393.     void SetUserData( void *pUserData ) { m_pUserData = pUserData; }
  394.     void *GetUserData() const { return m_pUserData; }
  395.  
  396.     virtual void SetTextColor( D3DCOLOR Color );
  397.     CDXUTElement* GetElement( UINT iElement ) { return m_Elements.GetAt( iElement ); }
  398.     HRESULT SetElement( UINT iElement, CDXUTElement* pElement);
  399.  
  400.     bool m_bVisible;                // Shown/hidden flag
  401.     bool m_bMouseOver;              // Mouse pointer is above control
  402.     bool m_bHasFocus;               // Control has input focus
  403.     bool m_bIsDefault;              // Is the default control
  404.  
  405.     // Size, scale, and positioning members
  406.     int m_x, m_y;
  407.     int m_width, m_height;
  408.  
  409.     // These members are set by the container
  410.     CDXUTDialog* m_pDialog;    // Parent container
  411.     UINT m_Index;              // Index within the control list
  412.     
  413.     CGrowableArray< CDXUTElement* > m_Elements;  // All display elements
  414.  
  415. protected:
  416.     virtual void UpdateRects();
  417.  
  418.     int  m_ID;                 // ID number
  419.     DXUT_CONTROL_TYPE m_Type;  // Control type, set once in constructor  
  420.     UINT m_nHotkey;            // Virtual key code for this control's hotkey
  421.     void *m_pUserData;         // Data associated with this control that is set by user.
  422.     
  423.     bool m_bEnabled;           // Enabled/disabled flag
  424.     
  425.     RECT m_rcBoundingBox;      // Rectangle defining the active region of the control
  426. };
  427.  
  428.  
  429. //-----------------------------------------------------------------------------
  430. // Contains all the display information for a given control type
  431. //-----------------------------------------------------------------------------
  432. struct DXUTElementHolder
  433. {
  434.     UINT nControlType;
  435.     UINT iElement;
  436.  
  437.     CDXUTElement Element;
  438. };
  439.  
  440.  
  441. //-----------------------------------------------------------------------------
  442. // Static control
  443. //-----------------------------------------------------------------------------
  444. class CDXUTStatic : public CDXUTControl
  445. {
  446. public:
  447.     CDXUTStatic( CDXUTDialog *pDialog = NULL );
  448.  
  449.     virtual void Render( IDirect3DDevice9* pd3dDevice, float fElapsedTime );
  450.     virtual BOOL ContainsPoint( POINT pt ) { return false; }
  451.  
  452.     HRESULT GetTextCopy( LPWSTR strDest, UINT bufferCount );
  453.     LPCWSTR GetText() { return m_strText; }
  454.     HRESULT SetText( LPCWSTR strText );
  455.  
  456.  
  457. protected:
  458.     WCHAR m_strText[MAX_PATH];      // Window text  
  459. };
  460.  
  461.  
  462. //-----------------------------------------------------------------------------
  463. // Button control
  464. //-----------------------------------------------------------------------------
  465. class CDXUTButton : public CDXUTStatic
  466. {
  467. public:
  468.     CDXUTButton( CDXUTDialog *pDialog = NULL );
  469.  
  470.     virtual bool HandleKeyboard( UINT uMsg, WPARAM wParam, LPARAM lParam );
  471.     virtual bool HandleMouse( UINT uMsg, POINT pt, WPARAM wParam, LPARAM lParam );
  472.     virtual void OnHotkey() { m_pDialog->SendEvent( EVENT_BUTTON_CLICKED, true, this ); }
  473.     
  474.     virtual BOOL ContainsPoint( POINT pt ) { return PtInRect( &m_rcBoundingBox, pt ); }
  475.     virtual bool CanHaveFocus() { return (m_bVisible && m_bEnabled); }
  476.  
  477.     virtual void Render( IDirect3DDevice9* pd3dDevice, float fElapsedTime );
  478.  
  479. protected:
  480.     bool m_bPressed;
  481. };
  482.  
  483.  
  484. //-----------------------------------------------------------------------------
  485. // CheckBox control
  486. //-----------------------------------------------------------------------------
  487. class CDXUTCheckBox : public CDXUTButton
  488. {
  489. public:
  490.     CDXUTCheckBox( CDXUTDialog *pDialog = NULL );
  491.  
  492.     virtual bool HandleKeyboard( UINT uMsg, WPARAM wParam, LPARAM lParam );
  493.     virtual bool HandleMouse( UINT uMsg, POINT pt, WPARAM wParam, LPARAM lParam );
  494.     virtual void OnHotkey() { SetCheckedInternal( !m_bChecked, true ); }
  495.  
  496.     virtual BOOL ContainsPoint( POINT pt ); 
  497.     virtual void UpdateRects(); 
  498.  
  499.     virtual void Render( IDirect3DDevice9* pd3dDevice, float fElapsedTime );
  500.  
  501.     bool GetChecked() { return m_bChecked; }
  502.     void SetChecked( bool bChecked ) { SetCheckedInternal( bChecked, false ); }
  503.     
  504. protected:
  505.     virtual void SetCheckedInternal( bool bChecked, bool bFromInput );
  506.  
  507.     bool m_bChecked;
  508.     RECT m_rcButton;
  509.     RECT m_rcText;
  510. };
  511.  
  512.  
  513. //-----------------------------------------------------------------------------
  514. // RadioButton control
  515. //-----------------------------------------------------------------------------
  516. class CDXUTRadioButton : public CDXUTCheckBox
  517. {
  518. public:
  519.     CDXUTRadioButton( CDXUTDialog *pDialog = NULL );
  520.  
  521.     virtual bool HandleKeyboard( UINT uMsg, WPARAM wParam, LPARAM lParam );
  522.     virtual bool HandleMouse( UINT uMsg, POINT pt, WPARAM wParam, LPARAM lParam );
  523.     virtual void OnHotkey() { SetCheckedInternal( true, true, true ); }
  524.     
  525.     void SetChecked( bool bChecked, bool bClearGroup=true ) { SetCheckedInternal( bChecked, bClearGroup, false ); }
  526.     void SetButtonGroup( UINT nButtonGroup ) { m_nButtonGroup = nButtonGroup; }
  527.     UINT GetButtonGroup() { return m_nButtonGroup; }
  528.     
  529. protected:
  530.     virtual void SetCheckedInternal( bool bChecked, bool bClearGroup, bool bFromInput );
  531.     UINT m_nButtonGroup;
  532. };
  533.  
  534.  
  535. //-----------------------------------------------------------------------------
  536. // Scrollbar control
  537. //-----------------------------------------------------------------------------
  538. class CDXUTScrollBar : public CDXUTControl
  539. {
  540. public:
  541.     CDXUTScrollBar( CDXUTDialog *pDialog = NULL );
  542.     virtual ~CDXUTScrollBar();
  543.  
  544.     virtual bool    HandleKeyboard( UINT uMsg, WPARAM wParam, LPARAM lParam );
  545.     virtual bool    HandleMouse( UINT uMsg, POINT pt, WPARAM wParam, LPARAM lParam );
  546.  
  547.     virtual void Render( IDirect3DDevice9* pd3dDevice, float fElapsedTime );
  548.     virtual void    UpdateRects();
  549.  
  550.     void SetTrackRange( int nStart, int nEnd );
  551.     int GetTrackPos() { return m_nPosition; }
  552.     void SetTrackPos( int nPosition ) { m_nPosition = nPosition; Cap(); UpdateThumbRect(); }
  553.     int GetPageSize() { return m_nPageSize; }
  554.     void SetPageSize( int nPageSize ) { m_nPageSize = nPageSize; Cap(); UpdateThumbRect(); }
  555.  
  556.     void Scroll( int nDelta );    // Scroll by nDelta items (plus or minus)
  557.     void ShowItem( int nIndex );  // Ensure that item nIndex is displayed, scroll if necessary
  558.  
  559. protected:
  560.     // ARROWSTATE indicates the state of the arrow buttons.
  561.     // CLEAR            No arrow is down.
  562.     // CLICKED_UP       Up arrow is clicked.
  563.     // CLICKED_DOWN     Down arrow is clicked.
  564.     // HELD_UP          Up arrow is held down for sustained period.
  565.     // HELD_DOWN        Down arrow is held down for sustained period.
  566.     enum ARROWSTATE { CLEAR, CLICKED_UP, CLICKED_DOWN, HELD_UP, HELD_DOWN };
  567.  
  568.     void UpdateThumbRect();
  569.     void Cap();  // Clips position at boundaries. Ensures it stays within legal range.
  570.  
  571.     bool m_bShowThumb;
  572.     RECT m_rcUpButton;
  573.     RECT m_rcDownButton;
  574.     RECT m_rcTrack;
  575.     RECT m_rcThumb;
  576.     int m_nPosition;  // Position of the first displayed item
  577.     int m_nPageSize;  // How many items are displayable in one page
  578.     int m_nStart;     // First item
  579.     int m_nEnd;       // The index after the last item
  580.     POINT m_LastMouse;// Last mouse position
  581.     ARROWSTATE m_Arrow; // State of the arrows
  582.     double m_dArrowTS;  // Timestamp of last arrow event.
  583. };
  584.  
  585.  
  586. //-----------------------------------------------------------------------------
  587. // ListBox control
  588. //-----------------------------------------------------------------------------
  589. struct DXUTListBoxItem
  590. {
  591.     WCHAR strText[256];
  592.     void*  pData;
  593.  
  594.     RECT  rcActive;
  595.     bool  bSelected;
  596. };
  597.  
  598. class CDXUTListBox : public CDXUTControl
  599. {
  600. public:
  601.     CDXUTListBox( CDXUTDialog *pDialog = NULL );
  602.     virtual ~CDXUTListBox();
  603.  
  604.     virtual HRESULT OnInit() { return m_pDialog->InitControl( &m_ScrollBar ); }
  605.     virtual bool    CanHaveFocus() { return (m_bVisible && m_bEnabled); }
  606.     virtual bool    HandleKeyboard( UINT uMsg, WPARAM wParam, LPARAM lParam );
  607.     virtual bool    HandleMouse( UINT uMsg, POINT pt, WPARAM wParam, LPARAM lParam );
  608.  
  609.     virtual void Render( IDirect3DDevice9* pd3dDevice, float fElapsedTime );
  610.     virtual void    UpdateRects();
  611.  
  612.     DWORD GetStyle() const { return m_dwStyle; }
  613.     int GetSize() const { return m_Items.GetSize(); }
  614.     void SetStyle( DWORD dwStyle ) { m_dwStyle = dwStyle; }
  615.     void SetScrollBarWidth( int nWidth ) { m_nSBWidth = nWidth; UpdateRects(); }
  616.     void SetBorder( int nBorder, int nMargin ) { m_nBorder = nBorder; m_nMargin = nMargin; }
  617.     HRESULT AddItem( const WCHAR *wszText, void *pData );
  618.     HRESULT InsertItem( int nIndex, const WCHAR *wszText, void *pData );
  619.     void RemoveItem( int nIndex );
  620.     void RemoveItemByText( WCHAR *wszText );
  621.     void RemoveItemByData( void *pData );
  622.     void RemoveAllItems();
  623.  
  624.     DXUTListBoxItem *GetItem( int nIndex );
  625.     int GetSelectedIndex( int nPreviousSelected = -1 );
  626.     DXUTListBoxItem *GetSelectedItem( int nPreviousSelected = -1 ) { return GetItem( GetSelectedIndex( nPreviousSelected ) ); }
  627.     void SelectItem( int nNewIndex );
  628.  
  629.     enum STYLE { MULTISELECTION = 1 };
  630.  
  631. protected:
  632.     RECT m_rcText;      // Text rendering bound
  633.     RECT m_rcSelection; // Selection box bound
  634.     CDXUTScrollBar m_ScrollBar;
  635.     int m_nSBWidth;
  636.     int m_nBorder;
  637.     int m_nMargin;
  638.     int m_nTextHeight;  // Height of a single line of text
  639.     DWORD m_dwStyle;    // List box style
  640.     int m_nSelected;    // Index of the selected item for single selection list box
  641.     int m_nSelStart;    // Index of the item where selection starts (for handling multi-selection)
  642.     bool m_bDrag;       // Whether the user is dragging the mouse to select
  643.  
  644.     CGrowableArray< DXUTListBoxItem* > m_Items;
  645. };
  646.  
  647.  
  648. //-----------------------------------------------------------------------------
  649. // ComboBox control
  650. //-----------------------------------------------------------------------------
  651. struct DXUTComboBoxItem
  652. {
  653.     WCHAR strText[256];
  654.     void*  pData;
  655.  
  656.     RECT  rcActive;
  657.     bool  bVisible;
  658. };
  659.  
  660.  
  661. class CDXUTComboBox : public CDXUTButton
  662. {
  663. public:
  664.     CDXUTComboBox( CDXUTDialog *pDialog = NULL );
  665.     virtual ~CDXUTComboBox();
  666.     
  667.     virtual void SetTextColor( D3DCOLOR Color );
  668.     virtual HRESULT OnInit() { return m_pDialog->InitControl( &m_ScrollBar ); }
  669.  
  670.     virtual bool HandleKeyboard( UINT uMsg, WPARAM wParam, LPARAM lParam );
  671.     virtual bool HandleMouse( UINT uMsg, POINT pt, WPARAM wParam, LPARAM lParam );
  672.     virtual void OnHotkey();
  673.  
  674.     virtual bool CanHaveFocus() { return (m_bVisible && m_bEnabled); }
  675.     virtual void OnFocusOut();
  676.     virtual void Render( IDirect3DDevice9* pd3dDevice, float fElapsedTime );
  677.  
  678.     virtual void UpdateRects(); 
  679.  
  680.     HRESULT AddItem( const WCHAR* strText, void* pData );
  681.     void    RemoveAllItems();
  682.     void    RemoveItem( UINT index );
  683.     bool    ContainsItem( const WCHAR* strText, UINT iStart=0 );
  684.     int     FindItem( const WCHAR* strText, UINT iStart=0 );
  685.     void*   GetItemData( const WCHAR* strText );
  686.     void*   GetItemData( int nIndex );
  687.     void    SetDropHeight( UINT nHeight ) { m_nDropHeight = nHeight; UpdateRects(); }
  688.     void    SetScrollBarWidth( int nWidth ) { m_nSBWidth = nWidth; UpdateRects(); }
  689.  
  690.     void*   GetSelectedData();
  691.     DXUTComboBoxItem* GetSelectedItem();
  692.  
  693.     UINT    GetNumItems() { return m_Items.GetSize(); }
  694.     DXUTComboBoxItem* GetItem( UINT index ) { return m_Items.GetAt( index ); }
  695.  
  696.     HRESULT SetSelectedByIndex( UINT index );
  697.     HRESULT SetSelectedByText( const WCHAR* strText );
  698.     HRESULT SetSelectedByData( void* pData );  
  699.  
  700. protected:
  701.     int     m_iSelected;
  702.     int     m_iFocused;
  703.     int     m_nDropHeight;
  704.     CDXUTScrollBar m_ScrollBar;
  705.     int     m_nSBWidth;
  706.  
  707.     bool    m_bOpened;
  708.  
  709.     RECT m_rcText;
  710.     RECT m_rcButton;
  711.     RECT m_rcDropdown;
  712.     RECT m_rcDropdownText;
  713.  
  714.     
  715.     CGrowableArray< DXUTComboBoxItem* > m_Items;
  716. };
  717.  
  718.  
  719. //-----------------------------------------------------------------------------
  720. // Slider control
  721. //-----------------------------------------------------------------------------
  722. class CDXUTSlider : public CDXUTControl
  723. {
  724. public:
  725.     CDXUTSlider( CDXUTDialog *pDialog = NULL );
  726.  
  727.     virtual BOOL ContainsPoint( POINT pt ); 
  728.     virtual bool CanHaveFocus() { return (m_bVisible && m_bEnabled); }
  729.     virtual bool HandleKeyboard( UINT uMsg, WPARAM wParam, LPARAM lParam );
  730.     virtual bool HandleMouse( UINT uMsg, POINT pt, WPARAM wParam, LPARAM lParam );
  731.     
  732.     virtual void UpdateRects(); 
  733.  
  734.     virtual void Render( IDirect3DDevice9* pd3dDevice, float fElapsedTime );
  735.  
  736.     void SetValue( int nValue ) { SetValueInternal( nValue, false ); }
  737.     int  GetValue() { return m_nValue; };
  738.  
  739.     void SetRange( int nMin, int nMax );
  740.  
  741. protected:
  742.     void SetValueInternal( int nValue, bool bFromInput );
  743.     int  ValueFromPos( int x ); 
  744.  
  745.     int m_nValue;
  746.  
  747.     int m_nMin;
  748.     int m_nMax;
  749.  
  750.     int m_nDragX;      // Mouse position at start of drag
  751.     int m_nDragOffset; // Drag offset from the center of the button
  752.     int m_nButtonX;
  753.  
  754.     bool m_bPressed;
  755.     RECT m_rcButton;
  756. };
  757.  
  758.  
  759. //-----------------------------------------------------------------------------
  760. // EditBox control
  761. //-----------------------------------------------------------------------------
  762. #define UNISCRIBE_DLLNAME L"\\usp10.dll"
  763.  
  764. #define GETPROCADDRESS( Module, APIName, Temp ) \
  765.     Temp = GetProcAddress( Module, #APIName ); \
  766.     if( Temp ) \
  767.         *(FARPROC*)&_##APIName = Temp
  768.  
  769. #define PLACEHOLDERPROC( APIName ) \
  770.     _##APIName = Dummy_##APIName
  771.  
  772. class CDXUTEditBox : public CDXUTControl
  773. {
  774.     friend class CExternalApiInitializer;
  775.  
  776. public:
  777.     CDXUTEditBox( CDXUTDialog *pDialog = NULL );
  778.     virtual ~CDXUTEditBox();
  779.  
  780.     virtual bool HandleKeyboard( UINT uMsg, WPARAM wParam, LPARAM lParam );
  781.     virtual bool HandleMouse( UINT uMsg, POINT pt, WPARAM wParam, LPARAM lParam );
  782.     virtual bool MsgProc( UINT uMsg, WPARAM wParam, LPARAM lParam );
  783.     virtual void UpdateRects();
  784.     virtual bool CanHaveFocus() { return (m_bVisible && m_bEnabled); }
  785.     virtual void Render( IDirect3DDevice9* pd3dDevice, float fElapsedTime );
  786.     virtual void    OnFocusIn();
  787.  
  788.     void SetText( LPCWSTR wszText, bool bSelected = false );
  789.     LPCWSTR GetText() { return m_Buffer.GetBuffer(); }
  790.     int GetTextLength() { return m_Buffer.GetTextSize(); }  // Returns text length in chars excluding NULL.
  791.     HRESULT GetTextCopy( LPWSTR strDest, UINT bufferCount );
  792.     void ClearText();
  793.     virtual void SetTextColor( D3DCOLOR Color ) { m_TextColor = Color; }  // Text color
  794.     void SetSelectedTextColor( D3DCOLOR Color ) { m_SelTextColor = Color; }  // Selected text color
  795.     void SetSelectedBackColor( D3DCOLOR Color ) { m_SelBkColor = Color; }  // Selected background color
  796.     void SetCaretColor( D3DCOLOR Color ) { m_CaretColor = Color; }  // Caret color
  797.     void SetBorderWidth( int nBorder ) { m_nBorder = nBorder; UpdateRects(); }  // Border of the window
  798.     void SetSpacing( int nSpacing ) { m_nSpacing = nSpacing; UpdateRects(); }
  799.     void ParseFloatArray( float *pNumbers, int nCount );
  800.     void SetTextFloatArray( const float *pNumbers, int nCount );
  801.  
  802. public:
  803.     //-----------------------------------------------------------------------------
  804.     // CUniBuffer class for the edit control
  805.     //-----------------------------------------------------------------------------
  806.     class CUniBuffer
  807.     {
  808.         friend class CExternalApiInitializer;
  809.  
  810.         // static member
  811.  
  812.         // Empty implementation of the Uniscribe API
  813.         static HRESULT WINAPI Dummy_ScriptApplyDigitSubstitution( const SCRIPT_DIGITSUBSTITUTE*, SCRIPT_CONTROL*, SCRIPT_STATE* ) { return E_NOTIMPL; }
  814.         static HRESULT WINAPI Dummy_ScriptStringAnalyse( HDC, const void *, int, int, int, DWORD, int, SCRIPT_CONTROL*, SCRIPT_STATE*, const int*, SCRIPT_TABDEF*, const BYTE*, SCRIPT_STRING_ANALYSIS* ) { return E_NOTIMPL; }
  815.         static HRESULT WINAPI Dummy_ScriptStringCPtoX( SCRIPT_STRING_ANALYSIS, int, BOOL, int* ) { return E_NOTIMPL; }
  816.         static HRESULT WINAPI Dummy_ScriptStringXtoCP( SCRIPT_STRING_ANALYSIS, int, int*, int* ) { return E_NOTIMPL; }
  817.         static HRESULT WINAPI Dummy_ScriptStringFree( SCRIPT_STRING_ANALYSIS* ) { return E_NOTIMPL; }
  818.         static const SCRIPT_LOGATTR* WINAPI Dummy_ScriptString_pLogAttr( SCRIPT_STRING_ANALYSIS ) { return NULL; }
  819.         static const int* WINAPI Dummy_ScriptString_pcOutChars( SCRIPT_STRING_ANALYSIS ) { return NULL; }
  820.  
  821.         // Function pointers
  822.         static HRESULT (WINAPI *_ScriptApplyDigitSubstitution)( const SCRIPT_DIGITSUBSTITUTE*, SCRIPT_CONTROL*, SCRIPT_STATE* );
  823.         static HRESULT (WINAPI *_ScriptStringAnalyse)( HDC, const void *, int, int, int, DWORD, int, SCRIPT_CONTROL*, SCRIPT_STATE*, const int*, SCRIPT_TABDEF*, const BYTE*, SCRIPT_STRING_ANALYSIS* );
  824.         static HRESULT (WINAPI *_ScriptStringCPtoX)( SCRIPT_STRING_ANALYSIS, int, BOOL, int* );
  825.         static HRESULT (WINAPI *_ScriptStringXtoCP)( SCRIPT_STRING_ANALYSIS, int, int*, int* );
  826.         static HRESULT (WINAPI *_ScriptStringFree)( SCRIPT_STRING_ANALYSIS* );
  827.         static const SCRIPT_LOGATTR* (WINAPI *_ScriptString_pLogAttr)( SCRIPT_STRING_ANALYSIS );
  828.         static const int* (WINAPI *_ScriptString_pcOutChars)( SCRIPT_STRING_ANALYSIS );
  829.  
  830.         static void InitializeUniscribe();
  831.         static void UninitializeUniscribe();
  832.  
  833.         static HINSTANCE s_hDll;  // Uniscribe DLL handle
  834.  
  835.     // Instance data
  836.     private:
  837.         WCHAR *m_pwszBuffer;    // Buffer to hold text
  838.         int    m_nBufferSize;   // Size of the buffer allocated, in characters
  839.         int    m_nTextSize;     // Size of the text in buffer excluding
  840.                                 //   NULL terminator, in characters
  841.         // Uniscribe-specific
  842.         int  m_iFont;           // Font index of this buffer
  843.         bool m_bAnalyseRequired;// True if the string has changed since last analysis.
  844.         SCRIPT_STRING_ANALYSIS m_Analysis;  // Analysis for the current string
  845.  
  846.     private:
  847.         bool Grow( int nNewSize = -1 );
  848.  
  849.         // Uniscribe -- Analyse() analyses the string in the buffer
  850.         HRESULT Analyse();
  851.  
  852.     public:
  853.         CUniBuffer( int nInitialSize = 1 );
  854.         ~CUniBuffer();
  855.         int GetBufferSize() { return m_nBufferSize; }
  856.         bool SetBufferSize( int nSize );
  857.         int GetTextSize() { return m_nTextSize; }
  858.         const WCHAR *GetBuffer() { return m_pwszBuffer; }
  859.         const WCHAR &operator[]( int n ) const { return m_pwszBuffer[n]; }
  860.         WCHAR &operator[]( int n );
  861.         int GetFontIndex() { return m_iFont; }
  862.         void SetFontIndex( int iFont ) { m_iFont = iFont; }
  863.         void Clear();
  864.  
  865.         // Inserts the char at specified index.
  866.         // If nIndex == -1, insert to the end.
  867.         bool InsertChar( int nIndex, WCHAR wChar );
  868.  
  869.         // Removes the char at specified index.
  870.         // If nIndex == -1, remove the last char.
  871.         bool RemoveChar( int nIndex );
  872.  
  873.         // Inserts the first nCount characters of the string pStr at specified index.
  874.         // If nCount == -1, the entire string is inserted.
  875.         // If nIndex == -1, insert to the end.
  876.         bool InsertString( int nIndex, const WCHAR *pStr, int nCount = -1 );
  877.  
  878.         bool SetText( LPCWSTR wszText );
  879.  
  880.         // Uniscribe
  881.         HRESULT CPtoX( int nCP, BOOL bTrail, int *pX );
  882.         HRESULT XtoCP( int nX, int *pCP, int *pnTrail );
  883.         void GetPriorItemPos( int nCP, int *pPrior );
  884.         void GetNextItemPos( int nCP, int *pPrior );
  885.     };
  886.  
  887. protected:
  888.     void PlaceCaret( int nCP );
  889.     void DeleteSelectionText();
  890.     void ResetCaretBlink();
  891.     void CopyToClipboard();
  892.     void PasteFromClipboard();
  893.  
  894.     CUniBuffer m_Buffer;     // Buffer to hold text
  895.     int      m_nBorder;      // Border of the window
  896.     int      m_nSpacing;     // Spacing between the text and the edge of border
  897.     RECT     m_rcText;       // Bounding rectangle for the text
  898.     RECT     m_rcRender[9];  // Convenient rectangles for rendering elements
  899.     double   m_dfBlink;      // Caret blink time in milliseconds
  900.     double   m_dfLastBlink;  // Last timestamp of caret blink
  901.     bool     m_bCaretOn;     // Flag to indicate whether caret is currently visible
  902.     int      m_nCaret;       // Caret position, in characters
  903.     bool     m_bInsertMode;  // If true, control is in insert mode. Else, overwrite mode.
  904.     int      m_nSelStart;    // Starting position of the selection. The caret marks the end.
  905.     int      m_nFirstVisible;// First visible character in the edit control
  906.     D3DCOLOR m_TextColor;    // Text color
  907.     D3DCOLOR m_SelTextColor; // Selected text color
  908.     D3DCOLOR m_SelBkColor;   // Selected background color
  909.     D3DCOLOR m_CaretColor;   // Caret color
  910.  
  911.     // Mouse-specific
  912.     bool m_bMouseDrag;       // True to indicate drag in progress
  913.  
  914.     // Static
  915.     static bool     s_bHideCaret;   // If true, we don't render the caret.
  916. };
  917.  
  918.  
  919. //-----------------------------------------------------------------------------
  920. // IME-enabled EditBox control
  921. //-----------------------------------------------------------------------------
  922. #define IMM32_DLLNAME L"\\imm32.dll"
  923. #define VER_DLLNAME L"\\version.dll"
  924. #define MAX_CANDLIST 10
  925. #define MAX_COMPSTRING_SIZE 256
  926.  
  927. class CDXUTIMEEditBox : public CDXUTEditBox
  928. {
  929.     friend class CExternalApiInitializer;
  930.  
  931.     static void InitializeImm();
  932.     static void UninitializeImm();
  933.  
  934.     static HINSTANCE s_hDllImm32;  // IMM32 DLL handle
  935.     static HINSTANCE s_hDllVer;    // Version DLL handle
  936.     static HIMC      s_hImcDef;    // Default input context
  937.  
  938. protected:
  939.     // Empty implementation of the IMM32 API
  940.     static INPUTCONTEXT* WINAPI Dummy_ImmLockIMC( HIMC ) { return NULL; }
  941.     static BOOL WINAPI Dummy_ImmUnlockIMC( HIMC ) { return FALSE; }
  942.     static LPVOID WINAPI Dummy_ImmLockIMCC( HIMCC ) { return NULL; }
  943.     static BOOL WINAPI Dummy_ImmUnlockIMCC( HIMCC ) { return FALSE; }
  944.     static BOOL WINAPI Dummy_ImmDisableTextFrameService( DWORD ) { return TRUE; }
  945.     static LONG WINAPI Dummy_ImmGetCompositionStringW( HIMC, DWORD, LPVOID, DWORD ) { return IMM_ERROR_GENERAL; }
  946.     static DWORD WINAPI Dummy_ImmGetCandidateListW( HIMC, DWORD, LPCANDIDATELIST, DWORD ) { return 0; }
  947.     static HIMC WINAPI Dummy_ImmGetContext( HWND ) { return NULL; }
  948.     static BOOL WINAPI Dummy_ImmReleaseContext( HWND, HIMC ) { return FALSE; }
  949.     static HIMC WINAPI Dummy_ImmAssociateContext( HWND, HIMC ) { return NULL; }
  950.     static BOOL WINAPI Dummy_ImmGetOpenStatus( HIMC ) { return 0; }
  951.     static BOOL WINAPI Dummy_ImmSetOpenStatus( HIMC, BOOL ) { return 0; }
  952.     static BOOL WINAPI Dummy_ImmGetConversionStatus( HIMC, LPDWORD, LPDWORD ) { return 0; }
  953.     static HWND WINAPI Dummy_ImmGetDefaultIMEWnd( HWND ) { return NULL; }
  954.     static UINT WINAPI Dummy_ImmGetIMEFileNameA( HKL, LPSTR, UINT ) { return 0; }
  955.     static UINT WINAPI Dummy_ImmGetVirtualKey( HWND ) { return 0; }
  956.     static BOOL WINAPI Dummy_ImmNotifyIME( HIMC, DWORD, DWORD, DWORD ) { return FALSE; }
  957.     static BOOL WINAPI Dummy_ImmSetConversionStatus( HIMC, DWORD, DWORD ) { return FALSE; }
  958.     static BOOL WINAPI Dummy_ImmSimulateHotKey( HWND, DWORD ) { return FALSE; }
  959.     static BOOL WINAPI Dummy_ImmIsIME( HKL ) { return FALSE; }
  960.  
  961.     // Traditional Chinese IME
  962.     static UINT WINAPI Dummy_GetReadingString( HIMC, UINT, LPWSTR, PINT, BOOL*, PUINT ) { return 0; }
  963.     static BOOL WINAPI Dummy_ShowReadingWindow( HIMC, BOOL ) { return FALSE; }
  964.  
  965.     // Verion library imports
  966.     static BOOL APIENTRY Dummy_VerQueryValueA( const LPVOID, LPSTR, LPVOID *, PUINT ) { return 0; }
  967.     static BOOL APIENTRY Dummy_GetFileVersionInfoA( LPSTR, DWORD, DWORD, LPVOID ) { return 0; }
  968.     static DWORD APIENTRY Dummy_GetFileVersionInfoSizeA( LPSTR, LPDWORD ) { return 0; }
  969.  
  970.     // Function pointers: IMM32
  971.     static INPUTCONTEXT* (WINAPI * _ImmLockIMC)( HIMC );
  972.     static BOOL (WINAPI * _ImmUnlockIMC)( HIMC );
  973.     static LPVOID (WINAPI * _ImmLockIMCC)( HIMCC );
  974.     static BOOL (WINAPI * _ImmUnlockIMCC)( HIMCC );
  975.     static BOOL (WINAPI * _ImmDisableTextFrameService)( DWORD );
  976.     static LONG (WINAPI * _ImmGetCompositionStringW)( HIMC, DWORD, LPVOID, DWORD );
  977.     static DWORD (WINAPI * _ImmGetCandidateListW)( HIMC, DWORD, LPCANDIDATELIST, DWORD );
  978.     static HIMC (WINAPI * _ImmGetContext)( HWND );
  979.     static BOOL (WINAPI * _ImmReleaseContext)( HWND, HIMC );
  980.     static HIMC (WINAPI * _ImmAssociateContext)( HWND, HIMC );
  981.     static BOOL (WINAPI * _ImmGetOpenStatus)( HIMC );
  982.     static BOOL (WINAPI * _ImmSetOpenStatus)( HIMC, BOOL );
  983.     static BOOL (WINAPI * _ImmGetConversionStatus)( HIMC, LPDWORD, LPDWORD );
  984.     static HWND (WINAPI * _ImmGetDefaultIMEWnd)( HWND );
  985.     static UINT (WINAPI * _ImmGetIMEFileNameA)( HKL, LPSTR, UINT );
  986.     static UINT (WINAPI * _ImmGetVirtualKey)( HWND );
  987.     static BOOL (WINAPI * _ImmNotifyIME)( HIMC, DWORD, DWORD, DWORD );
  988.     static BOOL (WINAPI * _ImmSetConversionStatus)( HIMC, DWORD, DWORD );
  989.     static BOOL (WINAPI * _ImmSimulateHotKey)( HWND, DWORD );
  990.     static BOOL (WINAPI * _ImmIsIME)( HKL );
  991.  
  992.     // Function pointers: Traditional Chinese IME
  993.     static UINT (WINAPI * _GetReadingString)( HIMC, UINT, LPWSTR, PINT, BOOL*, PUINT );
  994.     static BOOL (WINAPI * _ShowReadingWindow)( HIMC, BOOL );
  995.  
  996.     // Function pointers: Verion library imports
  997.     static BOOL (APIENTRY * _VerQueryValueA)( const LPVOID, LPSTR, LPVOID *, PUINT );
  998.     static BOOL (APIENTRY * _GetFileVersionInfoA)( LPSTR, DWORD, DWORD, LPVOID );
  999.     static DWORD (APIENTRY * _GetFileVersionInfoSizeA)( LPSTR, LPDWORD );
  1000.  
  1001. public:
  1002.     CDXUTIMEEditBox( CDXUTDialog *pDialog = NULL );
  1003.     virtual ~CDXUTIMEEditBox();
  1004.  
  1005.     static  HRESULT StaticOnCreateDevice();
  1006.     static  bool StaticMsgProc( UINT uMsg, WPARAM wParam, LPARAM lParam );
  1007.  
  1008.     static  void EnableImeSystem( bool bEnable );
  1009.  
  1010.     virtual void Render( IDirect3DDevice9* pd3dDevice, float fElapsedTime );
  1011.     virtual bool MsgProc( UINT uMsg, WPARAM wParam, LPARAM lParam );
  1012.     virtual bool HandleMouse( UINT uMsg, POINT pt, WPARAM wParam, LPARAM lParam );
  1013.     virtual void UpdateRects();
  1014.     virtual void OnFocusIn();
  1015.     virtual void OnFocusOut();
  1016.  
  1017.     void PumpMessage();
  1018.  
  1019.     virtual void RenderCandidateReadingWindow( IDirect3DDevice9* pd3dDevice, float fElapsedTime, bool bReading );
  1020.     virtual void RenderComposition( IDirect3DDevice9* pd3dDevice, float fElapsedTime );
  1021.     virtual void RenderIndicator( IDirect3DDevice9* pd3dDevice, float fElapsedTime );
  1022.  
  1023. protected:
  1024.     static WORD GetLanguage() { return LOWORD( s_hklCurrent ); }
  1025.     static WORD GetPrimaryLanguage() { return PRIMARYLANGID( LOWORD( s_hklCurrent ) ); }
  1026.     static WORD GetSubLanguage() { return SUBLANGID( LOWORD( s_hklCurrent ) ); }
  1027.     static void SendKey( BYTE nVirtKey );
  1028.     static DWORD GetImeId( UINT uIndex = 0 );
  1029.     static void CheckInputLocale();
  1030.     static void CheckToggleState();
  1031.     static void SetupImeApi();
  1032.     static void ResetCompositionString();
  1033.     void TruncateCompString( bool bUseBackSpace = true, int iNewStrLen = 0 );
  1034.     void FinalizeString( bool bSend );
  1035.     static void GetReadingWindowOrientation( DWORD dwId );
  1036.     static void GetPrivateReadingString();
  1037.  
  1038.     void SendCompString();
  1039.  
  1040. protected:
  1041.     enum { INDICATOR_NON_IME, INDICATOR_CHS, INDICATOR_CHT, INDICATOR_KOREAN, INDICATOR_JAPANESE };
  1042.     enum IMESTATE { IMEUI_STATE_OFF, IMEUI_STATE_ON, IMEUI_STATE_ENGLISH };
  1043.  
  1044.     struct CCandList
  1045.     {
  1046.         WCHAR awszCandidate[MAX_CANDLIST][256];
  1047.         CUniBuffer HoriCand; // Candidate list string (for horizontal candidate window)
  1048.         int   nFirstSelected; // First character position of the selected string in HoriCand
  1049.         int   nHoriSelectedLen; // Length of the selected string in HoriCand
  1050.         DWORD dwCount;       // Number of valid entries in the candidate list
  1051.         DWORD dwSelection;   // Currently selected candidate entry relative to page top
  1052.         DWORD dwPageSize;
  1053.         int   nReadingError; // Index of the error character
  1054.         bool  bShowWindow;   // Whether the candidate list window is visible
  1055.         RECT  rcCandidate;   // Candidate rectangle computed and filled each time before rendered
  1056.     };
  1057.  
  1058.     struct CInputLocale
  1059.     {
  1060.         HKL   m_hKL;            // Keyboard layout
  1061.         WCHAR m_wszLangAbb[3];  // Language abbreviation
  1062.         WCHAR m_wszLang[64];    // Localized language name
  1063.     };
  1064.  
  1065.     // Application-wide data
  1066.     static HKL     s_hklCurrent;          // Current keyboard layout of the process
  1067.     static bool    s_bVerticalCand;       // Indicates that the candidates are listed vertically
  1068.     static LPWSTR  s_wszCurrIndicator;    // Points to an indicator string that corresponds to current input locale
  1069.     static WCHAR   s_aszIndicator[5][3];  // String to draw to indicate current input locale
  1070.     static bool    s_bInsertOnType;       // Insert the character as soon as a key is pressed (Korean behavior)
  1071.     static HINSTANCE s_hDllIme;           // Instance handle of the current IME module
  1072.     static IMESTATE  s_ImeState;          // IME global state
  1073.     static bool    s_bEnableImeSystem;    // Whether the IME system is active
  1074.     static POINT   s_ptCompString;        // Composition string position. Updated every frame.
  1075.     static int     s_nCompCaret;          // Caret position of the composition string
  1076.     static int     s_nFirstTargetConv;    // Index of the first target converted char in comp string.  If none, -1.
  1077.     static CUniBuffer s_CompString;       // Buffer to hold the composition string (we fix its length)
  1078.     static BYTE    s_abCompStringAttr[MAX_COMPSTRING_SIZE];
  1079.     static DWORD   s_adwCompStringClause[MAX_COMPSTRING_SIZE];
  1080.     static WCHAR   s_wszReadingString[32];// Used only with horizontal reading window (why?)
  1081.     static CCandList s_CandList;          // Data relevant to the candidate list
  1082.     static bool    s_bShowReadingWindow;  // Indicates whether reading window is visible
  1083.     static bool    s_bHorizontalReading;  // Indicates whether the reading window is vertical or horizontal
  1084.     static bool    s_bChineseIME;
  1085.     static CGrowableArray< CInputLocale > s_Locale; // Array of loaded keyboard layout on system
  1086.  
  1087.     // Color of various IME elements
  1088.     D3DCOLOR       m_ReadingColor;        // Reading string color
  1089.     D3DCOLOR       m_ReadingWinColor;     // Reading window color
  1090.     D3DCOLOR       m_ReadingSelColor;     // Selected character in reading string
  1091.     D3DCOLOR       m_ReadingSelBkColor;   // Background color for selected char in reading str
  1092.     D3DCOLOR       m_CandidateColor;      // Candidate string color
  1093.     D3DCOLOR       m_CandidateWinColor;   // Candidate window color
  1094.     D3DCOLOR       m_CandidateSelColor;   // Selected candidate string color
  1095.     D3DCOLOR       m_CandidateSelBkColor; // Selected candidate background color
  1096.     D3DCOLOR       m_CompColor;           // Composition string color
  1097.     D3DCOLOR       m_CompWinColor;        // Composition string window color
  1098.     D3DCOLOR       m_CompCaretColor;      // Composition string caret color
  1099.     D3DCOLOR       m_CompTargetColor;     // Composition string target converted color
  1100.     D3DCOLOR       m_CompTargetBkColor;   // Composition string target converted background
  1101.     D3DCOLOR       m_CompTargetNonColor;  // Composition string target non-converted color
  1102.     D3DCOLOR       m_CompTargetNonBkColor;// Composition string target non-converted background
  1103.     D3DCOLOR       m_IndicatorImeColor;   // Indicator text color for IME
  1104.     D3DCOLOR       m_IndicatorEngColor;   // Indicator text color for English
  1105.     D3DCOLOR       m_IndicatorBkColor;    // Indicator text background color
  1106.  
  1107.     // Edit-control-specific data
  1108.     int            m_nIndicatorWidth;     // Width of the indicator symbol
  1109.     RECT           m_rcIndicator;         // Rectangle for drawing the indicator button
  1110. };
  1111.  
  1112.  
  1113.  
  1114. #endif // DXUT_GUI_H