1 // Copyright (C) 2002-2012 Nikolaus Gebhardt
\r
2 // This file is part of the "Irrlicht Engine".
\r
3 // For conditions of distribution and use, see copyright notice in irrlicht.h
\r
5 #include "guiButton.h"
\r
8 #include "client/guiscalingfilter.h"
\r
9 #include "client/tile.h"
\r
10 #include "IGUISkin.h"
\r
11 #include "IGUIEnvironment.h"
\r
12 #include "IVideoDriver.h"
\r
13 #include "IGUIFont.h"
\r
14 #include "irrlicht_changes/static_text.h"
\r
15 #include "porting.h"
\r
16 #include "StyleSpec.h"
\r
18 using namespace irr;
\r
19 using namespace gui;
\r
21 // Multiply with a color to get the default corresponding hovered color
\r
22 #define COLOR_HOVERED_MOD 1.25f
\r
24 // Multiply with a color to get the default corresponding pressed color
\r
25 #define COLOR_PRESSED_MOD 0.85f
\r
28 GUIButton::GUIButton(IGUIEnvironment* environment, IGUIElement* parent,
\r
29 s32 id, core::rect<s32> rectangle, bool noclip)
\r
30 : IGUIButton(environment, parent, id, rectangle),
\r
31 SpriteBank(0), OverrideFont(0),
\r
32 OverrideColorEnabled(false), OverrideColor(video::SColor(101,255,255,255)),
\r
33 ClickTime(0), HoverTime(0), FocusTime(0),
\r
34 ClickShiftState(false), ClickControlState(false),
\r
35 IsPushButton(false), Pressed(false),
\r
36 UseAlphaChannel(false), DrawBorder(true), ScaleImage(false)
\r
38 setNotClipped(noclip);
\r
40 // This element can be tabbed.
\r
45 for (size_t i = 0; i < 4; i++) {
\r
46 Colors[i] = Environment->getSkin()->getColor((EGUI_DEFAULT_COLOR)i);
\r
47 HoveredColors[i] = irr::video::SColor(Colors[i].getAlpha(),
\r
48 core::clamp<u32>(Colors[i].getRed() * COLOR_HOVERED_MOD, 0, 255),
\r
49 core::clamp<u32>(Colors[i].getGreen() * COLOR_HOVERED_MOD, 0, 255),
\r
50 core::clamp<u32>(Colors[i].getBlue() * COLOR_HOVERED_MOD, 0, 255));
\r
51 PressedColors[i] = irr::video::SColor(Colors[i].getAlpha(),
\r
52 core::clamp<u32>(Colors[i].getRed() * COLOR_PRESSED_MOD, 0, 255),
\r
53 core::clamp<u32>(Colors[i].getGreen() * COLOR_PRESSED_MOD, 0, 255),
\r
54 core::clamp<u32>(Colors[i].getBlue() * COLOR_PRESSED_MOD, 0, 255));
\r
57 StaticText = gui::StaticText::add(Environment, Text.c_str(), core::rect<s32>(0,0,rectangle.getWidth(),rectangle.getHeight()), false, false, this, id);
\r
58 StaticText->setTextAlignment(EGUIA_CENTER, EGUIA_CENTER);
\r
63 GUIButton::~GUIButton()
\r
66 OverrideFont->drop();
\r
73 //! Sets if the images should be scaled to fit the button
\r
74 void GUIButton::setScaleImage(bool scaleImage)
\r
76 ScaleImage = scaleImage;
\r
80 //! Returns whether the button scale the used images
\r
81 bool GUIButton::isScalingImage() const
\r
87 //! Sets if the button should use the skin to draw its border
\r
88 void GUIButton::setDrawBorder(bool border)
\r
90 DrawBorder = border;
\r
94 void GUIButton::setSpriteBank(IGUISpriteBank* sprites)
\r
100 SpriteBank->drop();
\r
102 SpriteBank = sprites;
\r
105 void GUIButton::setSprite(EGUI_BUTTON_STATE state, s32 index, video::SColor color, bool loop, bool scale)
\r
107 ButtonSprites[(u32)state].Index = index;
\r
108 ButtonSprites[(u32)state].Color = color;
\r
109 ButtonSprites[(u32)state].Loop = loop;
\r
110 ButtonSprites[(u32)state].Scale = scale;
\r
113 //! Get the sprite-index for the given state or -1 when no sprite is set
\r
114 s32 GUIButton::getSpriteIndex(EGUI_BUTTON_STATE state) const
\r
116 return ButtonSprites[(u32)state].Index;
\r
119 //! Get the sprite color for the given state. Color is only used when a sprite is set.
\r
120 video::SColor GUIButton::getSpriteColor(EGUI_BUTTON_STATE state) const
\r
122 return ButtonSprites[(u32)state].Color;
\r
125 //! Returns if the sprite in the given state does loop
\r
126 bool GUIButton::getSpriteLoop(EGUI_BUTTON_STATE state) const
\r
128 return ButtonSprites[(u32)state].Loop;
\r
131 //! Returns if the sprite in the given state is scaled
\r
132 bool GUIButton::getSpriteScale(EGUI_BUTTON_STATE state) const
\r
134 return ButtonSprites[(u32)state].Scale;
\r
137 //! called if an event happened.
\r
138 bool GUIButton::OnEvent(const SEvent& event)
\r
141 return IGUIElement::OnEvent(event);
\r
143 switch(event.EventType)
\r
145 case EET_KEY_INPUT_EVENT:
\r
146 if (event.KeyInput.PressedDown &&
\r
147 (event.KeyInput.Key == KEY_RETURN || event.KeyInput.Key == KEY_SPACE))
\r
152 setPressed(!Pressed);
\r
156 if (Pressed && !IsPushButton && event.KeyInput.PressedDown && event.KeyInput.Key == KEY_ESCAPE)
\r
162 if (!event.KeyInput.PressedDown && Pressed &&
\r
163 (event.KeyInput.Key == KEY_RETURN || event.KeyInput.Key == KEY_SPACE))
\r
171 ClickShiftState = event.KeyInput.Shift;
\r
172 ClickControlState = event.KeyInput.Control;
\r
175 newEvent.EventType = EET_GUI_EVENT;
\r
176 newEvent.GUIEvent.Caller = this;
\r
177 newEvent.GUIEvent.Element = 0;
\r
178 newEvent.GUIEvent.EventType = EGET_BUTTON_CLICKED;
\r
179 Parent->OnEvent(newEvent);
\r
184 case EET_GUI_EVENT:
\r
185 if (event.GUIEvent.Caller == this)
\r
187 if (event.GUIEvent.EventType == EGET_ELEMENT_FOCUS_LOST)
\r
191 FocusTime = (u32)porting::getTimeMs();
\r
193 else if (event.GUIEvent.EventType == EGET_ELEMENT_FOCUSED)
\r
195 FocusTime = (u32)porting::getTimeMs();
\r
197 else if (event.GUIEvent.EventType == EGET_ELEMENT_HOVERED || event.GUIEvent.EventType == EGET_ELEMENT_LEFT)
\r
199 HoverTime = (u32)porting::getTimeMs();
\r
203 case EET_MOUSE_INPUT_EVENT:
\r
204 if (event.MouseInput.Event == EMIE_LMOUSE_PRESSED_DOWN)
\r
212 if (event.MouseInput.Event == EMIE_LMOUSE_LEFT_UP)
\r
214 bool wasPressed = Pressed;
\r
216 if ( !AbsoluteClippingRect.isPointInside( core::position2d<s32>(event.MouseInput.X, event.MouseInput.Y ) ) )
\r
227 setPressed(!Pressed);
\r
230 if ((!IsPushButton && wasPressed && Parent) ||
\r
231 (IsPushButton && wasPressed != Pressed))
\r
233 ClickShiftState = event.MouseInput.Shift;
\r
234 ClickControlState = event.MouseInput.Control;
\r
237 newEvent.EventType = EET_GUI_EVENT;
\r
238 newEvent.GUIEvent.Caller = this;
\r
239 newEvent.GUIEvent.Element = 0;
\r
240 newEvent.GUIEvent.EventType = EGET_BUTTON_CLICKED;
\r
241 Parent->OnEvent(newEvent);
\r
251 return Parent ? Parent->OnEvent(event) : false;
\r
255 //! draws the element and its children
\r
256 void GUIButton::draw()
\r
262 GUISkin* skin = dynamic_cast<GUISkin*>(Environment->getSkin());
\r
263 video::IVideoDriver* driver = Environment->getVideoDriver();
\r
271 skin->drawColored3DButtonPaneStandard(this, AbsoluteRect, &AbsoluteClippingRect,
\r
272 isHovered() ? HoveredColors : Colors);
\r
278 skin->drawColored3DButtonPanePressed(this,
\r
279 AbsoluteRect, &AbsoluteClippingRect, PressedColors);
\r
284 const core::position2di buttonCenter(AbsoluteRect.getCenter());
\r
285 EGUI_BUTTON_IMAGE_STATE imageState = getImageState(Pressed);
\r
286 if ( ButtonImages[(u32)imageState].Texture )
\r
288 core::position2d<s32> pos(buttonCenter);
\r
289 core::rect<s32> sourceRect(ButtonImages[(u32)imageState].SourceRect);
\r
290 if ( sourceRect.getWidth() == 0 && sourceRect.getHeight() == 0 )
\r
291 sourceRect = core::rect<s32>(core::position2di(0,0), ButtonImages[(u32)imageState].Texture->getOriginalSize());
\r
293 pos.X -= sourceRect.getWidth() / 2;
\r
294 pos.Y -= sourceRect.getHeight() / 2;
\r
298 // Create a pressed-down effect by moving the image when it looks identical to the unpressed state image
\r
299 EGUI_BUTTON_IMAGE_STATE unpressedState = getImageState(false);
\r
300 if ( unpressedState == imageState || ButtonImages[(u32)imageState] == ButtonImages[(u32)unpressedState] )
\r
302 pos.X += skin->getSize(EGDS_BUTTON_PRESSED_IMAGE_OFFSET_X);
\r
303 pos.Y += skin->getSize(EGDS_BUTTON_PRESSED_IMAGE_OFFSET_Y);
\r
307 driver->draw2DImage(ButtonImages[(u32)imageState].Texture,
\r
308 ScaleImage? AbsoluteRect : core::rect<s32>(pos, sourceRect.getSize()),
\r
309 sourceRect, &AbsoluteClippingRect,
\r
310 0, UseAlphaChannel);
\r
315 core::position2di pos(buttonCenter);
\r
319 // pressed / unpressed animation
\r
320 EGUI_BUTTON_STATE state = Pressed ? EGBS_BUTTON_DOWN : EGBS_BUTTON_UP;
\r
321 drawSprite(state, ClickTime, pos);
\r
323 // focused / unfocused animation
\r
324 state = Environment->hasFocus(this) ? EGBS_BUTTON_FOCUSED : EGBS_BUTTON_NOT_FOCUSED;
\r
325 drawSprite(state, FocusTime, pos);
\r
327 // mouse over / off animation
\r
328 state = isHovered() ? EGBS_BUTTON_MOUSE_OVER : EGBS_BUTTON_MOUSE_OFF;
\r
329 drawSprite(state, HoverTime, pos);
\r
334 // drawSprite(EGBS_BUTTON_DISABLED, 0, pos);
\r
338 IGUIElement::draw();
\r
341 void GUIButton::drawSprite(EGUI_BUTTON_STATE state, u32 startTime, const core::position2di& center)
\r
343 u32 stateIdx = (u32)state;
\r
345 if (ButtonSprites[stateIdx].Index != -1)
\r
347 if ( ButtonSprites[stateIdx].Scale )
\r
349 const video::SColor colors[] = {ButtonSprites[stateIdx].Color,ButtonSprites[stateIdx].Color,ButtonSprites[stateIdx].Color,ButtonSprites[stateIdx].Color};
\r
350 SpriteBank->draw2DSprite(ButtonSprites[stateIdx].Index, AbsoluteRect.UpperLeftCorner,
\r
351 &AbsoluteClippingRect, colors[0], // FIXME: remove [0]
\r
352 porting::getTimeMs()-startTime, ButtonSprites[stateIdx].Loop);
\r
356 SpriteBank->draw2DSprite(ButtonSprites[stateIdx].Index, center,
\r
357 &AbsoluteClippingRect, ButtonSprites[stateIdx].Color, startTime, porting::getTimeMs(),
\r
358 ButtonSprites[stateIdx].Loop, true);
\r
363 EGUI_BUTTON_IMAGE_STATE GUIButton::getImageState(bool pressed) const
\r
366 return getImageState(pressed, ButtonImages);
\r
370 EGUI_BUTTON_IMAGE_STATE GUIButton::getImageState(bool pressed, const ButtonImage* images) const
\r
372 // figure state we should have
\r
373 EGUI_BUTTON_IMAGE_STATE state = EGBIS_IMAGE_DISABLED;
\r
374 bool focused = Environment->hasFocus((IGUIElement*)this);
\r
375 bool mouseOver = isHovered();
\r
380 if ( focused && mouseOver )
\r
381 state = EGBIS_IMAGE_DOWN_FOCUSED_MOUSEOVER;
\r
382 else if ( focused )
\r
383 state = EGBIS_IMAGE_DOWN_FOCUSED;
\r
384 else if ( mouseOver )
\r
385 state = EGBIS_IMAGE_DOWN_MOUSEOVER;
\r
387 state = EGBIS_IMAGE_DOWN;
\r
391 if ( focused && mouseOver )
\r
392 state = EGBIS_IMAGE_UP_FOCUSED_MOUSEOVER;
\r
393 else if ( focused )
\r
394 state = EGBIS_IMAGE_UP_FOCUSED;
\r
395 else if ( mouseOver )
\r
396 state = EGBIS_IMAGE_UP_MOUSEOVER;
\r
398 state = EGBIS_IMAGE_UP;
\r
402 // find a compatible state that has images
\r
403 while ( state != EGBIS_IMAGE_UP && !images[(u32)state].Texture )
\r
408 case EGBIS_IMAGE_UP_FOCUSED:
\r
409 state = EGBIS_IMAGE_UP;
\r
411 case EGBIS_IMAGE_UP_FOCUSED_MOUSEOVER:
\r
412 state = EGBIS_IMAGE_UP_FOCUSED;
\r
414 case EGBIS_IMAGE_DOWN_MOUSEOVER:
\r
415 state = EGBIS_IMAGE_DOWN;
\r
417 case EGBIS_IMAGE_DOWN_FOCUSED:
\r
418 state = EGBIS_IMAGE_DOWN;
\r
420 case EGBIS_IMAGE_DOWN_FOCUSED_MOUSEOVER:
\r
421 state = EGBIS_IMAGE_DOWN_FOCUSED;
\r
423 case EGBIS_IMAGE_DISABLED:
\r
425 state = EGBIS_IMAGE_DOWN;
\r
427 state = EGBIS_IMAGE_UP;
\r
430 state = EGBIS_IMAGE_UP;
\r
438 //! sets another skin independent font. if this is set to zero, the button uses the font of the skin.
\r
439 void GUIButton::setOverrideFont(IGUIFont* font)
\r
441 if (OverrideFont == font)
\r
445 OverrideFont->drop();
\r
447 OverrideFont = font;
\r
450 OverrideFont->grab();
\r
452 StaticText->setOverrideFont(font);
\r
455 //! Gets the override font (if any)
\r
456 IGUIFont * GUIButton::getOverrideFont() const
\r
458 return OverrideFont;
\r
461 //! Get the font which is used right now for drawing
\r
462 IGUIFont* GUIButton::getActiveFont() const
\r
464 if ( OverrideFont )
\r
465 return OverrideFont;
\r
466 IGUISkin* skin = Environment->getSkin();
\r
468 return skin->getFont(EGDF_BUTTON);
\r
472 //! Sets another color for the text.
\r
473 void GUIButton::setOverrideColor(video::SColor color)
\r
475 OverrideColor = color;
\r
476 OverrideColorEnabled = true;
\r
478 StaticText->setOverrideColor(color);
\r
481 video::SColor GUIButton::getOverrideColor() const
\r
483 return OverrideColor;
\r
486 void GUIButton::enableOverrideColor(bool enable)
\r
488 OverrideColorEnabled = enable;
\r
491 bool GUIButton::isOverrideColorEnabled() const
\r
493 return OverrideColorEnabled;
\r
496 void GUIButton::setImage(EGUI_BUTTON_IMAGE_STATE state, video::ITexture* image, const core::rect<s32>& sourceRect)
\r
498 if ( state >= EGBIS_COUNT )
\r
504 u32 stateIdx = (u32)state;
\r
505 if ( ButtonImages[stateIdx].Texture )
\r
506 ButtonImages[stateIdx].Texture->drop();
\r
508 ButtonImages[stateIdx].Texture = image;
\r
509 ButtonImages[stateIdx].SourceRect = sourceRect;
\r
513 void GUIButton::setImage(video::ITexture* image)
\r
515 setImage(gui::EGBIS_IMAGE_UP, image);
\r
518 void GUIButton::setImage(video::ITexture* image, const core::rect<s32>& pos)
\r
520 setImage(gui::EGBIS_IMAGE_UP, image, pos);
\r
523 void GUIButton::setPressedImage(video::ITexture* image)
\r
525 setImage(gui::EGBIS_IMAGE_DOWN, image);
\r
528 void GUIButton::setPressedImage(video::ITexture* image, const core::rect<s32>& pos)
\r
530 setImage(gui::EGBIS_IMAGE_DOWN, image, pos);
\r
533 void GUIButton::setHoveredImage(video::ITexture* image)
\r
535 setImage(gui::EGBIS_IMAGE_UP_MOUSEOVER, image);
\r
536 setImage(gui::EGBIS_IMAGE_UP_FOCUSED_MOUSEOVER, image);
\r
539 void GUIButton::setHoveredImage(video::ITexture* image, const core::rect<s32>& pos)
\r
541 setImage(gui::EGBIS_IMAGE_UP_MOUSEOVER, image, pos);
\r
542 setImage(gui::EGBIS_IMAGE_UP_FOCUSED_MOUSEOVER, image, pos);
\r
545 //! Sets the text displayed by the button
\r
546 void GUIButton::setText(const wchar_t* text)
\r
548 StaticText->setText(text);
\r
550 IGUIButton::setText(text);
\r
554 //! Sets if the button should behave like a push button. Which means it
\r
555 //! can be in two states: Normal or Pressed. With a click on the button,
\r
556 //! the user can change the state of the button.
\r
557 void GUIButton::setIsPushButton(bool isPushButton)
\r
559 IsPushButton = isPushButton;
\r
563 //! Returns if the button is currently pressed
\r
564 bool GUIButton::isPressed() const
\r
570 //! Returns if this element (or one of its direct children) is hovered
\r
571 bool GUIButton::isHovered() const
\r
573 IGUIElement *hovered = Environment->getHovered();
\r
574 return hovered == this || (hovered != nullptr && hovered->getParent() == this);
\r
578 //! Sets the pressed state of the button if this is a pushbutton
\r
579 void GUIButton::setPressed(bool pressed)
\r
581 if (Pressed != pressed)
\r
583 ClickTime = porting::getTimeMs();
\r
586 GUISkin* skin = dynamic_cast<GUISkin*>(Environment->getSkin());
\r
588 for(IGUIElement *child : getChildren())
\r
590 core::rect<s32> originalRect = child->getRelativePosition();
\r
592 child->setRelativePosition(originalRect +
\r
593 core::dimension2d<s32>(
\r
594 skin->getSize(irr::gui::EGDS_BUTTON_PRESSED_IMAGE_OFFSET_X),
\r
595 skin->getSize(irr::gui::EGDS_BUTTON_PRESSED_IMAGE_OFFSET_Y)));
\r
597 child->setRelativePosition(originalRect -
\r
598 core::dimension2d<s32>(
\r
599 skin->getSize(irr::gui::EGDS_BUTTON_PRESSED_IMAGE_OFFSET_X),
\r
600 skin->getSize(irr::gui::EGDS_BUTTON_PRESSED_IMAGE_OFFSET_Y)));
\r
607 //! Returns whether the button is a push button
\r
608 bool GUIButton::isPushButton() const
\r
610 return IsPushButton;
\r
614 //! Sets if the alpha channel should be used for drawing images on the button (default is false)
\r
615 void GUIButton::setUseAlphaChannel(bool useAlphaChannel)
\r
617 UseAlphaChannel = useAlphaChannel;
\r
621 //! Returns if the alpha channel should be used for drawing images on the button
\r
622 bool GUIButton::isAlphaChannelUsed() const
\r
624 return UseAlphaChannel;
\r
628 bool GUIButton::isDrawingBorder() const
\r
634 //! Writes attributes of the element.
\r
635 void GUIButton::serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options=0) const
\r
637 IGUIButton::serializeAttributes(out,options);
\r
639 out->addBool ("PushButton", IsPushButton );
\r
641 out->addBool("Pressed", Pressed);
\r
643 for ( u32 i=0; i<(u32)EGBIS_COUNT; ++i )
\r
645 if ( ButtonImages[i].Texture )
\r
647 core::stringc name( GUIButtonImageStateNames[i] );
\r
648 out->addTexture(name.c_str(), ButtonImages[i].Texture);
\r
650 out->addRect(name.c_str(), ButtonImages[i].SourceRect);
\r
654 out->addBool ("UseAlphaChannel", UseAlphaChannel);
\r
655 out->addBool ("Border", DrawBorder);
\r
656 out->addBool ("ScaleImage", ScaleImage);
\r
658 for ( u32 i=0; i<(u32)EGBS_COUNT; ++i )
\r
660 if ( ButtonSprites[i].Index >= 0 )
\r
662 core::stringc nameIndex( GUIButtonStateNames[i] );
\r
663 nameIndex += "Index";
\r
664 out->addInt(nameIndex.c_str(), ButtonSprites[i].Index );
\r
666 core::stringc nameColor( GUIButtonStateNames[i] );
\r
667 nameColor += "Color";
\r
668 out->addColor(nameColor.c_str(), ButtonSprites[i].Color );
\r
670 core::stringc nameLoop( GUIButtonStateNames[i] );
\r
671 nameLoop += "Loop";
\r
672 out->addBool(nameLoop.c_str(), ButtonSprites[i].Loop );
\r
674 core::stringc nameScale( GUIButtonStateNames[i] );
\r
675 nameScale += "Scale";
\r
676 out->addBool(nameScale.c_str(), ButtonSprites[i].Scale );
\r
680 // out->addString ("OverrideFont", OverrideFont);
\r
684 //! Reads attributes of the element
\r
685 void GUIButton::deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options=0)
\r
687 IGUIButton::deserializeAttributes(in,options);
\r
689 IsPushButton = in->getAttributeAsBool("PushButton");
\r
690 Pressed = IsPushButton ? in->getAttributeAsBool("Pressed") : false;
\r
692 core::rect<s32> rec = in->getAttributeAsRect("ImageRect");
\r
694 setImage( in->getAttributeAsTexture("Image"), rec);
\r
696 setImage( in->getAttributeAsTexture("Image") );
\r
698 rec = in->getAttributeAsRect("PressedImageRect");
\r
700 setPressedImage( in->getAttributeAsTexture("PressedImage"), rec);
\r
702 setPressedImage( in->getAttributeAsTexture("PressedImage") );
\r
704 setDrawBorder(in->getAttributeAsBool("Border"));
\r
705 setUseAlphaChannel(in->getAttributeAsBool("UseAlphaChannel"));
\r
706 setScaleImage(in->getAttributeAsBool("ScaleImage"));
\r
708 // setOverrideFont(in->getAttributeAsString("OverrideFont"));
\r
710 updateAbsolutePosition();
\r
714 GUIButton* GUIButton::addButton(IGUIEnvironment *environment, const core::rect<s32>& rectangle,
\r
715 IGUIElement* parent, s32 id, const wchar_t* text, const wchar_t *tooltiptext)
\r
717 GUIButton* button = new GUIButton(environment, parent ? parent : environment->getRootGUIElement(), id, rectangle);
\r
719 button->setText(text);
\r
722 button->setToolTipText ( tooltiptext );
\r
728 void GUIButton::setColor(video::SColor color)
\r
731 for (size_t i = 0; i < 4; i++) {
\r
732 video::SColor base = Environment->getSkin()->getColor((gui::EGUI_DEFAULT_COLOR)i);
\r
733 Colors[i] = base.getInterpolated(color, d);
\r
734 HoveredColors[i] = irr::video::SColor(Colors[i].getAlpha(),
\r
735 core::clamp<u32>(Colors[i].getRed() * COLOR_HOVERED_MOD, 0, 255),
\r
736 core::clamp<u32>(Colors[i].getGreen() * COLOR_HOVERED_MOD, 0, 255),
\r
737 core::clamp<u32>(Colors[i].getBlue() * COLOR_HOVERED_MOD, 0, 255));
\r
738 PressedColors[i] = irr::video::SColor(Colors[i].getAlpha(),
\r
739 core::clamp<u32>(Colors[i].getRed() * COLOR_PRESSED_MOD, 0, 255),
\r
740 core::clamp<u32>(Colors[i].getGreen() * COLOR_PRESSED_MOD, 0, 255),
\r
741 core::clamp<u32>(Colors[i].getBlue() * COLOR_PRESSED_MOD, 0, 255));
\r
744 void GUIButton::setHoveredColor(video::SColor color)
\r
747 for (size_t i = 0; i < 4; i++) {
\r
748 video::SColor base = Environment->getSkin()->getColor((gui::EGUI_DEFAULT_COLOR)i);
\r
749 HoveredColors[i] = base.getInterpolated(color, d);
\r
752 void GUIButton::setPressedColor(video::SColor color)
\r
755 for (size_t i = 0; i < 4; i++) {
\r
756 video::SColor base = Environment->getSkin()->getColor((gui::EGUI_DEFAULT_COLOR)i);
\r
757 PressedColors[i] = base.getInterpolated(color, d);
\r
761 //! Set element properties from a StyleSpec
\r
762 void GUIButton::setFromStyle(const StyleSpec& style, ISimpleTextureSource *tsrc)
\r
764 if (style.isNotDefault(StyleSpec::BGCOLOR)) {
\r
765 setColor(style.getColor(StyleSpec::BGCOLOR));
\r
767 if (style.isNotDefault(StyleSpec::BGCOLOR_HOVERED)) {
\r
768 setHoveredColor(style.getColor(StyleSpec::BGCOLOR_HOVERED));
\r
770 if (style.isNotDefault(StyleSpec::BGCOLOR_PRESSED)) {
\r
771 setPressedColor(style.getColor(StyleSpec::BGCOLOR_PRESSED));
\r
774 if (style.isNotDefault(StyleSpec::TEXTCOLOR)) {
\r
775 setOverrideColor(style.getColor(StyleSpec::TEXTCOLOR));
\r
777 setNotClipped(style.getBool(StyleSpec::NOCLIP, isNotClipped()));
\r
778 setDrawBorder(style.getBool(StyleSpec::BORDER, DrawBorder));
\r
779 setUseAlphaChannel(style.getBool(StyleSpec::ALPHA, true));
\r
781 if (style.isNotDefault(StyleSpec::BGIMG)) {
\r
782 video::ITexture *texture = style.getTexture(StyleSpec::BGIMG, tsrc);
\r
783 video::ITexture *hovered_texture = style.getTexture(StyleSpec::BGIMG_HOVERED, tsrc, texture);
\r
784 video::ITexture *pressed_texture = style.getTexture(StyleSpec::BGIMG_PRESSED, tsrc, texture);
\r
786 const core::position2di buttonCenter(AbsoluteRect.getCenter());
\r
787 core::position2d<s32> geom(buttonCenter);
\r
789 setImage(guiScalingImageButton(
\r
790 Environment->getVideoDriver(), texture, geom.X, geom.Y));
\r
791 setHoveredImage(guiScalingImageButton(
\r
792 Environment->getVideoDriver(), hovered_texture, geom.X, geom.Y));
\r
793 setPressedImage(guiScalingImageButton(
\r
794 Environment->getVideoDriver(), pressed_texture, geom.X, geom.Y));
\r
795 setScaleImage(true);
\r