mirror of
https://github.com/dashr9230/SA-MP.git
synced 2025-01-04 00:23:22 +08:00
1112 lines
46 KiB
C++
1112 lines
46 KiB
C++
//--------------------------------------------------------------------------------------
|
|
// File: DXUTgui.h
|
|
//
|
|
// Desc:
|
|
//
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//--------------------------------------------------------------------------------------
|
|
#pragma once
|
|
#ifndef DXUT_GUI_H
|
|
#define DXUT_GUI_H
|
|
|
|
#include <usp10.h>
|
|
#include <dimm.h>
|
|
|
|
|
|
//--------------------------------------------------------------------------------------
|
|
// Defines and macros
|
|
//--------------------------------------------------------------------------------------
|
|
#define EVENT_BUTTON_CLICKED 0x0101
|
|
#define EVENT_COMBOBOX_SELECTION_CHANGED 0x0201
|
|
#define EVENT_RADIOBUTTON_CHANGED 0x0301
|
|
#define EVENT_CHECKBOX_CHANGED 0x0401
|
|
#define EVENT_SLIDER_VALUE_CHANGED 0x0501
|
|
#define EVENT_EDITBOX_STRING 0x0601
|
|
// EVENT_EDITBOX_CHANGE is sent when the listbox content changes
|
|
// due to user input.
|
|
#define EVENT_EDITBOX_CHANGE 0x0602
|
|
#define EVENT_LISTBOX_ITEM_DBLCLK 0x0701
|
|
// EVENT_LISTBOX_SELECTION is fired off when the selection changes in
|
|
// a single selection list box.
|
|
#define EVENT_LISTBOX_SELECTION 0x0702
|
|
|
|
|
|
//--------------------------------------------------------------------------------------
|
|
// Forward declarations
|
|
//--------------------------------------------------------------------------------------
|
|
class CDXUTDialogResourceManager;
|
|
class CDXUTControl;
|
|
class CDXUTButton;
|
|
class CDXUTStatic;
|
|
class CDXUTCheckBox;
|
|
class CDXUTRadioButton;
|
|
class CDXUTComboBox;
|
|
class CDXUTSlider;
|
|
class CDXUTEditBox;
|
|
class CDXUTIMEEditBox;
|
|
class CDXUTListBox;
|
|
class CDXUTScrollBar;
|
|
class CDXUTElement;
|
|
struct DXUTElementHolder;
|
|
struct DXUTTextureNode;
|
|
struct DXUTFontNode;
|
|
typedef VOID (CALLBACK *PCALLBACKDXUTGUIEVENT) ( UINT nEvent, int nControlID, CDXUTControl* pControl, void* pUserContext );
|
|
|
|
|
|
//--------------------------------------------------------------------------------------
|
|
// Enums for pre-defined control types
|
|
//--------------------------------------------------------------------------------------
|
|
enum DXUT_CONTROL_TYPE
|
|
{
|
|
DXUT_CONTROL_BUTTON,
|
|
DXUT_CONTROL_STATIC,
|
|
DXUT_CONTROL_CHECKBOX,
|
|
DXUT_CONTROL_RADIOBUTTON,
|
|
DXUT_CONTROL_COMBOBOX,
|
|
DXUT_CONTROL_SLIDER,
|
|
DXUT_CONTROL_EDITBOX,
|
|
DXUT_CONTROL_IMEEDITBOX,
|
|
DXUT_CONTROL_LISTBOX,
|
|
DXUT_CONTROL_SCROLLBAR,
|
|
};
|
|
|
|
enum DXUT_CONTROL_STATE
|
|
{
|
|
DXUT_STATE_NORMAL = 0,
|
|
DXUT_STATE_DISABLED,
|
|
DXUT_STATE_HIDDEN,
|
|
DXUT_STATE_FOCUS,
|
|
DXUT_STATE_MOUSEOVER,
|
|
DXUT_STATE_PRESSED,
|
|
};
|
|
|
|
#define MAX_CONTROL_STATES 6
|
|
|
|
struct DXUTBlendColor
|
|
{
|
|
void Init( D3DCOLOR defaultColor, D3DCOLOR disabledColor = D3DCOLOR_ARGB(200, 128, 128, 128), D3DCOLOR hiddenColor = 0 );
|
|
void Blend( UINT iState, float fElapsedTime, float fRate = 0.7f );
|
|
|
|
D3DCOLOR States[ MAX_CONTROL_STATES ]; // Modulate colors for all possible control states
|
|
D3DXCOLOR Current;
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Contains all the display tweakables for a sub-control
|
|
//-----------------------------------------------------------------------------
|
|
class CDXUTElement
|
|
{
|
|
public:
|
|
void SetTexture( UINT iTexture, RECT* prcTexture, D3DCOLOR defaultTextureColor = D3DCOLOR_ARGB(255, 255, 255, 255) );
|
|
void SetFont( UINT iFont, D3DCOLOR defaultFontColor = D3DCOLOR_ARGB(255, 255, 255, 255), DWORD dwTextFormat = DT_CENTER | DT_VCENTER );
|
|
|
|
void Refresh();
|
|
|
|
UINT iTexture; // Index of the texture for this Element
|
|
UINT iFont; // Index of the font for this Element
|
|
DWORD dwTextFormat; // The format argument to DrawText
|
|
|
|
RECT rcTexture; // Bounding rect of this element on the composite texture
|
|
|
|
DXUTBlendColor TextureColor;
|
|
DXUTBlendColor FontColor;
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// All controls must be assigned to a dialog, which handles
|
|
// input and rendering for the controls.
|
|
//-----------------------------------------------------------------------------
|
|
class CDXUTDialog
|
|
{
|
|
public:
|
|
CDXUTDialog();
|
|
~CDXUTDialog();
|
|
|
|
// Need to call this now
|
|
void Init( CDXUTDialogResourceManager* pManager );
|
|
|
|
// Windows message handler
|
|
bool MsgProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam );
|
|
|
|
// Control creation
|
|
HRESULT AddStatic( int ID, LPCTSTR strText, int x, int y, int width, int height, bool bIsDefault=false, CDXUTStatic** ppCreated=NULL );
|
|
HRESULT AddButton( int ID, LPCTSTR strText, int x, int y, int width, int height, UINT nHotkey=0, bool bIsDefault=false, CDXUTButton** ppCreated=NULL );
|
|
HRESULT AddCheckBox( int ID, LPCTSTR strText, int x, int y, int width, int height, bool bChecked=false, UINT nHotkey=0, bool bIsDefault=false, CDXUTCheckBox** ppCreated=NULL );
|
|
HRESULT AddRadioButton( int ID, UINT nButtonGroup, LPCTSTR strText, int x, int y, int width, int height, bool bChecked=false, UINT nHotkey=0, bool bIsDefault=false, CDXUTRadioButton** ppCreated=NULL );
|
|
HRESULT AddComboBox( int ID, int x, int y, int width, int height, UINT nHotKey=0, bool bIsDefault=false, CDXUTComboBox** ppCreated=NULL );
|
|
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 );
|
|
HRESULT AddEditBox( int ID, LPCTSTR strText, int x, int y, int width, int height, bool bIsDefault=false, CDXUTEditBox** ppCreated=NULL );
|
|
HRESULT AddIMEEditBox( int ID, LPCTSTR strText, int x, int y, int width, int height, bool bIsDefault=false, CDXUTIMEEditBox** ppCreated=NULL );
|
|
HRESULT AddListBox( int ID, int x, int y, int width, int height, DWORD dwStyle=0, CDXUTListBox** ppCreated=NULL );
|
|
HRESULT AddControl( CDXUTControl* pControl );
|
|
HRESULT InitControl( CDXUTControl* pControl );
|
|
|
|
// Control retrieval
|
|
CDXUTStatic* GetStatic( int ID ) { return (CDXUTStatic*) GetControl( ID, DXUT_CONTROL_STATIC ); }
|
|
CDXUTButton* GetButton( int ID ) { return (CDXUTButton*) GetControl( ID, DXUT_CONTROL_BUTTON ); }
|
|
CDXUTCheckBox* GetCheckBox( int ID ) { return (CDXUTCheckBox*) GetControl( ID, DXUT_CONTROL_CHECKBOX ); }
|
|
CDXUTRadioButton* GetRadioButton( int ID ) { return (CDXUTRadioButton*) GetControl( ID, DXUT_CONTROL_RADIOBUTTON ); }
|
|
CDXUTComboBox* GetComboBox( int ID ) { return (CDXUTComboBox*) GetControl( ID, DXUT_CONTROL_COMBOBOX ); }
|
|
CDXUTSlider* GetSlider( int ID ) { return (CDXUTSlider*) GetControl( ID, DXUT_CONTROL_SLIDER ); }
|
|
CDXUTEditBox* GetEditBox( int ID ) { return (CDXUTEditBox*) GetControl( ID, DXUT_CONTROL_EDITBOX ); }
|
|
CDXUTIMEEditBox* GetIMEEditBox( int ID ) { return (CDXUTIMEEditBox*) GetControl( ID, DXUT_CONTROL_IMEEDITBOX ); }
|
|
CDXUTListBox* GetListBox( int ID ) { return (CDXUTListBox*) GetControl( ID, DXUT_CONTROL_LISTBOX ); }
|
|
|
|
CDXUTControl* GetControl( int ID );
|
|
CDXUTControl* GetControl( int ID, UINT nControlType );
|
|
CDXUTControl* GetControlAtPoint( POINT pt );
|
|
|
|
bool GetControlEnabled( int ID );
|
|
void SetControlEnabled( int ID, bool bEnabled );
|
|
|
|
void ClearRadioButtonGroup( UINT nGroup );
|
|
void ClearComboBox( int ID );
|
|
|
|
// Access the default display Elements used when adding new controls
|
|
HRESULT SetDefaultElement( UINT nControlType, UINT iElement, CDXUTElement* pElement );
|
|
CDXUTElement* GetDefaultElement( UINT nControlType, UINT iElement );
|
|
|
|
// Methods called by controls
|
|
void SendEvent( UINT nEvent, bool bTriggeredByUser, CDXUTControl* pControl );
|
|
void RequestFocus( CDXUTControl* pControl );
|
|
|
|
// Render helpers
|
|
HRESULT DrawRect( RECT* pRect, D3DCOLOR color );
|
|
HRESULT DrawPolyLine( POINT* apPoints, UINT nNumPoints, D3DCOLOR color );
|
|
HRESULT DrawSprite( CDXUTElement* pElement, RECT* prcDest );
|
|
HRESULT CalcTextRect( LPCTSTR strText, CDXUTElement* pElement, RECT* prcDest, int nCount = -1 );
|
|
HRESULT CalcTextRect( LPCWSTR strText, CDXUTElement* pElement, RECT* prcDest, int nCount = -1 );
|
|
HRESULT DrawText( LPCTSTR strText, CDXUTElement* pElement, RECT* prcDest, bool bShadow = false, int nCount = -1 );
|
|
HRESULT DrawText( LPCWSTR strText, CDXUTElement* pElement, RECT* prcDest, bool bShadow = false, int nCount = -1 );
|
|
|
|
// Attributes
|
|
bool GetVisible() { return m_bVisible; }
|
|
void SetVisible( bool bVisible ) { m_bVisible = bVisible; }
|
|
bool GetMinimized() { return m_bMinimized; }
|
|
void SetMinimized( bool bMinimized ) { m_bMinimized = bMinimized; }
|
|
void SetBackgroundColors( D3DCOLOR colorAllCorners ) { SetBackgroundColors( colorAllCorners, colorAllCorners, colorAllCorners, colorAllCorners ); }
|
|
void SetBackgroundColors( D3DCOLOR colorTopLeft, D3DCOLOR colorTopRight, D3DCOLOR colorBottomLeft, D3DCOLOR colorBottomRight );
|
|
void EnableCaption( bool bEnable ) { m_bCaption = bEnable; }
|
|
int GetCaptionHeight() const { return m_nCaptionHeight; }
|
|
void SetCaptionHeight( int nHeight ) { m_nCaptionHeight = nHeight; }
|
|
void SetCaptionText( const TCHAR *pwszText ) { strcpy(m_wszCaption,pwszText); }
|
|
void GetLocation( POINT &Pt ) const { Pt.x = m_x; Pt.y = m_y; }
|
|
void SetLocation( int x, int y ) { m_x = x; m_y = y; }
|
|
void SetSize( int width, int height ) { m_width = width; m_height = height; }
|
|
int GetWidth() { return m_width; }
|
|
int GetHeight() { return m_height; }
|
|
|
|
void SetNextDialog( CDXUTDialog* pNextDialog );
|
|
|
|
static void SetRefreshTime( float fTime ){ s_fTimeRefresh = fTime; }
|
|
|
|
static CDXUTControl* GetNextControl( CDXUTControl* pControl );
|
|
static CDXUTControl* GetPrevControl( CDXUTControl* pControl );
|
|
|
|
void RemoveControl( int ID );
|
|
void RemoveAllControls();
|
|
|
|
// Sets the callback used to notify the app of control events
|
|
void SetCallback( PCALLBACKDXUTGUIEVENT pCallback, void* pUserContext = NULL );
|
|
void EnableNonUserEvents( bool bEnable ) { m_bNonUserEvents = bEnable; }
|
|
void EnableKeyboardInput( bool bEnable ) { m_bKeyboardInput = bEnable; }
|
|
void EnableMouseInput( bool bEnable ) { m_bMouseInput = bEnable; }
|
|
|
|
// Device state notification
|
|
void Refresh();
|
|
HRESULT OnRender( float fElapsedTime );
|
|
|
|
// Shared resource access. Indexed fonts and textures are shared among
|
|
// all the controls.
|
|
HRESULT SetFont( UINT index, LPCTSTR strFaceName, LONG height, LONG weight );
|
|
DXUTFontNode* GetFont( UINT index );
|
|
|
|
HRESULT SetTexture( UINT index, LPCTSTR strFilename );
|
|
DXUTTextureNode* GetTexture( UINT index );
|
|
|
|
CDXUTDialogResourceManager* GetManager() { return m_pManager; }
|
|
|
|
static void ClearFocus();
|
|
void FocusDefaultControl();
|
|
|
|
void UpdateFont();
|
|
|
|
bool m_bNonUserEvents;
|
|
bool m_bKeyboardInput;
|
|
bool m_bMouseInput;
|
|
|
|
private:
|
|
int m_nDefaultControlID;
|
|
|
|
static double s_fTimeRefresh;
|
|
double m_fTimeLastRefresh;
|
|
|
|
// Initialize default Elements
|
|
void InitDefaultElements();
|
|
|
|
// Windows message handlers
|
|
void OnMouseMove( POINT pt );
|
|
void OnMouseUp( POINT pt );
|
|
|
|
// Control events
|
|
bool OnCycleFocus( bool bForward );
|
|
|
|
static CDXUTControl* s_pControlFocus; // The control which has focus
|
|
static CDXUTControl* s_pControlPressed; // The control currently pressed
|
|
|
|
CDXUTControl* m_pControlMouseOver; // The control which is hovered over
|
|
|
|
bool m_bVisible;
|
|
bool m_bCaption;
|
|
bool m_bMinimized;
|
|
TCHAR m_wszCaption[256];
|
|
|
|
int m_x;
|
|
int m_y;
|
|
int m_width;
|
|
int m_height;
|
|
int m_nCaptionHeight;
|
|
|
|
D3DCOLOR m_colorTopLeft;
|
|
D3DCOLOR m_colorTopRight;
|
|
D3DCOLOR m_colorBottomLeft;
|
|
D3DCOLOR m_colorBottomRight;
|
|
|
|
CDXUTDialogResourceManager* m_pManager;
|
|
PCALLBACKDXUTGUIEVENT m_pCallbackEvent;
|
|
void* m_pCallbackEventUserContext;
|
|
|
|
CGrowableArray< int > m_Textures; // Index into m_TextureCache;
|
|
CGrowableArray< int > m_Fonts; // Index into m_FontCache;
|
|
|
|
CGrowableArray< CDXUTControl* > m_Controls;
|
|
CGrowableArray< DXUTElementHolder* > m_DefaultElements;
|
|
|
|
CDXUTElement m_CapElement; // Element for the caption
|
|
|
|
CDXUTDialog* m_pNextDialog;
|
|
CDXUTDialog* m_pPrevDialog;
|
|
};
|
|
|
|
|
|
//--------------------------------------------------------------------------------------
|
|
// Structs for shared resources
|
|
//--------------------------------------------------------------------------------------
|
|
struct DXUTTextureNode
|
|
{
|
|
TCHAR strFilename[MAX_PATH];
|
|
IDirect3DTexture9* pTexture;
|
|
DWORD dwWidth;
|
|
DWORD dwHeight;
|
|
};
|
|
|
|
struct DXUTFontNode
|
|
{
|
|
TCHAR strFace[MAX_PATH];
|
|
ID3DXFont* pFont;
|
|
LONG nHeight;
|
|
LONG nWeight;
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Manages shared resources of dialogs
|
|
//-----------------------------------------------------------------------------
|
|
class CDXUTDialogResourceManager
|
|
{
|
|
public:
|
|
CDXUTDialogResourceManager();
|
|
~CDXUTDialogResourceManager();
|
|
|
|
HRESULT OnCreateDevice( LPDIRECT3DDEVICE9 pd3dDevice );
|
|
HRESULT OnResetDevice();
|
|
void OnLostDevice();
|
|
void OnDestroyDevice();
|
|
bool MsgProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam );
|
|
|
|
int AddFont( LPCTSTR strFaceName, LONG height, LONG weight );
|
|
int AddTexture( LPCTSTR strFilename );
|
|
|
|
DXUTFontNode* GetFontNode( int iIndex ) { return m_FontCache.GetAt( iIndex ); };
|
|
DXUTTextureNode* GetTextureNode( int iIndex ) { return m_TextureCache.GetAt( iIndex ); };
|
|
IDirect3DDevice9* GetD3DDevice() { return m_pd3dDevice; }
|
|
|
|
// Shared between all dialogs
|
|
IDirect3DStateBlock9* m_pStateBlock;
|
|
ID3DXSprite* m_pSprite; // Sprite used for drawing
|
|
|
|
protected:
|
|
CGrowableArray< DXUTTextureNode* > m_TextureCache; // Shared textures
|
|
CGrowableArray< DXUTFontNode* > m_FontCache; // Shared fonts
|
|
|
|
IDirect3DDevice9* m_pd3dDevice;
|
|
|
|
public:
|
|
|
|
// Resource creation helpers
|
|
HRESULT CreateFont( UINT index );
|
|
HRESULT CreateTexture( UINT index );
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Base class for controls
|
|
//-----------------------------------------------------------------------------
|
|
class CDXUTControl
|
|
{
|
|
public:
|
|
CDXUTControl( CDXUTDialog *pDialog = NULL );
|
|
virtual ~CDXUTControl();
|
|
|
|
virtual HRESULT OnInit() { return S_OK; }
|
|
virtual void Refresh();
|
|
virtual void Render( IDirect3DDevice9* pd3dDevice, float fElapsedTime ) { };
|
|
|
|
// Windows message handler
|
|
virtual bool MsgProc( UINT uMsg, WPARAM wParam, LPARAM lParam ) { return false; }
|
|
|
|
virtual bool HandleKeyboard( UINT uMsg, WPARAM wParam, LPARAM lParam ) { return false; }
|
|
virtual bool HandleMouse( UINT uMsg, POINT pt, WPARAM wParam, LPARAM lParam ) { return false; }
|
|
|
|
virtual bool CanHaveFocus() { return false; }
|
|
virtual void OnFocusIn() { m_bHasFocus = true; }
|
|
virtual void OnFocusOut() { m_bHasFocus = false; }
|
|
virtual void OnMouseEnter() { m_bMouseOver = true; }
|
|
virtual void OnMouseLeave() { m_bMouseOver = false; }
|
|
virtual void OnHotkey() {}
|
|
|
|
virtual BOOL ContainsPoint( POINT pt ) { return PtInRect( &m_rcBoundingBox, pt ); }
|
|
|
|
virtual void SetEnabled( bool bEnabled ) { m_bEnabled = bEnabled; }
|
|
virtual bool GetEnabled() { return m_bEnabled; }
|
|
virtual void SetVisible( bool bVisible ) { m_bVisible = bVisible; }
|
|
virtual bool GetVisible() { return m_bVisible; }
|
|
|
|
UINT GetType() const { return m_Type; }
|
|
|
|
int GetID() const { return m_ID; }
|
|
void SetID( int ID ) { m_ID = ID; }
|
|
|
|
void SetLocation( int x, int y ) { m_x = x; m_y = y; UpdateRects(); }
|
|
void SetSize( int width, int height ) { m_width = width; m_height = height; UpdateRects(); }
|
|
|
|
void SetHotkey( UINT nHotkey ) { m_nHotkey = nHotkey; }
|
|
UINT GetHotkey() { return m_nHotkey; }
|
|
|
|
void SetUserData( void *pUserData ) { m_pUserData = pUserData; }
|
|
void *GetUserData() const { return m_pUserData; }
|
|
|
|
virtual void SetTextColor( D3DCOLOR Color );
|
|
CDXUTElement* GetElement( UINT iElement ) { return m_Elements.GetAt( iElement ); }
|
|
HRESULT SetElement( UINT iElement, CDXUTElement* pElement);
|
|
|
|
bool m_bVisible; // Shown/hidden flag
|
|
bool m_bMouseOver; // Mouse pointer is above control
|
|
bool m_bHasFocus; // Control has input focus
|
|
bool m_bIsDefault; // Is the default control
|
|
|
|
// Size, scale, and positioning members
|
|
int m_x, m_y;
|
|
int m_width, m_height;
|
|
|
|
// These members are set by the container
|
|
CDXUTDialog* m_pDialog; // Parent container
|
|
UINT m_Index; // Index within the control list
|
|
|
|
CGrowableArray< CDXUTElement* > m_Elements; // All display elements
|
|
|
|
protected:
|
|
virtual void UpdateRects();
|
|
|
|
int m_ID; // ID number
|
|
DXUT_CONTROL_TYPE m_Type; // Control type, set once in constructor
|
|
UINT m_nHotkey; // Virtual key code for this control's hotkey
|
|
void *m_pUserData; // Data associated with this control that is set by user.
|
|
|
|
bool m_bEnabled; // Enabled/disabled flag
|
|
|
|
RECT m_rcBoundingBox; // Rectangle defining the active region of the control
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Contains all the display information for a given control type
|
|
//-----------------------------------------------------------------------------
|
|
struct DXUTElementHolder
|
|
{
|
|
UINT nControlType;
|
|
UINT iElement;
|
|
|
|
CDXUTElement Element;
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Static control
|
|
//-----------------------------------------------------------------------------
|
|
class CDXUTStatic : public CDXUTControl
|
|
{
|
|
public:
|
|
CDXUTStatic( CDXUTDialog *pDialog = NULL );
|
|
|
|
virtual void Render( IDirect3DDevice9* pd3dDevice, float fElapsedTime );
|
|
virtual BOOL ContainsPoint( POINT pt ) { return false; }
|
|
|
|
HRESULT GetTextCopy( PCHAR strDest, UINT bufferCount );
|
|
LPCTSTR GetText() { return m_strText; }
|
|
HRESULT SetText( LPCTSTR strText );
|
|
|
|
|
|
protected:
|
|
TCHAR m_strText[MAX_PATH]; // Window text
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Button control
|
|
//-----------------------------------------------------------------------------
|
|
class CDXUTButton : public CDXUTStatic
|
|
{
|
|
public:
|
|
CDXUTButton( CDXUTDialog *pDialog = NULL );
|
|
|
|
virtual bool HandleKeyboard( UINT uMsg, WPARAM wParam, LPARAM lParam );
|
|
virtual bool HandleMouse( UINT uMsg, POINT pt, WPARAM wParam, LPARAM lParam );
|
|
virtual void OnHotkey() { m_pDialog->RequestFocus( this ); m_pDialog->SendEvent( EVENT_BUTTON_CLICKED, true, this ); }
|
|
|
|
virtual BOOL ContainsPoint( POINT pt ) { return PtInRect( &m_rcBoundingBox, pt ); }
|
|
virtual bool CanHaveFocus() { return (m_bVisible && m_bEnabled); }
|
|
|
|
virtual void Render( IDirect3DDevice9* pd3dDevice, float fElapsedTime );
|
|
|
|
protected:
|
|
bool m_bPressed;
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// CheckBox control
|
|
//-----------------------------------------------------------------------------
|
|
class CDXUTCheckBox : public CDXUTButton
|
|
{
|
|
public:
|
|
CDXUTCheckBox( CDXUTDialog *pDialog = NULL );
|
|
|
|
virtual bool HandleKeyboard( UINT uMsg, WPARAM wParam, LPARAM lParam );
|
|
virtual bool HandleMouse( UINT uMsg, POINT pt, WPARAM wParam, LPARAM lParam );
|
|
virtual void OnHotkey() { m_pDialog->RequestFocus( this ); SetCheckedInternal( !m_bChecked, true ); }
|
|
|
|
virtual BOOL ContainsPoint( POINT pt );
|
|
virtual void UpdateRects();
|
|
|
|
virtual void Render( IDirect3DDevice9* pd3dDevice, float fElapsedTime );
|
|
|
|
bool GetChecked() { return m_bChecked; }
|
|
void SetChecked( bool bChecked ) { SetCheckedInternal( bChecked, false ); }
|
|
|
|
protected:
|
|
virtual void SetCheckedInternal( bool bChecked, bool bFromInput );
|
|
|
|
bool m_bChecked;
|
|
RECT m_rcButton;
|
|
RECT m_rcText;
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// RadioButton control
|
|
//-----------------------------------------------------------------------------
|
|
class CDXUTRadioButton : public CDXUTCheckBox
|
|
{
|
|
public:
|
|
CDXUTRadioButton( CDXUTDialog *pDialog = NULL );
|
|
|
|
virtual bool HandleKeyboard( UINT uMsg, WPARAM wParam, LPARAM lParam );
|
|
virtual bool HandleMouse( UINT uMsg, POINT pt, WPARAM wParam, LPARAM lParam );
|
|
virtual void OnHotkey() { m_pDialog->RequestFocus( this ); SetCheckedInternal( true, true, true ); }
|
|
|
|
void SetChecked( bool bChecked, bool bClearGroup=true ) { SetCheckedInternal( bChecked, bClearGroup, false ); }
|
|
void SetButtonGroup( UINT nButtonGroup ) { m_nButtonGroup = nButtonGroup; }
|
|
UINT GetButtonGroup() { return m_nButtonGroup; }
|
|
|
|
protected:
|
|
virtual void SetCheckedInternal( bool bChecked, bool bClearGroup, bool bFromInput );
|
|
UINT m_nButtonGroup;
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Scrollbar control
|
|
//-----------------------------------------------------------------------------
|
|
class CDXUTScrollBar : public CDXUTControl
|
|
{
|
|
public:
|
|
CDXUTScrollBar( CDXUTDialog *pDialog = NULL );
|
|
virtual ~CDXUTScrollBar();
|
|
|
|
virtual bool HandleKeyboard( UINT uMsg, WPARAM wParam, LPARAM lParam );
|
|
virtual bool HandleMouse( UINT uMsg, POINT pt, WPARAM wParam, LPARAM lParam );
|
|
|
|
virtual void Render( IDirect3DDevice9* pd3dDevice, float fElapsedTime );
|
|
virtual void UpdateRects();
|
|
|
|
void SetTrackRange( int nStart, int nEnd );
|
|
int GetTrackPos() { return m_nPosition; }
|
|
void SetTrackPos( int nPosition ) { m_nPosition = nPosition; Cap(); UpdateThumbRect(); }
|
|
int GetPageSize() { return m_nPageSize; }
|
|
void SetPageSize( int nPageSize ) { m_nPageSize = nPageSize; Cap(); UpdateThumbRect(); }
|
|
|
|
void Scroll( int nDelta ); // Scroll by nDelta items (plus or minus)
|
|
void ShowItem( int nIndex ); // Ensure that item nIndex is displayed, scroll if necessary
|
|
|
|
protected:
|
|
// ARROWSTATE indicates the state of the arrow buttons.
|
|
// CLEAR No arrow is down.
|
|
// CLICKED_UP Up arrow is clicked.
|
|
// CLICKED_DOWN Down arrow is clicked.
|
|
// HELD_UP Up arrow is held down for sustained period.
|
|
// HELD_DOWN Down arrow is held down for sustained period.
|
|
enum ARROWSTATE { CLEAR, CLICKED_UP, CLICKED_DOWN, HELD_UP, HELD_DOWN };
|
|
|
|
void UpdateThumbRect();
|
|
void Cap(); // Clips position at boundaries. Ensures it stays within legal range.
|
|
|
|
bool m_bShowThumb;
|
|
RECT m_rcUpButton;
|
|
RECT m_rcDownButton;
|
|
RECT m_rcTrack;
|
|
RECT m_rcThumb;
|
|
int m_nPosition; // Position of the first displayed item
|
|
int m_nPageSize; // How many items are displayable in one page
|
|
int m_nStart; // First item
|
|
int m_nEnd; // The index after the last item
|
|
POINT m_LastMouse;// Last mouse position
|
|
ARROWSTATE m_Arrow; // State of the arrows
|
|
double m_dArrowTS; // Timestamp of last arrow event.
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// ListBox control
|
|
//-----------------------------------------------------------------------------
|
|
struct DXUTListBoxItem
|
|
{
|
|
TCHAR strText[256];
|
|
void* pData;
|
|
|
|
RECT rcActive;
|
|
bool bSelected;
|
|
};
|
|
|
|
class CDXUTListBox : public CDXUTControl
|
|
{
|
|
public:
|
|
CDXUTListBox( CDXUTDialog *pDialog = NULL );
|
|
virtual ~CDXUTListBox();
|
|
|
|
virtual HRESULT OnInit() { return m_pDialog->InitControl( &m_ScrollBar ); }
|
|
virtual bool CanHaveFocus() { return (m_bVisible && m_bEnabled); }
|
|
virtual bool HandleKeyboard( UINT uMsg, WPARAM wParam, LPARAM lParam );
|
|
virtual bool HandleMouse( UINT uMsg, POINT pt, WPARAM wParam, LPARAM lParam );
|
|
|
|
virtual void Render( IDirect3DDevice9* pd3dDevice, float fElapsedTime );
|
|
virtual void UpdateRects();
|
|
|
|
DWORD GetStyle() const { return m_dwStyle; }
|
|
int GetSize() const { return m_Items.GetSize(); }
|
|
void SetStyle( DWORD dwStyle ) { m_dwStyle = dwStyle; }
|
|
void SetScrollBarWidth( int nWidth ) { m_nSBWidth = nWidth; UpdateRects(); }
|
|
void SetBorder( int nBorder, int nMargin ) { m_nBorder = nBorder; m_nMargin = nMargin; }
|
|
HRESULT AddItem( const TCHAR *wszText, void *pData );
|
|
HRESULT InsertItem( int nIndex, const TCHAR *wszText, void *pData );
|
|
void RemoveItem( int nIndex );
|
|
void RemoveItemByText( TCHAR *wszText );
|
|
void RemoveItemByData( void *pData );
|
|
void RemoveAllItems();
|
|
|
|
DXUTListBoxItem *GetItem( int nIndex );
|
|
int GetSelectedIndex( int nPreviousSelected = -1 );
|
|
DXUTListBoxItem *GetSelectedItem( int nPreviousSelected = -1 ) { return GetItem( GetSelectedIndex( nPreviousSelected ) ); }
|
|
void SelectItem( int nNewIndex );
|
|
|
|
enum STYLE { MULTISELECTION = 1 };
|
|
|
|
int field_4D;
|
|
int field_51;
|
|
int field_55;
|
|
int field_59;
|
|
|
|
protected:
|
|
RECT m_rcText; // Text rendering bound
|
|
RECT m_rcSelection; // Selection box bound
|
|
CDXUTScrollBar m_ScrollBar;
|
|
int m_nSBWidth;
|
|
int m_nBorder;
|
|
int m_nMargin;
|
|
int m_nTextHeight; // Height of a single line of text
|
|
DWORD m_dwStyle; // List box style
|
|
int m_nSelected; // Index of the selected item for single selection list box
|
|
int m_nSelStart; // Index of the item where selection starts (for handling multi-selection)
|
|
bool m_bDrag; // Whether the user is dragging the mouse to select
|
|
|
|
CGrowableArray< DXUTListBoxItem* > m_Items;
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// ComboBox control
|
|
//-----------------------------------------------------------------------------
|
|
struct DXUTComboBoxItem
|
|
{
|
|
TCHAR strText[256];
|
|
void* pData;
|
|
|
|
RECT rcActive;
|
|
bool bVisible;
|
|
};
|
|
|
|
|
|
class CDXUTComboBox : public CDXUTButton
|
|
{
|
|
public:
|
|
CDXUTComboBox( CDXUTDialog *pDialog = NULL );
|
|
virtual ~CDXUTComboBox();
|
|
|
|
virtual void SetTextColor( D3DCOLOR Color );
|
|
virtual HRESULT OnInit() { return m_pDialog->InitControl( &m_ScrollBar ); }
|
|
|
|
virtual bool HandleKeyboard( UINT uMsg, WPARAM wParam, LPARAM lParam );
|
|
virtual bool HandleMouse( UINT uMsg, POINT pt, WPARAM wParam, LPARAM lParam );
|
|
virtual void OnHotkey();
|
|
|
|
virtual bool CanHaveFocus() { return (m_bVisible && m_bEnabled); }
|
|
virtual void OnFocusOut();
|
|
virtual void Render( IDirect3DDevice9* pd3dDevice, float fElapsedTime );
|
|
|
|
virtual void UpdateRects();
|
|
|
|
HRESULT AddItem( const TCHAR* strText, void* pData );
|
|
void RemoveAllItems();
|
|
void RemoveItem( UINT index );
|
|
bool ContainsItem( const TCHAR* strText, UINT iStart=0 );
|
|
int FindItem( const TCHAR* strText, UINT iStart=0 );
|
|
void* GetItemData( const TCHAR* strText );
|
|
void* GetItemData( int nIndex );
|
|
void SetDropHeight( UINT nHeight ) { m_nDropHeight = nHeight; UpdateRects(); }
|
|
void SetScrollBarWidth( int nWidth ) { m_nSBWidth = nWidth; UpdateRects(); }
|
|
|
|
void* GetSelectedData();
|
|
DXUTComboBoxItem* GetSelectedItem();
|
|
|
|
UINT GetNumItems() { return m_Items.GetSize(); }
|
|
DXUTComboBoxItem* GetItem( UINT index ) { return m_Items.GetAt( index ); }
|
|
|
|
HRESULT SetSelectedByIndex( UINT index );
|
|
HRESULT SetSelectedByText( const TCHAR* strText );
|
|
HRESULT SetSelectedByData( void* pData );
|
|
|
|
protected:
|
|
int m_iSelected;
|
|
int m_iFocused;
|
|
int m_nDropHeight;
|
|
CDXUTScrollBar m_ScrollBar;
|
|
int m_nSBWidth;
|
|
|
|
bool m_bOpened;
|
|
|
|
RECT m_rcText;
|
|
RECT m_rcButton;
|
|
RECT m_rcDropdown;
|
|
RECT m_rcDropdownText;
|
|
|
|
|
|
CGrowableArray< DXUTComboBoxItem* > m_Items;
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Slider control
|
|
//-----------------------------------------------------------------------------
|
|
class CDXUTSlider : public CDXUTControl
|
|
{
|
|
public:
|
|
CDXUTSlider( CDXUTDialog *pDialog = NULL );
|
|
|
|
virtual BOOL ContainsPoint( POINT pt );
|
|
virtual bool CanHaveFocus() { return (m_bVisible && m_bEnabled); }
|
|
virtual bool HandleKeyboard( UINT uMsg, WPARAM wParam, LPARAM lParam );
|
|
virtual bool HandleMouse( UINT uMsg, POINT pt, WPARAM wParam, LPARAM lParam );
|
|
|
|
virtual void UpdateRects();
|
|
|
|
virtual void Render( IDirect3DDevice9* pd3dDevice, float fElapsedTime );
|
|
|
|
void SetValue( int nValue ) { SetValueInternal( nValue, false ); }
|
|
int GetValue() const { return m_nValue; };
|
|
|
|
void GetRange( int &nMin, int &nMax ) const { nMin = m_nMin; nMax = m_nMax; }
|
|
void SetRange( int nMin, int nMax );
|
|
|
|
protected:
|
|
void SetValueInternal( int nValue, bool bFromInput );
|
|
int ValueFromPos( int x );
|
|
|
|
int m_nValue;
|
|
|
|
int m_nMin;
|
|
int m_nMax;
|
|
|
|
int m_nDragX; // Mouse position at start of drag
|
|
int m_nDragOffset; // Drag offset from the center of the button
|
|
int m_nButtonX;
|
|
|
|
bool m_bPressed;
|
|
RECT m_rcButton;
|
|
|
|
bool field_76;
|
|
D3DXCOLOR field_77;
|
|
|
|
public:
|
|
void SetColor(D3DXCOLOR c) { field_76 = true; field_77 = c; };
|
|
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// CUniBuffer class for the edit control
|
|
//-----------------------------------------------------------------------------
|
|
class CUniBuffer
|
|
{
|
|
public:
|
|
CUniBuffer( int nInitialSize = 1 );
|
|
~CUniBuffer();
|
|
|
|
static void Initialize();
|
|
static void Uninitialize();
|
|
|
|
int GetBufferSize() { return m_nBufferSize; }
|
|
bool SetBufferSize( int nSize );
|
|
int GetTextSize() { return lstrlenW( m_pwszBuffer ); }
|
|
const WCHAR* GetBuffer() { return m_pwszBuffer; }
|
|
const WCHAR& operator[]( int n ) const { return m_pwszBuffer[n]; }
|
|
WCHAR& operator[]( int n );
|
|
DXUTFontNode* GetFontNode() { return m_pFontNode; }
|
|
void SetFontNode( DXUTFontNode *pFontNode ) { m_pFontNode = pFontNode; }
|
|
void Clear();
|
|
|
|
bool InsertChar( int nIndex, WCHAR tchr ); // Inserts the char at specified index. If nIndex == -1, insert to the end.
|
|
bool InsertChar( int nIndex, CHAR tchr );
|
|
bool RemoveChar( int nIndex ); // Removes the char at specified index. If nIndex == -1, remove the last char.
|
|
bool InsertString( int nIndex, const WCHAR *pStr, int nCount = -1 ); // Inserts the first nCount characters of the string pStr at specified index. If nCount == -1, the entire string is inserted. If nIndex == -1, insert to the end.
|
|
bool SetText( LPCWSTR wszText );
|
|
bool SetText( LPCTSTR wszText );
|
|
|
|
// Uniscribe
|
|
HRESULT CPtoX( int nCP, BOOL bTrail, int *pX );
|
|
HRESULT XtoCP( int nX, int *pCP, int *pnTrail );
|
|
void GetPriorItemPos( int nCP, int *pPrior );
|
|
void GetNextItemPos( int nCP, int *pPrior );
|
|
|
|
private:
|
|
HRESULT Analyse(); // Uniscribe -- Analyse() analyses the string in the buffer
|
|
|
|
WCHAR* m_pwszBuffer; // Buffer to hold text
|
|
int m_nBufferSize; // Size of the buffer allocated, in characters
|
|
|
|
char field_8;
|
|
|
|
// Uniscribe-specific
|
|
DXUTFontNode* m_pFontNode; // Font node for the font that this buffer uses
|
|
bool m_bAnalyseRequired; // True if the string has changed since last analysis.
|
|
SCRIPT_STRING_ANALYSIS m_Analysis; // Analysis for the current string
|
|
|
|
char field_12;
|
|
|
|
private:
|
|
// Empty implementation of the Uniscribe API
|
|
static HRESULT WINAPI Dummy_ScriptApplyDigitSubstitution( const SCRIPT_DIGITSUBSTITUTE*, SCRIPT_CONTROL*, SCRIPT_STATE* ) { return E_NOTIMPL; }
|
|
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; }
|
|
static HRESULT WINAPI Dummy_ScriptStringCPtoX( SCRIPT_STRING_ANALYSIS, int, BOOL, int* ) { return E_NOTIMPL; }
|
|
static HRESULT WINAPI Dummy_ScriptStringXtoCP( SCRIPT_STRING_ANALYSIS, int, int*, int* ) { return E_NOTIMPL; }
|
|
static HRESULT WINAPI Dummy_ScriptStringFree( SCRIPT_STRING_ANALYSIS* ) { return E_NOTIMPL; }
|
|
static const SCRIPT_LOGATTR* WINAPI Dummy_ScriptString_pLogAttr( SCRIPT_STRING_ANALYSIS ) { return NULL; }
|
|
static const int* WINAPI Dummy_ScriptString_pcOutChars( SCRIPT_STRING_ANALYSIS ) { return NULL; }
|
|
|
|
// Function pointers
|
|
static HRESULT (WINAPI *_ScriptApplyDigitSubstitution)( const SCRIPT_DIGITSUBSTITUTE*, SCRIPT_CONTROL*, SCRIPT_STATE* );
|
|
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* );
|
|
static HRESULT (WINAPI *_ScriptStringCPtoX)( SCRIPT_STRING_ANALYSIS, int, BOOL, int* );
|
|
static HRESULT (WINAPI *_ScriptStringXtoCP)( SCRIPT_STRING_ANALYSIS, int, int*, int* );
|
|
static HRESULT (WINAPI *_ScriptStringFree)( SCRIPT_STRING_ANALYSIS* );
|
|
static const SCRIPT_LOGATTR* (WINAPI *_ScriptString_pLogAttr)( SCRIPT_STRING_ANALYSIS );
|
|
static const int* (WINAPI *_ScriptString_pcOutChars)( SCRIPT_STRING_ANALYSIS );
|
|
|
|
static HINSTANCE s_hDll; // Uniscribe DLL handle
|
|
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// EditBox control
|
|
//-----------------------------------------------------------------------------
|
|
class CDXUTEditBox : public CDXUTControl
|
|
{
|
|
public:
|
|
CDXUTEditBox( CDXUTDialog *pDialog = NULL );
|
|
virtual ~CDXUTEditBox();
|
|
|
|
virtual bool HandleKeyboard( UINT uMsg, WPARAM wParam, LPARAM lParam );
|
|
virtual bool HandleMouse( UINT uMsg, POINT pt, WPARAM wParam, LPARAM lParam );
|
|
virtual bool MsgProc( UINT uMsg, WPARAM wParam, LPARAM lParam );
|
|
virtual void UpdateRects();
|
|
virtual bool CanHaveFocus() { return (m_bVisible && m_bEnabled); }
|
|
virtual void Render( IDirect3DDevice9* pd3dDevice, float fElapsedTime );
|
|
virtual void OnFocusIn();
|
|
|
|
void SetText( LPCTSTR wszText, bool bSelected = false );
|
|
LPCWSTR GetText() { return m_Buffer.GetBuffer(); }
|
|
PCHAR GetTextA();
|
|
int GetTextLength() { return m_Buffer.GetTextSize(); } // Returns text length in chars excluding NULL.
|
|
HRESULT GetTextCopy( PWCHAR strDest, UINT bufferCount );
|
|
void ClearText();
|
|
virtual void SetTextColor( D3DCOLOR Color ) { m_TextColor = Color; } // Text color
|
|
void SetSelectedTextColor( D3DCOLOR Color ) { m_SelTextColor = Color; } // Selected text color
|
|
void SetSelectedBackColor( D3DCOLOR Color ) { m_SelBkColor = Color; } // Selected background color
|
|
void SetCaretColor( D3DCOLOR Color ) { m_CaretColor = Color; } // Caret color
|
|
void SetBorderWidth( int nBorder ) { m_nBorder = nBorder; UpdateRects(); } // Border of the window
|
|
void SetSpacing( int nSpacing ) { m_nSpacing = nSpacing; UpdateRects(); }
|
|
void ParseFloatArray( float *pNumbers, int nCount );
|
|
void SetTextFloatArray( const float *pNumbers, int nCount );
|
|
|
|
protected:
|
|
void PlaceCaret( int nCP );
|
|
void DeleteSelectionText();
|
|
void ResetCaretBlink();
|
|
void CopyToClipboard();
|
|
void PasteFromClipboard();
|
|
|
|
CUniBuffer m_Buffer; // Buffer to hold text
|
|
int m_nBorder; // Border of the window
|
|
int m_nSpacing; // Spacing between the text and the edge of border
|
|
RECT m_rcText; // Bounding rectangle for the text
|
|
RECT m_rcRender[9]; // Convenient rectangles for rendering elements
|
|
double m_dfBlink; // Caret blink time in milliseconds
|
|
double m_dfLastBlink; // Last timestamp of caret blink
|
|
bool m_bCaretOn; // Flag to indicate whether caret is currently visible
|
|
int m_nCaret; // Caret position, in characters
|
|
bool m_bInsertMode; // If true, control is in insert mode. Else, overwrite mode.
|
|
int m_nSelStart; // Starting position of the selection. The caret marks the end.
|
|
int m_nFirstVisible;// First visible character in the edit control
|
|
|
|
char field_126;
|
|
|
|
D3DCOLOR m_TextColor; // Text color
|
|
D3DCOLOR m_SelTextColor; // Selected text color
|
|
D3DCOLOR m_SelBkColor; // Selected background color
|
|
D3DCOLOR m_CaretColor; // Caret color
|
|
|
|
// Mouse-specific
|
|
bool m_bMouseDrag; // True to indicate drag in progress
|
|
|
|
// Static
|
|
static bool s_bHideCaret; // If true, we don't render the caret.
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// IME-enabled EditBox control
|
|
//-----------------------------------------------------------------------------
|
|
#define MAX_CANDLIST 10
|
|
#define MAX_COMPSTRING_SIZE 256
|
|
|
|
class CDXUTIMEEditBox : public CDXUTEditBox
|
|
{
|
|
protected:
|
|
// Empty implementation of the IMM32 API
|
|
static INPUTCONTEXT* WINAPI Dummy_ImmLockIMC( HIMC ) { return NULL; }
|
|
static BOOL WINAPI Dummy_ImmUnlockIMC( HIMC ) { return FALSE; }
|
|
static LPVOID WINAPI Dummy_ImmLockIMCC( HIMCC ) { return NULL; }
|
|
static BOOL WINAPI Dummy_ImmUnlockIMCC( HIMCC ) { return FALSE; }
|
|
static BOOL WINAPI Dummy_ImmDisableTextFrameService( DWORD ) { return TRUE; }
|
|
static LONG WINAPI Dummy_ImmGetCompositionStringW( HIMC, DWORD, LPVOID, DWORD ) { return IMM_ERROR_GENERAL; }
|
|
static DWORD WINAPI Dummy_ImmGetCandidateListW( HIMC, DWORD, LPCANDIDATELIST, DWORD ) { return 0; }
|
|
static HIMC WINAPI Dummy_ImmGetContext( HWND ) { return NULL; }
|
|
static BOOL WINAPI Dummy_ImmReleaseContext( HWND, HIMC ) { return FALSE; }
|
|
static HIMC WINAPI Dummy_ImmAssociateContext( HWND, HIMC ) { return NULL; }
|
|
static BOOL WINAPI Dummy_ImmGetOpenStatus( HIMC ) { return 0; }
|
|
static BOOL WINAPI Dummy_ImmSetOpenStatus( HIMC, BOOL ) { return 0; }
|
|
static BOOL WINAPI Dummy_ImmGetConversionStatus( HIMC, LPDWORD, LPDWORD ) { return 0; }
|
|
static HWND WINAPI Dummy_ImmGetDefaultIMEWnd( HWND ) { return NULL; }
|
|
static UINT WINAPI Dummy_ImmGetIMEFileNameA( HKL, LPSTR, UINT ) { return 0; }
|
|
static UINT WINAPI Dummy_ImmGetVirtualKey( HWND ) { return 0; }
|
|
static BOOL WINAPI Dummy_ImmNotifyIME( HIMC, DWORD, DWORD, DWORD ) { return FALSE; }
|
|
static BOOL WINAPI Dummy_ImmSetConversionStatus( HIMC, DWORD, DWORD ) { return FALSE; }
|
|
static BOOL WINAPI Dummy_ImmSimulateHotKey( HWND, DWORD ) { return FALSE; }
|
|
static BOOL WINAPI Dummy_ImmIsIME( HKL ) { return FALSE; }
|
|
|
|
// Traditional Chinese IME
|
|
static UINT WINAPI Dummy_GetReadingString( HIMC, UINT, PCHAR, PINT, BOOL*, PUINT ) { return 0; }
|
|
static BOOL WINAPI Dummy_ShowReadingWindow( HIMC, BOOL ) { return FALSE; }
|
|
|
|
// Verion library imports
|
|
static BOOL APIENTRY Dummy_VerQueryValueA( const LPVOID, LPSTR, LPVOID *, PUINT ) { return 0; }
|
|
static BOOL APIENTRY Dummy_GetFileVersionInfoA( LPSTR, DWORD, DWORD, LPVOID ) { return 0; }
|
|
static DWORD APIENTRY Dummy_GetFileVersionInfoSizeA( LPSTR, LPDWORD ) { return 0; }
|
|
|
|
// Function pointers: IMM32
|
|
static INPUTCONTEXT* (WINAPI * _ImmLockIMC)( HIMC );
|
|
static BOOL (WINAPI * _ImmUnlockIMC)( HIMC );
|
|
static LPVOID (WINAPI * _ImmLockIMCC)( HIMCC );
|
|
static BOOL (WINAPI * _ImmUnlockIMCC)( HIMCC );
|
|
static BOOL (WINAPI * _ImmDisableTextFrameService)( DWORD );
|
|
static LONG (WINAPI * _ImmGetCompositionStringW)( HIMC, DWORD, LPVOID, DWORD );
|
|
static DWORD (WINAPI * _ImmGetCandidateListW)( HIMC, DWORD, LPCANDIDATELIST, DWORD );
|
|
static HIMC (WINAPI * _ImmGetContext)( HWND );
|
|
static BOOL (WINAPI * _ImmReleaseContext)( HWND, HIMC );
|
|
static HIMC (WINAPI * _ImmAssociateContext)( HWND, HIMC );
|
|
static BOOL (WINAPI * _ImmGetOpenStatus)( HIMC );
|
|
static BOOL (WINAPI * _ImmSetOpenStatus)( HIMC, BOOL );
|
|
static BOOL (WINAPI * _ImmGetConversionStatus)( HIMC, LPDWORD, LPDWORD );
|
|
static HWND (WINAPI * _ImmGetDefaultIMEWnd)( HWND );
|
|
static UINT (WINAPI * _ImmGetIMEFileNameA)( HKL, LPSTR, UINT );
|
|
static UINT (WINAPI * _ImmGetVirtualKey)( HWND );
|
|
static BOOL (WINAPI * _ImmNotifyIME)( HIMC, DWORD, DWORD, DWORD );
|
|
static BOOL (WINAPI * _ImmSetConversionStatus)( HIMC, DWORD, DWORD );
|
|
static BOOL (WINAPI * _ImmSimulateHotKey)( HWND, DWORD );
|
|
static BOOL (WINAPI * _ImmIsIME)( HKL );
|
|
|
|
// Function pointers: Traditional Chinese IME
|
|
static UINT (WINAPI * _GetReadingString)( HIMC, UINT, PCHAR, PINT, BOOL*, PUINT );
|
|
static BOOL (WINAPI * _ShowReadingWindow)( HIMC, BOOL );
|
|
|
|
// Function pointers: Verion library imports
|
|
static BOOL (APIENTRY * _VerQueryValueA)( const LPVOID, LPSTR, LPVOID *, PUINT );
|
|
static BOOL (APIENTRY * _GetFileVersionInfoA)( LPSTR, DWORD, DWORD, LPVOID );
|
|
static DWORD (APIENTRY * _GetFileVersionInfoSizeA)( LPSTR, LPDWORD );
|
|
|
|
public:
|
|
CDXUTIMEEditBox( CDXUTDialog *pDialog = NULL );
|
|
virtual ~CDXUTIMEEditBox();
|
|
|
|
static void Initialize();
|
|
static void Uninitialize();
|
|
|
|
static HRESULT StaticOnCreateDevice();
|
|
static bool StaticMsgProc( UINT uMsg, WPARAM wParam, LPARAM lParam );
|
|
|
|
static void EnableImeSystem( bool bEnable );
|
|
|
|
virtual void Render( IDirect3DDevice9* pd3dDevice, float fElapsedTime );
|
|
virtual bool MsgProc( UINT uMsg, WPARAM wParam, LPARAM lParam );
|
|
virtual bool HandleMouse( UINT uMsg, POINT pt, WPARAM wParam, LPARAM lParam );
|
|
virtual void UpdateRects();
|
|
virtual void OnFocusIn();
|
|
virtual void OnFocusOut();
|
|
|
|
void PumpMessage();
|
|
|
|
virtual void RenderCandidateReadingWindow( IDirect3DDevice9* pd3dDevice, float fElapsedTime, bool bReading );
|
|
virtual void RenderComposition( IDirect3DDevice9* pd3dDevice, float fElapsedTime );
|
|
virtual void RenderIndicator( IDirect3DDevice9* pd3dDevice, float fElapsedTime );
|
|
|
|
protected:
|
|
static WORD GetLanguage() { return LOWORD( s_hklCurrent ); }
|
|
static WORD GetPrimaryLanguage() { return PRIMARYLANGID( LOWORD( s_hklCurrent ) ); }
|
|
static WORD GetSubLanguage() { return SUBLANGID( LOWORD( s_hklCurrent ) ); }
|
|
static void SendKey( BYTE nVirtKey );
|
|
static DWORD GetImeId( UINT uIndex = 0 );
|
|
static void CheckInputLocale();
|
|
static void CheckToggleState();
|
|
static void SetupImeApi();
|
|
static void ResetCompositionString();
|
|
void TruncateCompString( bool bUseBackSpace = true, int iNewStrLen = 0 );
|
|
void FinalizeString( bool bSend );
|
|
static void GetReadingWindowOrientation( DWORD dwId );
|
|
static void GetPrivateReadingString();
|
|
|
|
void SendCompString();
|
|
|
|
protected:
|
|
enum { INDICATOR_NON_IME, INDICATOR_CHS, INDICATOR_CHT, INDICATOR_KOREAN, INDICATOR_JAPANESE };
|
|
enum IMESTATE { IMEUI_STATE_OFF, IMEUI_STATE_ON, IMEUI_STATE_ENGLISH };
|
|
|
|
struct CCandList
|
|
{
|
|
TCHAR awszCandidate[MAX_CANDLIST][256];
|
|
CUniBuffer HoriCand; // Candidate list string (for horizontal candidate window)
|
|
int nFirstSelected; // First character position of the selected string in HoriCand
|
|
int nHoriSelectedLen; // Length of the selected string in HoriCand
|
|
DWORD dwCount; // Number of valid entries in the candidate list
|
|
DWORD dwSelection; // Currently selected candidate entry relative to page top
|
|
DWORD dwPageSize;
|
|
int nReadingError; // Index of the error character
|
|
bool bShowWindow; // Whether the candidate list window is visible
|
|
RECT rcCandidate; // Candidate rectangle computed and filled each time before rendered
|
|
};
|
|
|
|
struct CInputLocale
|
|
{
|
|
HKL m_hKL; // Keyboard layout
|
|
WCHAR m_wszLangAbb[3]; // Language abbreviation
|
|
WCHAR m_wszLang[64]; // Localized language name
|
|
};
|
|
|
|
// Application-wide data
|
|
static HINSTANCE s_hDllImm32; // IMM32 DLL handle
|
|
static HINSTANCE s_hDllVer; // Version DLL handle
|
|
static HIMC s_hImcDef; // Default input context
|
|
|
|
static HKL s_hklCurrent; // Current keyboard layout of the process
|
|
static bool s_bVerticalCand; // Indicates that the candidates are listed vertically
|
|
static PWCHAR s_wszCurrIndicator; // Points to an indicator string that corresponds to current input locale
|
|
static WCHAR s_aszIndicator[5][3]; // String to draw to indicate current input locale
|
|
static bool s_bInsertOnType; // Insert the character as soon as a key is pressed (Korean behavior)
|
|
static HINSTANCE s_hDllIme; // Instance handle of the current IME module
|
|
static IMESTATE s_ImeState; // IME global state
|
|
static bool s_bEnableImeSystem; // Whether the IME system is active
|
|
static POINT s_ptCompString; // Composition string position. Updated every frame.
|
|
static int s_nCompCaret; // Caret position of the composition string
|
|
static int s_nFirstTargetConv; // Index of the first target converted char in comp string. If none, -1.
|
|
static CUniBuffer s_CompString; // Buffer to hold the composition string (we fix its length)
|
|
static BYTE s_abCompStringAttr[MAX_COMPSTRING_SIZE];
|
|
static DWORD s_adwCompStringClause[MAX_COMPSTRING_SIZE];
|
|
static TCHAR s_wszReadingString[32];// Used only with horizontal reading window (why?)
|
|
static CCandList s_CandList; // Data relevant to the candidate list
|
|
static bool s_bShowReadingWindow; // Indicates whether reading window is visible
|
|
static bool s_bHorizontalReading; // Indicates whether the reading window is vertical or horizontal
|
|
static bool s_bChineseIME;
|
|
static CGrowableArray< CInputLocale > s_Locale; // Array of loaded keyboard layout on system
|
|
|
|
// Color of various IME elements
|
|
D3DCOLOR m_ReadingColor; // Reading string color
|
|
D3DCOLOR m_ReadingWinColor; // Reading window color
|
|
D3DCOLOR m_ReadingSelColor; // Selected character in reading string
|
|
D3DCOLOR m_ReadingSelBkColor; // Background color for selected char in reading str
|
|
D3DCOLOR m_CandidateColor; // Candidate string color
|
|
D3DCOLOR m_CandidateWinColor; // Candidate window color
|
|
D3DCOLOR m_CandidateSelColor; // Selected candidate string color
|
|
D3DCOLOR m_CandidateSelBkColor; // Selected candidate background color
|
|
D3DCOLOR m_CompColor; // Composition string color
|
|
D3DCOLOR m_CompWinColor; // Composition string window color
|
|
D3DCOLOR m_CompCaretColor; // Composition string caret color
|
|
D3DCOLOR m_CompTargetColor; // Composition string target converted color
|
|
D3DCOLOR m_CompTargetBkColor; // Composition string target converted background
|
|
D3DCOLOR m_CompTargetNonColor; // Composition string target non-converted color
|
|
D3DCOLOR m_CompTargetNonBkColor;// Composition string target non-converted background
|
|
D3DCOLOR m_IndicatorImeColor; // Indicator text color for IME
|
|
D3DCOLOR m_IndicatorEngColor; // Indicator text color for English
|
|
D3DCOLOR m_IndicatorBkColor; // Indicator text background color
|
|
|
|
// Edit-control-specific data
|
|
int m_nIndicatorWidth; // Width of the indicator symbol
|
|
RECT m_rcIndicator; // Rectangle for drawing the indicator button
|
|
|
|
#if defined(DEBUG) | defined(_DEBUG)
|
|
static bool m_bIMEStaticMsgProcCalled;
|
|
#endif
|
|
};
|
|
|
|
|
|
|
|
#endif // DXUT_GUI_H
|