faerbit/Saxum
1
0
Fork 0
Code Issues 1 Pull Requests Projects Releases 2 Wiki Activity
e8fe6286a4
Saxum/extern/bullet/Demos/DX11ClothDemo/DXUT/Optional/DXUTgui.cpp

7242 lines
236 KiB
C++
Raw Normal View History

Adding Bullet Library
2014-10-24 09:42:47 +00:00
//--------------------------------------------------------------------------------------
// File: DXUTgui.cpp
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//--------------------------------------------------------------------------------------
#include "DXUT.h"
#include "DXUTgui.h"
#include "DXUTsettingsDlg.h"
#include "DXUTres.h"
#include "SDKMisc.h"
#undef min // use __min instead
#undef max // use __max instead
#ifndef WM_XBUTTONDOWN
#define WM_XBUTTONDOWN 0x020B // (not always defined)
#endif
#ifndef WM_XBUTTONUP
#define WM_XBUTTONUP 0x020C // (not always defined)
#endif
#ifndef WM_MOUSEWHEEL
#define WM_MOUSEWHEEL 0x020A // (not always defined)
#endif
#ifndef WHEEL_DELTA
#define WHEEL_DELTA 120 // (not always defined)
#endif
// Minimum scroll bar thumb size
#define SCROLLBAR_MINTHUMBSIZE 8
// Delay and repeat period when clicking on the scroll bar arrows
#define SCROLLBAR_ARROWCLICK_DELAY 0.33
#define SCROLLBAR_ARROWCLICK_REPEAT 0.05
#define DXUT_NEAR_BUTTON_DEPTH 0.6f
#define DXUT_FAR_BUTTON_DEPTH 0.8f
#define DXUT_MAX_GUI_SPRITES 500
D3DCOLORVALUE D3DCOLOR_TO_D3DCOLORVALUE( D3DCOLOR c )
{
D3DCOLORVALUE cv =
{
( ( c >> 16 ) & 0xFF ) / 255.0f,
( ( c >> 8 ) & 0xFF ) / 255.0f,
( c & 0xFF ) / 255.0f,
( ( c >> 24 ) & 0xFF ) / 255.0f
};
return cv;
}
#define UNISCRIBE_DLLNAME L"usp10.dll"
#define GETPROCADDRESS( Module, APIName, Temp ) \
Temp = GetProcAddress( Module, #APIName ); \
if( Temp ) \
*(FARPROC*)&_##APIName = Temp
#define PLACEHOLDERPROC( APIName ) \
_##APIName = Dummy_##APIName
#define IMM32_DLLNAME L"imm32.dll"
#define VER_DLLNAME L"version.dll"
CHAR g_strUIEffectFile[] = \
"Texture2D g_Texture;"\
""\
"SamplerState Sampler"\
"{"\
" Filter = MIN_MAG_MIP_LINEAR;"\
" AddressU = Wrap;"\
" AddressV = Wrap;"\
"};"\
""\
"BlendState UIBlend"\
"{"\
" AlphaToCoverageEnable = FALSE;"\
" BlendEnable[0] = TRUE;"\
" SrcBlend = SRC_ALPHA;"\
" DestBlend = INV_SRC_ALPHA;"\
" BlendOp = ADD;"\
" SrcBlendAlpha = ONE;"\
" DestBlendAlpha = ZERO;"\
" BlendOpAlpha = ADD;"\
" RenderTargetWriteMask[0] = 0x0F;"\
"};"\
""\
"BlendState NoBlending"\
"{"\
" BlendEnable[0] = FALSE;"\
" RenderTargetWriteMask[0] = 0x0F;"\
"};"\
""\
"DepthStencilState DisableDepth"\
"{"\
" DepthEnable = false;"\
"};"\
"DepthStencilState EnableDepth"\
"{"\
" DepthEnable = true;"\
"};"\
"struct VS_OUTPUT"\
"{"\
" float4 Pos : POSITION;"\
" float4 Dif : COLOR;"\
" float2 Tex : TEXCOORD;"\
"};"\
""\
"VS_OUTPUT VS( float3 vPos : POSITION,"\
" float4 Dif : COLOR,"\
" float2 vTexCoord0 : TEXCOORD )"\
"{"\
" VS_OUTPUT Output;"\
""\
" Output.Pos = float4( vPos, 1.0f );"\
" Output.Dif = Dif;"\
" Output.Tex = vTexCoord0;"\
""\
" return Output;"\
"}"\
""\
"float4 PS( VS_OUTPUT In ) : SV_Target"\
"{"\
" return g_Texture.Sample( Sampler, In.Tex ) * In.Dif;"\
"}"\
""\
"float4 PSUntex( VS_OUTPUT In ) : SV_Target"\
"{"\
" return In.Dif;"\
"}"\
""\
"technique10 RenderUI"\
"{"\
" pass P0"\
" {"\
" SetVertexShader( CompileShader( vs_4_0, VS() ) );"\
" SetGeometryShader( NULL );"\
" SetPixelShader( CompileShader( ps_4_0, PS() ) );"\
" SetDepthStencilState( DisableDepth, 0 );"\
" SetBlendState( UIBlend, float4( 0.0f, 0.0f, 0.0f, 0.0f ), 0xFFFFFFFF );"\
" }"\
"}"\
"technique10 RenderUIUntex"\
"{"\
" pass P0"\
" {"\
" SetVertexShader( CompileShader( vs_4_0, VS() ) );"\
" SetGeometryShader( NULL );"\
" SetPixelShader( CompileShader( ps_4_0, PSUntex() ) );"\
" SetDepthStencilState( DisableDepth, 0 );"\
" SetBlendState( UIBlend, float4( 0.0f, 0.0f, 0.0f, 0.0f ), 0xFFFFFFFF );"\
" }"\
"}"\
"technique10 RestoreState"\
"{"\
" pass P0"\
" {"\
" SetDepthStencilState( EnableDepth, 0 );"\
" SetBlendState( NoBlending, float4( 0.0f, 0.0f, 0.0f, 0.0f ), 0xFFFFFFFF );"\
" }"\
"}";
const UINT g_uUIEffectFileSize = sizeof( g_strUIEffectFile );
// DXUT_MAX_EDITBOXLENGTH is the maximum string length allowed in edit boxes,
// including the NULL terminator.
//
// Uniscribe does not support strings having bigger-than-16-bits length.
// This means that the string must be less than 65536 characters long,
// including the NULL terminator.
#define DXUT_MAX_EDITBOXLENGTH 0xFFFF
double CDXUTDialog::s_fTimeRefresh = 0.0f;
CDXUTControl* CDXUTDialog::s_pControlFocus = NULL; // The control which has focus
CDXUTControl* CDXUTDialog::s_pControlPressed = NULL; // The control currently pressed
struct DXUT_SCREEN_VERTEX
{
float x, y, z, h;
D3DCOLOR color;
float tu, tv;
static DWORD FVF;
};
DWORD DXUT_SCREEN_VERTEX::FVF = D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_TEX1;
struct DXUT_SCREEN_VERTEX_UNTEX
{
float x, y, z, h;
D3DCOLOR color;
static DWORD FVF;
};
DWORD DXUT_SCREEN_VERTEX_UNTEX::FVF = D3DFVF_XYZRHW | D3DFVF_DIFFUSE;
struct DXUT_SCREEN_VERTEX_10
{
float x, y, z;
D3DCOLORVALUE color;
float tu, tv;
};
inline int RectWidth( RECT& rc )
{
return ( ( rc ).right - ( rc ).left );
}
inline int RectHeight( RECT& rc )
{
return ( ( rc ).bottom - ( rc ).top );
}
HRESULT InitFont11( ID3D11Device* pd3d11Device, ID3D11InputLayout* pInputLayout );
void EndFont11();
//--------------------------------------------------------------------------------------
// CDXUTDialog class
//--------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------
CDXUTDialog::CDXUTDialog()
{
m_x = 0;
m_y = 0;
m_width = 0;
m_height = 0;
m_pManager = NULL;
m_bVisible = true;
m_bCaption = false;
m_bMinimized = false;
m_bDrag = false;
m_wszCaption[0] = L'\0';
m_nCaptionHeight = 18;
m_colorTopLeft = 0;
m_colorTopRight = 0;
m_colorBottomLeft = 0;
m_colorBottomRight = 0;
m_pCallbackEvent = NULL;
m_pCallbackEventUserContext = NULL;
m_fTimeLastRefresh = 0;
m_pControlMouseOver = NULL;
m_pNextDialog = this;
m_pPrevDialog = this;
m_nDefaultControlID = 0xffff;
m_bNonUserEvents = false;
m_bKeyboardInput = false;
m_bMouseInput = true;
}
//--------------------------------------------------------------------------------------
CDXUTDialog::~CDXUTDialog()
{
int i = 0;
RemoveAllControls();
m_Fonts.RemoveAll();
m_Textures.RemoveAll();
for( i = 0; i < m_DefaultElements.GetSize(); i++ )
{
DXUTElementHolder* pElementHolder = m_DefaultElements.GetAt( i );
SAFE_DELETE( pElementHolder );
}
m_DefaultElements.RemoveAll();
}
//--------------------------------------------------------------------------------------
void CDXUTDialog::Init( CDXUTDialogResourceManager* pManager, bool bRegisterDialog )
{
m_pManager = pManager;
if( bRegisterDialog )
pManager->RegisterDialog( this );
SetTexture( 0, MAKEINTRESOURCE( 0xFFFF ), ( HMODULE )0xFFFF );
InitDefaultElements();
}
//--------------------------------------------------------------------------------------
void CDXUTDialog::Init( CDXUTDialogResourceManager* pManager, bool bRegisterDialog, LPCWSTR pszControlTextureFilename )
{
m_pManager = pManager;
if( bRegisterDialog )
pManager->RegisterDialog( this );
SetTexture( 0, pszControlTextureFilename );
InitDefaultElements();
}
//--------------------------------------------------------------------------------------
void CDXUTDialog::Init( CDXUTDialogResourceManager* pManager, bool bRegisterDialog,
LPCWSTR szControlTextureResourceName, HMODULE hControlTextureResourceModule )
{
m_pManager = pManager;
if( bRegisterDialog )
pManager->RegisterDialog( this );
SetTexture( 0, szControlTextureResourceName, hControlTextureResourceModule );
InitDefaultElements();
}
//--------------------------------------------------------------------------------------
void CDXUTDialog::SetCallback( PCALLBACKDXUTGUIEVENT pCallback, void* pUserContext )
{
// If this assert triggers, you need to call CDXUTDialog::Init() first. This change
// was made so that the DXUT's GUI could become seperate and optional from DXUT's core. The
// creation and interfacing with CDXUTDialogResourceManager is now the responsibility
// of the application if it wishes to use DXUT's GUI.
assert( m_pManager != NULL && L"To fix call CDXUTDialog::Init() first. See comments for details." );
m_pCallbackEvent = pCallback;
m_pCallbackEventUserContext = pUserContext;
}
//--------------------------------------------------------------------------------------
void CDXUTDialog::RemoveControl( int ID )
{
for( int i = 0; i < m_Controls.GetSize(); i++ )
{
CDXUTControl* pControl = m_Controls.GetAt( i );
if( pControl->GetID() == ID )
{
// Clean focus first
ClearFocus();
// Clear references to this control
if( s_pControlFocus == pControl )
s_pControlFocus = NULL;
if( s_pControlPressed == pControl )
s_pControlPressed = NULL;
if( m_pControlMouseOver == pControl )
m_pControlMouseOver = NULL;
SAFE_DELETE( pControl );
m_Controls.Remove( i );
return;
}
}
}
//--------------------------------------------------------------------------------------
void CDXUTDialog::RemoveAllControls()
{
if( s_pControlFocus && s_pControlFocus->m_pDialog == this )
s_pControlFocus = NULL;
if( s_pControlPressed && s_pControlPressed->m_pDialog == this )
s_pControlPressed = NULL;
m_pControlMouseOver = NULL;
for( int i = 0; i < m_Controls.GetSize(); i++ )
{
CDXUTControl* pControl = m_Controls.GetAt( i );
SAFE_DELETE( pControl );
}
m_Controls.RemoveAll();
}
//--------------------------------------------------------------------------------------
CDXUTDialogResourceManager::CDXUTDialogResourceManager()
{
// Begin D3D9-specific
m_pd3d9Device = NULL;
m_pStateBlock = NULL;
m_pSprite = NULL;
// Begin D3D11-specific
// Shaders
m_pVSRenderUI11 = NULL;
m_pPSRenderUI11 = NULL;
m_pPSRenderUIUntex11 = NULL;
// States
m_pDepthStencilStateUI11 = NULL;
m_pRasterizerStateUI11 = NULL;
m_pBlendStateUI11 = NULL;
m_pSamplerStateUI11 = NULL;
m_pDepthStencilStateStored11 = NULL;
m_pRasterizerStateStored11 = NULL;
m_pBlendStateStored11 = NULL;
m_pSamplerStateStored11 = NULL;
m_pInputLayout11 = NULL;
m_pVBScreenQuad11 = NULL;
m_pSpriteBuffer11 = NULL;
}
//--------------------------------------------------------------------------------------
CDXUTDialogResourceManager::~CDXUTDialogResourceManager()
{
int i;
for( i = 0; i < m_FontCache.GetSize(); i++ )
{
DXUTFontNode* pFontNode = m_FontCache.GetAt( i );
SAFE_DELETE( pFontNode );
}
m_FontCache.RemoveAll();
for( i = 0; i < m_TextureCache.GetSize(); i++ )
{
DXUTTextureNode* pTextureNode = m_TextureCache.GetAt( i );
SAFE_DELETE( pTextureNode );
}
m_TextureCache.RemoveAll();
CUniBuffer::Uninitialize();
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTDialogResourceManager::OnD3D9CreateDevice( LPDIRECT3DDEVICE9 pd3dDevice )
{
HRESULT hr = S_OK;
int i = 0;
m_pd3d9Device = pd3dDevice;
for( i = 0; i < m_FontCache.GetSize(); i++ )
{
hr = CreateFont9( i );
if( FAILED( hr ) )
return hr;
}
for( i = 0; i < m_TextureCache.GetSize(); i++ )
{
hr = CreateTexture9( i );
if( FAILED( hr ) )
return hr;
}
hr = D3DXCreateSprite( pd3dDevice, &m_pSprite );
if( FAILED( hr ) )
return DXUT_ERR( L"D3DXCreateSprite", hr );
return S_OK;
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTDialogResourceManager::OnD3D9ResetDevice()
{
HRESULT hr = S_OK;
for( int i = 0; i < m_FontCache.GetSize(); i++ )
{
DXUTFontNode* pFontNode = m_FontCache.GetAt( i );
if( pFontNode->pFont9 )
pFontNode->pFont9->OnResetDevice();
}
if( m_pSprite )
m_pSprite->OnResetDevice();
V_RETURN( m_pd3d9Device->CreateStateBlock( D3DSBT_ALL, &m_pStateBlock ) );
return S_OK;
}
//--------------------------------------------------------------------------------------
bool CDXUTDialogResourceManager::MsgProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
{
return false;
}
//--------------------------------------------------------------------------------------
void CDXUTDialogResourceManager::OnD3D9LostDevice()
{
for( int i = 0; i < m_FontCache.GetSize(); i++ )
{
DXUTFontNode* pFontNode = m_FontCache.GetAt( i );
if( pFontNode->pFont9 )
pFontNode->pFont9->OnLostDevice();
}
if( m_pSprite )
m_pSprite->OnLostDevice();
SAFE_RELEASE( m_pStateBlock );
}
//--------------------------------------------------------------------------------------
void CDXUTDialogResourceManager::OnD3D9DestroyDevice()
{
int i = 0;
m_pd3d9Device = NULL;
// Release the resources but don't clear the cache, as these will need to be
// recreated if the device is recreated
for( i = 0; i < m_FontCache.GetSize(); i++ )
{
DXUTFontNode* pFontNode = m_FontCache.GetAt( i );
SAFE_RELEASE( pFontNode->pFont9 );
}
for( i = 0; i < m_TextureCache.GetSize(); i++ )
{
DXUTTextureNode* pTextureNode = m_TextureCache.GetAt( i );
SAFE_RELEASE( pTextureNode->pTexture9 );
}
SAFE_RELEASE( m_pSprite );
}
HRESULT CDXUTDialogResourceManager::OnD3D11CreateDevice( ID3D11Device* pd3dDevice, ID3D11DeviceContext* pd3d11DeviceContext )
{
m_pd3d11Device = pd3dDevice;
m_pd3d11DeviceContext = pd3d11DeviceContext;
HRESULT hr = S_OK;
// Compile Shaders
ID3DBlob* pVSBlob = NULL;
ID3DBlob* pPSBlob = NULL;
ID3DBlob* pPSUntexBlob = NULL;
V_RETURN( D3DCompile( g_strUIEffectFile, g_uUIEffectFileSize, "none", NULL, NULL, "VS", "vs_4_0_level_9_1",
D3D10_SHADER_ENABLE_BACKWARDS_COMPATIBILITY, 0, &pVSBlob, NULL ) );
V_RETURN( D3DCompile( g_strUIEffectFile, g_uUIEffectFileSize, "none", NULL, NULL, "PS", "ps_4_0_level_9_1",
D3D10_SHADER_ENABLE_BACKWARDS_COMPATIBILITY, 0, &pPSBlob, NULL ) );
V_RETURN( D3DCompile( g_strUIEffectFile, g_uUIEffectFileSize, "none", NULL, NULL, "PSUntex", "ps_4_0_level_9_1",
D3D10_SHADER_ENABLE_BACKWARDS_COMPATIBILITY, 0, &pPSUntexBlob, NULL ) );
//D3D10_SHADER_ENABLE_STRICTNESS
// Create Shaders
V_RETURN( pd3dDevice->CreateVertexShader( pVSBlob->GetBufferPointer(), pVSBlob->GetBufferSize(), NULL, &m_pVSRenderUI11 ) );
V_RETURN( pd3dDevice->CreatePixelShader( pPSBlob->GetBufferPointer(), pPSBlob->GetBufferSize(), NULL, &m_pPSRenderUI11 ) );
V_RETURN( pd3dDevice->CreatePixelShader( pPSUntexBlob->GetBufferPointer(), pPSUntexBlob->GetBufferSize(), NULL, &m_pPSRenderUIUntex11 ) );
// States
D3D11_DEPTH_STENCIL_DESC DSDesc;
ZeroMemory( &DSDesc, sizeof( D3D11_DEPTH_STENCIL_DESC ) );
DSDesc.DepthEnable = FALSE;
DSDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
DSDesc.DepthFunc = D3D11_COMPARISON_LESS;
DSDesc.StencilEnable = FALSE;
V_RETURN( pd3dDevice->CreateDepthStencilState( &DSDesc, &m_pDepthStencilStateUI11 ) );
D3D11_RASTERIZER_DESC RSDesc;
RSDesc.AntialiasedLineEnable = FALSE;
RSDesc.CullMode = D3D11_CULL_BACK;
RSDesc.DepthBias = 0;
RSDesc.DepthBiasClamp = 0.0f;
RSDesc.DepthClipEnable = TRUE;
RSDesc.FillMode = D3D11_FILL_SOLID;
RSDesc.FrontCounterClockwise = FALSE;
RSDesc.MultisampleEnable = TRUE;
RSDesc.ScissorEnable = FALSE;
RSDesc.SlopeScaledDepthBias = 0.0f;
V_RETURN( pd3dDevice->CreateRasterizerState( &RSDesc, &m_pRasterizerStateUI11 ) );
D3D11_BLEND_DESC BSDesc;
ZeroMemory( &BSDesc, sizeof( D3D11_BLEND_DESC ) );
BSDesc.RenderTarget[0].BlendEnable = TRUE;
BSDesc.RenderTarget[0].SrcBlend = D3D11_BLEND_SRC_ALPHA;
BSDesc.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA;
BSDesc.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD;
BSDesc.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ONE;
BSDesc.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_ZERO;
BSDesc.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD;
BSDesc.RenderTarget[0].RenderTargetWriteMask = 0x0F;
V_RETURN( pd3dDevice->CreateBlendState( &BSDesc, &m_pBlendStateUI11 ) );
D3D11_SAMPLER_DESC SSDesc;
ZeroMemory( &SSDesc, sizeof( D3D11_SAMPLER_DESC ) );
SSDesc.Filter = D3D11_FILTER_ANISOTROPIC ;
SSDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
SSDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
SSDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
SSDesc.ComparisonFunc = D3D11_COMPARISON_NEVER;
SSDesc.MaxAnisotropy = 16;
SSDesc.MinLOD = 0;
SSDesc.MaxLOD = D3D11_FLOAT32_MAX;
if ( pd3dDevice->GetFeatureLevel() < D3D_FEATURE_LEVEL_9_3 ) {
SSDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
SSDesc.MaxAnisotropy = 0;
}
V_RETURN( pd3dDevice->CreateSamplerState( &SSDesc, &m_pSamplerStateUI11 ) );
// Create the font and texture objects in the cache arrays.
int i = 0;
for( i = 0; i < m_FontCache.GetSize(); i++ )
{
hr = CreateFont11( i );
if( FAILED( hr ) )
return hr;
}
for( i = 0; i < m_TextureCache.GetSize(); i++ )
{
hr = CreateTexture11( i );
if( FAILED( hr ) )
return hr;
}
// Create input layout
const D3D11_INPUT_ELEMENT_DESC layout[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 28, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};
V_RETURN( pd3dDevice->CreateInputLayout( layout, ARRAYSIZE( layout ), pVSBlob->GetBufferPointer(), pVSBlob->GetBufferSize(), &m_pInputLayout11 ) );
// Release the blobs
SAFE_RELEASE( pVSBlob );
SAFE_RELEASE( pPSBlob );
SAFE_RELEASE( pPSUntexBlob );
// Create a vertex buffer quad for rendering later
D3D11_BUFFER_DESC BufDesc;
BufDesc.ByteWidth = sizeof( DXUT_SCREEN_VERTEX_10 ) * 4;
BufDesc.Usage = D3D11_USAGE_DYNAMIC;
BufDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
BufDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
BufDesc.MiscFlags = 0;
V_RETURN( pd3dDevice->CreateBuffer( &BufDesc, NULL, &m_pVBScreenQuad11 ) );
// Init the D3D11 font
InitFont11( pd3dDevice, m_pInputLayout11 );
return S_OK;
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTDialogResourceManager::OnD3D11ResizedSwapChain( ID3D11Device* pd3dDevice,
const DXGI_SURFACE_DESC* pBackBufferSurfaceDesc )
{
HRESULT hr = S_OK;
m_nBackBufferWidth = pBackBufferSurfaceDesc->Width;
m_nBackBufferHeight = pBackBufferSurfaceDesc->Height;
return hr;
}
//--------------------------------------------------------------------------------------
void CDXUTDialogResourceManager::OnD3D11ReleasingSwapChain()
{
}
//--------------------------------------------------------------------------------------
void CDXUTDialogResourceManager::OnD3D11DestroyDevice()
{
int i;
// Release the resources but don't clear the cache, as these will need to be
// recreated if the device is recreated
for( i = 0; i < m_TextureCache.GetSize(); i++ )
{
DXUTTextureNode* pTextureNode = m_TextureCache.GetAt( i );
SAFE_RELEASE( pTextureNode->pTexResView11 );
SAFE_RELEASE( pTextureNode->pTexture11 );
}
// D3D11
SAFE_RELEASE( m_pVBScreenQuad11 );
SAFE_RELEASE( m_pSpriteBuffer11 );
m_SpriteBufferBytes11 = 0;
SAFE_RELEASE( m_pInputLayout11 );
// Shaders
SAFE_RELEASE( m_pVSRenderUI11 );
SAFE_RELEASE( m_pPSRenderUI11 );
SAFE_RELEASE( m_pPSRenderUIUntex11 );
// States
SAFE_RELEASE( m_pDepthStencilStateUI11 );
SAFE_RELEASE( m_pRasterizerStateUI11 );
SAFE_RELEASE( m_pBlendStateUI11 );
SAFE_RELEASE( m_pSamplerStateUI11 );
SAFE_RELEASE( m_pDepthStencilStateStored11 );
SAFE_RELEASE( m_pRasterizerStateStored11 );
SAFE_RELEASE( m_pBlendStateStored11 );
SAFE_RELEASE( m_pSamplerStateStored11 );
EndFont11();
}
//--------------------------------------------------------------------------------------
void CDXUTDialogResourceManager::StoreD3D11State( ID3D11DeviceContext* pd3dImmediateContext )
{
pd3dImmediateContext->OMGetDepthStencilState( &m_pDepthStencilStateStored11, &m_StencilRefStored11 );
pd3dImmediateContext->RSGetState( &m_pRasterizerStateStored11 );
pd3dImmediateContext->OMGetBlendState( &m_pBlendStateStored11, m_BlendFactorStored11, &m_SampleMaskStored11 );
pd3dImmediateContext->PSGetSamplers( 0, 1, &m_pSamplerStateStored11 );
}
//--------------------------------------------------------------------------------------
void CDXUTDialogResourceManager::RestoreD3D11State( ID3D11DeviceContext* pd3dImmediateContext )
{
pd3dImmediateContext->OMSetDepthStencilState( m_pDepthStencilStateStored11, m_StencilRefStored11 );
pd3dImmediateContext->RSSetState( m_pRasterizerStateStored11 );
pd3dImmediateContext->OMSetBlendState( m_pBlendStateStored11, m_BlendFactorStored11, m_SampleMaskStored11 );
pd3dImmediateContext->PSSetSamplers( 0, 1, &m_pSamplerStateStored11 );
SAFE_RELEASE( m_pDepthStencilStateStored11 );
SAFE_RELEASE( m_pRasterizerStateStored11 );
SAFE_RELEASE( m_pBlendStateStored11 );
SAFE_RELEASE( m_pSamplerStateStored11 );
}
//--------------------------------------------------------------------------------------
void CDXUTDialogResourceManager::ApplyRenderUI11( ID3D11DeviceContext* pd3dImmediateContext )
{
// Shaders
pd3dImmediateContext->VSSetShader( m_pVSRenderUI11, NULL, 0 );
pd3dImmediateContext->HSSetShader( NULL, NULL, 0 );
pd3dImmediateContext->DSSetShader( NULL, NULL, 0 );
pd3dImmediateContext->GSSetShader( NULL, NULL, 0 );
pd3dImmediateContext->PSSetShader( m_pPSRenderUI11, NULL, 0 );
// States
pd3dImmediateContext->OMSetDepthStencilState( m_pDepthStencilStateUI11, 0 );
pd3dImmediateContext->RSSetState( m_pRasterizerStateUI11 );
float BlendFactor[4] = { 0, 0, 0, 0 };
pd3dImmediateContext->OMSetBlendState( m_pBlendStateUI11, BlendFactor, 0xFFFFFFFF );
pd3dImmediateContext->PSSetSamplers( 0, 1, &m_pSamplerStateUI11 );
}
//--------------------------------------------------------------------------------------
void CDXUTDialogResourceManager::ApplyRenderUIUntex11( ID3D11DeviceContext* pd3dImmediateContext )
{
// Shaders
pd3dImmediateContext->VSSetShader( m_pVSRenderUI11, NULL, 0 );
pd3dImmediateContext->HSSetShader( NULL, NULL, 0 );
pd3dImmediateContext->DSSetShader( NULL, NULL, 0 );
pd3dImmediateContext->GSSetShader( NULL, NULL, 0 );
pd3dImmediateContext->PSSetShader( m_pPSRenderUIUntex11, NULL, 0 );
// States
pd3dImmediateContext->OMSetDepthStencilState( m_pDepthStencilStateUI11, 0 );
pd3dImmediateContext->RSSetState( m_pRasterizerStateUI11 );
float BlendFactor[4] = { 0, 0, 0, 0 };
pd3dImmediateContext->OMSetBlendState( m_pBlendStateUI11, BlendFactor, 0xFFFFFFFF );
pd3dImmediateContext->PSSetSamplers( 0, 1, &m_pSamplerStateUI11 );
}
//--------------------------------------------------------------------------------------
void CDXUTDialogResourceManager::BeginSprites11( )
{
m_SpriteVertices.Reset();
}
//--------------------------------------------------------------------------------------
void CDXUTDialogResourceManager::EndSprites11( ID3D11Device* pd3dDevice, ID3D11DeviceContext* pd3dImmediateContext )
{
// ensure our buffer size can hold our sprites
UINT SpriteDataBytes = m_SpriteVertices.GetSize() * sizeof( DXUTSpriteVertex );
if( m_SpriteBufferBytes11 < SpriteDataBytes )
{
SAFE_RELEASE( m_pSpriteBuffer11 );
m_SpriteBufferBytes11 = SpriteDataBytes;
D3D11_BUFFER_DESC BufferDesc;
BufferDesc.ByteWidth = m_SpriteBufferBytes11;
BufferDesc.Usage = D3D11_USAGE_DYNAMIC;
BufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
BufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
BufferDesc.MiscFlags = 0;
pd3dDevice->CreateBuffer( &BufferDesc, NULL, &m_pSpriteBuffer11 );
}
// Copy the sprites over
D3D11_BOX destRegion;
destRegion.left = 0;
destRegion.right = SpriteDataBytes;
destRegion.top = 0;
destRegion.bottom = 1;
destRegion.front = 0;
destRegion.back = 1;
D3D11_MAPPED_SUBRESOURCE MappedResource;
if ( S_OK == pd3dImmediateContext->Map( m_pSpriteBuffer11, 0, D3D11_MAP_WRITE_DISCARD, 0, &MappedResource ) ) {
CopyMemory( MappedResource.pData, (void*)m_SpriteVertices.GetData(), SpriteDataBytes );
pd3dImmediateContext->Unmap(m_pSpriteBuffer11, 0);
}
// Draw
UINT Stride = sizeof( DXUTSpriteVertex );
UINT Offset = 0;
pd3dImmediateContext->IASetVertexBuffers( 0, 1, &m_pSpriteBuffer11, &Stride, &Offset );
pd3dImmediateContext->IASetInputLayout( m_pInputLayout11 );
pd3dImmediateContext->IASetPrimitiveTopology( D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST );
pd3dImmediateContext->Draw( m_SpriteVertices.GetSize(), 0 );
m_SpriteVertices.Reset();
}
//--------------------------------------------------------------------------------------
bool CDXUTDialogResourceManager::RegisterDialog( CDXUTDialog* pDialog )
{
// Check that the dialog isn't already registered.
for( int i = 0; i < m_Dialogs.GetSize(); ++i )
if( m_Dialogs.GetAt( i ) == pDialog )
return true;
// Add to the list.
if( FAILED( m_Dialogs.Add( pDialog ) ) )
return false;
// Set up next and prev pointers.
if( m_Dialogs.GetSize() > 1 )
m_Dialogs[m_Dialogs.GetSize() - 2]->SetNextDialog( pDialog );
m_Dialogs[m_Dialogs.GetSize() - 1]->SetNextDialog( m_Dialogs[0] );
return true;
}
//--------------------------------------------------------------------------------------
void CDXUTDialogResourceManager::UnregisterDialog( CDXUTDialog* pDialog )
{
// Search for the dialog in the list.
for( int i = 0; i < m_Dialogs.GetSize(); ++i )
if( m_Dialogs.GetAt( i ) == pDialog )
{
m_Dialogs.Remove( i );
if( m_Dialogs.GetSize() > 0 )
{
int l, r;
if( 0 == i )
l = m_Dialogs.GetSize() - 1;
else
l = i - 1;
if( m_Dialogs.GetSize() == i )
r = 0;
else
r = i;
m_Dialogs[l]->SetNextDialog( m_Dialogs[r] );
}
return;
}
}
//--------------------------------------------------------------------------------------
void CDXUTDialogResourceManager::EnableKeyboardInputForAllDialogs()
{
// Enable keyboard input for all registered dialogs
for( int i = 0; i < m_Dialogs.GetSize(); ++i )
m_Dialogs[i]->EnableKeyboardInput( true );
}
//--------------------------------------------------------------------------------------
void CDXUTDialog::Refresh()
{
if( s_pControlFocus )
s_pControlFocus->OnFocusOut();
if( m_pControlMouseOver )
m_pControlMouseOver->OnMouseLeave();
s_pControlFocus = NULL;
s_pControlPressed = NULL;
m_pControlMouseOver = NULL;
for( int i = 0; i < m_Controls.GetSize(); i++ )
{
CDXUTControl* pControl = m_Controls.GetAt( i );
pControl->Refresh();
}
if( m_bKeyboardInput )
FocusDefaultControl();
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTDialog::OnRender( float fElapsedTime )
{
if( m_pManager->GetD3D9Device() )
return OnRender9( fElapsedTime );
else
return OnRender11( fElapsedTime );
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTDialog::OnRender9( float fElapsedTime )
{
// If this assert triggers, you need to call CDXUTDialogResourceManager::On*Device() from inside
// the application's device callbacks. See the SDK samples for an example of how to do this.
assert( m_pManager->GetD3D9Device() && m_pManager->m_pStateBlock &&
L"To fix hook up CDXUTDialogResourceManager to device callbacks. See comments for details" );
// See if the dialog needs to be refreshed
if( m_fTimeLastRefresh < s_fTimeRefresh )
{
m_fTimeLastRefresh = DXUTGetTime();
Refresh();
}
// For invisible dialog, out now.
if( !m_bVisible ||
( m_bMinimized && !m_bCaption ) )
return S_OK;
IDirect3DDevice9* pd3dDevice = m_pManager->GetD3D9Device();
// Set up a state block here and restore it when finished drawing all the controls
m_pManager->m_pStateBlock->Capture();
//pd3dDevice->SetSamplerState(0, D3DSAMP_SRGBTEXTURE, TRUE);
//pd3dDevice->SetRenderState( D3DRS_SRGBWRITEENABLE, TRUE );
pd3dDevice->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
pd3dDevice->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA );
pd3dDevice->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA );
pd3dDevice->SetRenderState( D3DRS_ALPHATESTENABLE, FALSE );
pd3dDevice->SetRenderState( D3DRS_SEPARATEALPHABLENDENABLE, FALSE );
pd3dDevice->SetRenderState( D3DRS_BLENDOP, D3DBLENDOP_ADD );
pd3dDevice->SetRenderState( D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_ALPHA | D3DCOLORWRITEENABLE_BLUE |
D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_RED );
pd3dDevice->SetRenderState( D3DRS_SHADEMODE, D3DSHADE_GOURAUD );
pd3dDevice->SetRenderState( D3DRS_FOGENABLE, FALSE );
pd3dDevice->SetRenderState( D3DRS_ZWRITEENABLE, FALSE );
pd3dDevice->SetRenderState( D3DRS_FILLMODE, D3DFILL_SOLID );
pd3dDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_CCW );
pd3dDevice->SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG2 );
pd3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1 );
pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_DIFFUSE );
pd3dDevice->SetTextureStageState( 0, D3DTSS_RESULTARG, D3DTA_CURRENT );
pd3dDevice->SetTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE );
pd3dDevice->SetTextureStageState( 1, D3DTSS_ALPHAOP, D3DTOP_DISABLE );
BOOL bBackgroundIsVisible = ( m_colorTopLeft | m_colorTopRight | m_colorBottomRight | m_colorBottomLeft ) &
0xff000000;
if( !m_bMinimized && bBackgroundIsVisible )
{
DXUT_SCREEN_VERTEX_UNTEX vertices[4] =
{
( float )m_x, ( float )m_y, 0.5f, 1.0f, m_colorTopLeft,
( float )m_x + m_width, ( float )m_y, 0.5f, 1.0f, m_colorTopRight,
( float )m_x + m_width, ( float )m_y + m_height, 0.5f, 1.0f, m_colorBottomRight,
( float )m_x, ( float )m_y + m_height, 0.5f, 1.0f, m_colorBottomLeft,
};
pd3dDevice->SetVertexShader( NULL );
pd3dDevice->SetPixelShader( NULL );
pd3dDevice->SetRenderState( D3DRS_ZENABLE, FALSE );
pd3dDevice->SetFVF( DXUT_SCREEN_VERTEX_UNTEX::FVF );
pd3dDevice->DrawPrimitiveUP( D3DPT_TRIANGLEFAN, 2, vertices, sizeof( DXUT_SCREEN_VERTEX_UNTEX ) );
}
pd3dDevice->SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE );
pd3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
pd3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_MODULATE );
pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE );
pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE );
pd3dDevice->SetSamplerState( 0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR );
DXUTTextureNode* pTextureNode = GetTexture( 0 );
pd3dDevice->SetTexture( 0, pTextureNode->pTexture9 );
m_pManager->m_pSprite->Begin( D3DXSPRITE_DONOTSAVESTATE );
// Render the caption if it's enabled.
if( m_bCaption )
{
// DrawSprite will offset the rect down by
// m_nCaptionHeight, so adjust the rect higher
// here to negate the effect.
RECT rc =
{
0, -m_nCaptionHeight, m_width, 0
};
DrawSprite9( &m_CapElement, &rc );
rc.left += 5; // Make a left margin
WCHAR wszOutput[256];
wcscpy_s( wszOutput, 256, m_wszCaption );
if( m_bMinimized )
wcscat_s( wszOutput, 256, L" (Minimized)" );
DrawText9( wszOutput, &m_CapElement, &rc, true );
}
// If the dialog is minimized, skip rendering
// its controls.
if( !m_bMinimized )
{
for( int i = 0; i < m_Controls.GetSize(); i++ )
{
CDXUTControl* pControl = m_Controls.GetAt( i );
// Focused control is drawn last
if( pControl == s_pControlFocus )
continue;
pControl->Render( fElapsedTime );
}
if( s_pControlFocus != NULL && s_pControlFocus->m_pDialog == this )
s_pControlFocus->Render( fElapsedTime );
}
m_pManager->m_pSprite->End();
m_pManager->m_pStateBlock->Apply();
return S_OK;
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTDialog::OnRender11( float fElapsedTime )
{
// If this assert triggers, you need to call CDXUTDialogResourceManager::On*Device() from inside
// the application's device callbacks. See the SDK samples for an example of how to do this.
assert( m_pManager->GetD3D11Device() &&
L"To fix hook up CDXUTDialogResourceManager to device callbacks. See comments for details" );
// See if the dialog needs to be refreshed
if( m_fTimeLastRefresh < s_fTimeRefresh )
{
m_fTimeLastRefresh = DXUTGetTime();
Refresh();
}
// For invisible dialog, out now.
if( !m_bVisible ||
( m_bMinimized && !m_bCaption ) )
return S_OK;
ID3D11Device* pd3dDevice = m_pManager->GetD3D11Device();
ID3D11DeviceContext* pd3dDeviceContext = m_pManager->GetD3D11DeviceContext();
// Set up a state block here and restore it when finished drawing all the controls
m_pManager->StoreD3D11State( pd3dDeviceContext );
BOOL bBackgroundIsVisible = ( m_colorTopLeft | m_colorTopRight | m_colorBottomRight | m_colorBottomLeft ) &
0xff000000;
if( !m_bMinimized && bBackgroundIsVisible )
{
// Convert the draw rectangle from screen coordinates to clip space coordinates.
float Left, Right, Top, Bottom;
Left = m_x * 2.0f / m_pManager->m_nBackBufferWidth - 1.0f;
Right = ( m_x + m_width ) * 2.0f / m_pManager->m_nBackBufferWidth - 1.0f;
Top = 1.0f - m_y * 2.0f / m_pManager->m_nBackBufferHeight;
Bottom = 1.0f - ( m_y + m_height ) * 2.0f / m_pManager->m_nBackBufferHeight;
DXUT_SCREEN_VERTEX_10 vertices[4] =
{
Left, Top, 0.5f, D3DCOLOR_TO_D3DCOLORVALUE( m_colorTopLeft ), 0.0f, 0.0f,
Right, Top, 0.5f, D3DCOLOR_TO_D3DCOLORVALUE( m_colorTopRight ), 1.0f, 0.0f,
Left, Bottom, 0.5f, D3DCOLOR_TO_D3DCOLORVALUE( m_colorBottomLeft ), 0.0f, 1.0f,
Right, Bottom, 0.5f, D3DCOLOR_TO_D3DCOLORVALUE( m_colorBottomRight ), 1.0f, 1.0f,
};
//DXUT_SCREEN_VERTEX_10 *pVB;
D3D11_MAPPED_SUBRESOURCE MappedData;
if( SUCCEEDED( pd3dDeviceContext->Map( m_pManager->m_pVBScreenQuad11, 0, D3D11_MAP_WRITE_DISCARD,
0, &MappedData ) ) )
{
CopyMemory( MappedData.pData, vertices, sizeof( vertices ) );
pd3dDeviceContext->Unmap( m_pManager->m_pVBScreenQuad11, 0 );
}
// Set the quad VB as current
UINT stride = sizeof( DXUT_SCREEN_VERTEX_10 );
UINT offset = 0;
pd3dDeviceContext->IASetVertexBuffers( 0, 1, &m_pManager->m_pVBScreenQuad11, &stride, &offset );
pd3dDeviceContext->IASetInputLayout( m_pManager->m_pInputLayout11 );
pd3dDeviceContext->IASetPrimitiveTopology( D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP );
// Setup for rendering
m_pManager->ApplyRenderUIUntex11( pd3dDeviceContext );
pd3dDeviceContext->Draw( 4, 0 );
}
DXUTTextureNode* pTextureNode = GetTexture( 0 );
pd3dDeviceContext->PSSetShaderResources( 0, 1, &pTextureNode->pTexResView11 );
// Sort depth back to front
m_pManager->BeginSprites11();
BeginText11();
m_pManager->ApplyRenderUI11( pd3dDeviceContext );
// Render the caption if it's enabled.
if( m_bCaption )
{
// DrawSprite will offset the rect down by
// m_nCaptionHeight, so adjust the rect higher
// here to negate the effect.
RECT rc = { 0, -m_nCaptionHeight, m_width, 0 };
DrawSprite11( &m_CapElement, &rc, 0.99f );
rc.left += 5; // Make a left margin
WCHAR wszOutput[256];
wcscpy_s( wszOutput, 256, m_wszCaption );
if( m_bMinimized )
wcscat_s( wszOutput, 256, L" (Minimized)" );
DrawText11( pd3dDevice, pd3dDeviceContext, wszOutput, &m_CapElement, &rc, true );
}
// If the dialog is minimized, skip rendering
// its controls.
if( !m_bMinimized )
{
for( int i = 0; i < m_Controls.GetSize(); i++ )
{
CDXUTControl* pControl = m_Controls.GetAt( i );
// Focused control is drawn last
if( pControl == s_pControlFocus )
continue;
pControl->Render( fElapsedTime );
}
if( s_pControlFocus != NULL && s_pControlFocus->m_pDialog == this )
s_pControlFocus->Render( fElapsedTime );
}
// End sprites
if( m_bCaption )
{
m_pManager->EndSprites11( pd3dDevice, pd3dDeviceContext );
EndText11( pd3dDevice, pd3dDeviceContext );
}
m_pManager->RestoreD3D11State( pd3dDeviceContext );
return S_OK;
}
//--------------------------------------------------------------------------------------
VOID CDXUTDialog::SendEvent( UINT nEvent, bool bTriggeredByUser, CDXUTControl* pControl )
{
// If no callback has been registered there's nowhere to send the event to
if( m_pCallbackEvent == NULL )
return;
// Discard events triggered programatically if these types of events haven't been
// enabled
if( !bTriggeredByUser && !m_bNonUserEvents )
return;
m_pCallbackEvent( nEvent, pControl->GetID(), pControl, m_pCallbackEventUserContext );
}
//--------------------------------------------------------------------------------------
int CDXUTDialogResourceManager::AddFont( LPCWSTR strFaceName, LONG height, LONG weight )
{
// See if this font already exists
for( int i = 0; i < m_FontCache.GetSize(); i++ )
{
DXUTFontNode* pFontNode = m_FontCache.GetAt( i );
size_t nLen = 0;
nLen = wcsnlen( strFaceName, MAX_PATH);
if( 0 == _wcsnicmp( pFontNode->strFace, strFaceName, nLen ) &&
pFontNode->nHeight == height &&
pFontNode->nWeight == weight )
{
return i;
}
}
// Add a new font and try to create it
DXUTFontNode* pNewFontNode = new DXUTFontNode;
if( pNewFontNode == NULL )
return -1;
ZeroMemory( pNewFontNode, sizeof( DXUTFontNode ) );
wcscpy_s( pNewFontNode->strFace, MAX_PATH, strFaceName );
pNewFontNode->nHeight = height;
pNewFontNode->nWeight = weight;
m_FontCache.Add( pNewFontNode );
int iFont = m_FontCache.GetSize() - 1;
// If a device is available, try to create immediately
if( m_pd3d9Device )
CreateFont9( iFont );
return iFont;
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTDialog::SetFont( UINT index, LPCWSTR strFaceName, LONG height, LONG weight )
{
// If this assert triggers, you need to call CDXUTDialog::Init() first. This change
// was made so that the DXUT's GUI could become seperate and optional from DXUT's core. The
// creation and interfacing with CDXUTDialogResourceManager is now the responsibility
// of the application if it wishes to use DXUT's GUI.
assert( m_pManager != NULL && L"To fix call CDXUTDialog::Init() first. See comments for details." );
// Make sure the list is at least as large as the index being set
UINT i;
for( i = m_Fonts.GetSize(); i <= index; i++ )
{
m_Fonts.Add( -1 );
}
int iFont = m_pManager->AddFont( strFaceName, height, weight );
m_Fonts.SetAt( index, iFont );
return S_OK;
}
//--------------------------------------------------------------------------------------
DXUTFontNode* CDXUTDialog::GetFont( UINT index )
{
if( NULL == m_pManager )
return NULL;
return m_pManager->GetFontNode( m_Fonts.GetAt( index ) );
}
//--------------------------------------------------------------------------------------
int CDXUTDialogResourceManager::AddTexture( LPCWSTR strFilename )
{
// See if this texture already exists
for( int i = 0; i < m_TextureCache.GetSize(); i++ )
{
DXUTTextureNode* pTextureNode = m_TextureCache.GetAt( i );
size_t nLen = 0;
nLen = wcsnlen( strFilename, MAX_PATH);
if( pTextureNode->bFileSource && // Sources must match
0 == _wcsnicmp( pTextureNode->strFilename, strFilename, nLen ) )
{
return i;
}
}
// Add a new texture and try to create it
DXUTTextureNode* pNewTextureNode = new DXUTTextureNode;
if( pNewTextureNode == NULL )
return -1;
ZeroMemory( pNewTextureNode, sizeof( DXUTTextureNode ) );
pNewTextureNode->bFileSource = true;
wcscpy_s( pNewTextureNode->strFilename, MAX_PATH, strFilename );
m_TextureCache.Add( pNewTextureNode );
int iTexture = m_TextureCache.GetSize() - 1;
// If a device is available, try to create immediately
if( m_pd3d9Device )
CreateTexture9( iTexture );
return iTexture;
}
//--------------------------------------------------------------------------------------
int CDXUTDialogResourceManager::AddTexture( LPCWSTR strResourceName, HMODULE hResourceModule )
{
// See if this texture already exists
for( int i = 0; i < m_TextureCache.GetSize(); i++ )
{
DXUTTextureNode* pTextureNode = m_TextureCache.GetAt( i );
if( !pTextureNode->bFileSource && // Sources must match
pTextureNode->hResourceModule == hResourceModule ) // Module handles must match
{
if( IS_INTRESOURCE( strResourceName ) )
{
// Integer-based ID
if( ( INT_PTR )strResourceName == pTextureNode->nResourceID )
return i;
}
else
{
// String-based ID
size_t nLen = 0;
nLen = wcsnlen ( strResourceName, MAX_PATH );
if( 0 == _wcsnicmp( pTextureNode->strFilename, strResourceName, nLen ) )
return i;
}
}
}
// Add a new texture and try to create it
DXUTTextureNode* pNewTextureNode = new DXUTTextureNode;
if( pNewTextureNode == NULL )
return -1;
ZeroMemory( pNewTextureNode, sizeof( DXUTTextureNode ) );
pNewTextureNode->hResourceModule = hResourceModule;
if( IS_INTRESOURCE( strResourceName ) )
{
pNewTextureNode->nResourceID = ( int )( size_t )strResourceName;
}
else
{
pNewTextureNode->nResourceID = 0;
wcscpy_s( pNewTextureNode->strFilename, MAX_PATH, strResourceName );
}
m_TextureCache.Add( pNewTextureNode );
int iTexture = m_TextureCache.GetSize() - 1;
// If a device is available, try to create immediately
if( m_pd3d9Device )
CreateTexture9( iTexture );
return iTexture;
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTDialog::SetTexture( UINT index, LPCWSTR strFilename )
{
// If this assert triggers, you need to call CDXUTDialog::Init() first. This change
// was made so that the DXUT's GUI could become seperate and optional from DXUT's core. The
// creation and interfacing with CDXUTDialogResourceManager is now the responsibility
// of the application if it wishes to use DXUT's GUI.
assert( m_pManager != NULL && L"To fix this, call CDXUTDialog::Init() first. See comments for details." );
// Make sure the list is at least as large as the index being set
for( UINT i = m_Textures.GetSize(); i <= index; i++ )
{
m_Textures.Add( -1 );
}
int iTexture = m_pManager->AddTexture( strFilename );
m_Textures.SetAt( index, iTexture );
return S_OK;
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTDialog::SetTexture( UINT index, LPCWSTR strResourceName, HMODULE hResourceModule )
{
// If this assert triggers, you need to call CDXUTDialog::Init() first. This change
// was made so that the DXUT's GUI could become seperate and optional from DXUT's core. The
// creation and interfacing with CDXUTDialogResourceManager is now the responsibility
// of the application if it wishes to use DXUT's GUI.
assert( m_pManager != NULL && L"To fix this, call CDXUTDialog::Init() first. See comments for details." );
// Make sure the list is at least as large as the index being set
for( UINT i = m_Textures.GetSize(); i <= index; i++ )
{
m_Textures.Add( -1 );
}
int iTexture = m_pManager->AddTexture( strResourceName, hResourceModule );
m_Textures.SetAt( index, iTexture );
return S_OK;
}
//--------------------------------------------------------------------------------------
DXUTTextureNode* CDXUTDialog::GetTexture( UINT index )
{
if( NULL == m_pManager )
return NULL;
return m_pManager->GetTextureNode( m_Textures.GetAt( index ) );
}
//--------------------------------------------------------------------------------------
bool CDXUTDialog::MsgProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
{
bool bHandled = false;
// For invisible dialog, do not handle anything.
if( !m_bVisible )
return false;
// If automation command-line switch is on, enable this dialog's keyboard input
// upon any key press or mouse click.
if( DXUTGetAutomation() &&
( WM_LBUTTONDOWN == uMsg || WM_LBUTTONDBLCLK == uMsg || WM_KEYDOWN == uMsg ) )
{
m_pManager->EnableKeyboardInputForAllDialogs();
}
// If caption is enable, check for clicks in the caption area.
if( m_bCaption )
{
if( uMsg == WM_LBUTTONDOWN || uMsg == WM_LBUTTONDBLCLK )
{
POINT mousePoint =
{
short( LOWORD( lParam ) ), short( HIWORD( lParam ) )
};
if( mousePoint.x >= m_x && mousePoint.x < m_x + m_width &&
mousePoint.y >= m_y && mousePoint.y < m_y + m_nCaptionHeight )
{
m_bDrag = true;
SetCapture( DXUTGetHWND() );
return true;
}
}
else if( uMsg == WM_LBUTTONUP && m_bDrag )
{
POINT mousePoint =
{
short( LOWORD( lParam ) ), short( HIWORD( lParam ) )
};
if( mousePoint.x >= m_x && mousePoint.x < m_x + m_width &&
mousePoint.y >= m_y && mousePoint.y < m_y + m_nCaptionHeight )
{
ReleaseCapture();
m_bDrag = false;
m_bMinimized = !m_bMinimized;
return true;
}
}
}
// If the dialog is minimized, don't send any messages to controls.
if( m_bMinimized )
return false;
// If a control is in focus, it belongs to this dialog, and it's enabled, then give
// it the first chance at handling the message.
if( s_pControlFocus &&
s_pControlFocus->m_pDialog == this &&
s_pControlFocus->GetEnabled() )
{
// If the control MsgProc handles it, then we don't.
if( s_pControlFocus->MsgProc( uMsg, wParam, lParam ) )
return true;
}
switch( uMsg )
{
case WM_SIZE:
case WM_MOVE:
{
// Handle sizing and moving messages so that in case the mouse cursor is moved out
// of an UI control because of the window adjustment, we can properly
// unhighlight the highlighted control.
POINT pt =
{
-1, -1
};
OnMouseMove( pt );
break;
}
case WM_ACTIVATEAPP:
// Call OnFocusIn()/OnFocusOut() of the control that currently has the focus
// as the application is activated/deactivated. This matches the Windows
// behavior.
if( s_pControlFocus &&
s_pControlFocus->m_pDialog == this &&
s_pControlFocus->GetEnabled() )
{
if( wParam )
s_pControlFocus->OnFocusIn();
else
s_pControlFocus->OnFocusOut();
}
break;
// Keyboard messages
case WM_KEYDOWN:
case WM_SYSKEYDOWN:
case WM_KEYUP:
case WM_SYSKEYUP:
{
// If a control is in focus, it belongs to this dialog, and it's enabled, then give
// it the first chance at handling the message.
if( s_pControlFocus &&
s_pControlFocus->m_pDialog == this &&
s_pControlFocus->GetEnabled() )
{
if( s_pControlFocus->HandleKeyboard( uMsg, wParam, lParam ) )
return true;
}
// Not yet handled, see if this matches a control's hotkey
// Activate the hotkey if the focus doesn't belong to an
// edit box.
if( uMsg == WM_KEYDOWN && ( !s_pControlFocus ||
( s_pControlFocus->GetType() != DXUT_CONTROL_EDITBOX
&& s_pControlFocus->GetType() != DXUT_CONTROL_IMEEDITBOX ) ) )
{
for( int i = 0; i < m_Controls.GetSize(); i++ )
{
CDXUTControl* pControl = m_Controls.GetAt( i );
if( pControl->GetHotkey() == wParam )
{
pControl->OnHotkey();
return true;
}
}
}
// Not yet handled, check for focus messages
if( uMsg == WM_KEYDOWN )
{
// If keyboard input is not enabled, this message should be ignored
if( !m_bKeyboardInput )
return false;
switch( wParam )
{
case VK_RIGHT:
case VK_DOWN:
if( s_pControlFocus != NULL )
{
return OnCycleFocus( true );
}
break;
case VK_LEFT:
case VK_UP:
if( s_pControlFocus != NULL )
{
return OnCycleFocus( false );
}
break;
case VK_TAB:
{
bool bShiftDown = ( ( GetKeyState( VK_SHIFT ) & 0x8000 ) != 0 );
return OnCycleFocus( !bShiftDown );
}
}
}
break;
}
// Mouse messages
case WM_MOUSEMOVE:
case WM_LBUTTONDOWN:
case WM_LBUTTONUP:
case WM_MBUTTONDOWN:
case WM_MBUTTONUP:
case WM_RBUTTONDOWN:
case WM_RBUTTONUP:
case WM_XBUTTONDOWN:
case WM_XBUTTONUP:
case WM_LBUTTONDBLCLK:
case WM_MBUTTONDBLCLK:
case WM_RBUTTONDBLCLK:
case WM_XBUTTONDBLCLK:
case WM_MOUSEWHEEL:
{
// If not accepting mouse input, return false to indicate the message should still
// be handled by the application (usually to move the camera).
if( !m_bMouseInput )
return false;
POINT mousePoint =
{
short( LOWORD( lParam ) ), short( HIWORD( lParam ) )
};
mousePoint.x -= m_x;
mousePoint.y -= m_y;
// If caption is enabled, offset the Y coordinate by the negative of its height.
if( m_bCaption )
mousePoint.y -= m_nCaptionHeight;
// If a control is in focus, it belongs to this dialog, and it's enabled, then give
// it the first chance at handling the message.
if( s_pControlFocus &&
s_pControlFocus->m_pDialog == this &&
s_pControlFocus->GetEnabled() )
{
if( s_pControlFocus->HandleMouse( uMsg, mousePoint, wParam, lParam ) )
return true;
}
// Not yet handled, see if the mouse is over any controls
CDXUTControl* pControl = GetControlAtPoint( mousePoint );
if( pControl != NULL && pControl->GetEnabled() )
{
bHandled = pControl->HandleMouse( uMsg, mousePoint, wParam, lParam );
if( bHandled )
return true;
}
else
{
// Mouse not over any controls in this dialog, if there was a control
// which had focus it just lost it
if( uMsg == WM_LBUTTONDOWN &&
s_pControlFocus &&
s_pControlFocus->m_pDialog == this )
{
s_pControlFocus->OnFocusOut();
s_pControlFocus = NULL;
}
}
// Still not handled, hand this off to the dialog. Return false to indicate the
// message should still be handled by the application (usually to move the camera).
switch( uMsg )
{
case WM_MOUSEMOVE:
OnMouseMove( mousePoint );
return false;
}
break;
}
case WM_CAPTURECHANGED:
{
// The application has lost mouse capture.
// The dialog object may not have received
// a WM_MOUSEUP when capture changed. Reset
// m_bDrag so that the dialog does not mistakenly
// think the mouse button is still held down.
if( ( HWND )lParam != hWnd )
m_bDrag = false;
}
}
return false;
}
//--------------------------------------------------------------------------------------
CDXUTControl* CDXUTDialog::GetControlAtPoint( POINT pt )
{
// Search through all child controls for the first one which
// contains the mouse point
for( int i = 0; i < m_Controls.GetSize(); i++ )
{
CDXUTControl* pControl = m_Controls.GetAt( i );
if( pControl == NULL )
{
continue;
}
// We only return the current control if it is visible
// and enabled. Because GetControlAtPoint() is used to do mouse
// hittest, it makes sense to perform this filtering.
if( pControl->ContainsPoint( pt ) && pControl->GetEnabled() && pControl->GetVisible() )
{
return pControl;
}
}
return NULL;
}
//--------------------------------------------------------------------------------------
bool CDXUTDialog::GetControlEnabled( int ID )
{
CDXUTControl* pControl = GetControl( ID );
if( pControl == NULL )
return false;
return pControl->GetEnabled();
}
//--------------------------------------------------------------------------------------
void CDXUTDialog::SetControlEnabled( int ID, bool bEnabled )
{
CDXUTControl* pControl = GetControl( ID );
if( pControl == NULL )
return;
pControl->SetEnabled( bEnabled );
}
//--------------------------------------------------------------------------------------
void CDXUTDialog::OnMouseUp( POINT pt )
{
s_pControlPressed = NULL;
m_pControlMouseOver = NULL;
}
//--------------------------------------------------------------------------------------
void CDXUTDialog::OnMouseMove( POINT pt )
{
// Figure out which control the mouse is over now
CDXUTControl* pControl = GetControlAtPoint( pt );
// If the mouse is still over the same control, nothing needs to be done
if( pControl == m_pControlMouseOver )
return;
// Handle mouse leaving the old control
if( m_pControlMouseOver )
m_pControlMouseOver->OnMouseLeave();
// Handle mouse entering the new control
m_pControlMouseOver = pControl;
if( pControl != NULL )
m_pControlMouseOver->OnMouseEnter();
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTDialog::SetDefaultElement( UINT nControlType, UINT iElement, CDXUTElement* pElement )
{
// If this Element type already exist in the list, simply update the stored Element
for( int i = 0; i < m_DefaultElements.GetSize(); i++ )
{
DXUTElementHolder* pElementHolder = m_DefaultElements.GetAt( i );
if( pElementHolder->nControlType == nControlType &&
pElementHolder->iElement == iElement )
{
pElementHolder->Element = *pElement;
return S_OK;
}
}
// Otherwise, add a new entry
DXUTElementHolder* pNewHolder;
pNewHolder = new DXUTElementHolder;
if( pNewHolder == NULL )
return E_OUTOFMEMORY;
pNewHolder->nControlType = nControlType;
pNewHolder->iElement = iElement;
pNewHolder->Element = *pElement;
HRESULT hr = m_DefaultElements.Add( pNewHolder );
if( FAILED( hr ) )
{
delete pNewHolder;
}
return hr;
}
//--------------------------------------------------------------------------------------
CDXUTElement* CDXUTDialog::GetDefaultElement( UINT nControlType, UINT iElement )
{
for( int i = 0; i < m_DefaultElements.GetSize(); i++ )
{
DXUTElementHolder* pElementHolder = m_DefaultElements.GetAt( i );
if( pElementHolder->nControlType == nControlType &&
pElementHolder->iElement == iElement )
{
return &pElementHolder->Element;
}
}
return NULL;
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTDialog::AddStatic( int ID, LPCWSTR strText, int x, int y, int width, int height, bool bIsDefault,
CDXUTStatic** ppCreated )
{
HRESULT hr = S_OK;
CDXUTStatic* pStatic = new CDXUTStatic( this );
if( ppCreated != NULL )
*ppCreated = pStatic;
if( pStatic == NULL )
return E_OUTOFMEMORY;
hr = AddControl( pStatic );
if( FAILED( hr ) )
return hr;
// Set the ID and list index
pStatic->SetID( ID );
pStatic->SetText( strText );
pStatic->SetLocation( x, y );
pStatic->SetSize( width, height );
pStatic->m_bIsDefault = bIsDefault;
return S_OK;
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTDialog::AddButton( int ID, LPCWSTR strText, int x, int y, int width, int height, UINT nHotkey,
bool bIsDefault, CDXUTButton** ppCreated )
{
HRESULT hr = S_OK;
CDXUTButton* pButton = new CDXUTButton( this );
if( ppCreated != NULL )
*ppCreated = pButton;
if( pButton == NULL )
return E_OUTOFMEMORY;
hr = AddControl( pButton );
if( FAILED( hr ) )
return hr;
// Set the ID and list index
pButton->SetID( ID );
pButton->SetText( strText );
pButton->SetLocation( x, y );
pButton->SetSize( width, height );
pButton->SetHotkey( nHotkey );
pButton->m_bIsDefault = bIsDefault;
return S_OK;
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTDialog::AddCheckBox( int ID, LPCWSTR strText, int x, int y, int width, int height, bool bChecked,
UINT nHotkey, bool bIsDefault, CDXUTCheckBox** ppCreated )
{
HRESULT hr = S_OK;
CDXUTCheckBox* pCheckBox = new CDXUTCheckBox( this );
if( ppCreated != NULL )
*ppCreated = pCheckBox;
if( pCheckBox == NULL )
return E_OUTOFMEMORY;
hr = AddControl( pCheckBox );
if( FAILED( hr ) )
return hr;
// Set the ID and list index
pCheckBox->SetID( ID );
pCheckBox->SetText( strText );
pCheckBox->SetLocation( x, y );
pCheckBox->SetSize( width, height );
pCheckBox->SetHotkey( nHotkey );
pCheckBox->m_bIsDefault = bIsDefault;
pCheckBox->SetChecked( bChecked );
return S_OK;
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTDialog::AddRadioButton( int ID, UINT nButtonGroup, LPCWSTR strText, int x, int y, int width, int height,
bool bChecked, UINT nHotkey, bool bIsDefault, CDXUTRadioButton** ppCreated )
{
HRESULT hr = S_OK;
CDXUTRadioButton* pRadioButton = new CDXUTRadioButton( this );
if( ppCreated != NULL )
*ppCreated = pRadioButton;
if( pRadioButton == NULL )
return E_OUTOFMEMORY;
hr = AddControl( pRadioButton );
if( FAILED( hr ) )
return hr;
// Set the ID and list index
pRadioButton->SetID( ID );
pRadioButton->SetText( strText );
pRadioButton->SetButtonGroup( nButtonGroup );
pRadioButton->SetLocation( x, y );
pRadioButton->SetSize( width, height );
pRadioButton->SetHotkey( nHotkey );
pRadioButton->SetChecked( bChecked );
pRadioButton->m_bIsDefault = bIsDefault;
pRadioButton->SetChecked( bChecked );
return S_OK;
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTDialog::AddComboBox( int ID, int x, int y, int width, int height, UINT nHotkey, bool bIsDefault,
CDXUTComboBox** ppCreated )
{
HRESULT hr = S_OK;
CDXUTComboBox* pComboBox = new CDXUTComboBox( this );
if( ppCreated != NULL )
*ppCreated = pComboBox;
if( pComboBox == NULL )
return E_OUTOFMEMORY;
hr = AddControl( pComboBox );
if( FAILED( hr ) )
return hr;
// Set the ID and list index
pComboBox->SetID( ID );
pComboBox->SetLocation( x, y );
pComboBox->SetSize( width, height );
pComboBox->SetHotkey( nHotkey );
pComboBox->m_bIsDefault = bIsDefault;
return S_OK;
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTDialog::AddSlider( int ID, int x, int y, int width, int height, int min, int max, int value,
bool bIsDefault, CDXUTSlider** ppCreated )
{
HRESULT hr = S_OK;
CDXUTSlider* pSlider = new CDXUTSlider( this );
if( ppCreated != NULL )
*ppCreated = pSlider;
if( pSlider == NULL )
return E_OUTOFMEMORY;
hr = AddControl( pSlider );
if( FAILED( hr ) )
return hr;
// Set the ID and list index
pSlider->SetID( ID );
pSlider->SetLocation( x, y );
pSlider->SetSize( width, height );
pSlider->m_bIsDefault = bIsDefault;
pSlider->SetRange( min, max );
pSlider->SetValue( value );
pSlider->UpdateRects();
return S_OK;
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTDialog::AddEditBox( int ID, LPCWSTR strText, int x, int y, int width, int height, bool bIsDefault,
CDXUTEditBox** ppCreated )
{
HRESULT hr = S_OK;
CDXUTEditBox* pEditBox = new CDXUTEditBox( this );
if( ppCreated != NULL )
*ppCreated = pEditBox;
if( pEditBox == NULL )
return E_OUTOFMEMORY;
hr = AddControl( pEditBox );
if( FAILED( hr ) )
return hr;
// Set the ID and position
pEditBox->SetID( ID );
pEditBox->SetLocation( x, y );
pEditBox->SetSize( width, height );
pEditBox->m_bIsDefault = bIsDefault;
if( strText )
pEditBox->SetText( strText );
return S_OK;
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTDialog::AddListBox( int ID, int x, int y, int width, int height, DWORD dwStyle, CDXUTListBox** ppCreated )
{
HRESULT hr = S_OK;
CDXUTListBox* pListBox = new CDXUTListBox( this );
if( ppCreated != NULL )
*ppCreated = pListBox;
if( pListBox == NULL )
return E_OUTOFMEMORY;
hr = AddControl( pListBox );
if( FAILED( hr ) )
return hr;
// Set the ID and position
pListBox->SetID( ID );
pListBox->SetLocation( x, y );
pListBox->SetSize( width, height );
pListBox->SetStyle( dwStyle );
return S_OK;
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTDialog::InitControl( CDXUTControl* pControl )
{
HRESULT hr;
if( pControl == NULL )
return E_INVALIDARG;
pControl->m_Index = m_Controls.GetSize();
// Look for a default Element entries
for( int i = 0; i < m_DefaultElements.GetSize(); i++ )
{
DXUTElementHolder* pElementHolder = m_DefaultElements.GetAt( i );
if( pElementHolder->nControlType == pControl->GetType() )
pControl->SetElement( pElementHolder->iElement, &pElementHolder->Element );
}
V_RETURN( pControl->OnInit() );
return S_OK;
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTDialog::AddControl( CDXUTControl* pControl )
{
HRESULT hr = S_OK;
hr = InitControl( pControl );
if( FAILED( hr ) )
return DXTRACE_ERR( L"CDXUTDialog::InitControl", hr );
// Add to the list
hr = m_Controls.Add( pControl );
if( FAILED( hr ) )
{
return DXTRACE_ERR( L"CGrowableArray::Add", hr );
}
return S_OK;
}
//--------------------------------------------------------------------------------------
CDXUTControl* CDXUTDialog::GetControl( int ID )
{
// Try to find the control with the given ID
for( int i = 0; i < m_Controls.GetSize(); i++ )
{
CDXUTControl* pControl = m_Controls.GetAt( i );
if( pControl->GetID() == ID )
{
return pControl;
}
}
// Not found
return NULL;
}
//--------------------------------------------------------------------------------------
CDXUTControl* CDXUTDialog::GetControl( int ID, UINT nControlType )
{
// Try to find the control with the given ID
for( int i = 0; i < m_Controls.GetSize(); i++ )
{
CDXUTControl* pControl = m_Controls.GetAt( i );
if( pControl->GetID() == ID && pControl->GetType() == nControlType )
{
return pControl;
}
}
// Not found
return NULL;
}
//--------------------------------------------------------------------------------------
CDXUTControl* CDXUTDialog::GetNextControl( CDXUTControl* pControl )
{
int index = pControl->m_Index + 1;
CDXUTDialog* pDialog = pControl->m_pDialog;
// Cycle through dialogs in the loop to find the next control. Note
// that if only one control exists in all looped dialogs it will
// be the returned 'next' control.
while( index >= ( int )pDialog->m_Controls.GetSize() )
{
pDialog = pDialog->m_pNextDialog;
index = 0;
}
return pDialog->m_Controls.GetAt( index );
}
//--------------------------------------------------------------------------------------
CDXUTControl* CDXUTDialog::GetPrevControl( CDXUTControl* pControl )
{
int index = pControl->m_Index - 1;
CDXUTDialog* pDialog = pControl->m_pDialog;
// Cycle through dialogs in the loop to find the next control. Note
// that if only one control exists in all looped dialogs it will
// be the returned 'previous' control.
while( index < 0 )
{
pDialog = pDialog->m_pPrevDialog;
if( pDialog == NULL )
pDialog = pControl->m_pDialog;
index = pDialog->m_Controls.GetSize() - 1;
}
return pDialog->m_Controls.GetAt( index );
}
//--------------------------------------------------------------------------------------
void CDXUTDialog::ClearRadioButtonGroup( UINT nButtonGroup )
{
// Find all radio buttons with the given group number
for( int i = 0; i < m_Controls.GetSize(); i++ )
{
CDXUTControl* pControl = m_Controls.GetAt( i );
if( pControl->GetType() == DXUT_CONTROL_RADIOBUTTON )
{
CDXUTRadioButton* pRadioButton = ( CDXUTRadioButton* )pControl;
if( pRadioButton->GetButtonGroup() == nButtonGroup )
pRadioButton->SetChecked( false, false );
}
}
}
//--------------------------------------------------------------------------------------
void CDXUTDialog::ClearComboBox( int ID )
{
CDXUTComboBox* pComboBox = GetComboBox( ID );
if( pComboBox == NULL )
return;
pComboBox->RemoveAllItems();
}
//--------------------------------------------------------------------------------------
void CDXUTDialog::RequestFocus( CDXUTControl* pControl )
{
if( s_pControlFocus == pControl )
return;
if( !pControl->CanHaveFocus() )
return;
if( s_pControlFocus )
s_pControlFocus->OnFocusOut();
pControl->OnFocusIn();
s_pControlFocus = pControl;
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTDialog::DrawRect( RECT* pRect, D3DCOLOR color )
{
if( m_pManager->GetD3D9Device() )
return DrawRect9( pRect, color );
return E_FAIL;
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTDialog::DrawRect9( RECT* pRect, D3DCOLOR color )
{
RECT rcScreen = *pRect;
OffsetRect( &rcScreen, m_x, m_y );
// If caption is enabled, offset the Y position by its height.
if( m_bCaption )
OffsetRect( &rcScreen, 0, m_nCaptionHeight );
DXUT_SCREEN_VERTEX vertices[4] =
{
( float )rcScreen.left - 0.5f, ( float )rcScreen.top - 0.5f, 0.5f, 1.0f, color, 0, 0,
( float )rcScreen.right - 0.5f, ( float )rcScreen.top - 0.5f, 0.5f, 1.0f, color, 0, 0,
( float )rcScreen.right - 0.5f, ( float )rcScreen.bottom - 0.5f, 0.5f, 1.0f, color, 0, 0,
( float )rcScreen.left - 0.5f, ( float )rcScreen.bottom - 0.5f, 0.5f, 1.0f, color, 0, 0,
};
IDirect3DDevice9* pd3dDevice = m_pManager->GetD3D9Device();
// Since we're doing our own drawing here we need to flush the sprites
m_pManager->m_pSprite->Flush();
IDirect3DVertexDeclaration9* pDecl = NULL;
pd3dDevice->GetVertexDeclaration( &pDecl ); // Preserve the sprite's current vertex decl
pd3dDevice->SetFVF( DXUT_SCREEN_VERTEX::FVF );
pd3dDevice->SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG2 );
pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG2 );
pd3dDevice->DrawPrimitiveUP( D3DPT_TRIANGLEFAN, 2, vertices, sizeof( DXUT_SCREEN_VERTEX ) );
pd3dDevice->SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE );
pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_MODULATE );
// Restore the vertex decl
pd3dDevice->SetVertexDeclaration( pDecl );
pDecl->Release();
return S_OK;
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTDialog::DrawPolyLine( POINT* apPoints, UINT nNumPoints, D3DCOLOR color )
{
DXUT_SCREEN_VERTEX* vertices = new DXUT_SCREEN_VERTEX[ nNumPoints ];
if( vertices == NULL )
return E_OUTOFMEMORY;
DXUT_SCREEN_VERTEX* pVertex = vertices;
POINT* pt = apPoints;
for( UINT i = 0; i < nNumPoints; i++ )
{
pVertex->x = m_x + ( float )pt->x;
pVertex->y = m_y + ( float )pt->y;
pVertex->z = 0.5f;
pVertex->h = 1.0f;
pVertex->color = color;
pVertex->tu = 0.0f;
pVertex->tv = 0.0f;
pVertex++;
pt++;
}
IDirect3DDevice9* pd3dDevice = m_pManager->GetD3D9Device();
// Since we're doing our own drawing here we need to flush the sprites
m_pManager->m_pSprite->Flush();
IDirect3DVertexDeclaration9* pDecl = NULL;
pd3dDevice->GetVertexDeclaration( &pDecl ); // Preserve the sprite's current vertex decl
pd3dDevice->SetFVF( DXUT_SCREEN_VERTEX::FVF );
pd3dDevice->SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG2 );
pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG2 );
pd3dDevice->DrawPrimitiveUP( D3DPT_LINESTRIP, nNumPoints - 1, vertices, sizeof( DXUT_SCREEN_VERTEX ) );
pd3dDevice->SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE );
pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_MODULATE );
// Restore the vertex decl
pd3dDevice->SetVertexDeclaration( pDecl );
pDecl->Release();
SAFE_DELETE_ARRAY( vertices );
return S_OK;
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTDialog::DrawSprite( CDXUTElement* pElement, RECT* prcDest, float fDepth )
{
if( m_pManager->GetD3D9Device() )
return DrawSprite9( pElement, prcDest );
else
return DrawSprite11( pElement, prcDest, fDepth );
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTDialog::DrawSprite9( CDXUTElement* pElement, RECT* prcDest )
{
// No need to draw fully transparent layers
if( pElement->TextureColor.Current.a == 0 )
return S_OK;
RECT rcTexture = pElement->rcTexture;
RECT rcScreen = *prcDest;
OffsetRect( &rcScreen, m_x, m_y );
// If caption is enabled, offset the Y position by its height.
if( m_bCaption )
OffsetRect( &rcScreen, 0, m_nCaptionHeight );
DXUTTextureNode* pTextureNode = GetTexture( pElement->iTexture );
if( pTextureNode == NULL )
return E_FAIL;
float fScaleX = ( float )RectWidth( rcScreen ) / RectWidth( rcTexture );
float fScaleY = ( float )RectHeight( rcScreen ) / RectHeight( rcTexture );
D3DXMATRIXA16 matTransform;
D3DXMatrixScaling( &matTransform, fScaleX, fScaleY, 1.0f );
m_pManager->m_pSprite->SetTransform( &matTransform );
D3DXVECTOR3 vPos( ( float )rcScreen.left, ( float )rcScreen.top, 0.0f );
vPos.x /= fScaleX;
vPos.y /= fScaleY;
return m_pManager->m_pSprite->Draw( pTextureNode->pTexture9, &rcTexture, NULL, &vPos,
pElement->TextureColor.Current );
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTDialog::DrawSprite11( CDXUTElement* pElement, RECT* prcDest, float fDepth )
{
// No need to draw fully transparent layers
if( pElement->TextureColor.Current.a == 0 )
return S_OK;
RECT rcTexture = pElement->rcTexture;
RECT rcScreen = *prcDest;
OffsetRect( &rcScreen, m_x, m_y );
// If caption is enabled, offset the Y position by its height.
if( m_bCaption )
OffsetRect( &rcScreen, 0, m_nCaptionHeight );
DXUTTextureNode* pTextureNode = GetTexture( pElement->iTexture );
if( pTextureNode == NULL )
return E_FAIL;
float fBBWidth = ( float )m_pManager->m_nBackBufferWidth;
float fBBHeight = ( float )m_pManager->m_nBackBufferHeight;
float fTexWidth = ( float )pTextureNode->dwWidth;
float fTexHeight = ( float )pTextureNode->dwHeight;
float fRectLeft = rcScreen.left / fBBWidth;
float fRectTop = 1.0f - rcScreen.top / fBBHeight;
float fRectRight = rcScreen.right / fBBWidth;
float fRectBottom = 1.0f - rcScreen.bottom / fBBHeight;
fRectLeft = fRectLeft * 2.0f - 1.0f;
fRectTop = fRectTop * 2.0f - 1.0f;
fRectRight = fRectRight * 2.0f - 1.0f;
fRectBottom = fRectBottom * 2.0f - 1.0f;
float fTexLeft = rcTexture.left / fTexWidth;
float fTexTop = rcTexture.top / fTexHeight;
float fTexRight = rcTexture.right / fTexWidth;
float fTexBottom = rcTexture.bottom / fTexHeight;
// Add 6 sprite vertices
DXUTSpriteVertex SpriteVertex;
// tri1
SpriteVertex.vPos = D3DXVECTOR3( fRectLeft, fRectTop, fDepth );
SpriteVertex.vTex = D3DXVECTOR2( fTexLeft, fTexTop );
SpriteVertex.vColor = pElement->TextureColor.Current;
m_pManager->m_SpriteVertices.Add( SpriteVertex );
SpriteVertex.vPos = D3DXVECTOR3( fRectRight, fRectTop, fDepth );
SpriteVertex.vTex = D3DXVECTOR2( fTexRight, fTexTop );
SpriteVertex.vColor = pElement->TextureColor.Current;
m_pManager->m_SpriteVertices.Add( SpriteVertex );
SpriteVertex.vPos = D3DXVECTOR3( fRectLeft, fRectBottom, fDepth );
SpriteVertex.vTex = D3DXVECTOR2( fTexLeft, fTexBottom );
SpriteVertex.vColor = pElement->TextureColor.Current;
m_pManager->m_SpriteVertices.Add( SpriteVertex );
// tri2
SpriteVertex.vPos = D3DXVECTOR3( fRectRight, fRectTop, fDepth );
SpriteVertex.vTex = D3DXVECTOR2( fTexRight, fTexTop );
SpriteVertex.vColor = pElement->TextureColor.Current;
m_pManager->m_SpriteVertices.Add( SpriteVertex );
SpriteVertex.vPos = D3DXVECTOR3( fRectRight, fRectBottom, fDepth );
SpriteVertex.vTex = D3DXVECTOR2( fTexRight, fTexBottom );
SpriteVertex.vColor = pElement->TextureColor.Current;
m_pManager->m_SpriteVertices.Add( SpriteVertex );
SpriteVertex.vPos = D3DXVECTOR3( fRectLeft, fRectBottom, fDepth );
SpriteVertex.vTex = D3DXVECTOR2( fTexLeft, fTexBottom );
SpriteVertex.vColor = pElement->TextureColor.Current;
m_pManager->m_SpriteVertices.Add( SpriteVertex );
// TODO: Why are we drawing the sprite every time? This is very inefficient, but the sprite workaround doesn't have support for sorting now, so we have to
// draw a sprite every time to keep the order correct between sprites and text.
m_pManager->EndSprites11( DXUTGetD3D11Device(), DXUTGetD3D11DeviceContext() );
return S_OK;
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTDialog::CalcTextRect( LPCWSTR strText, CDXUTElement* pElement, RECT* prcDest, int nCount )
{
HRESULT hr = S_OK;
DXUTFontNode* pFontNode = GetFont( pElement->iFont );
if( pFontNode == NULL )
return E_FAIL;
DWORD dwTextFormat = pElement->dwTextFormat | DT_CALCRECT;
// Since we are only computing the rectangle, we don't need a sprite.
if( pFontNode->pFont9 )
{
hr = pFontNode->pFont9->DrawText( NULL, strText, nCount, prcDest, dwTextFormat, pElement->FontColor.Current );
if( FAILED( hr ) )
return hr;
}
return S_OK;
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTDialog::DrawText( LPCWSTR strText, CDXUTElement* pElement, RECT* prcDest, bool bShadow, int nCount, bool bCenter )
{
if( m_pManager->GetD3D9Device() )
return DrawText9( strText, pElement, prcDest, bShadow, nCount );
else
return DrawText11( m_pManager->GetD3D11Device(), m_pManager->GetD3D11DeviceContext(), strText, pElement, prcDest, bShadow, nCount, bCenter );
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTDialog::DrawText9( LPCWSTR strText, CDXUTElement* pElement, RECT* prcDest, bool bShadow, int nCount )
{
HRESULT hr = S_OK;
// No need to draw fully transparent layers
if( pElement->FontColor.Current.a == 0 )
return S_OK;
RECT rcScreen = *prcDest;
OffsetRect( &rcScreen, m_x, m_y );
// If caption is enabled, offset the Y position by its height.
if( m_bCaption )
OffsetRect( &rcScreen, 0, m_nCaptionHeight );
D3DXMATRIX matTransform;
D3DXMatrixIdentity( &matTransform );
m_pManager->m_pSprite->SetTransform( &matTransform );
DXUTFontNode* pFontNode = GetFont( pElement->iFont );
if( bShadow )
{
RECT rcShadow = rcScreen;
OffsetRect( &rcShadow, 1, 1 );
hr = pFontNode->pFont9->DrawText( m_pManager->m_pSprite, strText, nCount, &rcShadow, pElement->dwTextFormat,
D3DCOLOR_ARGB( DWORD( pElement->FontColor.Current.a * 255 ), 0, 0, 0 ) );
if( FAILED( hr ) )
return hr;
}
hr = pFontNode->pFont9->DrawText( m_pManager->m_pSprite, strText, nCount, &rcScreen, pElement->dwTextFormat,
pElement->FontColor.Current );
if( FAILED( hr ) )
return hr;
return S_OK;
}
ID3D11Buffer* g_pFontBuffer11 = NULL;
UINT g_FontBufferBytes11 = 0;
CGrowableArray<DXUTSpriteVertex> g_FontVertices;
ID3D11ShaderResourceView* g_pFont11 = NULL;
ID3D11InputLayout* g_pInputLayout11 = NULL;
HRESULT InitFont11( ID3D11Device* pd3d11Device, ID3D11InputLayout* pInputLayout )
{
HRESULT hr = S_OK;
WCHAR str[MAX_PATH];
V_RETURN( DXUTFindDXSDKMediaFileCch( str, MAX_PATH, L"UI\\Font.dds" ) );
if (pd3d11Device->GetFeatureLevel() < D3D_FEATURE_LEVEL_10_0 ) {
D3DX11_IMAGE_INFO dii;
D3DX11GetImageInfoFromFile( str, NULL, &dii, NULL );
D3DX11_IMAGE_LOAD_INFO dili;
dili.BindFlags = D3DX11_DEFAULT;
dili.CpuAccessFlags = D3DX11_DEFAULT;
dili.Depth = D3DX11_DEFAULT;
dili.Filter = D3DX11_DEFAULT;
dili.FirstMipLevel = 0;
dili.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
dili.Height = D3DX11_DEFAULT;
dili.MipFilter = D3DX11_DEFAULT;
dili.MipLevels = 1;
dili.MiscFlags = D3DX11_DEFAULT;
dili.pSrcInfo = &dii;
dili.Usage = D3D11_USAGE_DEFAULT ;
dili.Width = D3DX11_DEFAULT;
V_RETURN( D3DX11CreateShaderResourceViewFromFile( pd3d11Device, str, &dili, NULL, &g_pFont11, &hr) );
} else {
V_RETURN( D3DX11CreateShaderResourceViewFromFile( pd3d11Device, str, NULL, NULL, &g_pFont11, &hr) );
}
g_pInputLayout11 = pInputLayout;
return hr;
}
void EndFont11()
{
SAFE_RELEASE( g_pFontBuffer11 );
g_FontBufferBytes11 = 0;
SAFE_RELEASE( g_pFont11 );
}
void BeginText11()
{
g_FontVertices.Reset();
}
void DrawText11DXUT( ID3D11Device* pd3dDevice, ID3D11DeviceContext* pd3d11DeviceContext,
LPCWSTR strText, RECT rcScreen, D3DXCOLOR vFontColor,
float fBBWidth, float fBBHeight, bool bCenter )
{
float fCharTexSizeX = 0.010526315f;
//float fGlyphSizeX = 14.0f / fBBWidth;
//float fGlyphSizeY = 32.0f / fBBHeight;
float fGlyphSizeX = 15.0f / fBBWidth;
float fGlyphSizeY = 42.0f / fBBHeight;
float fRectLeft = rcScreen.left / fBBWidth;
float fRectTop = 1.0f - rcScreen.top / fBBHeight;
fRectLeft = fRectLeft * 2.0f - 1.0f;
fRectTop = fRectTop * 2.0f - 1.0f;
int NumChars = (int)wcslen( strText );
if (bCenter) {
float fRectRight = rcScreen.right / fBBWidth;
fRectRight = fRectRight * 2.0f - 1.0f;
float fRectBottom = 1.0f - rcScreen.bottom / fBBHeight;
fRectBottom = fRectBottom * 2.0f - 1.0f;
float fcenterx = ((fRectRight - fRectLeft) - (float)NumChars*fGlyphSizeX) *0.5f;
float fcentery = ((fRectTop - fRectBottom) - (float)1*fGlyphSizeY) *0.5f;
fRectLeft += fcenterx ;
fRectTop -= fcentery;
}
float fOriginalLeft = fRectLeft;
float fTexTop = 0.0f;
float fTexBottom = 1.0f;
float fDepth = 0.5f;
for( int i=0; i<NumChars; i++ )
{
if( strText[i] == '\n' )
{
fRectLeft = fOriginalLeft;
fRectTop -= fGlyphSizeY;
continue;
}
else if( strText[i] < 32 || strText[i] > 126 )
{
continue;
}
// Add 6 sprite vertices
DXUTSpriteVertex SpriteVertex;
float fRectRight = fRectLeft + fGlyphSizeX;
float fRectBottom = fRectTop - fGlyphSizeY;
float fTexLeft = ( strText[i] - 32 ) * fCharTexSizeX;
float fTexRight = fTexLeft + fCharTexSizeX;
// tri1
SpriteVertex.vPos = D3DXVECTOR3( fRectLeft, fRectTop, fDepth );
SpriteVertex.vTex = D3DXVECTOR2( fTexLeft, fTexTop );
SpriteVertex.vColor = vFontColor;
g_FontVertices.Add( SpriteVertex );
SpriteVertex.vPos = D3DXVECTOR3( fRectRight, fRectTop, fDepth );
SpriteVertex.vTex = D3DXVECTOR2( fTexRight, fTexTop );
SpriteVertex.vColor = vFontColor;
g_FontVertices.Add( SpriteVertex );
SpriteVertex.vPos = D3DXVECTOR3( fRectLeft, fRectBottom, fDepth );
SpriteVertex.vTex = D3DXVECTOR2( fTexLeft, fTexBottom );
SpriteVertex.vColor = vFontColor;
g_FontVertices.Add( SpriteVertex );
// tri2
SpriteVertex.vPos = D3DXVECTOR3( fRectRight, fRectTop, fDepth );
SpriteVertex.vTex = D3DXVECTOR2( fTexRight, fTexTop );
SpriteVertex.vColor = vFontColor;
g_FontVertices.Add( SpriteVertex );
SpriteVertex.vPos = D3DXVECTOR3( fRectRight, fRectBottom, fDepth );
SpriteVertex.vTex = D3DXVECTOR2( fTexRight, fTexBottom );
SpriteVertex.vColor = vFontColor;
g_FontVertices.Add( SpriteVertex );
SpriteVertex.vPos = D3DXVECTOR3( fRectLeft, fRectBottom, fDepth );
SpriteVertex.vTex = D3DXVECTOR2( fTexLeft, fTexBottom );
SpriteVertex.vColor = vFontColor;
g_FontVertices.Add( SpriteVertex );
fRectLeft += fGlyphSizeX;
}
// TODO: We have to end text after every line so that rendering order between sprites and fonts is preserved
EndText11( pd3dDevice, pd3d11DeviceContext );
}
void EndText11( ID3D11Device* pd3dDevice, ID3D11DeviceContext* pd3d11DeviceContext )
{
// ensure our buffer size can hold our sprites
UINT FontDataBytes = g_FontVertices.GetSize() * sizeof( DXUTSpriteVertex );
if( g_FontBufferBytes11 < FontDataBytes )
{
SAFE_RELEASE( g_pFontBuffer11 );
g_FontBufferBytes11 = FontDataBytes;
D3D11_BUFFER_DESC BufferDesc;
BufferDesc.ByteWidth = g_FontBufferBytes11;
BufferDesc.Usage = D3D11_USAGE_DYNAMIC;
BufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
BufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
BufferDesc.MiscFlags = 0;
pd3dDevice->CreateBuffer( &BufferDesc, NULL, &g_pFontBuffer11 );
}
// Copy the sprites over
D3D11_BOX destRegion;
destRegion.left = 0;
destRegion.right = FontDataBytes;
destRegion.top = 0;
destRegion.bottom = 1;
destRegion.front = 0;
destRegion.back = 1;
D3D11_MAPPED_SUBRESOURCE MappedResource;
if ( S_OK == pd3d11DeviceContext->Map( g_pFontBuffer11, 0, D3D11_MAP_WRITE_DISCARD, 0, &MappedResource ) ) {
CopyMemory( MappedResource.pData, (void*)g_FontVertices.GetData(), FontDataBytes );
pd3d11DeviceContext->Unmap(g_pFontBuffer11, 0);
}
ID3D11ShaderResourceView* pOldTexture = NULL;
pd3d11DeviceContext->PSGetShaderResources( 0, 1, &pOldTexture );
pd3d11DeviceContext->PSSetShaderResources( 0, 1, &g_pFont11 );
// Draw
UINT Stride = sizeof( DXUTSpriteVertex );
UINT Offset = 0;
pd3d11DeviceContext->IASetVertexBuffers( 0, 1, &g_pFontBuffer11, &Stride, &Offset );
pd3d11DeviceContext->IASetInputLayout( g_pInputLayout11 );
pd3d11DeviceContext->IASetPrimitiveTopology( D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST );
pd3d11DeviceContext->Draw( g_FontVertices.GetSize(), 0 );
pd3d11DeviceContext->PSSetShaderResources( 0, 1, &pOldTexture );
SAFE_RELEASE( pOldTexture );
g_FontVertices.Reset();
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTDialog::DrawText11( ID3D11Device* pd3dDevice, ID3D11DeviceContext* pd3d11DeviceContext,
LPCWSTR strText, CDXUTElement* pElement, RECT* prcDest, bool bShadow, int nCount, bool bCenter )
{
//HRESULT hr = S_OK;
// No need to draw fully transparent layers
if( pElement->FontColor.Current.a == 0 )
return S_OK;
RECT rcScreen = *prcDest;
OffsetRect( &rcScreen, m_x, m_y);
// If caption is enabled, offset the Y position by its height.
if( m_bCaption )
OffsetRect( &rcScreen, 0, m_nCaptionHeight );
float fBBWidth = ( float )m_pManager->m_nBackBufferWidth;
float fBBHeight = ( float )m_pManager->m_nBackBufferHeight;
if( bShadow )
{
RECT rcShadow = rcScreen;
OffsetRect( &rcShadow, 1, 1 );
D3DXCOLOR vShadowColor( 0,0,0, 1.0f );
DrawText11DXUT( pd3dDevice, pd3d11DeviceContext,
strText, rcShadow, vShadowColor,
fBBWidth, fBBHeight, bCenter );
}
D3DXCOLOR vFontColor( pElement->FontColor.Current.r, pElement->FontColor.Current.g, pElement->FontColor.Current.b, 1.0f );
DrawText11DXUT( pd3dDevice, pd3d11DeviceContext,
strText, rcScreen, vFontColor,
fBBWidth, fBBHeight, bCenter );
return S_OK;
}
//--------------------------------------------------------------------------------------
void CDXUTDialog::SetBackgroundColors( D3DCOLOR colorTopLeft, D3DCOLOR colorTopRight, D3DCOLOR colorBottomLeft,
D3DCOLOR colorBottomRight )
{
m_colorTopLeft = colorTopLeft;
m_colorTopRight = colorTopRight;
m_colorBottomLeft = colorBottomLeft;
m_colorBottomRight = colorBottomRight;
}
//--------------------------------------------------------------------------------------
void CDXUTDialog::SetNextDialog( CDXUTDialog* pNextDialog )
{
if( pNextDialog == NULL )
pNextDialog = this;
m_pNextDialog = pNextDialog;
if( pNextDialog )
m_pNextDialog->m_pPrevDialog = this;
}
//--------------------------------------------------------------------------------------
void CDXUTDialog::ClearFocus()
{
if( s_pControlFocus )
{
s_pControlFocus->OnFocusOut();
s_pControlFocus = NULL;
}
ReleaseCapture();
}
//--------------------------------------------------------------------------------------
void CDXUTDialog::FocusDefaultControl()
{
// Check for default control in this dialog
for( int i = 0; i < m_Controls.GetSize(); i++ )
{
CDXUTControl* pControl = m_Controls.GetAt( i );
if( pControl->m_bIsDefault )
{
// Remove focus from the current control
ClearFocus();
// Give focus to the default control
s_pControlFocus = pControl;
s_pControlFocus->OnFocusIn();
return;
}
}
}
//--------------------------------------------------------------------------------------
bool CDXUTDialog::OnCycleFocus( bool bForward )
{
CDXUTControl* pControl = NULL;
CDXUTDialog* pDialog = NULL; // pDialog and pLastDialog are used to track wrapping of
CDXUTDialog* pLastDialog; // focus from first control to last or vice versa.
if( s_pControlFocus == NULL )
{
// If s_pControlFocus is NULL, we focus the first control of first dialog in
// the case that bForward is true, and focus the last control of last dialog when
// bForward is false.
//
if( bForward )
{
// Search for the first control from the start of the dialog
// array.
for( int d = 0; d < m_pManager->m_Dialogs.GetSize(); ++d )
{
pDialog = pLastDialog = m_pManager->m_Dialogs.GetAt( d );
if( pDialog && pDialog->m_Controls.GetSize() > 0 )
{
pControl = pDialog->m_Controls.GetAt( 0 );
break;
}
}
if( !pDialog || !pControl )
{
// No dialog has been registered yet or no controls have been
// added to the dialogs. Cannot proceed.
return true;
}
}
else
{
// Search for the first control from the end of the dialog
// array.
for( int d = m_pManager->m_Dialogs.GetSize() - 1; d >= 0; --d )
{
pDialog = pLastDialog = m_pManager->m_Dialogs.GetAt( d );
if( pDialog && pDialog->m_Controls.GetSize() > 0 )
{
pControl = pDialog->m_Controls.GetAt( pDialog->m_Controls.GetSize() - 1 );
break;
}
}
if( !pDialog || !pControl )
{
// No dialog has been registered yet or no controls have been
// added to the dialogs. Cannot proceed.
return true;
}
}
}
else if( s_pControlFocus->m_pDialog != this )
{
// If a control belonging to another dialog has focus, let that other
// dialog handle this event by returning false.
//
return false;
}
else
{
// Focused control belongs to this dialog. Cycle to the
// next/previous control.
pLastDialog = s_pControlFocus->m_pDialog;
pControl = ( bForward ) ? GetNextControl( s_pControlFocus ) : GetPrevControl( s_pControlFocus );
pDialog = pControl->m_pDialog;
}
for( int i = 0; i < 0xffff; i++ )
{
// If we just wrapped from last control to first or vice versa,
// set the focused control to NULL. This state, where no control
// has focus, allows the camera to work.
int nLastDialogIndex = m_pManager->m_Dialogs.IndexOf( pLastDialog );
int nDialogIndex = m_pManager->m_Dialogs.IndexOf( pDialog );
if( ( !bForward && nLastDialogIndex < nDialogIndex ) ||
( bForward && nDialogIndex < nLastDialogIndex ) )
{
if( s_pControlFocus )
s_pControlFocus->OnFocusOut();
s_pControlFocus = NULL;
return true;
}
// If we've gone in a full circle then focus doesn't change
if( pControl == s_pControlFocus )
return true;
// If the dialog accepts keybord input and the control can have focus then
// move focus
if( pControl->m_pDialog->m_bKeyboardInput && pControl->CanHaveFocus() )
{
if( s_pControlFocus )
s_pControlFocus->OnFocusOut();
s_pControlFocus = pControl;
s_pControlFocus->OnFocusIn();
return true;
}
pLastDialog = pDialog;
pControl = ( bForward ) ? GetNextControl( pControl ) : GetPrevControl( pControl );
pDialog = pControl->m_pDialog;
}
// If we reached this point, the chain of dialogs didn't form a complete loop
DXTRACE_ERR( L"CDXUTDialog: Multiple dialogs are improperly chained together", E_FAIL );
return false;
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTDialogResourceManager::CreateFont9( UINT iFont )
{
HRESULT hr = S_OK;
DXUTFontNode* pFontNode = m_FontCache.GetAt( iFont );
SAFE_RELEASE( pFontNode->pFont9 );
V_RETURN( D3DXCreateFont( m_pd3d9Device, pFontNode->nHeight, 0, pFontNode->nWeight, 1, FALSE, DEFAULT_CHARSET,
OUT_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE,
pFontNode->strFace, &pFontNode->pFont9 ) );
return S_OK;
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTDialogResourceManager::CreateFont11( UINT iFont )
{
return S_OK;
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTDialogResourceManager::CreateTexture9( UINT iTexture )
{
HRESULT hr = S_OK;
DXUTTextureNode* pTextureNode = m_TextureCache.GetAt( iTexture );
D3DXIMAGE_INFO info;
if( !pTextureNode->bFileSource )
{
if( pTextureNode->nResourceID == 0xFFFF && pTextureNode->hResourceModule == ( HMODULE )0xFFFF )
{
hr = DXUTCreateGUITextureFromInternalArray9( m_pd3d9Device, &pTextureNode->pTexture9, &info );
if( FAILED( hr ) )
return DXTRACE_ERR( L"D3DXCreateTextureFromFileInMemoryEx", hr );
}
else
{
LPCWSTR pID = pTextureNode->nResourceID ? ( LPCWSTR )( size_t )pTextureNode->nResourceID :
pTextureNode->strFilename;
// Create texture from resource
hr = D3DXCreateTextureFromResourceEx( m_pd3d9Device, pTextureNode->hResourceModule, pID, D3DX_DEFAULT,
D3DX_DEFAULT,
1, 0, D3DFMT_UNKNOWN, D3DPOOL_MANAGED,
D3DX_DEFAULT, D3DX_DEFAULT, 0,
&info, NULL, &pTextureNode->pTexture9 );
if( FAILED( hr ) )
return DXTRACE_ERR( L"D3DXCreateTextureFromResourceEx", hr );
}
}
else
{
// Make sure there's a texture to create
if( pTextureNode->strFilename[0] == 0 )
return S_OK;
// Create texture from file
hr = D3DXCreateTextureFromFileEx( m_pd3d9Device, pTextureNode->strFilename, D3DX_DEFAULT, D3DX_DEFAULT,
1, 0, D3DFMT_UNKNOWN, D3DPOOL_MANAGED,
D3DX_DEFAULT, D3DX_DEFAULT, 0,
&info, NULL, &pTextureNode->pTexture9 );
if( FAILED( hr ) )
{
return DXTRACE_ERR( L"D3DXCreateTextureFromFileEx", hr );
}
}
// Store dimensions
pTextureNode->dwWidth = info.Width;
pTextureNode->dwHeight = info.Height;
return S_OK;
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTDialogResourceManager::CreateTexture11( UINT iTexture )
{
HRESULT hr = S_OK;
DXUTTextureNode* pTextureNode = m_TextureCache.GetAt( iTexture );
if( !pTextureNode->bFileSource )
{
if( pTextureNode->nResourceID == 0xFFFF && pTextureNode->hResourceModule == ( HMODULE )0xFFFF )
{
hr = DXUTCreateGUITextureFromInternalArray11( m_pd3d11Device, &pTextureNode->pTexture11, NULL );
if( FAILED( hr ) )
return DXTRACE_ERR( L"D3DX10CreateResourceFromFileInMemory", hr );
}
//else
//{
// LPCWSTR pID = pTextureNode->nResourceID ? ( LPCWSTR )( size_t )pTextureNode->nResourceID :
// pTextureNode->strFilename;
// D3DX10_IMAGE_INFO SrcInfo;
// D3DX10GetImageInfoFromResource( NULL, pID, NULL, &SrcInfo, NULL );
// // Create texture from resource
// ID3D10Resource* pRes;
// D3DX10_IMAGE_LOAD_INFO loadInfo;
// loadInfo.Width = D3DX10_DEFAULT;
// loadInfo.Height = D3DX10_DEFAULT;
// loadInfo.Depth = D3DX10_DEFAULT;
// loadInfo.FirstMipLevel = 0;
// loadInfo.MipLevels = 1;
// loadInfo.Usage = D3D10_USAGE_DEFAULT;
// loadInfo.BindFlags = D3D10_BIND_SHADER_RESOURCE;
// loadInfo.CpuAccessFlags = 0;
// loadInfo.MiscFlags = 0;
// loadInfo.Format = MAKE_TYPELESS( SrcInfo.Format );
// loadInfo.Filter = D3DX10_FILTER_NONE;
// loadInfo.MipFilter = D3DX10_FILTER_NONE;
// loadInfo.pSrcInfo = &SrcInfo;
// hr = D3DX10CreateTextureFromResource( m_pd3d10Device, pTextureNode->hResourceModule, pID, &loadInfo,
// NULL, &pRes, NULL );
// if( FAILED( hr ) )
// return DXTRACE_ERR( L"D3DX10CreateResourceFromResource", hr );
// hr = pRes->QueryInterface( __uuidof( ID3D10Texture2D ), ( LPVOID* )&pTextureNode->pTexture10 );
// SAFE_RELEASE( pRes );
// if( FAILED( hr ) )
// return hr;
//}
}
else
{
//
//// Make sure there's a texture to create
//if( pTextureNode->strFilename[0] == 0 )
// return S_OK;
//D3DX10_IMAGE_INFO SrcInfo;
//D3DX10GetImageInfoFromFile( pTextureNode->strFilename, NULL, &SrcInfo, NULL );
//// Create texture from file
//ID3D10Resource* pRes;
//D3DX10_IMAGE_LOAD_INFO loadInfo;
//loadInfo.Width = D3DX10_DEFAULT;
//loadInfo.Height = D3DX10_DEFAULT;
//loadInfo.Depth = D3DX10_DEFAULT;
//loadInfo.FirstMipLevel = 0;
//loadInfo.MipLevels = 1;
//loadInfo.Usage = D3D10_USAGE_DEFAULT;
//loadInfo.BindFlags = D3D10_BIND_SHADER_RESOURCE;
//loadInfo.CpuAccessFlags = 0;
//loadInfo.MiscFlags = 0;
//loadInfo.Format = MAKE_TYPELESS( SrcInfo.Format );
//loadInfo.Filter = D3DX10_FILTER_NONE;
//loadInfo.MipFilter = D3DX10_FILTER_NONE;
//loadInfo.pSrcInfo = &SrcInfo;
//hr = D3DX10CreateTextureFromFile( m_pd3d10Device, pTextureNode->strFilename, &loadInfo, NULL, &pRes, NULL );
//if( FAILED( hr ) )
//{
// return DXTRACE_ERR( L"D3DX10CreateResourceFromFileEx", hr );
//}
//hr = pRes->QueryInterface( __uuidof( ID3D10Texture2D ), ( LPVOID* )&pTextureNode->pTexture10 );
//SAFE_RELEASE( pRes );
//if( FAILED( hr ) )
// return hr;
//
}
// Store dimensions
D3D11_TEXTURE2D_DESC desc;
pTextureNode->pTexture11->GetDesc( &desc );
pTextureNode->dwWidth = desc.Width;
pTextureNode->dwHeight = desc.Height;
// Create resource view
D3D11_SHADER_RESOURCE_VIEW_DESC SRVDesc;
SRVDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
SRVDesc.Format = MAKE_SRGB( desc.Format );
SRVDesc.Texture2D.MipLevels = 1;
SRVDesc.Texture2D.MostDetailedMip = 0;
hr = m_pd3d11Device->CreateShaderResourceView( pTextureNode->pTexture11, &SRVDesc, &pTextureNode->pTexResView11 );
return hr;
}
//--------------------------------------------------------------------------------------
void CDXUTDialog::InitDefaultElements()
{
SetFont( 0, L"Arial", 14, FW_NORMAL );
CDXUTElement Element;
RECT rcTexture;
//-------------------------------------
// Element for the caption
//-------------------------------------
m_CapElement.SetFont( 0 );
SetRect( &rcTexture, 17, 269, 241, 287 );
m_CapElement.SetTexture( 0, &rcTexture );
m_CapElement.TextureColor.States[ DXUT_STATE_NORMAL ] = D3DCOLOR_ARGB( 255, 255, 255, 255 );
m_CapElement.FontColor.States[ DXUT_STATE_NORMAL ] = D3DCOLOR_ARGB( 255, 255, 255, 255 );
m_CapElement.SetFont( 0, D3DCOLOR_ARGB( 255, 255, 255, 255 ), DT_LEFT | DT_VCENTER );
// Pre-blend as we don't need to transition the state
m_CapElement.TextureColor.Blend( DXUT_STATE_NORMAL, 10.0f );
m_CapElement.FontColor.Blend( DXUT_STATE_NORMAL, 10.0f );
//-------------------------------------
// CDXUTStatic
//-------------------------------------
Element.SetFont( 0 );
Element.FontColor.States[ DXUT_STATE_DISABLED ] = D3DCOLOR_ARGB( 200, 200, 200, 200 );
// Assign the Element
SetDefaultElement( DXUT_CONTROL_STATIC, 0, &Element );
//-------------------------------------
// CDXUTButton - Button
//-------------------------------------
SetRect( &rcTexture, 0, 0, 136, 54 );
Element.SetTexture( 0, &rcTexture );
Element.SetFont( 0 );
Element.TextureColor.States[ DXUT_STATE_NORMAL ] = D3DCOLOR_ARGB( 150, 255, 255, 255 );
Element.TextureColor.States[ DXUT_STATE_PRESSED ] = D3DCOLOR_ARGB( 200, 255, 255, 255 );
Element.FontColor.States[ DXUT_STATE_MOUSEOVER ] = D3DCOLOR_ARGB( 255, 0, 0, 0 );
// Assign the Element
SetDefaultElement( DXUT_CONTROL_BUTTON, 0, &Element );
//-------------------------------------
// CDXUTButton - Fill layer
//-------------------------------------
SetRect( &rcTexture, 136, 0, 252, 54 );
Element.SetTexture( 0, &rcTexture, D3DCOLOR_ARGB( 0, 255, 255, 255 ) );
Element.TextureColor.States[ DXUT_STATE_MOUSEOVER ] = D3DCOLOR_ARGB( 160, 255, 255, 255 );
Element.TextureColor.States[ DXUT_STATE_PRESSED ] = D3DCOLOR_ARGB( 60, 0, 0, 0 );
Element.TextureColor.States[ DXUT_STATE_FOCUS ] = D3DCOLOR_ARGB( 30, 255, 255, 255 );
// Assign the Element
SetDefaultElement( DXUT_CONTROL_BUTTON, 1, &Element );
//-------------------------------------
// CDXUTCheckBox - Box
//-------------------------------------
SetRect( &rcTexture, 0, 54, 27, 81 );
Element.SetTexture( 0, &rcTexture );
Element.SetFont( 0, D3DCOLOR_ARGB( 255, 255, 255, 255 ), DT_LEFT | DT_VCENTER );
Element.FontColor.States[ DXUT_STATE_DISABLED ] = D3DCOLOR_ARGB( 200, 200, 200, 200 );
Element.TextureColor.States[ DXUT_STATE_NORMAL ] = D3DCOLOR_ARGB( 150, 255, 255, 255 );
Element.TextureColor.States[ DXUT_STATE_FOCUS ] = D3DCOLOR_ARGB( 200, 255, 255, 255 );
Element.TextureColor.States[ DXUT_STATE_PRESSED ] = D3DCOLOR_ARGB( 255, 255, 255, 255 );
// Assign the Element
SetDefaultElement( DXUT_CONTROL_CHECKBOX, 0, &Element );
//-------------------------------------
// CDXUTCheckBox - Check
//-------------------------------------
SetRect( &rcTexture, 27, 54, 54, 81 );
Element.SetTexture( 0, &rcTexture );
// Assign the Element
SetDefaultElement( DXUT_CONTROL_CHECKBOX, 1, &Element );
//-------------------------------------
// CDXUTRadioButton - Box
//-------------------------------------
SetRect( &rcTexture, 54, 54, 81, 81 );
Element.SetTexture( 0, &rcTexture );
Element.SetFont( 0, D3DCOLOR_ARGB( 255, 255, 255, 255 ), DT_LEFT | DT_VCENTER );
Element.FontColor.States[ DXUT_STATE_DISABLED ] = D3DCOLOR_ARGB( 200, 200, 200, 200 );
Element.TextureColor.States[ DXUT_STATE_NORMAL ] = D3DCOLOR_ARGB( 150, 255, 255, 255 );
Element.TextureColor.States[ DXUT_STATE_FOCUS ] = D3DCOLOR_ARGB( 200, 255, 255, 255 );
Element.TextureColor.States[ DXUT_STATE_PRESSED ] = D3DCOLOR_ARGB( 255, 255, 255, 255 );
// Assign the Element
SetDefaultElement( DXUT_CONTROL_RADIOBUTTON, 0, &Element );
//-------------------------------------
// CDXUTRadioButton - Check
//-------------------------------------
SetRect( &rcTexture, 81, 54, 108, 81 );
Element.SetTexture( 0, &rcTexture );
// Assign the Element
SetDefaultElement( DXUT_CONTROL_RADIOBUTTON, 1, &Element );
//-------------------------------------
// CDXUTComboBox - Main
//-------------------------------------
SetRect( &rcTexture, 7, 81, 247, 123 );
Element.SetTexture( 0, &rcTexture );
Element.SetFont( 0 );
Element.TextureColor.States[ DXUT_STATE_NORMAL ] = D3DCOLOR_ARGB( 150, 200, 200, 200 );
Element.TextureColor.States[ DXUT_STATE_FOCUS ] = D3DCOLOR_ARGB( 170, 230, 230, 230 );
Element.TextureColor.States[ DXUT_STATE_DISABLED ] = D3DCOLOR_ARGB( 70, 200, 200, 200 );
Element.FontColor.States[ DXUT_STATE_MOUSEOVER ] = D3DCOLOR_ARGB( 255, 0, 0, 0 );
Element.FontColor.States[ DXUT_STATE_PRESSED ] = D3DCOLOR_ARGB( 255, 0, 0, 0 );
Element.FontColor.States[ DXUT_STATE_DISABLED ] = D3DCOLOR_ARGB( 200, 200, 200, 200 );
// Assign the Element
SetDefaultElement( DXUT_CONTROL_COMBOBOX, 0, &Element );
//-------------------------------------
// CDXUTComboBox - Button
//-------------------------------------
SetRect( &rcTexture, 98, 189, 151, 238 );
Element.SetTexture( 0, &rcTexture );
Element.TextureColor.States[ DXUT_STATE_NORMAL ] = D3DCOLOR_ARGB( 150, 255, 255, 255 );
Element.TextureColor.States[ DXUT_STATE_PRESSED ] = D3DCOLOR_ARGB( 255, 150, 150, 150 );
Element.TextureColor.States[ DXUT_STATE_FOCUS ] = D3DCOLOR_ARGB( 200, 255, 255, 255 );
Element.TextureColor.States[ DXUT_STATE_DISABLED ] = D3DCOLOR_ARGB( 70, 255, 255, 255 );
// Assign the Element
SetDefaultElement( DXUT_CONTROL_COMBOBOX, 1, &Element );
//-------------------------------------
// CDXUTComboBox - Dropdown
//-------------------------------------
SetRect( &rcTexture, 13, 123, 241, 160 );
Element.SetTexture( 0, &rcTexture );
Element.SetFont( 0, D3DCOLOR_ARGB( 255, 0, 0, 0 ), DT_LEFT | DT_TOP );
// Assign the Element
SetDefaultElement( DXUT_CONTROL_COMBOBOX, 2, &Element );
//-------------------------------------
// CDXUTComboBox - Selection
//-------------------------------------
SetRect( &rcTexture, 12, 163, 239, 183 );
Element.SetTexture( 0, &rcTexture );
Element.SetFont( 0, D3DCOLOR_ARGB( 255, 255, 255, 255 ), DT_LEFT | DT_TOP );
// Assign the Element
SetDefaultElement( DXUT_CONTROL_COMBOBOX, 3, &Element );
//-------------------------------------
// CDXUTSlider - Track
//-------------------------------------
SetRect( &rcTexture, 1, 187, 93, 228 );
Element.SetTexture( 0, &rcTexture );
Element.TextureColor.States[ DXUT_STATE_NORMAL ] = D3DCOLOR_ARGB( 150, 255, 255, 255 );
Element.TextureColor.States[ DXUT_STATE_FOCUS ] = D3DCOLOR_ARGB( 200, 255, 255, 255 );
Element.TextureColor.States[ DXUT_STATE_DISABLED ] = D3DCOLOR_ARGB( 70, 255, 255, 255 );
// Assign the Element
SetDefaultElement( DXUT_CONTROL_SLIDER, 0, &Element );
//-------------------------------------
// CDXUTSlider - Button
//-------------------------------------
SetRect( &rcTexture, 151, 193, 192, 234 );
Element.SetTexture( 0, &rcTexture );
// Assign the Element
SetDefaultElement( DXUT_CONTROL_SLIDER, 1, &Element );
//-------------------------------------
// CDXUTScrollBar - Track
//-------------------------------------
int nScrollBarStartX = 196;
int nScrollBarStartY = 191;
SetRect( &rcTexture, nScrollBarStartX + 0, nScrollBarStartY + 21, nScrollBarStartX + 22, nScrollBarStartY + 32 );
Element.SetTexture( 0, &rcTexture );
Element.TextureColor.States[ DXUT_STATE_DISABLED ] = D3DCOLOR_ARGB( 255, 200, 200, 200 );
// Assign the Element
SetDefaultElement( DXUT_CONTROL_SCROLLBAR, 0, &Element );
//-------------------------------------
// CDXUTScrollBar - Up Arrow
//-------------------------------------
SetRect( &rcTexture, nScrollBarStartX + 0, nScrollBarStartY + 1, nScrollBarStartX + 22, nScrollBarStartY + 21 );
Element.SetTexture( 0, &rcTexture );
Element.TextureColor.States[ DXUT_STATE_DISABLED ] = D3DCOLOR_ARGB( 255, 200, 200, 200 );
// Assign the Element
SetDefaultElement( DXUT_CONTROL_SCROLLBAR, 1, &Element );
//-------------------------------------
// CDXUTScrollBar - Down Arrow
//-------------------------------------
SetRect( &rcTexture, nScrollBarStartX + 0, nScrollBarStartY + 32, nScrollBarStartX + 22, nScrollBarStartY + 53 );
Element.SetTexture( 0, &rcTexture );
Element.TextureColor.States[ DXUT_STATE_DISABLED ] = D3DCOLOR_ARGB( 255, 200, 200, 200 );
// Assign the Element
SetDefaultElement( DXUT_CONTROL_SCROLLBAR, 2, &Element );
//-------------------------------------
// CDXUTScrollBar - Button
//-------------------------------------
SetRect( &rcTexture, 220, 192, 238, 234 );
Element.SetTexture( 0, &rcTexture );
// Assign the Element
SetDefaultElement( DXUT_CONTROL_SCROLLBAR, 3, &Element );
//-------------------------------------
// CDXUTEditBox
//-------------------------------------
// Element assignment:
// 0 - text area
// 1 - top left border
// 2 - top border
// 3 - top right border
// 4 - left border
// 5 - right border
// 6 - lower left border
// 7 - lower border
// 8 - lower right border
Element.SetFont( 0, D3DCOLOR_ARGB( 255, 0, 0, 0 ), DT_LEFT | DT_TOP );
// Assign the style
SetRect( &rcTexture, 14, 90, 241, 113 );
Element.SetTexture( 0, &rcTexture );
SetDefaultElement( DXUT_CONTROL_EDITBOX, 0, &Element );
SetRect( &rcTexture, 8, 82, 14, 90 );
Element.SetTexture( 0, &rcTexture );
SetDefaultElement( DXUT_CONTROL_EDITBOX, 1, &Element );
SetRect( &rcTexture, 14, 82, 241, 90 );
Element.SetTexture( 0, &rcTexture );
SetDefaultElement( DXUT_CONTROL_EDITBOX, 2, &Element );
SetRect( &rcTexture, 241, 82, 246, 90 );
Element.SetTexture( 0, &rcTexture );
SetDefaultElement( DXUT_CONTROL_EDITBOX, 3, &Element );
SetRect( &rcTexture, 8, 90, 14, 113 );
Element.SetTexture( 0, &rcTexture );
SetDefaultElement( DXUT_CONTROL_EDITBOX, 4, &Element );
SetRect( &rcTexture, 241, 90, 246, 113 );
Element.SetTexture( 0, &rcTexture );
SetDefaultElement( DXUT_CONTROL_EDITBOX, 5, &Element );
SetRect( &rcTexture, 8, 113, 14, 121 );
Element.SetTexture( 0, &rcTexture );
SetDefaultElement( DXUT_CONTROL_EDITBOX, 6, &Element );
SetRect( &rcTexture, 14, 113, 241, 121 );
Element.SetTexture( 0, &rcTexture );
SetDefaultElement( DXUT_CONTROL_EDITBOX, 7, &Element );
SetRect( &rcTexture, 241, 113, 246, 121 );
Element.SetTexture( 0, &rcTexture );
SetDefaultElement( DXUT_CONTROL_EDITBOX, 8, &Element );
//-------------------------------------
// CDXUTListBox - Main
//-------------------------------------
SetRect( &rcTexture, 13, 123, 241, 160 );
Element.SetTexture( 0, &rcTexture );
Element.SetFont( 0, D3DCOLOR_ARGB( 255, 0, 0, 0 ), DT_LEFT | DT_TOP );
// Assign the Element
SetDefaultElement( DXUT_CONTROL_LISTBOX, 0, &Element );
//-------------------------------------
// CDXUTListBox - Selection
//-------------------------------------
SetRect( &rcTexture, 16, 166, 240, 183 );
Element.SetTexture( 0, &rcTexture );
Element.SetFont( 0, D3DCOLOR_ARGB( 255, 255, 255, 255 ), DT_LEFT | DT_TOP );
// Assign the Element
SetDefaultElement( DXUT_CONTROL_LISTBOX, 1, &Element );
}
//--------------------------------------------------------------------------------------
// CDXUTControl class
//--------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------
CDXUTControl::CDXUTControl( CDXUTDialog* pDialog )
{
m_Type = DXUT_CONTROL_BUTTON;
m_pDialog = pDialog;
m_ID = 0;
m_Index = 0;
m_pUserData = NULL;
m_bEnabled = true;
m_bVisible = true;
m_bMouseOver = false;
m_bHasFocus = false;
m_bIsDefault = false;
m_pDialog = NULL;
m_x = 0;
m_y = 0;
m_width = 0;
m_height = 0;
ZeroMemory( &m_rcBoundingBox, sizeof( m_rcBoundingBox ) );
}
CDXUTControl::~CDXUTControl()
{
for( int i = 0; i < m_Elements.GetSize(); ++i )
{
delete m_Elements[i];
}
m_Elements.RemoveAll();
}
//--------------------------------------------------------------------------------------
void CDXUTControl::SetTextColor( D3DCOLOR Color )
{
CDXUTElement* pElement = m_Elements.GetAt( 0 );
if( pElement )
pElement->FontColor.States[DXUT_STATE_NORMAL] = Color;
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTControl::SetElement( UINT iElement, CDXUTElement* pElement )
{
HRESULT hr = S_OK;
if( pElement == NULL )
return E_INVALIDARG;
// Make certain the array is this large
for( UINT i = m_Elements.GetSize(); i <= iElement; i++ )
{
CDXUTElement* pNewElement = new CDXUTElement();
if( pNewElement == NULL )
return E_OUTOFMEMORY;
hr = m_Elements.Add( pNewElement );
if( FAILED( hr ) )
{
SAFE_DELETE( pNewElement );
return hr;
}
}
// Update the data
CDXUTElement* pCurElement = m_Elements.GetAt( iElement );
*pCurElement = *pElement;
return S_OK;
}
//--------------------------------------------------------------------------------------
void CDXUTControl::Refresh()
{
m_bMouseOver = false;
m_bHasFocus = false;
for( int i = 0; i < m_Elements.GetSize(); i++ )
{
CDXUTElement* pElement = m_Elements.GetAt( i );
pElement->Refresh();
}
}
//--------------------------------------------------------------------------------------
void CDXUTControl::UpdateRects()
{
SetRect( &m_rcBoundingBox, m_x, m_y, m_x + m_width, m_y + m_height );
}
//--------------------------------------------------------------------------------------
// CDXUTStatic class
//--------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------
CDXUTStatic::CDXUTStatic( CDXUTDialog* pDialog )
{
m_Type = DXUT_CONTROL_STATIC;
m_pDialog = pDialog;
ZeroMemory( &m_strText, sizeof( m_strText ) );
for( int i = 0; i < m_Elements.GetSize(); i++ )
{
CDXUTElement* pElement = m_Elements.GetAt( i );
SAFE_DELETE( pElement );
}
m_Elements.RemoveAll();
}
//--------------------------------------------------------------------------------------
void CDXUTStatic::Render( float fElapsedTime )
{
if( m_bVisible == false )
return;
DXUT_CONTROL_STATE iState = DXUT_STATE_NORMAL;
if( m_bEnabled == false )
iState = DXUT_STATE_DISABLED;
CDXUTElement* pElement = m_Elements.GetAt( 0 );
pElement->FontColor.Blend( iState, fElapsedTime );
m_pDialog->DrawText( m_strText, pElement, &m_rcBoundingBox, false, -1, false);
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTStatic::GetTextCopy( __out_ecount(bufferCount) LPWSTR strDest,
UINT bufferCount )
{
// Validate incoming parameters
if( strDest == NULL || bufferCount == 0 )
{
return E_INVALIDARG;
}
// Copy the window text
wcscpy_s( strDest, bufferCount, m_strText );
return S_OK;
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTStatic::SetText( LPCWSTR strText )
{
if( strText == NULL )
{
m_strText[0] = 0;
return S_OK;
}
wcscpy_s( m_strText, MAX_PATH, strText );
return S_OK;
}
//--------------------------------------------------------------------------------------
// CDXUTButton class
//--------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------
CDXUTButton::CDXUTButton( CDXUTDialog* pDialog )
{
m_Type = DXUT_CONTROL_BUTTON;
m_pDialog = pDialog;
m_bPressed = false;
m_nHotkey = 0;
}
//--------------------------------------------------------------------------------------
bool CDXUTButton::HandleKeyboard( UINT uMsg, WPARAM wParam, LPARAM lParam )
{
if( !m_bEnabled || !m_bVisible )
return false;
switch( uMsg )
{
case WM_KEYDOWN:
{
switch( wParam )
{
case VK_SPACE:
m_bPressed = true;
return true;
}
}
case WM_KEYUP:
{
switch( wParam )
{
case VK_SPACE:
if( m_bPressed == true )
{
m_bPressed = false;
m_pDialog->SendEvent( EVENT_BUTTON_CLICKED, true, this );
}
return true;
}
}
}
return false;
}
//--------------------------------------------------------------------------------------
bool CDXUTButton::HandleMouse( UINT uMsg, POINT pt, WPARAM wParam, LPARAM lParam )
{
if( !m_bEnabled || !m_bVisible )
return false;
switch( uMsg )
{
case WM_LBUTTONDOWN:
case WM_LBUTTONDBLCLK:
{
if( ContainsPoint( pt ) )
{
// Pressed while inside the control
m_bPressed = true;
SetCapture( DXUTGetHWND() );
if( !m_bHasFocus )
m_pDialog->RequestFocus( this );
return true;
}
break;
}
case WM_LBUTTONUP:
{
if( m_bPressed )
{
m_bPressed = false;
ReleaseCapture();
if( !m_pDialog->m_bKeyboardInput )
m_pDialog->ClearFocus();
// Button click
if( ContainsPoint( pt ) )
m_pDialog->SendEvent( EVENT_BUTTON_CLICKED, true, this );
return true;
}
break;
}
};
return false;
}
//--------------------------------------------------------------------------------------
void CDXUTButton::Render( float fElapsedTime )
{
if( m_bVisible == false )
return;
int nOffsetX = 0;
int nOffsetY = 0;
DXUT_CONTROL_STATE iState = DXUT_STATE_NORMAL;
if( m_bVisible == false )
{
iState = DXUT_STATE_HIDDEN;
}
else if( m_bEnabled == false )
{
iState = DXUT_STATE_DISABLED;
}
else if( m_bPressed )
{
iState = DXUT_STATE_PRESSED;
nOffsetX = 1;
nOffsetY = 2;
}
else if( m_bMouseOver )
{
iState = DXUT_STATE_MOUSEOVER;
nOffsetX = -1;
nOffsetY = -2;
}
else if( m_bHasFocus )
{
iState = DXUT_STATE_FOCUS;
}
// Background fill layer
//TODO: remove magic numbers
CDXUTElement* pElement = m_Elements.GetAt( 0 );
float fBlendRate = ( iState == DXUT_STATE_PRESSED ) ? 0.0f : 0.8f;
RECT rcWindow = m_rcBoundingBox;
OffsetRect( &rcWindow, nOffsetX, nOffsetY );
// Blend current color
pElement->TextureColor.Blend( iState, fElapsedTime, fBlendRate );
pElement->FontColor.Blend( iState, fElapsedTime, fBlendRate );
m_pDialog->DrawSprite( pElement, &rcWindow, DXUT_FAR_BUTTON_DEPTH );
m_pDialog->DrawText( m_strText, pElement, &rcWindow, false, -1, true );
// Main button
pElement = m_Elements.GetAt( 1 );
// Blend current color
pElement->TextureColor.Blend( iState, fElapsedTime, fBlendRate );
pElement->FontColor.Blend( iState, fElapsedTime, fBlendRate );
m_pDialog->DrawSprite( pElement, &rcWindow, DXUT_NEAR_BUTTON_DEPTH );
m_pDialog->DrawText( m_strText, pElement, &rcWindow, false, -1, true );
}
//--------------------------------------------------------------------------------------
// CDXUTCheckBox class
//--------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------
CDXUTCheckBox::CDXUTCheckBox( CDXUTDialog* pDialog )
{
m_Type = DXUT_CONTROL_CHECKBOX;
m_pDialog = pDialog;
m_bChecked = false;
}
//--------------------------------------------------------------------------------------
bool CDXUTCheckBox::HandleKeyboard( UINT uMsg, WPARAM wParam, LPARAM lParam )
{
if( !m_bEnabled || !m_bVisible )
return false;
switch( uMsg )
{
case WM_KEYDOWN:
{
switch( wParam )
{
case VK_SPACE:
m_bPressed = true;
return true;
}
}
case WM_KEYUP:
{
switch( wParam )
{
case VK_SPACE:
if( m_bPressed == true )
{
m_bPressed = false;
SetCheckedInternal( !m_bChecked, true );
}
return true;
}
}
}
return false;
}
//--------------------------------------------------------------------------------------
bool CDXUTCheckBox::HandleMouse( UINT uMsg, POINT pt, WPARAM wParam, LPARAM lParam )
{
if( !m_bEnabled || !m_bVisible )
return false;
switch( uMsg )
{
case WM_LBUTTONDOWN:
case WM_LBUTTONDBLCLK:
{
if( ContainsPoint( pt ) )
{
// Pressed while inside the control
m_bPressed = true;
SetCapture( DXUTGetHWND() );
if( !m_bHasFocus )
m_pDialog->RequestFocus( this );
return true;
}
break;
}
case WM_LBUTTONUP:
{
if( m_bPressed )
{
m_bPressed = false;
ReleaseCapture();
// Button click
if( ContainsPoint( pt ) )
SetCheckedInternal( !m_bChecked, true );
return true;
}
break;
}
};
return false;
}
//--------------------------------------------------------------------------------------
void CDXUTCheckBox::SetCheckedInternal( bool bChecked, bool bFromInput )
{
m_bChecked = bChecked;
m_pDialog->SendEvent( EVENT_CHECKBOX_CHANGED, bFromInput, this );
}
//--------------------------------------------------------------------------------------
BOOL CDXUTCheckBox::ContainsPoint( POINT pt )
{
return ( PtInRect( &m_rcBoundingBox, pt ) ||
PtInRect( &m_rcButton, pt ) );
}
//--------------------------------------------------------------------------------------
void CDXUTCheckBox::UpdateRects()
{
CDXUTButton::UpdateRects();
m_rcButton = m_rcBoundingBox;
m_rcButton.right = m_rcButton.left + RectHeight( m_rcButton );
m_rcText = m_rcBoundingBox;
m_rcText.left += ( int )( 1.25f * RectWidth( m_rcButton ) );
}
//--------------------------------------------------------------------------------------
void CDXUTCheckBox::Render( float fElapsedTime )
{
if( m_bVisible == false )
return;
DXUT_CONTROL_STATE iState = DXUT_STATE_NORMAL;
if( m_bVisible == false )
iState = DXUT_STATE_HIDDEN;
else if( m_bEnabled == false )
iState = DXUT_STATE_DISABLED;
else if( m_bPressed )
iState = DXUT_STATE_PRESSED;
else if( m_bMouseOver )
iState = DXUT_STATE_MOUSEOVER;
else if( m_bHasFocus )
iState = DXUT_STATE_FOCUS;
CDXUTElement* pElement = m_Elements.GetAt( 0 );
float fBlendRate = ( iState == DXUT_STATE_PRESSED ) ? 0.0f : 0.8f;
pElement->TextureColor.Blend( iState, fElapsedTime, fBlendRate );
pElement->FontColor.Blend( iState, fElapsedTime, fBlendRate );
m_pDialog->DrawSprite( pElement, &m_rcButton, DXUT_NEAR_BUTTON_DEPTH );
m_pDialog->DrawText( m_strText, pElement, &m_rcText, false, -1, false );
if( !m_bChecked )
iState = DXUT_STATE_HIDDEN;
pElement = m_Elements.GetAt( 1 );
pElement->TextureColor.Blend( iState, fElapsedTime, fBlendRate );
m_pDialog->DrawSprite( pElement, &m_rcButton, DXUT_FAR_BUTTON_DEPTH );
}
//--------------------------------------------------------------------------------------
// CDXUTRadioButton class
//--------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------
CDXUTRadioButton::CDXUTRadioButton( CDXUTDialog* pDialog )
{
m_Type = DXUT_CONTROL_RADIOBUTTON;
m_pDialog = pDialog;
}
//--------------------------------------------------------------------------------------
bool CDXUTRadioButton::HandleKeyboard( UINT uMsg, WPARAM wParam, LPARAM lParam )
{
if( !m_bEnabled || !m_bVisible )
return false;
switch( uMsg )
{
case WM_KEYDOWN:
{
switch( wParam )
{
case VK_SPACE:
m_bPressed = true;
return true;
}
}
case WM_KEYUP:
{
switch( wParam )
{
case VK_SPACE:
if( m_bPressed == true )
{
m_bPressed = false;
m_pDialog->ClearRadioButtonGroup( m_nButtonGroup );
m_bChecked = !m_bChecked;
m_pDialog->SendEvent( EVENT_RADIOBUTTON_CHANGED, true, this );
}
return true;
}
}
}
return false;
}
//--------------------------------------------------------------------------------------
bool CDXUTRadioButton::HandleMouse( UINT uMsg, POINT pt, WPARAM wParam, LPARAM lParam )
{
if( !m_bEnabled || !m_bVisible )
return false;
switch( uMsg )
{
case WM_LBUTTONDOWN:
case WM_LBUTTONDBLCLK:
{
if( ContainsPoint( pt ) )
{
// Pressed while inside the control
m_bPressed = true;
SetCapture( DXUTGetHWND() );
if( !m_bHasFocus )
m_pDialog->RequestFocus( this );
return true;
}
break;
}
case WM_LBUTTONUP:
{
if( m_bPressed )
{
m_bPressed = false;
ReleaseCapture();
// Button click
if( ContainsPoint( pt ) )
{
m_pDialog->ClearRadioButtonGroup( m_nButtonGroup );
m_bChecked = !m_bChecked;
m_pDialog->SendEvent( EVENT_RADIOBUTTON_CHANGED, true, this );
}
return true;
}
break;
}
};
return false;
}
//--------------------------------------------------------------------------------------
void CDXUTRadioButton::SetCheckedInternal( bool bChecked, bool bClearGroup, bool bFromInput )
{
if( bChecked && bClearGroup )
m_pDialog->ClearRadioButtonGroup( m_nButtonGroup );
m_bChecked = bChecked;
m_pDialog->SendEvent( EVENT_RADIOBUTTON_CHANGED, bFromInput, this );
}
//--------------------------------------------------------------------------------------
// CDXUTComboBox class
//--------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------
CDXUTComboBox::CDXUTComboBox( CDXUTDialog* pDialog ) : m_ScrollBar( pDialog )
{
m_Type = DXUT_CONTROL_COMBOBOX;
m_pDialog = pDialog;
m_nDropHeight = 100;
m_nSBWidth = 16;
m_bOpened = false;
m_iSelected = -1;
m_iFocused = -1;
}
//--------------------------------------------------------------------------------------
CDXUTComboBox::~CDXUTComboBox()
{
RemoveAllItems();
}
//--------------------------------------------------------------------------------------
void CDXUTComboBox::SetTextColor( D3DCOLOR Color )
{
CDXUTElement* pElement = m_Elements.GetAt( 0 );
if( pElement )
pElement->FontColor.States[DXUT_STATE_NORMAL] = Color;
pElement = m_Elements.GetAt( 2 );
if( pElement )
pElement->FontColor.States[DXUT_STATE_NORMAL] = Color;
}
//--------------------------------------------------------------------------------------
void CDXUTComboBox::UpdateRects()
{
CDXUTButton::UpdateRects();
m_rcButton = m_rcBoundingBox;
m_rcButton.left = m_rcButton.right - RectHeight( m_rcButton );
m_rcText = m_rcBoundingBox;
m_rcText.right = m_rcButton.left;
m_rcDropdown = m_rcText;
OffsetRect( &m_rcDropdown, 0, ( int )( 0.90f * RectHeight( m_rcText ) ) );
m_rcDropdown.bottom += m_nDropHeight;
m_rcDropdown.right -= m_nSBWidth;
m_rcDropdownText = m_rcDropdown;
m_rcDropdownText.left += ( int )( 0.1f * RectWidth( m_rcDropdown ) );
m_rcDropdownText.right -= ( int )( 0.1f * RectWidth( m_rcDropdown ) );
m_rcDropdownText.top += ( int )( 0.1f * RectHeight( m_rcDropdown ) );
m_rcDropdownText.bottom -= ( int )( 0.1f * RectHeight( m_rcDropdown ) );
// Update the scrollbar's rects
m_ScrollBar.SetLocation( m_rcDropdown.right, m_rcDropdown.top + 2 );
m_ScrollBar.SetSize( m_nSBWidth, RectHeight( m_rcDropdown ) - 2 );
DXUTFontNode* pFontNode = m_pDialog->GetManager()->GetFontNode( m_Elements.GetAt( 2 )->iFont );
if( pFontNode && pFontNode->nHeight )
{
m_ScrollBar.SetPageSize( RectHeight( m_rcDropdownText ) / pFontNode->nHeight );
// The selected item may have been scrolled off the page.
// Ensure that it is in page again.
m_ScrollBar.ShowItem( m_iSelected );
}
}
//--------------------------------------------------------------------------------------
void CDXUTComboBox::OnFocusOut()
{
CDXUTButton::OnFocusOut();
m_bOpened = false;
}
//--------------------------------------------------------------------------------------
bool CDXUTComboBox::HandleKeyboard( UINT uMsg, WPARAM wParam, LPARAM lParam )
{
const DWORD REPEAT_MASK = ( 0x40000000 );
if( !m_bEnabled || !m_bVisible )
return false;
// Let the scroll bar have a chance to handle it first
if( m_ScrollBar.HandleKeyboard( uMsg, wParam, lParam ) )
return true;
switch( uMsg )
{
case WM_KEYDOWN:
{
switch( wParam )
{
case VK_RETURN:
if( m_bOpened )
{
if( m_iSelected != m_iFocused )
{
m_iSelected = m_iFocused;
m_pDialog->SendEvent( EVENT_COMBOBOX_SELECTION_CHANGED, true, this );
}
m_bOpened = false;
if( !m_pDialog->m_bKeyboardInput )
m_pDialog->ClearFocus();
return true;
}
break;
case VK_F4:
// Filter out auto-repeats
if( lParam & REPEAT_MASK )
return true;
m_bOpened = !m_bOpened;
if( !m_bOpened )
{
m_pDialog->SendEvent( EVENT_COMBOBOX_SELECTION_CHANGED, true, this );
if( !m_pDialog->m_bKeyboardInput )
m_pDialog->ClearFocus();
}
return true;
case VK_LEFT:
case VK_UP:
if( m_iFocused > 0 )
{
m_iFocused--;
m_iSelected = m_iFocused;
if( !m_bOpened )
m_pDialog->SendEvent( EVENT_COMBOBOX_SELECTION_CHANGED, true, this );
}
return true;
case VK_RIGHT:
case VK_DOWN:
if( m_iFocused + 1 < ( int )GetNumItems() )
{
m_iFocused++;
m_iSelected = m_iFocused;
if( !m_bOpened )
m_pDialog->SendEvent( EVENT_COMBOBOX_SELECTION_CHANGED, true, this );
}
return true;
}
break;
}
}
return false;
}
//--------------------------------------------------------------------------------------
bool CDXUTComboBox::HandleMouse( UINT uMsg, POINT pt, WPARAM wParam, LPARAM lParam )
{
if( !m_bEnabled || !m_bVisible )
return false;
// Let the scroll bar handle it first.
if( m_ScrollBar.HandleMouse( uMsg, pt, wParam, lParam ) )
return true;
switch( uMsg )
{
case WM_MOUSEMOVE:
{
if( m_bOpened && PtInRect( &m_rcDropdown, pt ) )
{
// Determine which item has been selected
for( int i = 0; i < m_Items.GetSize(); i++ )
{
DXUTComboBoxItem* pItem = m_Items.GetAt( i );
if( pItem->bVisible &&
PtInRect( &pItem->rcActive, pt ) )
{
m_iFocused = i;
}
}
return true;
}
break;
}
case WM_LBUTTONDOWN:
case WM_LBUTTONDBLCLK:
{
if( ContainsPoint( pt ) )
{
// Pressed while inside the control
m_bPressed = true;
SetCapture( DXUTGetHWND() );
if( !m_bHasFocus )
m_pDialog->RequestFocus( this );
// Toggle dropdown
if( m_bHasFocus )
{
m_bOpened = !m_bOpened;
if( !m_bOpened )
{
if( !m_pDialog->m_bKeyboardInput )
m_pDialog->ClearFocus();
}
}
return true;
}
// Perhaps this click is within the dropdown
if( m_bOpened && PtInRect( &m_rcDropdown, pt ) )
{
// Determine which item has been selected
for( int i = m_ScrollBar.GetTrackPos(); i < m_Items.GetSize(); i++ )
{
DXUTComboBoxItem* pItem = m_Items.GetAt( i );
if( pItem->bVisible &&
PtInRect( &pItem->rcActive, pt ) )
{
m_iFocused = m_iSelected = i;
m_pDialog->SendEvent( EVENT_COMBOBOX_SELECTION_CHANGED, true, this );
m_bOpened = false;
if( !m_pDialog->m_bKeyboardInput )
m_pDialog->ClearFocus();
break;
}
}
return true;
}
// Mouse click not on main control or in dropdown, fire an event if needed
if( m_bOpened )
{
m_iFocused = m_iSelected;
m_pDialog->SendEvent( EVENT_COMBOBOX_SELECTION_CHANGED, true, this );
m_bOpened = false;
}
// Make sure the control is no longer in a pressed state
m_bPressed = false;
// Release focus if appropriate
if( !m_pDialog->m_bKeyboardInput )
{
m_pDialog->ClearFocus();
}
break;
}
case WM_LBUTTONUP:
{
if( m_bPressed && ContainsPoint( pt ) )
{
// Button click
m_bPressed = false;
ReleaseCapture();
return true;
}
break;
}
case WM_MOUSEWHEEL:
{
int zDelta = ( short )HIWORD( wParam ) / WHEEL_DELTA;
if( m_bOpened )
{
UINT uLines;
SystemParametersInfo( SPI_GETWHEELSCROLLLINES, 0, &uLines, 0 );
m_ScrollBar.Scroll( -zDelta * uLines );
}
else
{
if( zDelta > 0 )
{
if( m_iFocused > 0 )
{
m_iFocused--;
m_iSelected = m_iFocused;
if( !m_bOpened )
m_pDialog->SendEvent( EVENT_COMBOBOX_SELECTION_CHANGED, true, this );
}
}
else
{
if( m_iFocused + 1 < ( int )GetNumItems() )
{
m_iFocused++;
m_iSelected = m_iFocused;
if( !m_bOpened )
m_pDialog->SendEvent( EVENT_COMBOBOX_SELECTION_CHANGED, true, this );
}
}
}
return true;
}
};
return false;
}
//--------------------------------------------------------------------------------------
void CDXUTComboBox::OnHotkey()
{
if( m_bOpened )
return;
if( m_iSelected == -1 )
return;
if( m_pDialog->IsKeyboardInputEnabled() )
m_pDialog->RequestFocus( this );
m_iSelected++;
if( m_iSelected >= ( int )m_Items.GetSize() )
m_iSelected = 0;
m_iFocused = m_iSelected;
m_pDialog->SendEvent( EVENT_COMBOBOX_SELECTION_CHANGED, true, this );
}
//--------------------------------------------------------------------------------------
void CDXUTComboBox::Render( float fElapsedTime )
{
if( m_bVisible == false )
return;
DXUT_CONTROL_STATE iState = DXUT_STATE_NORMAL;
if( !m_bOpened )
iState = DXUT_STATE_HIDDEN;
// Dropdown box
CDXUTElement* pElement = m_Elements.GetAt( 2 );
// If we have not initialized the scroll bar page size,
// do that now.
static bool bSBInit;
if( !bSBInit )
{
// Update the page size of the scroll bar
if( m_pDialog->GetManager()->GetFontNode( pElement->iFont )->nHeight )
m_ScrollBar.SetPageSize( RectHeight( m_rcDropdownText ) /
m_pDialog->GetManager()->GetFontNode( pElement->iFont )->nHeight );
else
m_ScrollBar.SetPageSize( RectHeight( m_rcDropdownText ) );
bSBInit = true;
}
// Scroll bar
if( m_bOpened )
m_ScrollBar.Render( fElapsedTime );
// Blend current color
pElement->TextureColor.Blend( iState, fElapsedTime );
pElement->FontColor.Blend( iState, fElapsedTime );
m_pDialog->DrawSprite( pElement, &m_rcDropdown, DXUT_NEAR_BUTTON_DEPTH );
// Selection outline
CDXUTElement* pSelectionElement = m_Elements.GetAt( 3 );
pSelectionElement->TextureColor.Current = pElement->TextureColor.Current;
pSelectionElement->FontColor.Current = pSelectionElement->FontColor.States[ DXUT_STATE_NORMAL ];
DXUTFontNode* pFont = m_pDialog->GetFont( pElement->iFont );
if( pFont )
{
int curY = m_rcDropdownText.top;
int nRemainingHeight = RectHeight( m_rcDropdownText );
//WCHAR strDropdown[4096] = {0};
for( int i = m_ScrollBar.GetTrackPos(); i < m_Items.GetSize(); i++ )
{
DXUTComboBoxItem* pItem = m_Items.GetAt( i );
// Make sure there's room left in the dropdown
nRemainingHeight -= pFont->nHeight;
if( nRemainingHeight < 0 )
{
pItem->bVisible = false;
continue;
}
SetRect( &pItem->rcActive, m_rcDropdownText.left, curY, m_rcDropdownText.right, curY + pFont->nHeight );
curY += pFont->nHeight;
//debug
//int blue = 50 * i;
//m_pDialog->DrawRect( &pItem->rcActive, 0xFFFF0000 | blue );
pItem->bVisible = true;
if( m_bOpened )
{
if( ( int )i == m_iFocused )
{
RECT rc;
SetRect( &rc, m_rcDropdown.left, pItem->rcActive.top - 2, m_rcDropdown.right,
pItem->rcActive.bottom + 2 );
m_pDialog->DrawSprite( pSelectionElement, &rc, DXUT_NEAR_BUTTON_DEPTH );
m_pDialog->DrawText( pItem->strText, pSelectionElement, &pItem->rcActive );
}
else
{
m_pDialog->DrawText( pItem->strText, pElement, &pItem->rcActive );
}
}
}
}
int nOffsetX = 0;
int nOffsetY = 0;
iState = DXUT_STATE_NORMAL;
if( m_bVisible == false )
iState = DXUT_STATE_HIDDEN;
else if( m_bEnabled == false )
iState = DXUT_STATE_DISABLED;
else if( m_bPressed )
{
iState = DXUT_STATE_PRESSED;
nOffsetX = 1;
nOffsetY = 2;
}
else if( m_bMouseOver )
{
iState = DXUT_STATE_MOUSEOVER;
nOffsetX = -1;
nOffsetY = -2;
}
else if( m_bHasFocus )
iState = DXUT_STATE_FOCUS;
float fBlendRate = ( iState == DXUT_STATE_PRESSED ) ? 0.0f : 0.8f;
// Button
pElement = m_Elements.GetAt( 1 );
// Blend current color
pElement->TextureColor.Blend( iState, fElapsedTime, fBlendRate );
RECT rcWindow = m_rcButton;
OffsetRect( &rcWindow, nOffsetX, nOffsetY );
m_pDialog->DrawSprite( pElement, &rcWindow, DXUT_FAR_BUTTON_DEPTH );
if( m_bOpened )
iState = DXUT_STATE_PRESSED;
// Main text box
//TODO: remove magic numbers
pElement = m_Elements.GetAt( 0 );
// Blend current color
pElement->TextureColor.Blend( iState, fElapsedTime, fBlendRate );
pElement->FontColor.Blend( iState, fElapsedTime, fBlendRate );
m_pDialog->DrawSprite( pElement, &m_rcText, DXUT_NEAR_BUTTON_DEPTH );
if( m_iSelected >= 0 && m_iSelected < ( int )m_Items.GetSize() )
{
DXUTComboBoxItem* pItem = m_Items.GetAt( m_iSelected );
if( pItem != NULL )
{
m_pDialog->DrawText( pItem->strText, pElement, &m_rcText, false, -1, true );
}
}
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTComboBox::AddItem( const WCHAR* strText, void* pData )
{
// Validate parameters
if( strText == NULL )
{
return E_INVALIDARG;
}
// Create a new item and set the data
DXUTComboBoxItem* pItem = new DXUTComboBoxItem;
if( pItem == NULL )
{
return DXTRACE_ERR_MSGBOX( L"new", E_OUTOFMEMORY );
}
ZeroMemory( pItem, sizeof( DXUTComboBoxItem ) );
wcscpy_s( pItem->strText, 256, strText );
pItem->pData = pData;
m_Items.Add( pItem );
// Update the scroll bar with new range
m_ScrollBar.SetTrackRange( 0, m_Items.GetSize() );
// If this is the only item in the list, it's selected
if( GetNumItems() == 1 )
{
m_iSelected = 0;
m_iFocused = 0;
m_pDialog->SendEvent( EVENT_COMBOBOX_SELECTION_CHANGED, false, this );
}
return S_OK;
}
//--------------------------------------------------------------------------------------
void CDXUTComboBox::RemoveItem( UINT index )
{
DXUTComboBoxItem* pItem = m_Items.GetAt( index );
SAFE_DELETE( pItem );
m_Items.Remove( index );
m_ScrollBar.SetTrackRange( 0, m_Items.GetSize() );
if( m_iSelected >= m_Items.GetSize() )
m_iSelected = m_Items.GetSize() - 1;
}
//--------------------------------------------------------------------------------------
void CDXUTComboBox::RemoveAllItems()
{
for( int i = 0; i < m_Items.GetSize(); i++ )
{
DXUTComboBoxItem* pItem = m_Items.GetAt( i );
SAFE_DELETE( pItem );
}
m_Items.RemoveAll();
m_ScrollBar.SetTrackRange( 0, 1 );
m_iFocused = m_iSelected = -1;
}
//--------------------------------------------------------------------------------------
bool CDXUTComboBox::ContainsItem( const WCHAR* strText, UINT iStart )
{
return ( -1 != FindItem( strText, iStart ) );
}
//--------------------------------------------------------------------------------------
int CDXUTComboBox::FindItem( const WCHAR* strText, UINT iStart )
{
if( strText == NULL )
return -1;
for( int i = iStart; i < m_Items.GetSize(); i++ )
{
DXUTComboBoxItem* pItem = m_Items.GetAt( i );
if( 0 == wcscmp( pItem->strText, strText ) )
{
return i;
}
}
return -1;
}
//--------------------------------------------------------------------------------------
void* CDXUTComboBox::GetSelectedData()
{
if( m_iSelected < 0 )
return NULL;
DXUTComboBoxItem* pItem = m_Items.GetAt( m_iSelected );
return pItem->pData;
}
//--------------------------------------------------------------------------------------
DXUTComboBoxItem* CDXUTComboBox::GetSelectedItem()
{
if( m_iSelected < 0 )
return NULL;
return m_Items.GetAt( m_iSelected );
}
//--------------------------------------------------------------------------------------
void* CDXUTComboBox::GetItemData( const WCHAR* strText )
{
int index = FindItem( strText );
if( index == -1 )
{
return NULL;
}
DXUTComboBoxItem* pItem = m_Items.GetAt( index );
if( pItem == NULL )
{
DXTRACE_ERR( L"CGrowableArray::GetAt", E_FAIL );
return NULL;
}
return pItem->pData;
}
//--------------------------------------------------------------------------------------
void* CDXUTComboBox::GetItemData( int nIndex )
{
if( nIndex < 0 || nIndex >= m_Items.GetSize() )
return NULL;
return m_Items.GetAt( nIndex )->pData;
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTComboBox::SetSelectedByIndex( UINT index )
{
if( index >= GetNumItems() )
return E_INVALIDARG;
m_iFocused = m_iSelected = index;
m_pDialog->SendEvent( EVENT_COMBOBOX_SELECTION_CHANGED, false, this );
return S_OK;
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTComboBox::SetSelectedByText( const WCHAR* strText )
{
if( strText == NULL )
return E_INVALIDARG;
int index = FindItem( strText );
if( index == -1 )
return E_FAIL;
m_iFocused = m_iSelected = index;
m_pDialog->SendEvent( EVENT_COMBOBOX_SELECTION_CHANGED, false, this );
return S_OK;
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTComboBox::SetSelectedByData( void* pData )
{
for( int i = 0; i < m_Items.GetSize(); i++ )
{
DXUTComboBoxItem* pItem = m_Items.GetAt( i );
if( pItem->pData == pData )
{
m_iFocused = m_iSelected = i;
m_pDialog->SendEvent( EVENT_COMBOBOX_SELECTION_CHANGED, false, this );
return S_OK;
}
}
return E_FAIL;
}
//--------------------------------------------------------------------------------------
CDXUTSlider::CDXUTSlider( CDXUTDialog* pDialog )
{
m_Type = DXUT_CONTROL_SLIDER;
m_pDialog = pDialog;
m_nMin = 0;
m_nMax = 100;
m_nValue = 50;
m_bPressed = false;
}
//--------------------------------------------------------------------------------------
BOOL CDXUTSlider::ContainsPoint( POINT pt )
{
return ( PtInRect( &m_rcBoundingBox, pt ) ||
PtInRect( &m_rcButton, pt ) );
}
//--------------------------------------------------------------------------------------
void CDXUTSlider::UpdateRects()
{
CDXUTControl::UpdateRects();
m_rcButton = m_rcBoundingBox;
m_rcButton.right = m_rcButton.left + RectHeight( m_rcButton );
OffsetRect( &m_rcButton, -RectWidth( m_rcButton ) / 2, 0 );
m_nButtonX = ( int )( ( m_nValue - m_nMin ) * ( float )RectWidth( m_rcBoundingBox ) / ( m_nMax - m_nMin ) );
OffsetRect( &m_rcButton, m_nButtonX, 0 );
}
int CDXUTSlider::ValueFromPos( int x )
{
float fValuePerPixel = ( float )( m_nMax - m_nMin ) / RectWidth( m_rcBoundingBox );
return ( int )( 0.5f + m_nMin + fValuePerPixel * ( x - m_rcBoundingBox.left ) );
}
//--------------------------------------------------------------------------------------
bool CDXUTSlider::HandleKeyboard( UINT uMsg, WPARAM wParam, LPARAM lParam )
{
if( !m_bEnabled || !m_bVisible )
return false;
switch( uMsg )
{
case WM_KEYDOWN:
{
switch( wParam )
{
case VK_HOME:
SetValueInternal( m_nMin, true );
return true;
case VK_END:
SetValueInternal( m_nMax, true );
return true;
case VK_LEFT:
case VK_DOWN:
SetValueInternal( m_nValue - 1, true );
return true;
case VK_RIGHT:
case VK_UP:
SetValueInternal( m_nValue + 1, true );
return true;
case VK_NEXT:
SetValueInternal( m_nValue - ( 10 > ( m_nMax - m_nMin ) / 10 ? 10 : ( m_nMax - m_nMin ) / 10 ),
true );
return true;
case VK_PRIOR:
SetValueInternal( m_nValue + ( 10 > ( m_nMax - m_nMin ) / 10 ? 10 : ( m_nMax - m_nMin ) / 10 ),
true );
return true;
}
break;
}
}
return false;
}
//--------------------------------------------------------------------------------------
bool CDXUTSlider::HandleMouse( UINT uMsg, POINT pt, WPARAM wParam, LPARAM lParam )
{
if( !m_bEnabled || !m_bVisible )
return false;
switch( uMsg )
{
case WM_LBUTTONDOWN:
case WM_LBUTTONDBLCLK:
{
if( PtInRect( &m_rcButton, pt ) )
{
// Pressed while inside the control
m_bPressed = true;
SetCapture( DXUTGetHWND() );
m_nDragX = pt.x;
//m_nDragY = pt.y;
m_nDragOffset = m_nButtonX - m_nDragX;
//m_nDragValue = m_nValue;
if( !m_bHasFocus )
m_pDialog->RequestFocus( this );
return true;
}
if( PtInRect( &m_rcBoundingBox, pt ) )
{
m_nDragX = pt.x;
m_nDragOffset = 0;
m_bPressed = true;
if( !m_bHasFocus )
m_pDialog->RequestFocus( this );
if( pt.x > m_nButtonX + m_x )
{
SetValueInternal( m_nValue + 1, true );
return true;
}
if( pt.x < m_nButtonX + m_x )
{
SetValueInternal( m_nValue - 1, true );
return true;
}
}
break;
}
case WM_LBUTTONUP:
{
if( m_bPressed )
{
m_bPressed = false;
ReleaseCapture();
m_pDialog->SendEvent( EVENT_SLIDER_VALUE_CHANGED_UP, true, this );
return true;
}
break;
}
case WM_MOUSEMOVE:
{
if( m_bPressed )
{
SetValueInternal( ValueFromPos( m_x + pt.x + m_nDragOffset ), true );
return true;
}
break;
}
case WM_MOUSEWHEEL:
{
int nScrollAmount = int( ( short )HIWORD( wParam ) ) / WHEEL_DELTA;
SetValueInternal( m_nValue - nScrollAmount, true );
return true;
}
};
return false;
}
//--------------------------------------------------------------------------------------
void CDXUTSlider::SetRange( int nMin, int nMax )
{
m_nMin = nMin;
m_nMax = nMax;
SetValueInternal( m_nValue, false );
}
//--------------------------------------------------------------------------------------
void CDXUTSlider::SetValueInternal( int nValue, bool bFromInput )
{
// Clamp to range
nValue = __max( m_nMin, nValue );
nValue = __min( m_nMax, nValue );
if( nValue == m_nValue )
return;
m_nValue = nValue;
UpdateRects();
m_pDialog->SendEvent( EVENT_SLIDER_VALUE_CHANGED, bFromInput, this );
}
//--------------------------------------------------------------------------------------
void CDXUTSlider::Render( float fElapsedTime )
{
if( m_bVisible == false )
return;
int nOffsetX = 0;
int nOffsetY = 0;
DXUT_CONTROL_STATE iState = DXUT_STATE_NORMAL;
if( m_bVisible == false )
{
iState = DXUT_STATE_HIDDEN;
}
else if( m_bEnabled == false )
{
iState = DXUT_STATE_DISABLED;
}
else if( m_bPressed )
{
iState = DXUT_STATE_PRESSED;
nOffsetX = 1;
nOffsetY = 2;
}
else if( m_bMouseOver )
{
iState = DXUT_STATE_MOUSEOVER;
nOffsetX = -1;
nOffsetY = -2;
}
else if( m_bHasFocus )
{
iState = DXUT_STATE_FOCUS;
}
float fBlendRate = ( iState == DXUT_STATE_PRESSED ) ? 0.0f : 0.8f;
CDXUTElement* pElement = m_Elements.GetAt( 0 );
// Blend current color
pElement->TextureColor.Blend( iState, fElapsedTime, fBlendRate );
m_pDialog->DrawSprite( pElement, &m_rcBoundingBox, DXUT_FAR_BUTTON_DEPTH );
//TODO: remove magic numbers
pElement = m_Elements.GetAt( 1 );
// Blend current color
pElement->TextureColor.Blend( iState, fElapsedTime, fBlendRate );
m_pDialog->DrawSprite( pElement, &m_rcButton, DXUT_NEAR_BUTTON_DEPTH );
}
//--------------------------------------------------------------------------------------
// CDXUTScrollBar class
//--------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------
CDXUTScrollBar::CDXUTScrollBar( CDXUTDialog* pDialog )
{
m_Type = DXUT_CONTROL_SCROLLBAR;
m_pDialog = pDialog;
m_bShowThumb = true;
m_bDrag = false;
SetRect( &m_rcUpButton, 0, 0, 0, 0 );
SetRect( &m_rcDownButton, 0, 0, 0, 0 );
SetRect( &m_rcTrack, 0, 0, 0, 0 );
SetRect( &m_rcThumb, 0, 0, 0, 0 );
m_nPosition = 0;
m_nPageSize = 1;
m_nStart = 0;
m_nEnd = 1;
m_Arrow = CLEAR;
m_dArrowTS = 0.0;
}
//--------------------------------------------------------------------------------------
CDXUTScrollBar::~CDXUTScrollBar()
{
}
//--------------------------------------------------------------------------------------
void CDXUTScrollBar::UpdateRects()
{
CDXUTControl::UpdateRects();
// Make the buttons square
SetRect( &m_rcUpButton, m_rcBoundingBox.left, m_rcBoundingBox.top,
m_rcBoundingBox.right, m_rcBoundingBox.top + RectWidth( m_rcBoundingBox ) );
SetRect( &m_rcDownButton, m_rcBoundingBox.left, m_rcBoundingBox.bottom - RectWidth( m_rcBoundingBox ),
m_rcBoundingBox.right, m_rcBoundingBox.bottom );
SetRect( &m_rcTrack, m_rcUpButton.left, m_rcUpButton.bottom,
m_rcDownButton.right, m_rcDownButton.top );
m_rcThumb.left = m_rcUpButton.left;
m_rcThumb.right = m_rcUpButton.right;
UpdateThumbRect();
}
//--------------------------------------------------------------------------------------
// Compute the dimension of the scroll thumb
void CDXUTScrollBar::UpdateThumbRect()
{
if( m_nEnd - m_nStart > m_nPageSize )
{
int nThumbHeight = __max( RectHeight( m_rcTrack ) * m_nPageSize / ( m_nEnd - m_nStart ),
SCROLLBAR_MINTHUMBSIZE );
int nMaxPosition = m_nEnd - m_nStart - m_nPageSize;
m_rcThumb.top = m_rcTrack.top + ( m_nPosition - m_nStart ) * ( RectHeight( m_rcTrack ) - nThumbHeight )
/ nMaxPosition;
m_rcThumb.bottom = m_rcThumb.top + nThumbHeight;
m_bShowThumb = true;
}
else
{
// No content to scroll
m_rcThumb.bottom = m_rcThumb.top;
m_bShowThumb = false;
}
}
//--------------------------------------------------------------------------------------
// Scroll() scrolls by nDelta items. A positive value scrolls down, while a negative
// value scrolls up.
void CDXUTScrollBar::Scroll( int nDelta )
{
// Perform scroll
m_nPosition += nDelta;
// Cap position
Cap();
// Update thumb position
UpdateThumbRect();
}
//--------------------------------------------------------------------------------------
void CDXUTScrollBar::ShowItem( int nIndex )
{
// Cap the index
if( nIndex < 0 )
nIndex = 0;
if( nIndex >= m_nEnd )
nIndex = m_nEnd - 1;
// Adjust position
if( m_nPosition > nIndex )
m_nPosition = nIndex;
else if( m_nPosition + m_nPageSize <= nIndex )
m_nPosition = nIndex - m_nPageSize + 1;
UpdateThumbRect();
}
//--------------------------------------------------------------------------------------
bool CDXUTScrollBar::HandleKeyboard( UINT uMsg, WPARAM wParam, LPARAM lParam )
{
return false;
}
//--------------------------------------------------------------------------------------
bool CDXUTScrollBar::HandleMouse( UINT uMsg, POINT pt, WPARAM wParam, LPARAM lParam )
{
static int ThumbOffsetY;
m_LastMouse = pt;
switch( uMsg )
{
case WM_LBUTTONDOWN:
case WM_LBUTTONDBLCLK:
{
// Check for click on up button
if( PtInRect( &m_rcUpButton, pt ) )
{
SetCapture( DXUTGetHWND() );
if( m_nPosition > m_nStart )
--m_nPosition;
UpdateThumbRect();
m_Arrow = CLICKED_UP;
m_dArrowTS = DXUTGetTime();
return true;
}
// Check for click on down button
if( PtInRect( &m_rcDownButton, pt ) )
{
SetCapture( DXUTGetHWND() );
if( m_nPosition + m_nPageSize < m_nEnd )
++m_nPosition;
UpdateThumbRect();
m_Arrow = CLICKED_DOWN;
m_dArrowTS = DXUTGetTime();
return true;
}
// Check for click on thumb
if( PtInRect( &m_rcThumb, pt ) )
{
SetCapture( DXUTGetHWND() );
m_bDrag = true;
ThumbOffsetY = pt.y - m_rcThumb.top;
return true;
}
// Check for click on track
if( m_rcThumb.left <= pt.x &&
m_rcThumb.right > pt.x )
{
SetCapture( DXUTGetHWND() );
if( m_rcThumb.top > pt.y &&
m_rcTrack.top <= pt.y )
{
Scroll( -( m_nPageSize - 1 ) );
return true;
}
else if( m_rcThumb.bottom <= pt.y &&
m_rcTrack.bottom > pt.y )
{
Scroll( m_nPageSize - 1 );
return true;
}
}
break;
}
case WM_LBUTTONUP:
{
m_bDrag = false;
ReleaseCapture();
UpdateThumbRect();
m_Arrow = CLEAR;
break;
}
case WM_MOUSEMOVE:
{
if( m_bDrag )
{
m_rcThumb.bottom += pt.y - ThumbOffsetY - m_rcThumb.top;
m_rcThumb.top = pt.y - ThumbOffsetY;
if( m_rcThumb.top < m_rcTrack.top )
OffsetRect( &m_rcThumb, 0, m_rcTrack.top - m_rcThumb.top );
else if( m_rcThumb.bottom > m_rcTrack.bottom )
OffsetRect( &m_rcThumb, 0, m_rcTrack.bottom - m_rcThumb.bottom );
// Compute first item index based on thumb position
int nMaxFirstItem = m_nEnd - m_nStart - m_nPageSize; // Largest possible index for first item
int nMaxThumb = RectHeight( m_rcTrack ) - RectHeight( m_rcThumb ); // Largest possible thumb position from the top
m_nPosition = m_nStart +
( m_rcThumb.top - m_rcTrack.top +
nMaxThumb / ( nMaxFirstItem * 2 ) ) * // Shift by half a row to avoid last row covered by only one pixel
nMaxFirstItem / nMaxThumb;
return true;
}
break;
}
}
return false;
}
//--------------------------------------------------------------------------------------
bool CDXUTScrollBar::MsgProc( UINT uMsg, WPARAM wParam, LPARAM lParam )
{
if( WM_CAPTURECHANGED == uMsg )
{
// The application just lost mouse capture. We may not have gotten
// the WM_MOUSEUP message, so reset m_bDrag here.
if( ( HWND )lParam != DXUTGetHWND() )
m_bDrag = false;
}
return false;
}
//--------------------------------------------------------------------------------------
void CDXUTScrollBar::Render( float fElapsedTime )
{
if( m_bVisible == false )
return;
// Check if the arrow button has been held for a while.
// If so, update the thumb position to simulate repeated
// scroll.
if( m_Arrow != CLEAR )
{
double dCurrTime = DXUTGetTime();
if( PtInRect( &m_rcUpButton, m_LastMouse ) )
{
switch( m_Arrow )
{
case CLICKED_UP:
if( SCROLLBAR_ARROWCLICK_DELAY < dCurrTime - m_dArrowTS )
{
Scroll( -1 );
m_Arrow = HELD_UP;
m_dArrowTS = dCurrTime;
}
break;
case HELD_UP:
if( SCROLLBAR_ARROWCLICK_REPEAT < dCurrTime - m_dArrowTS )
{
Scroll( -1 );
m_dArrowTS = dCurrTime;
}
break;
}
}
else if( PtInRect( &m_rcDownButton, m_LastMouse ) )
{
switch( m_Arrow )
{
case CLICKED_DOWN:
if( SCROLLBAR_ARROWCLICK_DELAY < dCurrTime - m_dArrowTS )
{
Scroll( 1 );
m_Arrow = HELD_DOWN;
m_dArrowTS = dCurrTime;
}
break;
case HELD_DOWN:
if( SCROLLBAR_ARROWCLICK_REPEAT < dCurrTime - m_dArrowTS )
{
Scroll( 1 );
m_dArrowTS = dCurrTime;
}
break;
}
}
}
DXUT_CONTROL_STATE iState = DXUT_STATE_NORMAL;
if( m_bVisible == false )
iState = DXUT_STATE_HIDDEN;
else if( m_bEnabled == false || m_bShowThumb == false )
iState = DXUT_STATE_DISABLED;
else if( m_bMouseOver )
iState = DXUT_STATE_MOUSEOVER;
else if( m_bHasFocus )
iState = DXUT_STATE_FOCUS;
float fBlendRate = ( iState == DXUT_STATE_PRESSED ) ? 0.0f : 0.8f;
// Background track layer
CDXUTElement* pElement = m_Elements.GetAt( 0 );
// Blend current color
pElement->TextureColor.Blend( iState, fElapsedTime, fBlendRate );
m_pDialog->DrawSprite( pElement, &m_rcTrack, DXUT_FAR_BUTTON_DEPTH );
// Up Arrow
pElement = m_Elements.GetAt( 1 );
// Blend current color
pElement->TextureColor.Blend( iState, fElapsedTime, fBlendRate );
m_pDialog->DrawSprite( pElement, &m_rcUpButton, DXUT_NEAR_BUTTON_DEPTH );
// Down Arrow
pElement = m_Elements.GetAt( 2 );
// Blend current color
pElement->TextureColor.Blend( iState, fElapsedTime, fBlendRate );
m_pDialog->DrawSprite( pElement, &m_rcDownButton, DXUT_NEAR_BUTTON_DEPTH );
// Thumb button
pElement = m_Elements.GetAt( 3 );
// Blend current color
pElement->TextureColor.Blend( iState, fElapsedTime, fBlendRate );
m_pDialog->DrawSprite( pElement, &m_rcThumb, DXUT_NEAR_BUTTON_DEPTH );
}
//--------------------------------------------------------------------------------------
void CDXUTScrollBar::SetTrackRange( int nStart, int nEnd )
{
m_nStart = nStart; m_nEnd = nEnd;
Cap();
UpdateThumbRect();
}
//--------------------------------------------------------------------------------------
void CDXUTScrollBar::Cap() // Clips position at boundaries. Ensures it stays within legal range.
{
if( m_nPosition < m_nStart ||
m_nEnd - m_nStart <= m_nPageSize )
{
m_nPosition = m_nStart;
}
else if( m_nPosition + m_nPageSize > m_nEnd )
m_nPosition = m_nEnd - m_nPageSize;
}
//--------------------------------------------------------------------------------------
// CDXUTListBox class
//--------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------
CDXUTListBox::CDXUTListBox( CDXUTDialog* pDialog ) : m_ScrollBar( pDialog )
{
m_Type = DXUT_CONTROL_LISTBOX;
m_pDialog = pDialog;
m_dwStyle = 0;
m_nSBWidth = 16;
m_nSelected = -1;
m_nSelStart = 0;
m_bDrag = false;
m_nBorder = 6;
m_nMargin = 5;
m_nTextHeight = 0;
}
//--------------------------------------------------------------------------------------
CDXUTListBox::~CDXUTListBox()
{
RemoveAllItems();
}
//--------------------------------------------------------------------------------------
void CDXUTListBox::UpdateRects()
{
CDXUTControl::UpdateRects();
m_rcSelection = m_rcBoundingBox;
m_rcSelection.right -= m_nSBWidth;
InflateRect( &m_rcSelection, -m_nBorder, -m_nBorder );
m_rcText = m_rcSelection;
InflateRect( &m_rcText, -m_nMargin, 0 );
// Update the scrollbar's rects
m_ScrollBar.SetLocation( m_rcBoundingBox.right - m_nSBWidth, m_rcBoundingBox.top );
m_ScrollBar.SetSize( m_nSBWidth, m_height );
DXUTFontNode* pFontNode = m_pDialog->GetManager()->GetFontNode( m_Elements.GetAt( 0 )->iFont );
if( pFontNode && pFontNode->nHeight )
{
m_ScrollBar.SetPageSize( RectHeight( m_rcText ) / pFontNode->nHeight );
// The selected item may have been scrolled off the page.
// Ensure that it is in page again.
m_ScrollBar.ShowItem( m_nSelected );
}
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTListBox::AddItem( const WCHAR* wszText, void* pData )
{
DXUTListBoxItem* pNewItem = new DXUTListBoxItem;
if( !pNewItem )
return E_OUTOFMEMORY;
wcscpy_s( pNewItem->strText, 256, wszText );
pNewItem->pData = pData;
SetRect( &pNewItem->rcActive, 0, 0, 0, 0 );
pNewItem->bSelected = false;
HRESULT hr = m_Items.Add( pNewItem );
if( FAILED( hr ) )
{
SAFE_DELETE( pNewItem );
}
else
{
m_ScrollBar.SetTrackRange( 0, m_Items.GetSize() );
}
return hr;
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTListBox::InsertItem( int nIndex, const WCHAR* wszText, void* pData )
{
DXUTListBoxItem* pNewItem = new DXUTListBoxItem;
if( !pNewItem )
return E_OUTOFMEMORY;
wcscpy_s( pNewItem->strText, 256, wszText );
pNewItem->pData = pData;
SetRect( &pNewItem->rcActive, 0, 0, 0, 0 );
pNewItem->bSelected = false;
HRESULT hr = m_Items.Insert( nIndex, pNewItem );
if( SUCCEEDED( hr ) )
m_ScrollBar.SetTrackRange( 0, m_Items.GetSize() );
else
SAFE_DELETE( pNewItem );
return hr;
}
//--------------------------------------------------------------------------------------
void CDXUTListBox::RemoveItem( int nIndex )
{
if( nIndex < 0 || nIndex >= ( int )m_Items.GetSize() )
return;
DXUTListBoxItem* pItem = m_Items.GetAt( nIndex );
delete pItem;
m_Items.Remove( nIndex );
m_ScrollBar.SetTrackRange( 0, m_Items.GetSize() );
if( m_nSelected >= ( int )m_Items.GetSize() )
m_nSelected = m_Items.GetSize() - 1;
m_pDialog->SendEvent( EVENT_LISTBOX_SELECTION, true, this );
}
//--------------------------------------------------------------------------------------
void CDXUTListBox::RemoveAllItems()
{
for( int i = 0; i < m_Items.GetSize(); ++i )
{
DXUTListBoxItem* pItem = m_Items.GetAt( i );
delete pItem;
}
m_Items.RemoveAll();
m_ScrollBar.SetTrackRange( 0, 1 );
}
//--------------------------------------------------------------------------------------
DXUTListBoxItem* CDXUTListBox::GetItem( int nIndex )
{
if( nIndex < 0 || nIndex >= ( int )m_Items.GetSize() )
return NULL;
return m_Items[nIndex];
}
//--------------------------------------------------------------------------------------
// For single-selection listbox, returns the index of the selected item.
// For multi-selection, returns the first selected item after the nPreviousSelected position.
// To search for the first selected item, the app passes -1 for nPreviousSelected. For
// subsequent searches, the app passes the returned index back to GetSelectedIndex as.
// nPreviousSelected.
// Returns -1 on error or if no item is selected.
int CDXUTListBox::GetSelectedIndex( int nPreviousSelected )
{
if( nPreviousSelected < -1 )
return -1;
if( m_dwStyle & MULTISELECTION )
{
// Multiple selection enabled. Search for the next item with the selected flag.
for( int i = nPreviousSelected + 1; i < ( int )m_Items.GetSize(); ++i )
{
DXUTListBoxItem* pItem = m_Items.GetAt( i );
if( pItem->bSelected )
return i;
}
return -1;
}
else
{
// Single selection
return m_nSelected;
}
}
//--------------------------------------------------------------------------------------
void CDXUTListBox::SelectItem( int nNewIndex )
{
// If no item exists, do nothing.
if( m_Items.GetSize() == 0 )
return;
int nOldSelected = m_nSelected;
// Adjust m_nSelected
m_nSelected = nNewIndex;
// Perform capping
if( m_nSelected < 0 )
m_nSelected = 0;
if( m_nSelected >= ( int )m_Items.GetSize() )
m_nSelected = m_Items.GetSize() - 1;
if( nOldSelected != m_nSelected )
{
if( m_dwStyle & MULTISELECTION )
{
m_Items[m_nSelected]->bSelected = true;
}
// Update selection start
m_nSelStart = m_nSelected;
// Adjust scroll bar
m_ScrollBar.ShowItem( m_nSelected );
}
m_pDialog->SendEvent( EVENT_LISTBOX_SELECTION, true, this );
}
//--------------------------------------------------------------------------------------
bool CDXUTListBox::HandleKeyboard( UINT uMsg, WPARAM wParam, LPARAM lParam )
{
if( !m_bEnabled || !m_bVisible )
return false;
// Let the scroll bar have a chance to handle it first
if( m_ScrollBar.HandleKeyboard( uMsg, wParam, lParam ) )
return true;
switch( uMsg )
{
case WM_KEYDOWN:
switch( wParam )
{
case VK_UP:
case VK_DOWN:
case VK_NEXT:
case VK_PRIOR:
case VK_HOME:
case VK_END:
{
// If no item exists, do nothing.
if( m_Items.GetSize() == 0 )
return true;
int nOldSelected = m_nSelected;
// Adjust m_nSelected
switch( wParam )
{
case VK_UP:
--m_nSelected; break;
case VK_DOWN:
++m_nSelected; break;
case VK_NEXT:
m_nSelected += m_ScrollBar.GetPageSize() - 1; break;
case VK_PRIOR:
m_nSelected -= m_ScrollBar.GetPageSize() - 1; break;
case VK_HOME:
m_nSelected = 0; break;
case VK_END:
m_nSelected = m_Items.GetSize() - 1; break;
}
// Perform capping
if( m_nSelected < 0 )
m_nSelected = 0;
if( m_nSelected >= ( int )m_Items.GetSize() )
m_nSelected = m_Items.GetSize() - 1;
if( nOldSelected != m_nSelected )
{
if( m_dwStyle & MULTISELECTION )
{
// Multiple selection
// Clear all selection
for( int i = 0; i < ( int )m_Items.GetSize(); ++i )
{
DXUTListBoxItem* pItem = m_Items[i];
pItem->bSelected = false;
}
if( GetKeyState( VK_SHIFT ) < 0 )
{
// Select all items from m_nSelStart to
// m_nSelected
int nEnd = __max( m_nSelStart, m_nSelected );
for( int n = __min( m_nSelStart, m_nSelected ); n <= nEnd; ++n )
m_Items[n]->bSelected = true;
}
else
{
m_Items[m_nSelected]->bSelected = true;
// Update selection start
m_nSelStart = m_nSelected;
}
}
else
m_nSelStart = m_nSelected;
// Adjust scroll bar
m_ScrollBar.ShowItem( m_nSelected );
// Send notification
m_pDialog->SendEvent( EVENT_LISTBOX_SELECTION, true, this );
}
return true;
}
// Space is the hotkey for double-clicking an item.
//
case VK_SPACE:
m_pDialog->SendEvent( EVENT_LISTBOX_ITEM_DBLCLK, true, this );
return true;
}
break;
}
return false;
}
//--------------------------------------------------------------------------------------
bool CDXUTListBox::HandleMouse( UINT uMsg, POINT pt, WPARAM wParam, LPARAM lParam )
{
if( !m_bEnabled || !m_bVisible )
return false;
// First acquire focus
if( WM_LBUTTONDOWN == uMsg )
if( !m_bHasFocus )
m_pDialog->RequestFocus( this );
// Let the scroll bar handle it first.
if( m_ScrollBar.HandleMouse( uMsg, pt, wParam, lParam ) )
return true;
switch( uMsg )
{
case WM_LBUTTONDOWN:
case WM_LBUTTONDBLCLK:
// Check for clicks in the text area
if( m_Items.GetSize() > 0 && PtInRect( &m_rcSelection, pt ) )
{
// Compute the index of the clicked item
int nClicked;
if( m_nTextHeight )
nClicked = m_ScrollBar.GetTrackPos() + ( pt.y - m_rcText.top ) / m_nTextHeight;
else
nClicked = -1;
// Only proceed if the click falls on top of an item.
if( nClicked >= m_ScrollBar.GetTrackPos() &&
nClicked < ( int )m_Items.GetSize() &&
nClicked < m_ScrollBar.GetTrackPos() + m_ScrollBar.GetPageSize() )
{
SetCapture( DXUTGetHWND() );
m_bDrag = true;
// If this is a double click, fire off an event and exit
// since the first click would have taken care of the selection
// updating.
if( uMsg == WM_LBUTTONDBLCLK )
{
m_pDialog->SendEvent( EVENT_LISTBOX_ITEM_DBLCLK, true, this );
return true;
}
m_nSelected = nClicked;
if( !( wParam & MK_SHIFT ) )
m_nSelStart = m_nSelected;
// If this is a multi-selection listbox, update per-item
// selection data.
if( m_dwStyle & MULTISELECTION )
{
// Determine behavior based on the state of Shift and Ctrl
DXUTListBoxItem* pSelItem = m_Items.GetAt( m_nSelected );
if( ( wParam & ( MK_SHIFT | MK_CONTROL ) ) == MK_CONTROL )
{
// Control click. Reverse the selection of this item.
pSelItem->bSelected = !pSelItem->bSelected;
}
else if( ( wParam & ( MK_SHIFT | MK_CONTROL ) ) == MK_SHIFT )
{
// Shift click. Set the selection for all items
// from last selected item to the current item.
// Clear everything else.
int nBegin = __min( m_nSelStart, m_nSelected );
int nEnd = __max( m_nSelStart, m_nSelected );
for( int i = 0; i < nBegin; ++i )
{
DXUTListBoxItem* pItem = m_Items.GetAt( i );
pItem->bSelected = false;
}
for( int i = nEnd + 1; i < ( int )m_Items.GetSize(); ++i )
{
DXUTListBoxItem* pItem = m_Items.GetAt( i );
pItem->bSelected = false;
}
for( int i = nBegin; i <= nEnd; ++i )
{
DXUTListBoxItem* pItem = m_Items.GetAt( i );
pItem->bSelected = true;
}
}
else if( ( wParam & ( MK_SHIFT | MK_CONTROL ) ) == ( MK_SHIFT | MK_CONTROL ) )
{
// Control-Shift-click.
// The behavior is:
// Set all items from m_nSelStart to m_nSelected to
// the same state as m_nSelStart, not including m_nSelected.
// Set m_nSelected to selected.
int nBegin = __min( m_nSelStart, m_nSelected );
int nEnd = __max( m_nSelStart, m_nSelected );
// The two ends do not need to be set here.
bool bLastSelected = m_Items.GetAt( m_nSelStart )->bSelected;
for( int i = nBegin + 1; i < nEnd; ++i )
{
DXUTListBoxItem* pItem = m_Items.GetAt( i );
pItem->bSelected = bLastSelected;
}
pSelItem->bSelected = true;
// Restore m_nSelected to the previous value
// This matches the Windows behavior
m_nSelected = m_nSelStart;
}
else
{
// Simple click. Clear all items and select the clicked
// item.
for( int i = 0; i < ( int )m_Items.GetSize(); ++i )
{
DXUTListBoxItem* pItem = m_Items.GetAt( i );
pItem->bSelected = false;
}
pSelItem->bSelected = true;
}
} // End of multi-selection case
m_pDialog->SendEvent( EVENT_LISTBOX_SELECTION, true, this );
}
return true;
}
break;
case WM_LBUTTONUP:
{
ReleaseCapture();
m_bDrag = false;
if( m_nSelected != -1 )
{
// Set all items between m_nSelStart and m_nSelected to
// the same state as m_nSelStart
int nEnd = __max( m_nSelStart, m_nSelected );
for( int n = __min( m_nSelStart, m_nSelected ) + 1; n < nEnd; ++n )
m_Items[n]->bSelected = m_Items[m_nSelStart]->bSelected;
m_Items[m_nSelected]->bSelected = m_Items[m_nSelStart]->bSelected;
// If m_nSelStart and m_nSelected are not the same,
// the user has dragged the mouse to make a selection.
// Notify the application of this.
if( m_nSelStart != m_nSelected )
m_pDialog->SendEvent( EVENT_LISTBOX_SELECTION, true, this );
m_pDialog->SendEvent( EVENT_LISTBOX_SELECTION_END, true, this );
}
return false;
}
case WM_MOUSEMOVE:
if( m_bDrag )
{
// Compute the index of the item below cursor
int nItem;
if( m_nTextHeight )
nItem = m_ScrollBar.GetTrackPos() + ( pt.y - m_rcText.top ) / m_nTextHeight;
else
nItem = -1;
// Only proceed if the cursor is on top of an item.
if( nItem >= ( int )m_ScrollBar.GetTrackPos() &&
nItem < ( int )m_Items.GetSize() &&
nItem < m_ScrollBar.GetTrackPos() + m_ScrollBar.GetPageSize() )
{
m_nSelected = nItem;
m_pDialog->SendEvent( EVENT_LISTBOX_SELECTION, true, this );
}
else if( nItem < ( int )m_ScrollBar.GetTrackPos() )
{
// User drags the mouse above window top
m_ScrollBar.Scroll( -1 );
m_nSelected = m_ScrollBar.GetTrackPos();
m_pDialog->SendEvent( EVENT_LISTBOX_SELECTION, true, this );
}
else if( nItem >= m_ScrollBar.GetTrackPos() + m_ScrollBar.GetPageSize() )
{
// User drags the mouse below window bottom
m_ScrollBar.Scroll( 1 );
m_nSelected = __min( ( int )m_Items.GetSize(), m_ScrollBar.GetTrackPos() +
m_ScrollBar.GetPageSize() ) - 1;
m_pDialog->SendEvent( EVENT_LISTBOX_SELECTION, true, this );
}
}
break;
case WM_MOUSEWHEEL:
{
UINT uLines;
SystemParametersInfo( SPI_GETWHEELSCROLLLINES, 0, &uLines, 0 );
int nScrollAmount = int( ( short )HIWORD( wParam ) ) / WHEEL_DELTA * uLines;
m_ScrollBar.Scroll( -nScrollAmount );
return true;
}
}
return false;
}
//--------------------------------------------------------------------------------------
bool CDXUTListBox::MsgProc( UINT uMsg, WPARAM wParam, LPARAM lParam )
{
if( WM_CAPTURECHANGED == uMsg )
{
// The application just lost mouse capture. We may not have gotten
// the WM_MOUSEUP message, so reset m_bDrag here.
if( ( HWND )lParam != DXUTGetHWND() )
m_bDrag = false;
}
return false;
}
//--------------------------------------------------------------------------------------
void CDXUTListBox::Render( float fElapsedTime )
{
if( m_bVisible == false )
return;
CDXUTElement* pElement = m_Elements.GetAt( 0 );
pElement->TextureColor.Blend( DXUT_STATE_NORMAL, fElapsedTime );
pElement->FontColor.Blend( DXUT_STATE_NORMAL, fElapsedTime );
CDXUTElement* pSelElement = m_Elements.GetAt( 1 );
pSelElement->TextureColor.Blend( DXUT_STATE_NORMAL, fElapsedTime );
pSelElement->FontColor.Blend( DXUT_STATE_NORMAL, fElapsedTime );
m_pDialog->DrawSprite( pElement, &m_rcBoundingBox, DXUT_FAR_BUTTON_DEPTH );
// Render the text
if( m_Items.GetSize() > 0 )
{
// Find out the height of a single line of text
RECT rc = m_rcText;
RECT rcSel = m_rcSelection;
rc.bottom = rc.top + m_pDialog->GetManager()->GetFontNode( pElement->iFont )->nHeight;
// Update the line height formation
m_nTextHeight = rc.bottom - rc.top;
static bool bSBInit;
if( !bSBInit )
{
// Update the page size of the scroll bar
if( m_nTextHeight )
m_ScrollBar.SetPageSize( RectHeight( m_rcText ) / m_nTextHeight );
else
m_ScrollBar.SetPageSize( RectHeight( m_rcText ) );
bSBInit = true;
}
rc.right = m_rcText.right;
for( int i = m_ScrollBar.GetTrackPos(); i < ( int )m_Items.GetSize(); ++i )
{
if( rc.bottom > m_rcText.bottom )
break;
DXUTListBoxItem* pItem = m_Items.GetAt( i );
// Determine if we need to render this item with the
// selected element.
bool bSelectedStyle = false;
if( !( m_dwStyle & MULTISELECTION ) && i == m_nSelected )
bSelectedStyle = true;
else if( m_dwStyle & MULTISELECTION )
{
if( m_bDrag &&
( ( i >= m_nSelected && i < m_nSelStart ) ||
( i <= m_nSelected && i > m_nSelStart ) ) )
bSelectedStyle = m_Items[m_nSelStart]->bSelected;
else if( pItem->bSelected )
bSelectedStyle = true;
}
if( bSelectedStyle )
{
rcSel.top = rc.top; rcSel.bottom = rc.bottom;
m_pDialog->DrawSprite( pSelElement, &rcSel, DXUT_NEAR_BUTTON_DEPTH );
m_pDialog->DrawText( pItem->strText, pSelElement, &rc );
}
else
m_pDialog->DrawText( pItem->strText, pElement, &rc );
OffsetRect( &rc, 0, m_nTextHeight );
}
}
// Render the scroll bar
m_ScrollBar.Render( fElapsedTime );
}
// Static member initialization
HINSTANCE CUniBuffer::s_hDll = NULL;
HRESULT ( WINAPI*CUniBuffer::_ScriptApplyDigitSubstitution )( const SCRIPT_DIGITSUBSTITUTE*, SCRIPT_CONTROL*,
SCRIPT_STATE* ) = Dummy_ScriptApplyDigitSubstitution;
HRESULT ( WINAPI*CUniBuffer::_ScriptStringAnalyse )( HDC, const void*, int, int, int, DWORD, int, SCRIPT_CONTROL*,
SCRIPT_STATE*, const int*, SCRIPT_TABDEF*, const BYTE*,
SCRIPT_STRING_ANALYSIS* ) = Dummy_ScriptStringAnalyse;
HRESULT ( WINAPI*CUniBuffer::_ScriptStringCPtoX )( SCRIPT_STRING_ANALYSIS, int, BOOL, int* ) = Dummy_ScriptStringCPtoX;
HRESULT ( WINAPI*CUniBuffer::_ScriptStringXtoCP )( SCRIPT_STRING_ANALYSIS, int, int*, int* ) = Dummy_ScriptStringXtoCP;
HRESULT ( WINAPI*CUniBuffer::_ScriptStringFree )( SCRIPT_STRING_ANALYSIS* ) = Dummy_ScriptStringFree;
const SCRIPT_LOGATTR* ( WINAPI*CUniBuffer::_ScriptString_pLogAttr )( SCRIPT_STRING_ANALYSIS ) =
Dummy_ScriptString_pLogAttr;
const int* ( WINAPI*CUniBuffer::_ScriptString_pcOutChars )( SCRIPT_STRING_ANALYSIS ) =
Dummy_ScriptString_pcOutChars;
bool CDXUTEditBox::s_bHideCaret; // If true, we don't render the caret.
//--------------------------------------------------------------------------------------
// CDXUTEditBox class
//--------------------------------------------------------------------------------------
// When scrolling, EDITBOX_SCROLLEXTENT is reciprocal of the amount to scroll.
// If EDITBOX_SCROLLEXTENT = 4, then we scroll 1/4 of the control each time.
#define EDITBOX_SCROLLEXTENT 4
//--------------------------------------------------------------------------------------
CDXUTEditBox::CDXUTEditBox( CDXUTDialog* pDialog )
{
m_Type = DXUT_CONTROL_EDITBOX;
m_pDialog = pDialog;
m_nBorder = 5; // Default border width
m_nSpacing = 4; // Default spacing
m_bCaretOn = true;
m_dfBlink = GetCaretBlinkTime() * 0.001f;
m_dfLastBlink = DXUTGetGlobalTimer()->GetAbsoluteTime();
s_bHideCaret = false;
m_nFirstVisible = 0;
m_TextColor = D3DCOLOR_ARGB( 255, 16, 16, 16 );
m_SelTextColor = D3DCOLOR_ARGB( 255, 255, 255, 255 );
m_SelBkColor = D3DCOLOR_ARGB( 255, 40, 50, 92 );
m_CaretColor = D3DCOLOR_ARGB( 255, 0, 0, 0 );
m_nCaret = m_nSelStart = 0;
m_bInsertMode = true;
m_bMouseDrag = false;
}
//--------------------------------------------------------------------------------------
CDXUTEditBox::~CDXUTEditBox()
{
}
//--------------------------------------------------------------------------------------
// PlaceCaret: Set the caret to a character position, and adjust the scrolling if
// necessary.
//--------------------------------------------------------------------------------------
void CDXUTEditBox::PlaceCaret( int nCP )
{
assert( nCP >= 0 && nCP <= m_Buffer.GetTextSize() );
m_nCaret = nCP;
// Obtain the X offset of the character.
int nX1st, nX, nX2;
m_Buffer.CPtoX( m_nFirstVisible, FALSE, &nX1st ); // 1st visible char
m_Buffer.CPtoX( nCP, FALSE, &nX ); // LEAD
// If nCP is the NULL terminator, get the leading edge instead of trailing.
if( nCP == m_Buffer.GetTextSize() )
nX2 = nX;
else
m_Buffer.CPtoX( nCP, TRUE, &nX2 ); // TRAIL
// If the left edge of the char is smaller than the left edge of the 1st visible char,
// we need to scroll left until this char is visible.
if( nX < nX1st )
{
// Simply make the first visible character the char at the new caret position.
m_nFirstVisible = nCP;
}
else // If the right of the character is bigger than the offset of the control's
// right edge, we need to scroll right to this character.
if( nX2 > nX1st + RectWidth( m_rcText ) )
{
// Compute the X of the new left-most pixel
int nXNewLeft = nX2 - RectWidth( m_rcText );
// Compute the char position of this character
int nCPNew1st, nNewTrail;
m_Buffer.XtoCP( nXNewLeft, &nCPNew1st, &nNewTrail );
// If this coordinate is not on a character border,
// start from the next character so that the caret
// position does not fall outside the text rectangle.
int nXNew1st;
m_Buffer.CPtoX( nCPNew1st, FALSE, &nXNew1st );
if( nXNew1st < nXNewLeft )
++nCPNew1st;
m_nFirstVisible = nCPNew1st;
}
}
//--------------------------------------------------------------------------------------
void CDXUTEditBox::ClearText()
{
m_Buffer.Clear();
m_nFirstVisible = 0;
PlaceCaret( 0 );
m_nSelStart = 0;
}
//--------------------------------------------------------------------------------------
void CDXUTEditBox::SetText( LPCWSTR wszText, bool bSelected )
{
assert( wszText != NULL );
m_Buffer.SetText( wszText );
m_nFirstVisible = 0;
// Move the caret to the end of the text
PlaceCaret( m_Buffer.GetTextSize() );
m_nSelStart = bSelected ? 0 : m_nCaret;
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTEditBox::GetTextCopy( __out_ecount(bufferCount) LPWSTR strDest,
UINT bufferCount )
{
assert( strDest );
wcscpy_s( strDest, bufferCount, m_Buffer.GetBuffer() );
return S_OK;
}
//--------------------------------------------------------------------------------------
void CDXUTEditBox::DeleteSelectionText()
{
int nFirst = __min( m_nCaret, m_nSelStart );
int nLast = __max( m_nCaret, m_nSelStart );
// Update caret and selection
PlaceCaret( nFirst );
m_nSelStart = m_nCaret;
// Remove the characters
for( int i = nFirst; i < nLast; ++i )
m_Buffer.RemoveChar( nFirst );
}
//--------------------------------------------------------------------------------------
void CDXUTEditBox::UpdateRects()
{
CDXUTControl::UpdateRects();
// Update the text rectangle
m_rcText = m_rcBoundingBox;
// First inflate by m_nBorder to compute render rects
InflateRect( &m_rcText, -m_nBorder, -m_nBorder );
// Update the render rectangles
m_rcRender[0] = m_rcText;
SetRect( &m_rcRender[1], m_rcBoundingBox.left, m_rcBoundingBox.top, m_rcText.left, m_rcText.top );
SetRect( &m_rcRender[2], m_rcText.left, m_rcBoundingBox.top, m_rcText.right, m_rcText.top );
SetRect( &m_rcRender[3], m_rcText.right, m_rcBoundingBox.top, m_rcBoundingBox.right, m_rcText.top );
SetRect( &m_rcRender[4], m_rcBoundingBox.left, m_rcText.top, m_rcText.left, m_rcText.bottom );
SetRect( &m_rcRender[5], m_rcText.right, m_rcText.top, m_rcBoundingBox.right, m_rcText.bottom );
SetRect( &m_rcRender[6], m_rcBoundingBox.left, m_rcText.bottom, m_rcText.left, m_rcBoundingBox.bottom );
SetRect( &m_rcRender[7], m_rcText.left, m_rcText.bottom, m_rcText.right, m_rcBoundingBox.bottom );
SetRect( &m_rcRender[8], m_rcText.right, m_rcText.bottom, m_rcBoundingBox.right, m_rcBoundingBox.bottom );
// Inflate further by m_nSpacing
InflateRect( &m_rcText, -m_nSpacing, -m_nSpacing );
}
void CDXUTEditBox::CopyToClipboard()
{
// Copy the selection text to the clipboard
if( m_nCaret != m_nSelStart && OpenClipboard( NULL ) )
{
EmptyClipboard();
HGLOBAL hBlock = GlobalAlloc( GMEM_MOVEABLE, sizeof( WCHAR ) * ( m_Buffer.GetTextSize() + 1 ) );
if( hBlock )
{
WCHAR* pwszText = ( WCHAR* )GlobalLock( hBlock );
if( pwszText )
{
int nFirst = __min( m_nCaret, m_nSelStart );
int nLast = __max( m_nCaret, m_nSelStart );
if( nLast - nFirst > 0 )
CopyMemory( pwszText, m_Buffer.GetBuffer() + nFirst, ( nLast - nFirst ) * sizeof( WCHAR ) );
pwszText[nLast - nFirst] = L'\0'; // Terminate it
GlobalUnlock( hBlock );
}
SetClipboardData( CF_UNICODETEXT, hBlock );
}
CloseClipboard();
// We must not free the object until CloseClipboard is called.
if( hBlock )
GlobalFree( hBlock );
}
}
void CDXUTEditBox::PasteFromClipboard()
{
DeleteSelectionText();
if( OpenClipboard( NULL ) )
{
HANDLE handle = GetClipboardData( CF_UNICODETEXT );
if( handle )
{
// Convert the ANSI string to Unicode, then
// insert to our buffer.
WCHAR* pwszText = ( WCHAR* )GlobalLock( handle );
if( pwszText )
{
// Copy all characters up to null.
if( m_Buffer.InsertString( m_nCaret, pwszText ) )
PlaceCaret( m_nCaret + lstrlenW( pwszText ) );
m_nSelStart = m_nCaret;
GlobalUnlock( handle );
}
}
CloseClipboard();
}
}
//--------------------------------------------------------------------------------------
bool CDXUTEditBox::HandleKeyboard( UINT uMsg, WPARAM wParam, LPARAM lParam )
{
if( !m_bEnabled || !m_bVisible )
return false;
bool bHandled = false;
switch( uMsg )
{
case WM_KEYDOWN:
{
switch( wParam )
{
case VK_TAB:
// We don't process Tab in case keyboard input is enabled and the user
// wishes to Tab to other controls.
break;
case VK_HOME:
PlaceCaret( 0 );
if( GetKeyState( VK_SHIFT ) >= 0 )
// Shift is not down. Update selection
// start along with the caret.
m_nSelStart = m_nCaret;
ResetCaretBlink();
bHandled = true;
break;
case VK_END:
PlaceCaret( m_Buffer.GetTextSize() );
if( GetKeyState( VK_SHIFT ) >= 0 )
// Shift is not down. Update selection
// start along with the caret.
m_nSelStart = m_nCaret;
ResetCaretBlink();
bHandled = true;
break;
case VK_INSERT:
if( GetKeyState( VK_CONTROL ) < 0 )
{
// Control Insert. Copy to clipboard
CopyToClipboard();
}
else if( GetKeyState( VK_SHIFT ) < 0 )
{
// Shift Insert. Paste from clipboard
PasteFromClipboard();
}
else
{
// Toggle caret insert mode
m_bInsertMode = !m_bInsertMode;
}
break;
case VK_DELETE:
// Check if there is a text selection.
if( m_nCaret != m_nSelStart )
{
DeleteSelectionText();
m_pDialog->SendEvent( EVENT_EDITBOX_CHANGE, true, this );
}
else
{
// Deleting one character
if( m_Buffer.RemoveChar( m_nCaret ) )
m_pDialog->SendEvent( EVENT_EDITBOX_CHANGE, true, this );
}
ResetCaretBlink();
bHandled = true;
break;
case VK_LEFT:
if( GetKeyState( VK_CONTROL ) < 0 )
{
// Control is down. Move the caret to a new item
// instead of a character.
m_Buffer.GetPriorItemPos( m_nCaret, &m_nCaret );
PlaceCaret( m_nCaret );
}
else if( m_nCaret > 0 )
PlaceCaret( m_nCaret - 1 );
if( GetKeyState( VK_SHIFT ) >= 0 )
// Shift is not down. Update selection
// start along with the caret.
m_nSelStart = m_nCaret;
ResetCaretBlink();
bHandled = true;
break;
case VK_RIGHT:
if( GetKeyState( VK_CONTROL ) < 0 )
{
// Control is down. Move the caret to a new item
// instead of a character.
m_Buffer.GetNextItemPos( m_nCaret, &m_nCaret );
PlaceCaret( m_nCaret );
}
else if( m_nCaret < m_Buffer.GetTextSize() )
PlaceCaret( m_nCaret + 1 );
if( GetKeyState( VK_SHIFT ) >= 0 )
// Shift is not down. Update selection
// start along with the caret.
m_nSelStart = m_nCaret;
ResetCaretBlink();
bHandled = true;
break;
case VK_UP:
case VK_DOWN:
// Trap up and down arrows so that the dialog
// does not switch focus to another control.
bHandled = true;
break;
default:
bHandled = wParam != VK_ESCAPE; // Let the application handle Esc.
}
}
}
return bHandled;
}
//--------------------------------------------------------------------------------------
bool CDXUTEditBox::HandleMouse( UINT uMsg, POINT pt, WPARAM wParam, LPARAM lParam )
{
if( !m_bEnabled || !m_bVisible )
return false;
switch( uMsg )
{
case WM_LBUTTONDOWN:
case WM_LBUTTONDBLCLK:
{
if( !m_bHasFocus )
m_pDialog->RequestFocus( this );
if( !ContainsPoint( pt ) )
return false;
m_bMouseDrag = true;
SetCapture( DXUTGetHWND() );
// Determine the character corresponding to the coordinates.
int nCP, nTrail, nX1st;
m_Buffer.CPtoX( m_nFirstVisible, FALSE, &nX1st ); // X offset of the 1st visible char
if( SUCCEEDED( m_Buffer.XtoCP( pt.x - m_rcText.left + nX1st, &nCP, &nTrail ) ) )
{
// Cap at the NULL character.
if( nTrail && nCP < m_Buffer.GetTextSize() )
PlaceCaret( nCP + 1 );
else
PlaceCaret( nCP );
m_nSelStart = m_nCaret;
ResetCaretBlink();
}
return true;
}
case WM_LBUTTONUP:
ReleaseCapture();
m_bMouseDrag = false;
break;
case WM_MOUSEMOVE:
if( m_bMouseDrag )
{
// Determine the character corresponding to the coordinates.
int nCP, nTrail, nX1st;
m_Buffer.CPtoX( m_nFirstVisible, FALSE, &nX1st ); // X offset of the 1st visible char
if( SUCCEEDED( m_Buffer.XtoCP( pt.x - m_rcText.left + nX1st, &nCP, &nTrail ) ) )
{
// Cap at the NULL character.
if( nTrail && nCP < m_Buffer.GetTextSize() )
PlaceCaret( nCP + 1 );
else
PlaceCaret( nCP );
}
}
break;
}
return false;
}
//--------------------------------------------------------------------------------------
void CDXUTEditBox::OnFocusIn()
{
CDXUTControl::OnFocusIn();
ResetCaretBlink();
}
//--------------------------------------------------------------------------------------
bool CDXUTEditBox::MsgProc( UINT uMsg, WPARAM wParam, LPARAM lParam )
{
if( !m_bEnabled || !m_bVisible )
return false;
switch( uMsg )
{
// Make sure that while editing, the keyup and keydown messages associated with
// WM_CHAR messages don't go to any non-focused controls or cameras
case WM_KEYUP:
case WM_KEYDOWN:
return true;
case WM_CHAR:
{
switch( ( WCHAR )wParam )
{
// Backspace
case VK_BACK:
{
// If there's a selection, treat this
// like a delete key.
if( m_nCaret != m_nSelStart )
{
DeleteSelectionText();
m_pDialog->SendEvent( EVENT_EDITBOX_CHANGE, true, this );
}
else if( m_nCaret > 0 )
{
// Move the caret, then delete the char.
PlaceCaret( m_nCaret - 1 );
m_nSelStart = m_nCaret;
m_Buffer.RemoveChar( m_nCaret );
m_pDialog->SendEvent( EVENT_EDITBOX_CHANGE, true, this );
}
ResetCaretBlink();
break;
}
case 24: // Ctrl-X Cut
case VK_CANCEL: // Ctrl-C Copy
{
CopyToClipboard();
// If the key is Ctrl-X, delete the selection too.
if( ( WCHAR )wParam == 24 )
{
DeleteSelectionText();
m_pDialog->SendEvent( EVENT_EDITBOX_CHANGE, true, this );
}
break;
}
// Ctrl-V Paste
case 22:
{
PasteFromClipboard();
m_pDialog->SendEvent( EVENT_EDITBOX_CHANGE, true, this );
break;
}
// Ctrl-A Select All
case 1:
if( m_nSelStart == m_nCaret )
{
m_nSelStart = 0;
PlaceCaret( m_Buffer.GetTextSize() );
}
break;
case VK_RETURN:
// Invoke the callback when the user presses Enter.
m_pDialog->SendEvent( EVENT_EDITBOX_STRING, true, this );
break;
// Junk characters we don't want in the string
case 26: // Ctrl Z
case 2: // Ctrl B
case 14: // Ctrl N
case 19: // Ctrl S
case 4: // Ctrl D
case 6: // Ctrl F
case 7: // Ctrl G
case 10: // Ctrl J
case 11: // Ctrl K
case 12: // Ctrl L
case 17: // Ctrl Q
case 23: // Ctrl W
case 5: // Ctrl E
case 18: // Ctrl R
case 20: // Ctrl T
case 25: // Ctrl Y
case 21: // Ctrl U
case 9: // Ctrl I
case 15: // Ctrl O
case 16: // Ctrl P
case 27: // Ctrl [
case 29: // Ctrl ]
case 28: // Ctrl \
break;
default:
{
// If there's a selection and the user
// starts to type, the selection should
// be deleted.
if( m_nCaret != m_nSelStart )
DeleteSelectionText();
// If we are in overwrite mode and there is already
// a char at the caret's position, simply replace it.
// Otherwise, we insert the char as normal.
if( !m_bInsertMode && m_nCaret < m_Buffer.GetTextSize() )
{
m_Buffer[m_nCaret] = ( WCHAR )wParam;
PlaceCaret( m_nCaret + 1 );
m_nSelStart = m_nCaret;
}
else
{
// Insert the char
if( m_Buffer.InsertChar( m_nCaret, ( WCHAR )wParam ) )
{
PlaceCaret( m_nCaret + 1 );
m_nSelStart = m_nCaret;
}
}
ResetCaretBlink();
m_pDialog->SendEvent( EVENT_EDITBOX_CHANGE, true, this );
}
}
return true;
}
}
return false;
}
//--------------------------------------------------------------------------------------
void CDXUTEditBox::Render( float fElapsedTime )
{
if( m_bVisible == false )
return;
HRESULT hr;
int nSelStartX = 0, nCaretX = 0; // Left and right X cordinates of the selection region
CDXUTElement* pElement = GetElement( 0 );
if( pElement )
{
m_Buffer.SetFontNode( m_pDialog->GetFont( pElement->iFont ) );
PlaceCaret( m_nCaret ); // Call PlaceCaret now that we have the font info (node),
// so that scrolling can be handled.
}
// Render the control graphics
for( int e = 0; e < 9; ++e )
{
pElement = m_Elements.GetAt( e );
pElement->TextureColor.Blend( DXUT_STATE_NORMAL, fElapsedTime );
m_pDialog->DrawSprite( pElement, &m_rcRender[e], DXUT_FAR_BUTTON_DEPTH );
}
//
// Compute the X coordinates of the first visible character.
//
int nXFirst;
m_Buffer.CPtoX( m_nFirstVisible, FALSE, &nXFirst );
//
// Compute the X coordinates of the selection rectangle
//
hr = m_Buffer.CPtoX( m_nCaret, FALSE, &nCaretX );
if( m_nCaret != m_nSelStart )
hr = m_Buffer.CPtoX( m_nSelStart, FALSE, &nSelStartX );
else
nSelStartX = nCaretX;
//
// Render the selection rectangle
//
RECT rcSelection; // Make this available for rendering selected text
if( m_nCaret != m_nSelStart )
{
int nSelLeftX = nCaretX, nSelRightX = nSelStartX;
// Swap if left is bigger than right
if( nSelLeftX > nSelRightX )
{
int nTemp = nSelLeftX; nSelLeftX = nSelRightX; nSelRightX = nTemp;
}
SetRect( &rcSelection, nSelLeftX, m_rcText.top, nSelRightX, m_rcText.bottom );
OffsetRect( &rcSelection, m_rcText.left - nXFirst, 0 );
IntersectRect( &rcSelection, &m_rcText, &rcSelection );
IDirect3DDevice9* pd3dDevice = m_pDialog->GetManager()->GetD3D9Device();
if( pd3dDevice )
pd3dDevice->SetRenderState( D3DRS_ZENABLE, FALSE );
m_pDialog->DrawRect( &rcSelection, m_SelBkColor );
if( pd3dDevice )
pd3dDevice->SetRenderState( D3DRS_ZENABLE, TRUE );
}
//
// Render the text
//
// Element 0 for text
m_Elements.GetAt( 0 )->FontColor.Current = m_TextColor;
m_pDialog->DrawText( m_Buffer.GetBuffer() + m_nFirstVisible, m_Elements.GetAt( 0 ), &m_rcText );
// Render the selected text
if( m_nCaret != m_nSelStart )
{
int nFirstToRender = __max( m_nFirstVisible, __min( m_nSelStart, m_nCaret ) );
int nNumChatToRender = __max( m_nSelStart, m_nCaret ) - nFirstToRender;
m_Elements.GetAt( 0 )->FontColor.Current = m_SelTextColor;
m_pDialog->DrawText( m_Buffer.GetBuffer() + nFirstToRender,
m_Elements.GetAt( 0 ), &rcSelection, false, nNumChatToRender );
}
//
// Blink the caret
//
if( DXUTGetGlobalTimer()->GetAbsoluteTime() - m_dfLastBlink >= m_dfBlink )
{
m_bCaretOn = !m_bCaretOn;
m_dfLastBlink = DXUTGetGlobalTimer()->GetAbsoluteTime();
}
//
// Render the caret if this control has the focus
//
if( m_bHasFocus && m_bCaretOn && !s_bHideCaret )
{
// Start the rectangle with insert mode caret
RECT rcCaret =
{
m_rcText.left - nXFirst + nCaretX - 1, m_rcText.top,
m_rcText.left - nXFirst + nCaretX + 1, m_rcText.bottom
};
// If we are in overwrite mode, adjust the caret rectangle
// to fill the entire character.
if( !m_bInsertMode )
{
// Obtain the right edge X coord of the current character
int nRightEdgeX;
m_Buffer.CPtoX( m_nCaret, TRUE, &nRightEdgeX );
rcCaret.right = m_rcText.left - nXFirst + nRightEdgeX;
}
m_pDialog->DrawRect( &rcCaret, m_CaretColor );
}
}
#define IN_FLOAT_CHARSET( c ) \
( (c) == L'-' || (c) == L'.' || ( (c) >= L'0' && (c) <= L'9' ) )
void CDXUTEditBox::ParseFloatArray( float* pNumbers, int nCount )
{
int nWritten = 0; // Number of floats written
const WCHAR* pToken, *pEnd;
WCHAR wszToken[60];
pToken = m_Buffer.GetBuffer();
while( nWritten < nCount && *pToken != L'\0' )
{
// Skip leading spaces
while( *pToken == L' ' )
++pToken;
if( *pToken == L'\0' )
break;
// Locate the end of number
pEnd = pToken;
while( IN_FLOAT_CHARSET( *pEnd ) )
++pEnd;
// Copy the token to our buffer
int nTokenLen = __min( sizeof( wszToken ) / sizeof( wszToken[0] ) - 1, int( pEnd - pToken ) );
wcscpy_s( wszToken, nTokenLen, pToken );
*pNumbers = ( float )wcstod( wszToken, NULL );
++nWritten;
++pNumbers;
pToken = pEnd;
}
}
void CDXUTEditBox::SetTextFloatArray( const float* pNumbers, int nCount )
{
WCHAR wszBuffer[512] =
{
0
};
WCHAR wszTmp[64];
if( pNumbers == NULL )
return;
for( int i = 0; i < nCount; ++i )
{
swprintf_s( wszTmp, 64, L"%.4f ", pNumbers[i] );
wcscat_s( wszBuffer, 512, wszTmp );
}
// Don't want the last space
if( nCount > 0 && wcslen( wszBuffer ) > 0 )
wszBuffer[wcslen( wszBuffer ) - 1] = 0;
SetText( wszBuffer );
}
//--------------------------------------------------------------------------------------
void CUniBuffer::Initialize()
{
if( s_hDll ) // Only need to do once
return;
s_hDll = LoadLibrary( UNISCRIBE_DLLNAME );
if( s_hDll )
{
FARPROC Temp;
GETPROCADDRESS( s_hDll, ScriptApplyDigitSubstitution, Temp );
GETPROCADDRESS( s_hDll, ScriptStringAnalyse, Temp );
GETPROCADDRESS( s_hDll, ScriptStringCPtoX, Temp );
GETPROCADDRESS( s_hDll, ScriptStringXtoCP, Temp );
GETPROCADDRESS( s_hDll, ScriptStringFree, Temp );
GETPROCADDRESS( s_hDll, ScriptString_pLogAttr, Temp );
GETPROCADDRESS( s_hDll, ScriptString_pcOutChars, Temp );
}
}
//--------------------------------------------------------------------------------------
void CUniBuffer::Uninitialize()
{
if( s_hDll )
{
PLACEHOLDERPROC( ScriptApplyDigitSubstitution );
PLACEHOLDERPROC( ScriptStringAnalyse );
PLACEHOLDERPROC( ScriptStringCPtoX );
PLACEHOLDERPROC( ScriptStringXtoCP );
PLACEHOLDERPROC( ScriptStringFree );
PLACEHOLDERPROC( ScriptString_pLogAttr );
PLACEHOLDERPROC( ScriptString_pcOutChars );
FreeLibrary( s_hDll );
s_hDll = NULL;
}
}
//--------------------------------------------------------------------------------------
bool CUniBuffer::SetBufferSize( int nNewSize )
{
// If the current size is already the maximum allowed,
// we can't possibly allocate more.
if( m_nBufferSize == DXUT_MAX_EDITBOXLENGTH )
return false;
int nAllocateSize = ( nNewSize == -1 || nNewSize < m_nBufferSize * 2 ) ? ( m_nBufferSize ? m_nBufferSize *
2 : 256 ) : nNewSize * 2;
// Cap the buffer size at the maximum allowed.
if( nAllocateSize > DXUT_MAX_EDITBOXLENGTH )
nAllocateSize = DXUT_MAX_EDITBOXLENGTH;
WCHAR* pTempBuffer = new WCHAR[nAllocateSize];
if( !pTempBuffer )
return false;
ZeroMemory( pTempBuffer, sizeof( WCHAR ) * nAllocateSize );
if( m_pwszBuffer )
{
CopyMemory( pTempBuffer, m_pwszBuffer, m_nBufferSize * sizeof( WCHAR ) );
delete[] m_pwszBuffer;
}
m_pwszBuffer = pTempBuffer;
m_nBufferSize = nAllocateSize;
return true;
}
//--------------------------------------------------------------------------------------
// Uniscribe -- Analyse() analyses the string in the buffer
//--------------------------------------------------------------------------------------
HRESULT CUniBuffer::Analyse()
{
if( m_Analysis )
_ScriptStringFree( &m_Analysis );
SCRIPT_CONTROL ScriptControl; // For uniscribe
SCRIPT_STATE ScriptState; // For uniscribe
ZeroMemory( &ScriptControl, sizeof( ScriptControl ) );
ZeroMemory( &ScriptState, sizeof( ScriptState ) );
_ScriptApplyDigitSubstitution( NULL, &ScriptControl, &ScriptState );
if( !m_pFontNode )
return E_FAIL;
HDC hDC =
( m_pFontNode->pFont9 ? m_pFontNode->pFont9->GetDC() : NULL );
HRESULT hr = _ScriptStringAnalyse( hDC,
m_pwszBuffer,
lstrlenW( m_pwszBuffer ) + 1, // NULL is also analyzed.
lstrlenW( m_pwszBuffer ) * 3 / 2 + 16,
-1,
SSA_BREAK | SSA_GLYPHS | SSA_FALLBACK | SSA_LINK,
0,
&ScriptControl,
&ScriptState,
NULL,
NULL,
NULL,
&m_Analysis );
if( SUCCEEDED( hr ) )
m_bAnalyseRequired = false; // Analysis is up-to-date
return hr;
}
//--------------------------------------------------------------------------------------
CUniBuffer::CUniBuffer( int nInitialSize )
{
CUniBuffer::Initialize(); // ensure static vars are properly init'ed first
m_nBufferSize = 0;
m_pwszBuffer = NULL;
m_bAnalyseRequired = true;
m_Analysis = NULL;
m_pFontNode = NULL;
if( nInitialSize > 0 )
SetBufferSize( nInitialSize );
}
//--------------------------------------------------------------------------------------
CUniBuffer::~CUniBuffer()
{
delete[] m_pwszBuffer;
if( m_Analysis )
_ScriptStringFree( &m_Analysis );
}
//--------------------------------------------------------------------------------------
WCHAR& CUniBuffer::operator[]( int n ) // No param checking
{
// This version of operator[] is called only
// if we are asking for write access, so
// re-analysis is required.
m_bAnalyseRequired = true;
return m_pwszBuffer[n];
}
//--------------------------------------------------------------------------------------
void CUniBuffer::Clear()
{
*m_pwszBuffer = L'\0';
m_bAnalyseRequired = true;
}
//--------------------------------------------------------------------------------------
// Inserts the char at specified index.
// If nIndex == -1, insert to the end.
//--------------------------------------------------------------------------------------
bool CUniBuffer::InsertChar( int nIndex, WCHAR wChar )
{
assert( nIndex >= 0 );
if( nIndex < 0 || nIndex > lstrlenW( m_pwszBuffer ) )
return false; // invalid index
// Check for maximum length allowed
if( GetTextSize() + 1 >= DXUT_MAX_EDITBOXLENGTH )
return false;
if( lstrlenW( m_pwszBuffer ) + 1 >= m_nBufferSize )
{
if( !SetBufferSize( -1 ) )
return false; // out of memory
}
assert( m_nBufferSize >= 2 );
// Shift the characters after the index, start by copying the null terminator
WCHAR* dest = m_pwszBuffer + lstrlenW( m_pwszBuffer ) + 1;
WCHAR* stop = m_pwszBuffer + nIndex;
WCHAR* src = dest - 1;
while( dest > stop )
{
*dest-- = *src--;
}
// Set new character
m_pwszBuffer[ nIndex ] = wChar;
m_bAnalyseRequired = true;
return true;
}
//--------------------------------------------------------------------------------------
// Removes the char at specified index.
// If nIndex == -1, remove the last char.
//--------------------------------------------------------------------------------------
bool CUniBuffer::RemoveChar( int nIndex )
{
if( !lstrlenW( m_pwszBuffer ) || nIndex < 0 || nIndex >= lstrlenW( m_pwszBuffer ) )
return false; // Invalid index
MoveMemory( m_pwszBuffer + nIndex, m_pwszBuffer + nIndex + 1, sizeof( WCHAR ) *
( lstrlenW( m_pwszBuffer ) - nIndex ) );
m_bAnalyseRequired = true;
return true;
}
//--------------------------------------------------------------------------------------
// 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 CUniBuffer::InsertString( int nIndex, const WCHAR* pStr, int nCount )
{
assert( nIndex >= 0 );
if( nIndex < 0 )
return false;
if( nIndex > lstrlenW( m_pwszBuffer ) )
return false; // invalid index
if( -1 == nCount )
nCount = lstrlenW( pStr );
// Check for maximum length allowed
if( GetTextSize() + nCount >= DXUT_MAX_EDITBOXLENGTH )
return false;
if( lstrlenW( m_pwszBuffer ) + nCount >= m_nBufferSize )
{
if( !SetBufferSize( lstrlenW( m_pwszBuffer ) + nCount + 1 ) )
return false; // out of memory
}
MoveMemory( m_pwszBuffer + nIndex + nCount, m_pwszBuffer + nIndex, sizeof( WCHAR ) *
( lstrlenW( m_pwszBuffer ) - nIndex + 1 ) );
CopyMemory( m_pwszBuffer + nIndex, pStr, nCount * sizeof( WCHAR ) );
m_bAnalyseRequired = true;
return true;
}
//--------------------------------------------------------------------------------------
bool CUniBuffer::SetText( LPCWSTR wszText )
{
assert( wszText != NULL );
int nRequired = int( wcslen( wszText ) + 1 );
// Check for maximum length allowed
if( nRequired >= DXUT_MAX_EDITBOXLENGTH )
return false;
while( GetBufferSize() < nRequired )
if( !SetBufferSize( -1 ) )
break;
// Check again in case out of memory occurred inside while loop.
if( GetBufferSize() >= nRequired )
{
wcscpy_s( m_pwszBuffer, GetBufferSize(), wszText );
m_bAnalyseRequired = true;
return true;
}
else
return false;
}
//--------------------------------------------------------------------------------------
HRESULT CUniBuffer::CPtoX( int nCP, BOOL bTrail, int* pX )
{
assert( pX );
*pX = 0; // Default
HRESULT hr = S_OK;
if( m_bAnalyseRequired )
hr = Analyse();
if( SUCCEEDED( hr ) )
hr = _ScriptStringCPtoX( m_Analysis, nCP, bTrail, pX );
return hr;
}
//--------------------------------------------------------------------------------------
HRESULT CUniBuffer::XtoCP( int nX, int* pCP, int* pnTrail )
{
assert( pCP && pnTrail );
*pCP = 0; *pnTrail = FALSE; // Default
HRESULT hr = S_OK;
if( m_bAnalyseRequired )
hr = Analyse();
if( SUCCEEDED( hr ) )
hr = _ScriptStringXtoCP( m_Analysis, nX, pCP, pnTrail );
// If the coordinate falls outside the text region, we
// can get character positions that don't exist. We must
// filter them here and convert them to those that do exist.
if( *pCP == -1 && *pnTrail == TRUE )
{
*pCP = 0; *pnTrail = FALSE;
}
else if( *pCP > lstrlenW( m_pwszBuffer ) && *pnTrail == FALSE )
{
*pCP = lstrlenW( m_pwszBuffer ); *pnTrail = TRUE;
}
return hr;
}
//--------------------------------------------------------------------------------------
void CUniBuffer::GetPriorItemPos( int nCP, int* pPrior )
{
*pPrior = nCP; // Default is the char itself
if( m_bAnalyseRequired )
if( FAILED( Analyse() ) )
return;
const SCRIPT_LOGATTR* pLogAttr = _ScriptString_pLogAttr( m_Analysis );
if( !pLogAttr )
return;
if( !_ScriptString_pcOutChars( m_Analysis ) )
return;
int nInitial = *_ScriptString_pcOutChars( m_Analysis );
if( nCP - 1 < nInitial )
nInitial = nCP - 1;
for( int i = nInitial; i > 0; --i )
if( pLogAttr[i].fWordStop || // Either the fWordStop flag is set
( !pLogAttr[i].fWhiteSpace && // Or the previous char is whitespace but this isn't.
pLogAttr[i - 1].fWhiteSpace ) )
{
*pPrior = i;
return;
}
// We have reached index 0. 0 is always a break point, so simply return it.
*pPrior = 0;
}
//--------------------------------------------------------------------------------------
void CUniBuffer::GetNextItemPos( int nCP, int* pPrior )
{
*pPrior = nCP; // Default is the char itself
HRESULT hr = S_OK;
if( m_bAnalyseRequired )
hr = Analyse();
if( FAILED( hr ) )
return;
const SCRIPT_LOGATTR* pLogAttr = _ScriptString_pLogAttr( m_Analysis );
if( !pLogAttr )
return;
if( !_ScriptString_pcOutChars( m_Analysis ) )
return;
int nInitial = *_ScriptString_pcOutChars( m_Analysis );
if( nCP + 1 < nInitial )
nInitial = nCP + 1;
int i = nInitial;
int limit = *_ScriptString_pcOutChars( m_Analysis );
while( limit > 0 && i < limit - 1 )
{
if( pLogAttr[i].fWordStop ) // Either the fWordStop flag is set
{
*pPrior = i;
return;
}
else if( pLogAttr[i].fWhiteSpace && // Or this whitespace but the next char isn't.
!pLogAttr[i + 1].fWhiteSpace )
{
*pPrior = i + 1; // The next char is a word stop
return;
}
++i;
limit = *_ScriptString_pcOutChars( m_Analysis );
}
// We have reached the end. It's always a word stop, so simply return it.
*pPrior = *_ScriptString_pcOutChars( m_Analysis ) - 1;
}
//--------------------------------------------------------------------------------------
void CDXUTEditBox::ResetCaretBlink()
{
m_bCaretOn = true;
m_dfLastBlink = DXUTGetGlobalTimer()->GetAbsoluteTime();
}
//--------------------------------------------------------------------------------------
void DXUTBlendColor::Init( D3DCOLOR defaultColor, D3DCOLOR disabledColor, D3DCOLOR hiddenColor )
{
for( int i = 0; i < MAX_CONTROL_STATES; i++ )
{
States[ i ] = defaultColor;
}
States[ DXUT_STATE_DISABLED ] = disabledColor;
States[ DXUT_STATE_HIDDEN ] = hiddenColor;
Current = hiddenColor;
}
//--------------------------------------------------------------------------------------
void DXUTBlendColor::Blend( UINT iState, float fElapsedTime, float fRate )
{
D3DXCOLOR destColor = States[ iState ];
D3DXColorLerp( &Current, &Current, &destColor, 1.0f - powf( fRate, 30 * fElapsedTime ) );
}
//--------------------------------------------------------------------------------------
void CDXUTElement::SetTexture( UINT iTexture, RECT* prcTexture, D3DCOLOR defaultTextureColor )
{
this->iTexture = iTexture;
if( prcTexture )
rcTexture = *prcTexture;
else
SetRectEmpty( &rcTexture );
TextureColor.Init( defaultTextureColor );
}
//--------------------------------------------------------------------------------------
void CDXUTElement::SetFont( UINT iFont, D3DCOLOR defaultFontColor, DWORD dwTextFormat )
{
this->iFont = iFont;
this->dwTextFormat = dwTextFormat;
FontColor.Init( defaultFontColor );
}
//--------------------------------------------------------------------------------------
void CDXUTElement::Refresh()
{
TextureColor.Current = TextureColor.States[ DXUT_STATE_HIDDEN ];
FontColor.Current = FontColor.States[ DXUT_STATE_HIDDEN ];
}
Reference in New Issue Copy Permalink