bool UKUISliderWidget::OnMouseButtonDown( const FKUIInterfaceContainerMouseButtonEvent& stEventInfo )
{
if ( !CanReceieveMouseEvents() )
return Super::OnMouseButtonDown( stEventInfo );
if ( stEventInfo.eButton != EMouseButtons::Left )
return Super::OnMouseButtonDown( stEventInfo );
if ( !IsVisibleRecursive() )
return Super::OnMouseButtonDown( stEventInfo );
if ( IsDisabledRecursive() )
return Super::OnMouseButtonDown( stEventInfo );
if ( !IsMouseOver() )
return Super::OnMouseButtonDown( stEventInfo );
if ( oHandle.IsValid() && oHandle->IsMouseOver() )
{
if ( bHorizontal )
fMouseDownOffset = stEventInfo.v2Location.X - oHandle->GetScreenLocation().X - oHandle->GetSize().X / 2.f;
else
fMouseDownOffset = stEventInfo.v2Location.Y - oHandle->GetScreenLocation().Y - oHandle->GetSize().Y / 2.f;
}
else
fMouseDownOffset = 0.f;
bDragging = true;
OnDrag( bHorizontal ? stEventInfo.v2Location.X : stEventInfo.v2Location.Y );
KUISendSubEvent( FKUIInterfaceEvent, EKUIInterfaceWidgetEventList::E_StateChange );
return true;
}
void cUIMap::Update() {
cUIComplexControl::Update();
if ( NULL != mMap ) {
mMap->Update();
if ( mEnabled && mVisible && IsMouseOver() ) {
Uint32 Flags = cUIManager::instance()->GetInput()->ClickTrigger();
if ( EDITING_LIGHT == mEditingMode ) {
if ( NULL != mSelLight ) {
if ( Flags & EE_BUTTONS_WUWD ) {
if ( Flags & EE_BUTTON_WUMASK ) {
mSelLight->Radius( mSelLight->Radius() + 10 );
} else if ( Flags & EE_BUTTON_WDMASK ) {
mSelLight->Radius( mSelLight->Radius() - 10 );
}
if ( mLightRadiusChangeCb.IsSet() )
mLightRadiusChangeCb( mSelLight );
} else if ( Flags & EE_BUTTON_RMASK ) {
if ( mSelLight == mAddLight ) {
mMap->GetLightManager()->RemoveLight( mAddLight );
eeSAFE_DELETE( mAddLight );
mSelLight = NULL;
} else if ( NULL != mSelLight ) {
if ( mSelLight->GetAABB().Contains( mMap->GetMouseMapPosf() ) ) {
mMap->GetLightManager()->RemoveLight( mSelLight );
eeSAFE_DELETE( mSelLight );
}
}
} else if ( Flags & EE_BUTTON_LMASK ) {
if ( mSelLight == mAddLight ) {
mAddLight = NULL;
} else {
TryToSelectLight();
}
}
Flags = cUIManager::instance()->GetInput()->PressTrigger();
if ( Flags & EE_BUTTON_MMASK ) {
mSelLight->Position( mMap->GetMouseMapPosf() );
}
} else {
if ( Flags & EE_BUTTON_LMASK ) {
TryToSelectLight();
}
}
} else if ( EDITING_OBJECT == mEditingMode ) {
ManageObject( Flags );
}
}
}
}
void CheckBox::Draw()
{
if (m_checked) {
if (IsDisabled())
GetContext()->GetSkin().DrawCheckBoxCheckedDisabled(GetActiveOffset(), GetActiveArea());
else if (IsMouseOver())
GetContext()->GetSkin().DrawCheckBoxCheckedHover(GetActiveOffset(), GetActiveArea());
else
GetContext()->GetSkin().DrawCheckBoxCheckedNormal(GetActiveOffset(), GetActiveArea());
} else {
if (IsDisabled())
GetContext()->GetSkin().DrawCheckBoxDisabled(GetActiveOffset(), GetActiveArea());
else if (IsMouseOver())
GetContext()->GetSkin().DrawCheckBoxHover(GetActiveOffset(), GetActiveArea());
else
GetContext()->GetSkin().DrawCheckBoxNormal(GetActiveOffset(), GetActiveArea());
}
}
void CheckButton::OnMouseLeftButtonUp(suic::MouseEventArg& e)
{
if (IsMouseOver())
{
// 触发选中事件
SetCheck(!_bChecked);
}
__super::OnMouseLeftButtonUp(e);
}
void Button::Draw()
{
if (IsMouseActive())
GetContext()->GetSkin().DrawButtonActive(GetActiveOffset(), GetActiveArea());
else if (IsMouseOver())
GetContext()->GetSkin().DrawButtonHover(GetActiveOffset(), GetActiveArea());
else
GetContext()->GetSkin().DrawButtonNormal(GetActiveOffset(), GetActiveArea());
Single::Draw();
}
void SmallButton::Draw()
{
if (IsDisabled())
GetContext()->GetSkin().DrawSmallButtonDisabled(GetActiveOffset(), GetActiveArea());
else if (IsMouseActive())
GetContext()->GetSkin().DrawSmallButtonActive(GetActiveOffset(), GetActiveArea());
else if (IsMouseOver())
GetContext()->GetSkin().DrawSmallButtonHover(GetActiveOffset(), GetActiveArea());
else
GetContext()->GetSkin().DrawSmallButtonNormal(GetActiveOffset(), GetActiveArea());
}
bool ProcessInput( const TInputMsg & tData )
{
switch ( tData.eType )
{
case IMT_MOUSE_LKEY:
{
if ( IsMouseOver( g_pUIManager->GetMousePos() ) )
{
for ( uint n = 0; n < GetParent()->GetChildCount(); ++n )
{
// hack - clear all list items color
GetParent()->GetChildControl( n )->SetColor( 0xFFFFFFFF );
}
SetColor( 0xFF0000FF );
return true;
}
}
break;
case IMT_MOUSE_MOVE_X:
case IMT_MOUSE_MOVE_Y:
{
if ( IsMouseOver( g_pUIManager->GetMousePos() ) )
{
for ( uint n = 0; n < GetParent()->GetChildCount(); ++n )
{
// hack - clear all list items color
GetParent()->GetChildControl( n )->SetColor( 0xFFFFFFFF );
}
SetColor( 0xFF5087E7 );
return true;
}
}
break;
default:
return false;
}
}
void ButtonVector::SetStyles(Style *def, Style *mouseOver)
{
styleDefault = def;
styleMouseOver = mouseOver;
if (IsMouseOver())
SetStyle(styleMouseOver);
else
SetStyle(styleDefault);
RecalculateSize(true);
}
void Button::Update()
{
if(IsMouseOver(Controller::GetX(), Controller::GetY()))
grow += 2;
else
grow -= 2;
if(grow > height/8) grow = height/8;
if(grow < 0) grow = 0;
if(clickfade > 0) clickfade -= 20;
if(clickfade < 0) clickfade = 0;
if(clickfade > 0 && clickfade < 100) clicked = true;
}
void cUIListBoxItem::Update() {
cUITextBox::Update();
if ( mEnabled && mVisible ) {
cUIListBox * LBParent = reinterpret_cast<cUIListBox*> ( Parent()->Parent() );
Uint32 Flags = cUIManager::instance()->GetInput()->ClickTrigger();
if ( IsMouseOver() ) {
if ( Flags & EE_BUTTONS_WUWD && LBParent->VerticalScrollBar()->Visible() ) {
LBParent->VerticalScrollBar()->Slider()->ManageClick( Flags );
}
}
}
}
void UKUISimpleClickWidget::OnMouseMove( const FKUIInterfaceContainerMouseLocationEvent& stEventInfo )
{
Super::OnMouseMove( stEventInfo );
if ( !CanReceieveMouseEvents() )
return;
bool bMouseOver = IsMouseOver();
if ( this->bMouseOver == bMouseOver )
return;
this->bMouseOver = bMouseOver;
KUISendSubEvent( FKUIInterfaceEvent, EKUIInterfaceWidgetEventList::E_StateChange );
}
void cgUIButton::DrawBackground( const cgRectF& clipRect )
{
if (IfFillBackground())
{
cgColor uDrawColor = m_uBackColor;
if (!IsEnable())
uDrawColor = m_uDisableColor;
else if (IsClickDown())
uDrawColor = m_uPressColor;
else if (IsMouseOver())
uDrawColor = m_uHotColor;
cgUIRender::GetRender()->FillRect(clipRect, uDrawColor);
}
}
void clGUITabControl::PreRender()
{
clGUIBorderPanel::PreRender();
LVector2 Pos = GetMousePos();
// OutTextXY( 0.0f, -0.05f, Pos.ToString(','), LC_White );
FSelectedTab = NULL;
const float TextOffset = -0.025f;
for ( size_t i = 0; i != FTabsList.size(); ++i )
{
LVector4 Color = LC_Red;
if ( FActiveTab )
{
float Y = FActiveTab->GetY1();
if ( FTabsList[i].FTab == FActiveTab )
{
Env->Renderer->GetCanvas()->Rect( GetX1() + FTabsList[i].FX,
GetY1() + 0.005f,
GetX1() + FTabsList[i].FX + FTabsList[i].FWidth,
//GetY1() + Env->GUI->GetStringHeight() + 0.005f,
Y,
LC_Blue );
Color = LC_Green;
}
}
if ( IsMouseOver() )
{
if ( Pos.X > FTabsList[i].FX &&
Pos.Y > 0 &&
Pos.X < FTabsList[i].FX + FTabsList[i].FWidth &&
Pos.Y < FTabsList[i].FTab->GetY1() /*0.02f*/ )
{
FSelectedTab = FTabsList[i].FTab;
Color = LC_Yellow;
}
}
OutTextXY( FTabsList[i].FX, TextOffset, FTabsList[i].FTab->GetTitle(), Color );
}
}
void cgUIButton::DrawBackPic(const cgRectF& clipRect)
{
cgUIWidget::DrawBackPic(clipRect);
cgUIImagePtr ptr;
if (!IsEnable())
ptr = m_spDisablePic;
else if (IsClickDown())
ptr = m_spPressPic;
else if (IsMouseOver())
ptr = m_spHotPic;
else
ptr = m_spNormalPic;
DoDrawPic(ptr, m_kRect, clipRect);
}
void UKUIInterfaceElement::Render( AKUIInterface* aHud, UCanvas* oCanvas, const FVector2D& v2Origin, UKUIInterfaceElement* oRenderCacheObject )
{
aLastRenderedBy = aHud;
if ( !HasValidAlignLocation() )
{
TArray<UKUIInterfaceElement*> arAlignStack;
CalculateAlignLocation( arAlignStack );
}
if ( IsRenderCaching() )
{
if ( oRenderCacheObject != this )
{
if ( !oRenderCache->IsRenderCacheValid() )
oRenderCache->UpdateRenderCache( this );
//v2LastScreenRenderLocation = v2Origin + GetRenderLocation()/* + oRenderCacheObject->GetLastScreenRenderLocation()*/;
oCanvas->Reset();
oRenderCache->Render( aHud, oCanvas, GetScreenLocation() );
KUISendEvent( FKUIInterfaceElementRenderEvent, EKUIInterfaceElementEventList::E_Render, oCanvas, v2Origin );
}
}
else
{
if ( oRenderCacheObject == NULL )
v2LastScreenRenderLocation = v2Origin + GetRenderLocation();
oCanvas->Reset();
KUISendEvent( FKUIInterfaceElementRenderEvent, EKUIInterfaceElementEventList::E_Render, oCanvas, v2Origin );
}
#if KUI_INTERFACE_MOUSEOVER_DEBUG
AKUIInterface* aInterface = GetInterface();
if ( aInterface && aInterface->bDebugMouseOver && IsMouseOver() )
{
aInterface->cmDebugMouseOver = this;
aInterface->v2DebugMouseOverLocation = GetLastScreenRenderLocation();
aInterface->v2DebugMouseOverSize = GetSize();
}
#endif // KUI_INTERFACE_MOUSEOVER_DEBUG
}
//-----------------------------------------------------------------------------------------------------------------------------------
void Button::HandleInput(float elapsedSeconds, const Vector2& mousePosition)
{
ClickableImage::HandleInput(elapsedSeconds, mousePosition);
if (AcceptsInput())
{
if (HasMouseEntered())
{
SFXManager::GetInstance().PlaySound(BUTTON_HOVER_SOUND_ASSET);
}
if (IsMouseOver() && GetClickState() != ClickState::kPressed)
{
SetColour(m_highlightedColour);
}
}
}
void ScrollBar::Paint(Graphics *gfx, int offX, int offY) {
CrashIf(!IsVisible());
// TODO: take padding into account
CachedStyle *s = cachedStyle;
int dy = inactiveDy;
if (IsMouseOver())
dy = onOverDy;
Rect r(offX, offY + pos.Height - dy, pos.Width, dy);
Brush *br = BrushFromColorData(s->bgColor, r);
gfx->FillRectangle(br, r);
int filledDx = IntFromPerc(pos.Width, filledPerc);
if (0 == filledDx)
return;
r.Width = filledDx;
br = BrushFromColorData(s->color, r);
gfx->FillRectangle(br, r);
}
void cUITab::Update() {
cUISelectButton::Update();
if ( mEnabled && mVisible ) {
if ( IsMouseOver() ) {
cUITabWidget * tTabW = GetTabWidget();
if ( NULL != tTabW ) {
Uint32 Flags = cUIManager::instance()->GetInput()->ClickTrigger();
if ( Flags & EE_BUTTONS_WUWD ) {
if ( Flags & EE_BUTTON_WUMASK ) {
tTabW->SelectPrev();
} else if ( Flags & EE_BUTTON_WDMASK ) {
tTabW->SelectNext();
}
} else if ( tTabW->mTabsClosable && ( Flags & EE_BUTTON_MMASK ) ) {
tTabW->Remove( this );
}
}
}
}
}
//-----------------------------------------------------------------------------------------------------------------------------------
void Button::HandleInput(DX::StepTimer const& timer, const Vector2& mousePosition)
{
UIObject::HandleInput(timer, mousePosition);
if (AcceptsInput())
{
if (IsMouseOver() && m_buttonState != ButtonState::kPressed)
{
m_buttonState = ButtonState::kHighlighted;
SetColour(m_highlightedColour);
}
if (IsSelected())
{
if (m_buttonState != ButtonState::kPressed)
{
assert(m_clickFunction);
m_clickFunction();
m_buttonState = ButtonState::kPressed;
}
}
}
}
void Slider::UpdateButton()
{
const Skin &skin = GetContext()->GetSkin();
const Point activeArea(GetActiveArea());
if (m_orient == SLIDER_HORIZONTAL) {
const Skin::EdgedRectElement &gutterRect = skin.SliderHorizontalGutter();
const Skin::RectElement &buttonRect = skin.SliderHorizontalButtonNormal();
m_buttonSize = Point(buttonRect.size.x, buttonRect.size.y);
m_buttonPos = Point(((activeArea.x-gutterRect.edgeWidth*2-buttonRect.size.x)*m_value)+gutterRect.edgeWidth, (activeArea.y-buttonRect.size.y)/2);
}
else {
const Skin::EdgedRectElement &gutterRect = skin.SliderVerticalGutter();
const Skin::RectElement &buttonRect = skin.SliderVerticalButtonNormal();
m_buttonSize = Point(buttonRect.size.x, buttonRect.size.y);
m_buttonPos = Point((activeArea.x-buttonRect.size.x)/2, ((activeArea.y-gutterRect.edgeWidth*2-buttonRect.size.y)*m_value)+gutterRect.edgeWidth);
}
m_mouseOverButton = IsMouseOver() && PointInsideButton(m_lastMousePosition);
}
bool CButton::ProcessInput( const TInputMsg & tData )
{
if ( IsMouseOver( g_pUIManager->GetMousePos() ) )
SetText( "Over" );
else
SetText( "OK" );
switch ( tData.eType )
{
case IMT_MOUSE_MOVE_X:
case IMT_MOUSE_MOVE_Y:
{
if ( IsMouseOver( g_pUIManager->GetMousePos() ) )
{
if ( this == g_pUIManager->GetActiveControl() )
{
m_bPressed = true;
}
}
else
{
m_bPressed = false;
}
}
break;
case IMT_MOUSE_LKEY:
{
if ( IsMouseOver( g_pUIManager->GetMousePos() ) )
{
if ( tData.dwData & 0x80 )
{
Press();
g_pUIManager->SetActiveControl( this );
}
else
{
if ( this == g_pUIManager->GetActiveControl() )
{
g_pUIManager->SetActiveControl( NULL );
MessageBeep( MB_OK );
//if ( m_pParent )
// m_pParent->OnChildEvent( this );
Press( false );
}
}
return true;
}
else if ( this == g_pUIManager->GetActiveControl() )
{
if ( !( tData.dwData & 0x80 ) )
g_pUIManager->SetActiveControl( NULL );
}
}
break;
}
return false;
}
void Button::OnButton(bool isDown)
{
if(isDown && IsMouseOver(Controller::GetX(), Controller::GetY()))
clickfade = 255;
}
/*
Updates player moves
*/
void clash::Update(float dt) {
_keyPress += dt;
if (_turn == AI) NextTurn();
else if (sf::Keyboard::isKeyPressed(sf::Keyboard::Key::Return) && _keyPress > 1.f) {
NextTurn();
_keyPress = 0;
}
// Mouse-over type marker
for (int i = 0; i < CHECKBOARD; i++) {
for (int j = 0; j < CHECKBOARD; j++) {
if (IsMouseOver(_checkBoard[i][j])) {
_currentMouseOver = sf::Vector2i(i, j);
}
}
}
// Selection tool
if (sf::Mouse::isButtonPressed(sf::Mouse::Left)) {
_currentChoosen = _currentMouseOver;
}
// Moving units
else if (sf::Mouse::isButtonPressed(sf::Mouse::Right) && _currentChoosen.x >= 0 && _keyPress > 0.2f) {
int i = _currentChoosen.x;
int j = _currentChoosen.y;
int x = _currentMouseOver.x;
int y = _currentMouseOver.y;
if (((abs(x - i) <= 1 && j == y) || (abs(j - y) <= 1 && i == x)) && _movesPPlayer > 0 && _checkBoard[i][j].CountUnits() > 0) {
if (_checkBoard[i][j]._entity == _checkBoard[x][y]._entity && _turn == _checkBoard[i][j]._entity)
MoveUnit(_currentChoosen, _currentMouseOver);
if (_checkBoard[x][y]._entity == NONE && _turn == _checkBoard[i][j]._entity) {
_checkBoard[x][y]._entity = _turn;
_checkBoard[x][y]._field = UNIT;
MoveUnit(_currentChoosen, _currentMouseOver);
}
if (_checkBoard[x][y]._entity >= 0 && _checkBoard[x][y]._entity != _checkBoard[i][j]._entity) {
if (_checkBoard[x][y].CountUnits() > 0 && _checkBoard[i][j].CountUnits() > 0) {
_checkBoard[x][y].Kill(1);
_checkBoard[i][j].Kill(1);
_movesPPlayer--;
}
else if (_checkBoard[x][y].CountUnits() == 0 && _checkBoard[i][j].CountUnits() > 0) {
if (_checkBoard[x][y]._field == FACTORY) {
_checkBoard[x][y]._field = UNIT;
_player[_checkBoard[x][y]._entity - 1] = false;
}
if (_checkBoard[x][y]._field == CORE) {
//Window.GetGameManager()->_winner = (int)(_checkBoard[i][j]._entity + 1);
//Window.GetGameManager()->MoveForward();
Window.Stop();
}
_checkBoard[x][y]._entity = _checkBoard[i][j]._entity;
MoveUnit(_currentChoosen, _currentMouseOver);
}
}
}
_keyPress = 0;
}
if (_turn == AI && _pcTurn >= 2 && _pcTurn != 3) {
if (_pcTurn == 4) {
for (int i = 0; i < CHECKBOARD; i++) {
for (int j = 0; j < CHECKBOARD; j++) {
if (_checkBoard[i][j]._entity == AI) {
_checkBoard[i][j].TurnAlive(1);
}
}
}
_pcTurn = 0;
}
for (int i = 1; i <= 2; i++) {
int ww = 0, wh = 0;
if (i == 1 || i == 4) wh = 1;
if (i == 1 || i == 3) ww = 1;
if (i == 3 || i == 2) wh = CHECKBOARD - 2;
if (i == 4 || i == 2) ww = CHECKBOARD - 2;
if (_checkBoard[ww][wh]._entity == NONE) {
_checkBoard[ww][wh]._entity = (ENTITY_TYPE) (i);
_checkBoard[ww][wh]._field = UNIT;
}
if (_checkBoard[ww][wh]._entity == (ENTITY_TYPE) (i) && _player[_checkBoard[ww][wh]._entity-1]) {
_checkBoard[ww][wh].TurnAlive(2);
}
}
}
if (_movesPPlayer > 0) _check = false;
if (_moves != _movesPPlayer) {
if (_movesPPlayer == 0) Window.UpdateStatusbar("Press ENTER for next turn");
else if (_turnCounter == 1 && _movesPPlayer == 0 && _check) {
_moves = 1;
_check = false;
}
else Window.UpdateStatusbar(toString(_movesPPlayer) + " moves left");
}
}
std::wstring GSGUI_FLOAT_INPUT::GetDescription()
{
if (!IsMouseOver())
return L"";
return m_desc;
}
bool GUI_Interactable::IsMouseOver(Vector2f mpos)
{
return IsMouseOver(mpos.x, mpos.y);
}
void COXEditTip::NeedItemTip(LPNEEDITEMTIPINFO pnitInfo)
{
ASSERT(::IsWindow(m_hWndHooked));
ASSERT(m_hWndHooked==m_pAttachedCtrl->m_hWnd);
// we already been there so we don't need to show the tip again
if(IsMouseOver())
{
pnitInfo->result=ID_NIT_CUSTOMREJECT;
return;
}
DWORD dwStyle=m_pAttachedCtrl->GetStyle();
// Make sure that the Edit control has single line style
if((dwStyle&ES_MULTILINE)==ES_MULTILINE)
{
pnitInfo->result=ID_NIT_WRONGFORMAT;
return;
}
CString sText;
m_pAttachedCtrl->GetWindowText(sText);
if(sText.IsEmpty())
{
pnitInfo->result=ID_NIT_NOTHIDDEN;
return;
}
if(sText.GetLength()>pnitInfo->sizeText)
{
pnitInfo->result=ID_NIT_WRONGFORMAT;
return;
}
CRect rectItem;
m_pAttachedCtrl->GetRect(rectItem);
CRect rectClient;
m_pAttachedCtrl->GetClientRect(rectClient);
CRect rectWindow;
m_pAttachedCtrl->GetWindowRect(rectWindow);
m_pAttachedCtrl->ScreenToClient(rectWindow);
pnitInfo->offset=rectItem.left-rectWindow.left;
CClientDC dc(m_pAttachedCtrl);
CFont* pOldFont=pnitInfo->pFont==NULL ? NULL :
dc.SelectObject((CFont*)pnitInfo->pFont);
CRect rectText(0, 0, 0, 0);
dc.DrawText(sText,&rectText,DT_CALCRECT|DT_LEFT|DT_SINGLELINE);
if(pOldFont)
{
dc.SelectObject(pOldFont);
}
if(rectText.Width()<=rectItem.Width() && rectText.Height()<=rectItem.Height())
{
pnitInfo->result=ID_NIT_NOTHIDDEN;
return;
}
rectItem.right=rectItem.left+rectText.Width();
rectItem.bottom=rectItem.top+rectText.Height();
if((dwStyle&ES_CENTER)==ES_CENTER)
pnitInfo->alignment=DT_CENTER;
else if((dwStyle&ES_RIGHT)==ES_RIGHT)
pnitInfo->alignment=DT_RIGHT;
else
pnitInfo->alignment=DT_LEFT;
pnitInfo->rectItem.left=rectWindow.left;
pnitInfo->rectItem.top=rectWindow.top;
pnitInfo->rectItem.right=rectWindow.left+rectItem.Width();
pnitInfo->rectItem.bottom=rectWindow.bottom;
lstrcpyn(pnitInfo->itemText,sText,pnitInfo->sizeText);
if(pnitInfo->clrText==ID_OX_COLOR_NONE)
pnitInfo->clrText=::GetSysColor(COLOR_WINDOWTEXT);
pnitInfo->result=ID_NIT_SUCCESS;
}
str_type::string GSGUI_FLOAT_INPUT::GetDescription()
{
if (!IsMouseOver())
return GS_L("");
return m_desc;
}
