From cd662ed08b050ecc00ee47e8956ba9e77193f9e9 Mon Sep 17 00:00:00 2001 From: spartanj Date: Wed, 29 Dec 2010 01:33:26 -0300 Subject: [PATCH] Added cUIGenericGrid ( for multi-purpose grid, accepts any kind of control ), and cUIGridCell. Added tUIItemContainer, replaced for cUIListBoxContainer, so it can be used as a generic container for listbox, grids, etc. Added align capabilities to cUIGfx and cUISprite. Fixed some minor bugs. Fixed some friend classes. --- src/ee.h | 2 + src/graphics/csprite.cpp | 2 +- src/test/ee.cpp | 44 +- src/ui/cuicontrol.hpp | 2 - src/ui/cuicontrolanim.cpp | 2 +- src/ui/cuigenericgrid.cpp | 495 ++++++++++++++++++ src/ui/cuigenericgrid.hpp | 137 +++++ src/ui/cuigfx.cpp | 47 +- src/ui/cuigfx.hpp | 9 + src/ui/cuigridcell.cpp | 164 ++++++ src/ui/cuigridcell.hpp | 49 ++ src/ui/cuilistbox.cpp | 16 +- src/ui/cuilistbox.hpp | 10 +- src/ui/cuilistboxcontainer.hpp | 23 - src/ui/cuilistboxitem.cpp | 4 +- src/ui/cuilistboxitem.hpp | 5 + src/ui/cuimanager.cpp | 2 +- src/ui/cuimessage.hpp | 3 +- src/ui/cuisprite.cpp | 47 +- src/ui/cuisprite.hpp | 10 + src/ui/cuitheme.cpp | 2 + ...tboxcontainer.cpp => tuiitemcontainer.hpp} | 44 +- src/ui/uihelper.hpp | 3 +- 23 files changed, 1057 insertions(+), 65 deletions(-) create mode 100644 src/ui/cuigenericgrid.cpp create mode 100644 src/ui/cuigenericgrid.hpp create mode 100644 src/ui/cuigridcell.cpp create mode 100644 src/ui/cuigridcell.hpp delete mode 100644 src/ui/cuilistboxcontainer.hpp rename src/ui/{cuilistboxcontainer.cpp => tuiitemcontainer.hpp} (53%) diff --git a/src/ee.h b/src/ee.h index 6827f2e9a..4c5166abc 100755 --- a/src/ee.h +++ b/src/ee.h @@ -169,5 +169,7 @@ #include "ui/cuipopupmenu.hpp" #include "ui/cuisprite.hpp" #include "ui/cuitextedit.hpp" + #include "ui/cuigridcell.hpp" + #include "ui/cuigenericgrid.hpp" using namespace EE::UI; #endif diff --git a/src/graphics/csprite.cpp b/src/graphics/csprite.cpp index 5e326d074..b213326b5 100755 --- a/src/graphics/csprite.cpp +++ b/src/graphics/csprite.cpp @@ -374,7 +374,7 @@ bool cSprite::AddSubFrame(const Uint32& TexId, const eeUint& NumFrame, const eeU } void cSprite::Animate( const eeFloat& ElapsedTime ) { - if ( mFrames.size() > 1 && SPR_FGET( SPRITE_FLAG_AUTO_ANIM ) && !SPR_FGET( SPRITE_FLAG_ANIM_PAUSED ) ) { + if ( mFrames.size() > 1 && SPR_FGET( SPRITE_FLAG_AUTO_ANIM ) && !SPR_FGET( SPRITE_FLAG_ANIM_PAUSED ) && 0.f != ElapsedTime ) { eeUint Size = (eeUint)mFrames.size() - 1; eeFloat Elapsed = ( ElapsedTime != -99999.f ) ? (eeFloat)ElapsedTime : (eeFloat)cEngine::instance()->Elapsed(); diff --git a/src/test/ee.cpp b/src/test/ee.cpp index 048393f2d..a6ebf5d34 100644 --- a/src/test/ee.cpp +++ b/src/test/ee.cpp @@ -302,7 +302,7 @@ void cEETest::Init() { Mus = eeNew( cMusic, () ); if ( Mus->OpenFromPack( &PAK, "music.ogg" ) ) { Mus->Loop(true); - //Mus.Volume( 0.f ); + Mus->Volume( 0.f ); Mus->Play(); } @@ -662,12 +662,52 @@ void cEETest::CreateUI() { TextEdit->Visible( true ); TextEdit->Enabled( true ); + cUIGenericGrid::CreateParams GridParams; + GridParams.Parent( C ); + GridParams.PosSet( 325, 245 ); + GridParams.SizeSet( 200, 130 ); + GridParams.Flags = UI_AUTO_PADDING; + GridParams.RowHeight = 24; + GridParams.CollumnsCount = 3; + cUIGenericGrid * mGenGrid = eeNew( cUIGenericGrid, ( GridParams ) ); + mGenGrid->Visible( true ); + mGenGrid->Enabled( true ); + + cUIGridCell::CreateParams CellParams; + CellParams.Parent( mGenGrid->Container() ); + + cUITextBox::CreateParams TxtBoxParams; + cUITextInput::CreateParams TxtInputParams; + TxtInputParams.Flags = UI_CLIP_ENABLE | UI_AUTO_PADDING | UI_VALIGN_CENTER; + + cUIGfx::CreateParams TxtGfxParams; + TxtGfxParams.Flags = UI_VALIGN_CENTER | UI_HALIGN_CENTER; + TxtGfxParams.Shape = cGlobalShapeGroup::instance()->GetByName( "aqua_button_ok" ); + + for ( Uint32 i = 0; i < 10; i++ ) { + cUIGridCell * Cell = eeNew( cUIGridCell, ( CellParams ) ); + cUITextBox * TxtBox = eeNew( cUITextBox, ( TxtBoxParams ) ); + cUITextInput * TxtInput = eeNew( cUITextInput, ( TxtInputParams ) ); + cUIGfx * TxtGfx = eeNew( cUIGfx, ( TxtGfxParams ) ); + + TxtBox->Text( L"Test " + toWStr( i+1 ) ); + + Cell->Cell( 0, TxtBox ); + Cell->Cell( 1, TxtGfx ); + Cell->Cell( 2, TxtInput ); + + mGenGrid->Add( Cell ); + } + + mGenGrid->CollumnWidth( 0, 50 ); + mGenGrid->CollumnWidth( 1, 24 ); + mGenGrid->CollumnWidth( 2, 100 ); + mBuda = L"El mono ve el pez en el agua y sufre. Piensa que su mundo es el único que existe, el mejor, el real. Sufre porque es bueno y tiene compasión, lo ve y piensa: \"Pobre se está ahogando no puede respirar\". Y lo saca, lo saca y se queda tranquilo, por fin lo salvé. Pero el pez se retuerce de dolor y muere. Por eso te mostré el sueño, es imposible meter el mar en tu cabeza, que es un balde."; TextEdit->Text( mBuda ); TTFB->ShrinkText( mBuda, 400 ); - mBudaTC.Create( TTFB, mBuda, eeColorA(255,255,255,255) ); mEEText.Create( TTFB, L"Entropia Engine++\nCTRL + 1 = Screen 1 - CTRL + 2 = Screen 2\nCTRL + 3 = Screen 3" ); mFBOText.Create( TTFB, L"This is a VBO\nInside of a FBO" ); diff --git a/src/ui/cuicontrol.hpp b/src/ui/cuicontrol.hpp index a292af840..a8a708158 100644 --- a/src/ui/cuicontrol.hpp +++ b/src/ui/cuicontrol.hpp @@ -224,8 +224,6 @@ class EE_API cUIControl { void SendCommonEvent( const Uint32& Event ); protected: friend class cUIManager; - friend class cUIControlAnim; - friend class cUIListBoxContainer; bool mVisible; bool mEnabled; diff --git a/src/ui/cuicontrolanim.cpp b/src/ui/cuicontrolanim.cpp index bf81b24cd..15b051ff6 100644 --- a/src/ui/cuicontrolanim.cpp +++ b/src/ui/cuicontrolanim.cpp @@ -160,7 +160,7 @@ void cUIControlAnim::StartAlphaAnim( const eeFloat& From, const eeFloat& To, con AnimChild->StartAlphaAnim( From, To, TotalTime, AlphaChilds ); } - CurChild = CurChild->mNext; + CurChild = CurChild->NextGet(); } } } diff --git a/src/ui/cuigenericgrid.cpp b/src/ui/cuigenericgrid.cpp new file mode 100644 index 000000000..3b10f8b4b --- /dev/null +++ b/src/ui/cuigenericgrid.cpp @@ -0,0 +1,495 @@ +#include "cuigenericgrid.hpp" +#include "cuimanager.hpp" + +namespace EE { namespace UI { + +cUIGenericGrid::cUIGenericGrid( const cUIGenericGrid::CreateParams& Params ) : + cUIControlAnim( Params ), + mPadding( Params.PaddingContainer ), + mSmoothScroll( Params.SmoothScroll ), + mContainer( NULL ), + mVScrollBar( NULL ), + mHScrollBar( NULL ), + mVScrollMode( Params.VScrollMode ), + mHScrollMode( Params.HScrollMode ), + mCollumnsCount( Params.CollumnsCount ), + mRowHeight( Params.RowHeight ), + mTotalWidth( Params.GridWidth ), + mLastPos( 0xFFFFFFFF ), + mVisibleFirst(0), + mVisibleLast(0), + mHScrollInit(0), + mItemsNotVisible(0), + mSelected(-1), + mCollWidthAssigned( false ) +{ + mType |= UI_TYPE_GENERICGRID; + + mCollumnsWidth.resize( mCollumnsCount, 0 ); + mCollumnsPos.resize( mCollumnsCount, 0 ); + + cUIComplexControl::CreateParams CParams; + CParams.Parent( this ); + CParams.PosSet( mPadding.Left, mPadding.Top ); + CParams.Size = eeSize( mSize.Width() - mPadding.Right - mPadding.Left, mSize.Height() - mPadding.Top - mPadding.Bottom ); + CParams.Flags = Params.Flags; + mContainer = eeNew( tUIItemContainer , ( CParams ) ); + mContainer->Visible( true ); + mContainer->Enabled( true ); + + if ( mFlags & UI_CLIP_ENABLE ) + mFlags &= ~UI_CLIP_ENABLE; + + cUIScrollBar::CreateParams ScrollBarP; + ScrollBarP.Parent ( this ); + ScrollBarP.PosSet ( mSize.Width() - 15, 0 ); + ScrollBarP.Flags = UI_AUTO_SIZE; + ScrollBarP.VerticalScrollBar = true; + ScrollBarP.Size = eeSize( 15, mSize.Height() ); + mVScrollBar = eeNew( cUIScrollBar, ( ScrollBarP ) ); + + ScrollBarP.PosSet ( 0, mSize.Height() - 15 ); + ScrollBarP.Size = eeSize( mSize.Width() - mVScrollBar->Size().Width(), 15 ); + ScrollBarP.VerticalScrollBar = false; + mHScrollBar = eeNew( cUIScrollBar, ( ScrollBarP ) ); + + if ( UI_SCROLLBAR_ALWAYS_ON == mHScrollMode ) { + mHScrollBar->Visible( true ); + mHScrollBar->Enabled( true ); + } + + if ( UI_SCROLLBAR_ALWAYS_ON == mVScrollMode ) { + mVScrollBar->Visible( true ); + mVScrollBar->Enabled( true ); + } + + mVScrollBar->AddEventListener( cUIEvent::EventOnValueChange, cb::Make1( this, &cUIGenericGrid::OnScrollValueChange ) ); + mHScrollBar->AddEventListener( cUIEvent::EventOnValueChange, cb::Make1( this, &cUIGenericGrid::OnScrollValueChange ) ); + + ApplyDefaultTheme(); +} + +cUIGenericGrid::~cUIGenericGrid() { +} + +void cUIGenericGrid::SetDefaultCollumnsWidth() { + if ( mCollWidthAssigned ) + return; + + if ( mItemsNotVisible <= 0 ) { + Uint32 VisibleItems = mContainer->Size().Height() / mRowHeight; + Int32 oItemsNotVisible = (Int32)mItems.size() - VisibleItems; + + if ( oItemsNotVisible > 0 ) { + mItemsNotVisible = oItemsNotVisible; + + UpdateVScroll(); + + ContainerResize(); + } + } + + Uint32 CollumnWidh = mContainer->Size().Width() / mCollumnsCount; + + for ( Uint32 i = 0; i < mCollumnsCount; i++ ) { + mCollumnsWidth[ i ] = CollumnWidh; + } + + UpdateSize(); + UpdateCells(); +} + +void cUIGenericGrid::OnScrollValueChange( const cUIEvent * Event ) { + UpdateScroll( true ); +} + +void cUIGenericGrid::SetTheme( cUITheme * Theme ) { + cUIControl::SetTheme( Theme, "genericgrid" ); + + AutoPadding(); + + OnSizeChange(); +} + +void cUIGenericGrid::AutoPadding() { + if ( mFlags & UI_AUTO_PADDING ) { + mPadding = MakePadding(); + } +} + +void cUIGenericGrid::OnSizeChange() { + mVScrollBar->Pos( mSize.Width() - mVScrollBar->Size().Width(), 0 ); + mVScrollBar->Size( mVScrollBar->Size().Width(), mSize.Height() ); + + mHScrollBar->Pos( 0, mSize.Height() - mHScrollBar->Size().Height() ); + mHScrollBar->Size( mSize.Width() - mVScrollBar->Size().Width(), mHScrollBar->Size().Height() ); + + if ( mContainer->IsClipped() && UI_SCROLLBAR_AUTO == mHScrollMode ) { + if ( (Int32)mTotalWidth <= mContainer->Size().Width() ) { + mHScrollBar->Visible( false ); + mHScrollBar->Enabled( false ); + mHScrollInit = 0; + } + } + + ContainerResize(); + SetDefaultCollumnsWidth(); + UpdateScroll(); +} + +void cUIGenericGrid::ContainerResize() { + mContainer->Pos( mPadding.Left, mPadding.Top ); + + if( mHScrollBar->Visible() ) + mContainer->Size( mSize.Width() - mPadding.Right, mSize.Height() - mPadding.Top - mHScrollBar->Size().Height() ); + else + mContainer->Size( mSize.Width() - mPadding.Right, mSize.Height() - mPadding.Bottom - mPadding.Top ); + + if ( mVScrollBar->Visible() ) + mContainer->Size( mContainer->Size().Width() - mVScrollBar->Size().Width(), mContainer->Size().Height() ); + + SetDefaultCollumnsWidth(); +} + +void cUIGenericGrid::UpdateVScroll() { + if ( mItemsNotVisible <= 0 ) { + if ( UI_SCROLLBAR_ALWAYS_ON == mVScrollMode ) { + mVScrollBar->Visible( true ); + mVScrollBar->Enabled( true ); + } else { + mVScrollBar->Visible( false ); + mVScrollBar->Enabled( false ); + } + } else { + if ( UI_SCROLLBAR_AUTO == mVScrollMode || UI_SCROLLBAR_ALWAYS_ON == mVScrollMode ) { + mVScrollBar->Visible( true ); + mVScrollBar->Enabled( true ); + } else { + mVScrollBar->Visible( false ); + mVScrollBar->Enabled( false ); + } + } + + ContainerResize(); +} + +void cUIGenericGrid::UpdateScroll( bool FromScrollChange ) { + if ( !mItems.size() ) + return; + + cUIGridCell * Item; + Uint32 i, RelPos = 0, RelPosMax; + Int32 ItemPos, ItemPosMax; + Int32 tHLastScroll = mHScrollInit; + + Uint32 VisibleItems = mContainer->Size().Height() / mRowHeight; + mItemsNotVisible = (Int32)mItems.size() - VisibleItems; + bool Clipped = 0 != mContainer->IsClipped(); + + UpdateVScroll(); + + if ( Clipped && ( UI_SCROLLBAR_AUTO == mHScrollMode || UI_SCROLLBAR_ALWAYS_ON == mHScrollMode ) ) { + if ( mContainer->Size().Width() < (Int32)mTotalWidth ) { + mHScrollBar->Visible( true ); + mHScrollBar->Enabled( true ); + + ContainerResize(); + + Int32 ScrollH = mTotalWidth - mContainer->Size().Width(); + + Int32 HScrolleable = (Uint32)( mHScrollBar->Value() * ScrollH ); + + mHScrollInit = -HScrolleable; + } else { + if ( UI_SCROLLBAR_AUTO == mHScrollMode ) { + mHScrollBar->Visible( false ); + mHScrollBar->Enabled( false ); + + mHScrollInit = 0; + + ContainerResize(); + } + } + } + + VisibleItems = mContainer->Size().Height() / mRowHeight; + mItemsNotVisible = (Uint32)mItems.size() - VisibleItems; + Int32 Scrolleable = (Int32)mItems.size() * mRowHeight - mContainer->Size().Height(); + bool FirstVisible = false; + + if ( Clipped && mSmoothScroll ) { + if ( Scrolleable >= 0 ) + RelPos = (Uint32)( mVScrollBar->Value() * Scrolleable ); + else + RelPos = 0; + + RelPosMax = RelPos + mContainer->Size().Height() + mRowHeight; + + if ( ( FromScrollChange && 0xFFFFFFFF != mLastPos && mLastPos == RelPos ) && ( tHLastScroll == mHScrollInit ) ) + return; + + mLastPos = RelPos; + + for ( i = 0; i < mItems.size(); i++ ) { + Item = mItems[i]; + ItemPos = mRowHeight * i; + ItemPosMax = ItemPos + mRowHeight; + + if ( ( ItemPos >= (Int32)RelPos || ItemPosMax >= (Int32)RelPos ) && ( ItemPos <= (Int32)RelPosMax ) ) { + Item->Pos( mHScrollInit, ItemPos - RelPos ); + Item->Enabled( true ); + Item->Visible( true ); + + if ( !FirstVisible ) { + mVisibleFirst = i; + FirstVisible = true; + } + + mVisibleLast = i; + } else { + Item->Enabled( false ); + Item->Visible( false ); + } + } + } else { + RelPosMax = (Uint32)mItems.size(); + + if ( mItemsNotVisible > 0 ) { + RelPos = (Uint32)( mVScrollBar->Value() * mItemsNotVisible ); + RelPosMax = RelPos + VisibleItems; + } + + if ( ( FromScrollChange && 0xFFFFFFFF != mLastPos && mLastPos == RelPos ) && ( !Clipped || tHLastScroll == mHScrollInit ) ) + return; + + mLastPos = RelPos; + + for ( i = 0; i < mItems.size(); i++ ) { + Item = mItems[i]; + ItemPos = mRowHeight * ( i - RelPos ); + + if ( i >= RelPos && i < RelPosMax ) { + if ( Clipped ) + Item->Pos( mHScrollInit, ItemPos ); + else + Item->Pos( 0, ItemPos ); + + Item->Enabled( true ); + Item->Visible( true ); + + if ( !FirstVisible ) { + mVisibleFirst = i; + FirstVisible = true; + } + + mVisibleLast = i; + } else { + Item->Enabled( false ); + Item->Visible( false ); + } + } + } + + if ( mHScrollBar->Visible() && !mVScrollBar->Visible() ) { + mHScrollBar->Pos( 0, mSize.Height() - mHScrollBar->Size().Height() ); + mHScrollBar->Size( mSize.Width(), mHScrollBar->Size().Height() ); + } else { + mHScrollBar->Pos( 0, mSize.Height() - mHScrollBar->Size().Height() ); + mHScrollBar->Size( mSize.Width() - mVScrollBar->Size().Width(), mHScrollBar->Size().Height() ); + } +} + +void cUIGenericGrid::UpdateSize() { + UpdateCollumnsPos(); + + mTotalHeight = mItems.size() * mRowHeight; +} + +void cUIGenericGrid::Add( cUIGridCell * Cell ) { + mItems.push_back( Cell ); + + if ( mContainer != Cell->Parent() ) + Cell->Parent( mContainer ); + + SetDefaultCollumnsWidth(); + + Cell->AutoSize(); + + UpdateSize(); + + UpdateScroll(); +} + +void cUIGenericGrid::Remove( cUIGridCell * Cell ) { + +} + +void cUIGenericGrid::CollumnWidth( const Uint32& CollumnIndex, const Uint32& CollumnWidth ) { + eeASSERT( CollumnIndex < mCollumnsCount ); + + mCollWidthAssigned = true; + + mCollumnsWidth[ CollumnIndex ] = CollumnWidth; + + UpdateCollumnsPos(); + UpdateCells(); + UpdateScroll(); +} + +Uint32 cUIGenericGrid::Count() const { + return mItems.size(); +} + +const Uint32& cUIGenericGrid::CollumnsCount() const { + return mCollumnsCount; +} + +const Uint32& cUIGenericGrid::CollumnWidth( const Uint32& CollumnIndex ) const { + eeASSERT( CollumnIndex < mCollumnsCount ); + + return mCollumnsWidth[ CollumnIndex ]; +} + +void cUIGenericGrid::RowHeight( const Uint32& height ) { + if ( mRowHeight != height ) { + mRowHeight = height; + + UpdateSize(); + UpdateCells(); + UpdateScroll(); + } +} + +const Uint32& cUIGenericGrid::RowHeight() const { + return mRowHeight; +} + +cUIGridCell * cUIGenericGrid::GetCell( const Uint32& CellIndex ) const { + eeASSERT( CellIndex < mItems.size() ); + + return mItems[ CellIndex ]; +} + +Uint32 cUIGenericGrid::GetCellPos( const Uint32& CollumnIndex ) { + eeASSERT( CollumnIndex < mCollumnsCount ); + + return mCollumnsPos[ CollumnIndex ]; +} + +void cUIGenericGrid::UpdateCells() { + for ( Uint32 i = 0; i < mItems.size(); i++ ) { + mItems[i]->FixCell(); + } +} + +void cUIGenericGrid::UpdateCollumnsPos() { + Uint32 Pos = 0; + + for ( Uint32 i = 0; i < mCollumnsCount; i++ ) { + mCollumnsPos[ i ] = Pos; + + Pos += mCollumnsWidth[ i ]; + } + + mTotalWidth = Pos; +} + + +void cUIGenericGrid::OnAlphaChange() { + cUIControlAnim::OnAlphaChange(); + + mVScrollBar->Alpha( mAlpha ); + mHScrollBar->Alpha( mAlpha ); +} + +void cUIGenericGrid::VerticalScrollMode( const UI_SCROLLBAR_MODE& Mode ) { + if ( Mode != mVScrollMode ) { + mVScrollMode = Mode; + + UpdateScroll(); + } +} + +const UI_SCROLLBAR_MODE& cUIGenericGrid::VerticalScrollMode() { + return mVScrollMode; +} + +void cUIGenericGrid::HorizontalScrollMode( const UI_SCROLLBAR_MODE& Mode ) { + if ( Mode != mHScrollMode ) { + mHScrollMode = Mode; + + if ( UI_SCROLLBAR_ALWAYS_ON == mHScrollMode ) { + mHScrollBar->Visible( true ); + mHScrollBar->Enabled( true ); + ContainerResize(); + } else if ( UI_SCROLLBAR_ALWAYS_OFF == mHScrollMode ) { + mHScrollBar->Visible( false ); + mHScrollBar->Enabled( false ); + ContainerResize(); + } + + UpdateScroll(); + } +} + +const UI_SCROLLBAR_MODE& cUIGenericGrid::HorizontalScrollMode() { + return mHScrollMode; +} + +cUIScrollBar * cUIGenericGrid::VerticalScrollBar() const { + return mVScrollBar; +} + +cUIScrollBar * cUIGenericGrid::HorizontalScrollBar() const { + return mHScrollBar; +} + +Uint32 cUIGenericGrid::GetItemIndex( cUIGridCell * Item ) { + for ( Uint32 i = 0; i < mItems.size(); i++ ) { + if ( Item == mItems[i] ) + return i; + } + + return 0xFFFFFFFF; +} + +Uint32 cUIGenericGrid::OnSelected() { + SendCommonEvent( cUIEvent::EventOnSelected ); + + return 1; +} + +cUIGridCell * cUIGenericGrid::GetItemSelected() { + if ( -1 != mSelected ) + return mItems[ mSelected ]; + + return NULL; +} + +Uint32 cUIGenericGrid::GetItemSelectedIndex() const { + return mSelected; +} + +Uint32 cUIGenericGrid::OnMessage( const cUIMessage * Msg ) { + switch ( Msg->Msg() ) { + case cUIMessage::MsgFocusLoss: + { + cUIControl * FocusCtrl = cUIManager::instance()->FocusControl(); + + if ( this != FocusCtrl && !IsParentOf( FocusCtrl ) ) { + SendCommonEvent( cUIEvent::EventOnComplexControlFocusLoss ); + OnComplexControlFocusLoss(); + } + + return 1; + } + } + + return 0; +} + +tUIItemContainer * cUIGenericGrid::Container() const { + return mContainer; +} + +}} diff --git a/src/ui/cuigenericgrid.hpp b/src/ui/cuigenericgrid.hpp new file mode 100644 index 000000000..ed85a8078 --- /dev/null +++ b/src/ui/cuigenericgrid.hpp @@ -0,0 +1,137 @@ +#ifndef EE_UICUIGENERICGRID_HPP +#define EE_UICUIGENERICGRID_HPP + +#include "cuicontrolanim.hpp" +#include "cuigridcell.hpp" +#include "cuiscrollbar.hpp" +#include "tuiitemcontainer.hpp" + +namespace EE { namespace UI { + +class EE_API cUIGenericGrid : public cUIControlAnim { + public: + class CreateParams : public cUIControlAnim::CreateParams { + public: + inline CreateParams() : + cUIControlAnim::CreateParams(), + SmoothScroll( true ), + VScrollMode( UI_SCROLLBAR_AUTO ), + HScrollMode( UI_SCROLLBAR_AUTO ), + CollumnsCount(1), + RowHeight( 24 ), + GridWidth( 0 ) + { + } + + inline ~CreateParams() {}; + + bool SmoothScroll; + UI_SCROLLBAR_MODE VScrollMode; + UI_SCROLLBAR_MODE HScrollMode; + Uint32 CollumnsCount; + Uint32 RowHeight; + Uint32 GridWidth; + eeRecti PaddingContainer; + }; + + cUIGenericGrid( const cUIGenericGrid::CreateParams& Params ); + + ~cUIGenericGrid(); + + virtual void SetTheme( cUITheme * Theme ); + + void Add( cUIGridCell * Cell ); + + void Remove( cUIGridCell * Cell ); + + void CollumnWidth( const Uint32& CollumnIndex, const Uint32& CollumnWidth ); + + Uint32 Count() const; + + const Uint32& CollumnsCount() const; + + const Uint32& CollumnWidth( const Uint32& CollumnIndex ) const; + + void RowHeight( const Uint32& height ); + + const Uint32& RowHeight() const; + + cUIGridCell * GetCell( const Uint32& CellIndex ) const; + + void VerticalScrollMode( const UI_SCROLLBAR_MODE& Mode ); + + const UI_SCROLLBAR_MODE& VerticalScrollMode(); + + void HorizontalScrollMode( const UI_SCROLLBAR_MODE& Mode ); + + const UI_SCROLLBAR_MODE& HorizontalScrollMode(); + + Uint32 GetCellPos( const Uint32& CollumnIndex ); + + cUIScrollBar * VerticalScrollBar() const; + + cUIScrollBar * HorizontalScrollBar() const; + + Uint32 GetItemIndex( cUIGridCell * Item ); + + cUIGridCell * GetItemSelected(); + + Uint32 GetItemSelectedIndex() const; + + Uint32 OnMessage( const cUIMessage * Msg ); + + tUIItemContainer * Container() const; + protected: + friend class tUIItemContainer; + friend class cUIGridCell; + + eeRecti mPadding; + bool mSmoothScroll; + tUIItemContainer * mContainer; + cUIScrollBar * mVScrollBar; + cUIScrollBar * mHScrollBar; + UI_SCROLLBAR_MODE mVScrollMode; + UI_SCROLLBAR_MODE mHScrollMode; + std::vector mItems; + Uint32 mCollumnsCount; + Uint32 mRowHeight; + std::vector mCollumnsWidth; + std::vector mCollumnsPos; + Uint32 mTotalWidth; + Uint32 mTotalHeight; + Uint32 mLastPos; + Uint32 mVisibleFirst; + Uint32 mVisibleLast; + Int32 mHScrollInit; + Int32 mItemsNotVisible; + Int32 mSelected; + bool mCollWidthAssigned; + + void UpdateCells(); + + void UpdateCollumnsPos(); + + void AutoPadding(); + + virtual void OnSizeChange(); + + virtual void OnAlphaChange(); + + void ContainerResize(); + + void OnScrollValueChange( const cUIEvent * Event ); + + void SetDefaultCollumnsWidth(); + + void UpdateScroll( bool FromScrollChange = false ); + + void UpdateSize(); + + virtual Uint32 OnSelected(); + + void UpdateVScroll(); +}; + +}} + +#endif diff --git a/src/ui/cuigfx.cpp b/src/ui/cuigfx.cpp index 7fb1fe46a..115e265c3 100644 --- a/src/ui/cuigfx.cpp +++ b/src/ui/cuigfx.cpp @@ -6,7 +6,8 @@ cUIGfx::cUIGfx( const cUIGfx::CreateParams& Params ) : cUIComplexControl( Params ), mShape( Params.Shape ), mColor( Params.ShapeColor ), - mRender( Params.ShapeRender ) + mRender( Params.ShapeRender ), + mAlignOffset(0,0) { mType |= UI_TYPE_GET(UI_TYPE_GFX); @@ -14,6 +15,8 @@ cUIGfx::cUIGfx( const cUIGfx::CreateParams& Params ) : Size( mShape->Size() ); mColor.Alpha = (Uint8)mAlpha; + + AutoSize(); } cUIGfx::~cUIGfx() { @@ -22,7 +25,11 @@ cUIGfx::~cUIGfx() { void cUIGfx::Shape( cShape * shape ) { mShape = shape; - if ( Flags() & UI_AUTO_SIZE ) { + AutoSize(); +} + +void cUIGfx::AutoSize() { + if ( mFlags & UI_AUTO_SIZE ) { if ( NULL != mShape ) { Size( mShape->Size() ); } else { @@ -36,7 +43,7 @@ void cUIGfx::Draw() { if ( mVisible ) { if ( NULL != mShape && 0.f != mAlpha ) - mShape->Draw( (eeFloat)mScreenPos.x, (eeFloat)mScreenPos.y, mColor, 0.f, 1.f, mBlend, mRender ); + mShape->Draw( (eeFloat)mScreenPos.x + mAlignOffset.x, (eeFloat)mScreenPos.y + mAlignOffset.y, mColor, 0.f, 1.f, mBlend, mRender ); } } @@ -66,13 +73,43 @@ void cUIGfx::RenderType( const EE_RENDERTYPE& render ) { mRender = render; } -void cUIGfx::OnSizeChange() { - if ( NULL != mShape && Flags() & UI_FIT_TO_CONTROL ) { +void cUIGfx::FitToControl() { + if ( NULL != mShape && mFlags & UI_FIT_TO_CONTROL ) { mShape->DestWidth( (eeFloat)mSize.x ); mShape->DestHeight( (eeFloat)mSize.y ); } +} +void cUIGfx::AutoAlign() { + if ( NULL == mShape ) + return; + + if ( HAlignGet( mFlags ) == UI_HALIGN_CENTER ) { + mAlignOffset.x = mSize.Width() / 2 - mShape->Size().Width() / 2; + } else if ( FontHAlignGet( mFlags ) == UI_HALIGN_RIGHT ) { + mAlignOffset.x = mSize.Width() - mShape->Size().Width(); + } else { + mAlignOffset.x = 0; + } + + if ( VAlignGet( mFlags ) == UI_VALIGN_CENTER ) { + mAlignOffset.y = mSize.Height() / 2 - mShape->Size().Height() / 2; + } else if ( FontVAlignGet( mFlags ) == UI_VALIGN_BOTTOM ) { + mAlignOffset.y = mSize.Height() - mShape->Size().Height(); + } else { + mAlignOffset.y = 0; + } +} + +void cUIGfx::OnSizeChange() { + FitToControl(); + AutoSize(); + AutoAlign(); cUIControlAnim::OnSizeChange(); } +const eeVector2i& cUIGfx::AlignOffset() const { + return mAlignOffset; +} + }} diff --git a/src/ui/cuigfx.hpp b/src/ui/cuigfx.hpp index 720bbde3a..f8f3607fc 100644 --- a/src/ui/cuigfx.hpp +++ b/src/ui/cuigfx.hpp @@ -43,12 +43,21 @@ class EE_API cUIGfx : public cUIComplexControl { const EE_RENDERTYPE& RenderType() const; void RenderType( const EE_RENDERTYPE& render ); + + const eeVector2i& AlignOffset() const; protected: cShape * mShape; eeColorA mColor; EE_RENDERTYPE mRender; + eeVector2i mAlignOffset; virtual void OnSizeChange(); + + void AutoSize(); + + void FitToControl(); + + void AutoAlign(); }; }} diff --git a/src/ui/cuigridcell.cpp b/src/ui/cuigridcell.cpp new file mode 100644 index 000000000..01d62116f --- /dev/null +++ b/src/ui/cuigridcell.cpp @@ -0,0 +1,164 @@ +#include "cuigridcell.hpp" +#include "cuigenericgrid.hpp" +#include "cuimanager.hpp" + +namespace EE { namespace UI { + +cUIGridCell::cUIGridCell( cUIGridCell::CreateParams& Params ) : + cUIComplexControl( Params ) +{ + mCells.resize( GridParent()->CollumnsCount(), NULL ); + + ApplyDefaultTheme(); +} + +cUIGridCell::~cUIGridCell() { + if ( cUIManager::instance()->FocusControl() == this ) + mParentCtrl->SetFocus(); + + if ( cUIManager::instance()->OverControl() == this ) + cUIManager::instance()->OverControl( mParentCtrl ); +} + +void cUIGridCell::SetTheme( cUITheme * Theme ) { + cUIControl::SetTheme( Theme, "gridcell" ); +} + +cUIGenericGrid * cUIGridCell::GridParent() const { + return reinterpret_cast ( mParentCtrl->Parent() ); +} + +void cUIGridCell::Cell( const Uint32& CollumnIndex, cUIControl * Ctrl ) { + eeASSERT( CollumnIndex < GridParent()->CollumnsCount() ); + + cUIGenericGrid * P = GridParent(); + + mCells[ CollumnIndex ] = Ctrl; + + if ( Ctrl->Parent() != this ) + Ctrl->Parent( this ); + + Ctrl->Pos ( P->GetCellPos( CollumnIndex ) , 0 ); + Ctrl->Size ( P->CollumnWidth( CollumnIndex ) , P->RowHeight() ); + + Ctrl->Visible( true ); + Ctrl->Enabled( true ); +} + +cUIControl * cUIGridCell::Cell( const Uint32& CollumnIndex ) const { + eeASSERT( CollumnIndex < GridParent()->CollumnsCount() ); + + return mCells[ CollumnIndex ]; +} + +void cUIGridCell::FixCell() { + AutoSize(); + + cUIGenericGrid * P = GridParent(); + + for ( Uint32 i = 0; i < mCells.size(); i++ ) { + mCells[i]->Pos ( P->GetCellPos( i ) , 0 ); + mCells[i]->Size ( P->CollumnWidth( i ) , P->RowHeight() ); + } +} + +void cUIGridCell::Update() { + if ( mEnabled && mVisible ) { + cUIGenericGrid * MyParent = reinterpret_cast ( Parent()->Parent() ); + Uint32 Flags = cUIManager::instance()->GetInput()->ClickTrigger(); + + if ( NULL != MyParent && MyParent->Alpha() != mAlpha ) { + Alpha( MyParent->Alpha() ); + + for ( Uint32 i = 0; i < mCells.size(); i++ ) { + if ( NULL != mCells[i] && mCells[i]->IsType( UI_TYPE_CONTROL_ANIM ) ) { + reinterpret_cast( mCells[i] )->Alpha( MyParent->Alpha() ); + } + } + } + + if ( IsMouseOverMeOrChilds() ) { + if ( Flags & EE_BUTTONS_WUWD && MyParent->VerticalScrollBar()->Visible() ) + MyParent->VerticalScrollBar()->Slider()->ManageClick( Flags ); + } + + /*if ( ( mControlFlags & UI_CTRL_FLAG_HAS_FOCUS ) ) + LBParent->ManageKeyboard();*/ + } + + cUIComplexControl::Update(); +} + + +void cUIGridCell::Select() { + cUIGenericGrid * MyParent = reinterpret_cast ( Parent()->Parent() ); + + bool wasSelected = 0 != ( mControlFlags & UI_CTRL_FLAG_SELECTED ); + + SetSkinState( cUISkinState::StateSelected ); + + mControlFlags |= UI_CTRL_FLAG_SELECTED; + + MyParent->mSelected = MyParent->GetItemIndex( this ); + + if ( !wasSelected ) { + MyParent->OnSelected(); + } +} + +void cUIGridCell::Unselect() { + if ( mControlFlags & UI_CTRL_FLAG_SELECTED ) + mControlFlags &= ~UI_CTRL_FLAG_SELECTED; + + SetSkinState( cUISkinState::StateNormal ); +} + +bool cUIGridCell::Selected() const { + return 0 != ( mControlFlags & UI_CTRL_FLAG_SELECTED ); +} + +Uint32 cUIGridCell::OnMouseExit( const eeVector2i& Pos, const Uint32 Flags ) { + cUIControl::OnMouseExit( Pos, Flags ); + + if ( mControlFlags & UI_CTRL_FLAG_SELECTED ) + SetSkinState( cUISkinState::StateSelected ); + + return 1; +} + +Uint32 cUIGridCell::OnMessage( const cUIMessage * Msg ) { + switch( Msg->Msg() ) { + case cUIMessage::MsgMouseEnter: + { + OnMouseEnter( eeVector2i(), Msg->Flags() ); + break; + } + case cUIMessage::MsgMouseExit: + { + OnMouseExit( eeVector2i(), Msg->Flags() ); + break; + } + case cUIMessage::MsgClick: + { + if ( Msg->Flags() == EE_BUTTONS_LRM ) { + Select(); + + cUIMessage tMsg( this, cUIMessage::MsgCellClicked, Msg->Flags() ); + + MessagePost( &tMsg ); + + return 1; + } + } + } + + return 0; +} + +void cUIGridCell::AutoSize() { + cUIGenericGrid * MyParent = reinterpret_cast ( Parent()->Parent() ); + + Size( MyParent->mTotalWidth, MyParent->mRowHeight ); +} + +}} diff --git a/src/ui/cuigridcell.hpp b/src/ui/cuigridcell.hpp new file mode 100644 index 000000000..bbba01f6e --- /dev/null +++ b/src/ui/cuigridcell.hpp @@ -0,0 +1,49 @@ +#ifndef EE_UICUIGRIDCELL_HPP +#define EE_UICUIGRIDCELL_HPP + +#include "cuicomplexcontrol.hpp" +#include "tuiitemcontainer.hpp" + +namespace EE { namespace UI { + +class cUIGenericGrid; + +class EE_API cUIGridCell : public cUIComplexControl { + public: + cUIGridCell( cUIGridCell::CreateParams& Params ); + + ~cUIGridCell(); + + virtual void SetTheme( cUITheme * Theme ); + + void Cell( const Uint32& CollumnIndex, cUIControl * Ctrl ); + + cUIControl * Cell( const Uint32& CollumnIndex ) const; + + virtual void Update(); + + bool Selected() const; + + void Unselect(); + + void Select(); + + Uint32 OnMessage( const cUIMessage * Msg ); + + void AutoSize(); + protected: + friend class tUIItemContainer; + friend class cUIGenericGrid; + + std::vector mCells; + + cUIGenericGrid * GridParent() const; + + void FixCell(); + + Uint32 OnMouseExit( const eeVector2i& Pos, const Uint32 Flags ); +}; + +}} + +#endif diff --git a/src/ui/cuilistbox.cpp b/src/ui/cuilistbox.cpp index d5cc5db06..98702d25b 100644 --- a/src/ui/cuilistbox.cpp +++ b/src/ui/cuilistbox.cpp @@ -1,5 +1,7 @@ #include "cuilistbox.hpp" #include "cuimanager.hpp" +#include "cuilistboxitem.hpp" +#include "tuiitemcontainer.hpp" namespace EE { namespace UI { @@ -35,7 +37,7 @@ cUIListBox::cUIListBox( cUIListBox::CreateParams& Params ) : CParams.PosSet( mPaddingContainer.Left, mPaddingContainer.Top ); CParams.Size = eeSize( mSize.Width() - mPaddingContainer.Right - mPaddingContainer.Left, mSize.Height() - mPaddingContainer.Top - mPaddingContainer.Bottom ); CParams.Flags = Params.Flags; - mContainer = eeNew( cUIListBoxContainer, ( CParams ) ); + mContainer = eeNew( tUIItemContainer, ( CParams ) ); mContainer->Visible( true ); mContainer->Enabled( true ); @@ -93,11 +95,11 @@ void cUIListBox::AutoPadding() { } } -cUIScrollBar * cUIListBox::ScrollBar() const { +cUIScrollBar * cUIListBox::VerticalScrollBar() const { return mVScrollBar; } -cUIScrollBar * cUIListBox::HScrollBar() const { +cUIScrollBar * cUIListBox::HorizontalScrollBar() const { return mHScrollBar; } @@ -752,7 +754,7 @@ void cUIListBox::SelectPrev() { mItems[ mSelected.front() ]->Unselect(); if ( mItems[ SelIndex ]->Pos().y < 0 ) { - ScrollBar()->Value( (eeFloat)( SelIndex * mRowHeight ) / (eeFloat)( ( mItems.size() - 1 ) * mRowHeight ) ); + mVScrollBar->Value( (eeFloat)( SelIndex * mRowHeight ) / (eeFloat)( ( mItems.size() - 1 ) * mRowHeight ) ); mItems[ SelIndex ]->SetFocus(); } @@ -776,7 +778,7 @@ void cUIListBox::SelectNext() { mItems[ mSelected.front() ]->Unselect(); if ( mItems[ SelIndex ]->Pos().y + (Int32)RowHeight() > mContainer->Size().Height() ) { - ScrollBar()->Value( (eeFloat)( SelIndex * mRowHeight ) / (eeFloat)( ( mItems.size() - 1 ) * mRowHeight ) ); + mVScrollBar->Value( (eeFloat)( SelIndex * mRowHeight ) / (eeFloat)( ( mItems.size() - 1 ) * mRowHeight ) ); mItems[ SelIndex ]->SetFocus(); } @@ -815,7 +817,7 @@ void cUIListBox::ManageKeyboard() { if ( mSelected.front() != 0 ) { mItems[ mSelected.front() ]->Unselect(); - ScrollBar()->Value( 0 ); + mVScrollBar->Value( 0 ); mItems[ 0 ]->SetFocus(); @@ -827,7 +829,7 @@ void cUIListBox::ManageKeyboard() { if ( mSelected.front() != Count() - 1 ) { mItems[ mSelected.front() ]->Unselect(); - ScrollBar()->Value( 1 ); + mVScrollBar->Value( 1 ); mItems[ Count() - 1 ]->SetFocus(); diff --git a/src/ui/cuilistbox.hpp b/src/ui/cuilistbox.hpp index e918a2389..ea232359c 100644 --- a/src/ui/cuilistbox.hpp +++ b/src/ui/cuilistbox.hpp @@ -3,8 +3,8 @@ #include "cuicontrolanim.hpp" #include "cuiscrollbar.hpp" +#include "tuiitemcontainer.hpp" #include "cuilistboxitem.hpp" -#include "cuilistboxcontainer.hpp" namespace EE { namespace UI { @@ -74,9 +74,9 @@ class EE_API cUIListBox : public cUIComplexControl { bool IsMultiSelect() const; - cUIScrollBar * ScrollBar() const; + cUIScrollBar * VerticalScrollBar() const; - cUIScrollBar * HScrollBar() const; + cUIScrollBar * HorizontalScrollBar() const; cUIListBoxItem * GetItem( const Uint32& Index ) const; @@ -141,7 +141,7 @@ class EE_API cUIListBox : public cUIComplexControl { const UI_SCROLLBAR_MODE& HorizontalScrollMode(); protected: friend class cUIListBoxItem; - friend class cUIListBoxContainer; + friend class tUIItemContainer; friend class cUIDropDownList; Uint32 mRowHeight; @@ -149,7 +149,7 @@ class EE_API cUIListBox : public cUIComplexControl { UI_SCROLLBAR_MODE mHScrollMode; bool mSmoothScroll; eeRecti mPaddingContainer; - cUIListBoxContainer * mContainer; + tUIItemContainer * mContainer; cUIScrollBar * mVScrollBar; cUIScrollBar * mHScrollBar; cFont * mFont; diff --git a/src/ui/cuilistboxcontainer.hpp b/src/ui/cuilistboxcontainer.hpp deleted file mode 100644 index 91ebbb71b..000000000 --- a/src/ui/cuilistboxcontainer.hpp +++ /dev/null @@ -1,23 +0,0 @@ -#ifndef EE_UICUILISTBOXCONTAINER_HPP -#define EE_UICUILISTBOXCONTAINER_HPP - -#include "cuicontrol.hpp" - -namespace EE { namespace UI { - -class cUIListBoxContainer : public cUIControl { - public: - cUIListBoxContainer( cUIControl::CreateParams& Params ); - - ~cUIListBoxContainer(); - - void Update(); - - void DrawChilds(); - protected: - cUIControl * OverFind( const eeVector2f& Point ); -}; - -}} - -#endif diff --git a/src/ui/cuilistboxitem.cpp b/src/ui/cuilistboxitem.cpp index b14167ee6..8d5247810 100644 --- a/src/ui/cuilistboxitem.cpp +++ b/src/ui/cuilistboxitem.cpp @@ -82,8 +82,8 @@ void cUIListBoxItem::Update() { Alpha( LBParent->Alpha() ); if ( IsMouseOver() ) { - if ( Flags & EE_BUTTONS_WUWD && LBParent->ScrollBar()->Visible() ) - LBParent->ScrollBar()->Slider()->ManageClick( Flags ); + if ( Flags & EE_BUTTONS_WUWD && LBParent->VerticalScrollBar()->Visible() ) + LBParent->VerticalScrollBar()->Slider()->ManageClick( Flags ); } if ( ( mControlFlags & UI_CTRL_FLAG_HAS_FOCUS ) ) diff --git a/src/ui/cuilistboxitem.hpp b/src/ui/cuilistboxitem.hpp index d86671526..93b13b64a 100644 --- a/src/ui/cuilistboxitem.hpp +++ b/src/ui/cuilistboxitem.hpp @@ -2,9 +2,12 @@ #define EE_UICUILISTBOXITEM_HPP #include "cuitextbox.hpp" +#include "tuiitemcontainer.hpp" namespace EE { namespace UI { +class cUIListBox; + class EE_API cUIListBoxItem : public cUITextBox { public: cUIListBoxItem( cUITextBox::CreateParams& Params ); @@ -21,6 +24,8 @@ class EE_API cUIListBoxItem : public cUITextBox { void Select(); protected: + friend class tUIItemContainer; + virtual void OnStateChange(); virtual Uint32 OnMouseClick( const eeVector2i& Pos, const Uint32 Flags ); diff --git a/src/ui/cuimanager.cpp b/src/ui/cuimanager.cpp index 3d20afade..6f2de8442 100644 --- a/src/ui/cuimanager.cpp +++ b/src/ui/cuimanager.cpp @@ -167,7 +167,7 @@ void cUIManager::Update() { if ( pOver != mOverControl ) { if ( NULL != mOverControl ) { - SendMsg( mOverControl, cUIMessage::MsgMouseEnter ); + SendMsg( mOverControl, cUIMessage::MsgMouseExit ); mOverControl->OnMouseExit( mKM->GetMousePos(), 0 ); } diff --git a/src/ui/cuimessage.hpp b/src/ui/cuimessage.hpp index 058955a0d..7e70db93b 100644 --- a/src/ui/cuimessage.hpp +++ b/src/ui/cuimessage.hpp @@ -19,11 +19,12 @@ class EE_API cUIMessage { MsgWindowResize, MsgFocus, MsgFocusLoss, + MsgCellClicked, MsgUser, MsgForceDWord = 0xFFFFFFFF }; - cUIMessage( cUIControl * Ctrl, const Uint32& Msg, const Uint32& Flags ); + cUIMessage( cUIControl * Ctrl, const Uint32& Msg, const Uint32& Flags = MsgForceDWord ); ~cUIMessage(); diff --git a/src/ui/cuisprite.cpp b/src/ui/cuisprite.cpp index 3665c158d..50bc7207c 100644 --- a/src/ui/cuisprite.cpp +++ b/src/ui/cuisprite.cpp @@ -5,7 +5,9 @@ namespace EE { namespace UI { cUISprite::cUISprite( const cUISprite::CreateParams& Params ) : cUIComplexControl( Params ), mSprite( Params.Sprite ), - mRender( Params.SpriteRender ) + mRender( Params.SpriteRender ), + mAlignOffset(0,0), + mShapeLast(NULL) { mType |= UI_TYPE_GET(UI_TYPE_SPRITE); @@ -30,13 +32,21 @@ void cUISprite::Draw() { if ( mVisible ) { if ( NULL != mSprite && 0.f != mAlpha ) { - UpdateSize(); - mSprite->Position( (eeFloat)mScreenPos.x, (eeFloat)mScreenPos.y ); + CheckShapeUpdate(); + mSprite->Position( (eeFloat)( mScreenPos.x + mAlignOffset.x ), (eeFloat)( mScreenPos.y + mAlignOffset.y ) ); mSprite->Draw( mBlend, mRender ); } } } +void cUISprite::CheckShapeUpdate() { + if ( NULL != mSprite && NULL != mSprite->GetCurrentShape() && mSprite->GetCurrentShape() != mShapeLast ) { + UpdateSize(); + AutoAlign(); + mShapeLast = mSprite->GetCurrentShape(); + } +} + void cUISprite::Alpha( const eeFloat& alpha ) { cUIControlAnim::Alpha( alpha ); @@ -79,4 +89,35 @@ void cUISprite::UpdateSize() { } } +void cUISprite::AutoAlign() { + if ( NULL == mSprite || NULL == mSprite->GetCurrentShape() ) + return; + + cShape * tShape = mSprite->GetCurrentShape(); + + if ( HAlignGet( mFlags ) == UI_HALIGN_CENTER ) { + mAlignOffset.x = mSize.Width() / 2 - tShape->Size().Width() / 2; + } else if ( FontHAlignGet( mFlags ) == UI_HALIGN_RIGHT ) { + mAlignOffset.x = mSize.Width() - tShape->Size().Width(); + } else { + mAlignOffset.x = 0; + } + + if ( VAlignGet( mFlags ) == UI_VALIGN_CENTER ) { + mAlignOffset.y = mSize.Height() / 2 - tShape->Size().Height() / 2; + } else if ( FontVAlignGet( mFlags ) == UI_VALIGN_BOTTOM ) { + mAlignOffset.y = mSize.Height() - tShape->Size().Height(); + } else { + mAlignOffset.y = 0; + } +} + +const eeVector2i& cUISprite::AlignOffset() const { + return mAlignOffset; +} + +void cUISprite::OnSizeChange() { + AutoAlign(); +} + }} diff --git a/src/ui/cuisprite.hpp b/src/ui/cuisprite.hpp index 8d606d205..8140fd0d3 100644 --- a/src/ui/cuisprite.hpp +++ b/src/ui/cuisprite.hpp @@ -41,11 +41,21 @@ class EE_API cUISprite : public cUIComplexControl { const EE_RENDERTYPE& RenderType() const; void RenderType( const EE_RENDERTYPE& render ); + + const eeVector2i& AlignOffset() const; protected: cSprite * mSprite; EE_RENDERTYPE mRender; + eeVector2i mAlignOffset; + cShape * mShapeLast; void UpdateSize(); + + void AutoAlign(); + + void CheckShapeUpdate(); + + virtual void OnSizeChange(); }; }} diff --git a/src/ui/cuitheme.cpp b/src/ui/cuitheme.cpp index d5be1f588..af6790188 100644 --- a/src/ui/cuitheme.cpp +++ b/src/ui/cuitheme.cpp @@ -58,6 +58,8 @@ static void LoadThemeElements() { UI_THEME_ELEMENTS.push_back( "textedit" ); UI_THEME_ELEMENTS.push_back( "textedit_box" ); UI_THEME_ELEMENTS.push_back( "tooltip" ); + UI_THEME_ELEMENTS.push_back( "genericgrid" ); + UI_THEME_ELEMENTS.push_back( "gridcell" ); } } diff --git a/src/ui/cuilistboxcontainer.cpp b/src/ui/tuiitemcontainer.hpp similarity index 53% rename from src/ui/cuilistboxcontainer.cpp rename to src/ui/tuiitemcontainer.hpp index 51244c7e5..a7f72b314 100644 --- a/src/ui/cuilistboxcontainer.cpp +++ b/src/ui/tuiitemcontainer.hpp @@ -1,21 +1,39 @@ -#include "cuilistboxcontainer.hpp" -#include "cuilistbox.hpp" -#include "cuilistboxitem.hpp" +#ifndef EE_UITUIITEMCONTAINER_HPP +#define EE_UITUIITEMCONTAINER_HPP + +#include "cuicontrol.hpp" namespace EE { namespace UI { -cUIListBoxContainer::cUIListBoxContainer( cUIControl::CreateParams& Params ) : +template +class tUIItemContainer : public cUIControl { + public: + tUIItemContainer( cUIControl::CreateParams& Params ); + + ~tUIItemContainer(); + + void Update(); + + void DrawChilds(); + protected: + cUIControl * OverFind( const eeVector2f& Point ); +}; + +template +tUIItemContainer::tUIItemContainer( cUIControl::CreateParams& Params ) : cUIControl( Params ) { DisableChildCloseCheck(); } -cUIListBoxContainer::~cUIListBoxContainer() +template +tUIItemContainer::~tUIItemContainer() { } -void cUIListBoxContainer::Update() { - cUIListBox * LBParent = reinterpret_cast ( Parent() ); +template +void tUIItemContainer::Update() { + TContainer * LBParent = reinterpret_cast ( Parent() ); if ( LBParent->mItems.size() ) { for ( Uint32 i = LBParent->mVisibleFirst; i <= LBParent->mVisibleLast; i++ ) { @@ -25,8 +43,9 @@ void cUIListBoxContainer::Update() { } } -void cUIListBoxContainer::DrawChilds() { - cUIListBox * LBParent = reinterpret_cast ( Parent() ); +template +void tUIItemContainer::DrawChilds() { + TContainer * LBParent = reinterpret_cast ( Parent() ); if ( LBParent->mItems.size() ) { for ( Uint32 i = LBParent->mVisibleFirst; i <= LBParent->mVisibleLast; i++ ) @@ -35,8 +54,9 @@ void cUIListBoxContainer::DrawChilds() { } } -cUIControl * cUIListBoxContainer::OverFind( const eeVector2f& Point ) { - cUIListBox * LBParent = reinterpret_cast ( Parent() ); +template +cUIControl * tUIItemContainer::OverFind( const eeVector2f& Point ) { + TContainer * LBParent = reinterpret_cast ( Parent() ); cUIControl * pOver = NULL; @@ -67,3 +87,5 @@ cUIControl * cUIListBoxContainer::OverFind( const eeVector2f& Point ) { } }} + +#endif diff --git a/src/ui/uihelper.hpp b/src/ui/uihelper.hpp index dacdfb95b..e2e2269ba 100644 --- a/src/ui/uihelper.hpp +++ b/src/ui/uihelper.hpp @@ -82,7 +82,8 @@ enum UI_CONTROL_TYPES { UI_TYPE_MENUSUBMENU = 20, UI_TYPE_SPRITE = 21, UI_TYPE_TEXTEDIT = 22, - UI_TYPE_TOOLTIP = 23 + UI_TYPE_TOOLTIP = 23, + UI_TYPE_GENERICGRID = 24 }; #define UI_TYPE_GET(X) ( 1 << (X) )