#include <gui.h>

Public Member Functions
	Gui ()

	~Gui ()

void	postInit (Graphics *const graphics)

void	logic ()

void	slowLogic ()

void	clearFonts ()

void	draw ()

void	videoResized () const

FocusHandler *	getFocusHandler () const

Font *	getFont () const

Font *	getHelpFont () const

Font *	getSecureFont () const

Font *	getNpcFont () const

Font *	getInfoParticleFont () const

void	setUseCustomCursor (const bool customCursor)

void	setCursorType (const CursorT index)

void	setDoubleClick (const bool b)

void	updateFonts ()

bool	handleInput ()

bool	handleKeyInput ()

void	resetClickCount ()

MouseEvent *	createMouseEvent (Window *const widget)

void	addGlobalFocusListener (FocusListener *focusListener)

void	removeGlobalFocusListener (FocusListener *focusListener)

void	distributeGlobalFocusGainedEvent (const Event &focusEvent)

void	removeDragged (const Widget *const widget)

int	getLastMouseX () const

int	getLastMouseY () const

void	setTop (Widget *const top)

Widget *	getTop () const

void	setGraphics (Graphics *const graphics)

Graphics *	getGraphics () const

void	setInput (SDLInput *const input)

SDLInput *	getInput () const

void	addGlobalKeyListener (KeyListener *const keyListener)

void	removeGlobalKeyListener (KeyListener *const keyListener)

bool	isLongPress () const

int	getMousePressLength () const

Static Public Member Functions
static void	getAbsolutePosition (Widget *widget, int &x, int &y)

static uint8_t	getMouseState (int &x, int &y)

Protected Member Functions
void	handleMouseMoved (const MouseInput &mouseInput)

void	handleMouseReleased (const MouseInput &mouseInput)

void	handleMousePressed (const MouseInput &mouseInput)

void	handleMouseInput ()

void	distributeMouseEvent (Widget *const source, const MouseEventTypeT type, const MouseButtonT button, const int x, const int y, const bool force, const bool toSourceOnly)

void	handleMouseWheelMovedDown (const MouseInput &mouseInput)

void	handleMouseWheelMovedUp (const MouseInput &mouseInput)

Widget *	getWidgetAt (const int x, const int y) const

Widget *	getMouseEventSource (const int x, const int y) const

Widget *	getKeyEventSource () const

void	distributeKeyEvent (KeyEvent &event) const

void	distributeKeyEventToGlobalKeyListeners (KeyEvent &event)

void	handleModalMouseInputFocus ()

void	handleModalFocus ()

void	handleModalFocusGained ()

void	handleModalFocusReleased ()

Private Types
typedef std::list< KeyListener * >	KeyListenerList

typedef KeyListenerList::iterator	KeyListenerListIterator

typedef std::list< FocusListener * >	FocusListenerList

typedef FocusListenerList::iterator	FocusListenerIterator

Private Attributes
Widget *	mTop

Graphics *	mGraphics

SDLInput *	mInput

FocusHandler *	mFocusHandler

KeyListenerList	mKeyListeners

MouseButtonT	mLastMousePressButton

unsigned int	mLastMousePressTimeStamp

int	mLastMouseX

int	mLastMouseY

int	mClickCount

MouseButtonT	mLastMouseDragButton

std::deque< Widget * >	mWidgetWithMouseQueue

GuiConfigListener *	mConfigListener

Font *	mGuiFont

Font *	mInfoParticleFont

Font *	mHelpFont

Font *	mSecureFont

Font *	mNpcFont

ImageSet *	mMouseCursors

float	mMouseCursorAlpha

int	mMouseInactivityTimer

CursorT	mCursorType

FocusListenerList	mFocusListeners

Color	mForegroundColor

Color	mForegroundColor2

time_t	mTime

time_t	mTime10

bool	mCustomCursor

bool	mDoubleClick

Detailed Description

Main GUI class.

Definition at line 116 of file gui.h.

Member Typedef Documentation

◆ FocusListenerIterator

typedef FocusListenerList::iterator Gui::FocusListenerIterator

private

Definition at line 511 of file gui.h.

◆ FocusListenerList

typedef std::list<FocusListener*> Gui::FocusListenerList

private

Definition at line 510 of file gui.h.

◆ KeyListenerList

typedef std::list<KeyListener*> Gui::KeyListenerList

private

Typedef.

Definition at line 438 of file gui.h.

◆ KeyListenerListIterator

typedef KeyListenerList::iterator Gui::KeyListenerListIterator

private

Typedef.

Definition at line 443 of file gui.h.

Constructor & Destructor Documentation

◆ Gui()

Gui::Gui ( )

Constructor.

Definition at line 114 of file gui.cpp.

          :
     mTop(nullptr),
     mGraphics(nullptr),
     mInput(nullptr),
     mFocusHandler(new FocusHandler),
     mKeyListeners(),
     mLastMousePressButton(MouseButton::EMPTY),
     mLastMousePressTimeStamp(0U),
     mLastMouseX(0),
     mLastMouseY(0),
     mClickCount(1),
     mLastMouseDragButton(MouseButton::EMPTY),
     mWidgetWithMouseQueue(),
     mConfigListener(new GuiConfigListener(this)),
     mGuiFont(nullptr),
     mInfoParticleFont(nullptr),
     mHelpFont(nullptr),
     mSecureFont(nullptr),
     mNpcFont(nullptr),
     mMouseCursors(nullptr),
     mMouseCursorAlpha(1.0F),
     mMouseInactivityTimer(0),
     mCursorType(Cursor::CURSOR_POINTER),
 #ifdef ANDROID
     mLastMouseRealX(0),
     mLastMouseRealY(0),
 #endif  // ANDROID
     mFocusListeners(),
     mForegroundColor(theme->getColor(ThemeColorId::TEXT, 255)),
     mForegroundColor2(theme->getColor(ThemeColorId::TEXT_OUTLINE, 255)),
     mTime(0),
     mTime10(0),
     mCustomCursor(false),
     mDoubleClick(true)
 {
 }

◆ ~Gui()

Gui::~Gui ( )

Destructor.

Definition at line 268 of file gui.cpp.

 {
     config.removeListeners(mConfigListener);
     delete2(mConfigListener)
  
     if (mMouseCursors != nullptr)
     {
         mMouseCursors->decRef();
         mMouseCursors = nullptr;
     }
  
     if (windowContainer != nullptr)
         windowContainer->slowLogic();
     Widget *top = mTop;
     if (Widget::widgetExists(mTop))
         setTop(nullptr);
     Window::setWindowContainer(nullptr);
     delete top;
  
     delete2(mGuiFont)
     delete2(boldFont)
     delete2(mHelpFont)
     delete2(mSecureFont)
     delete2(mInfoParticleFont)
     delete2(mNpcFont)
     delete2(guiInput)
     delete2(theme)
  
     delete2(mFocusHandler)
     Label::finalCleanup();
     Tab::finalCleanup();
     Widget::cleanGlobalFont();
 }

References boldFont, Widget::cleanGlobalFont(), config, Resource::decRef(), delete2, Label::finalCleanup(), Tab::finalCleanup(), guiInput, mConfigListener, mFocusHandler, mGuiFont, mHelpFont, mInfoParticleFont, mMouseCursors, mNpcFont, mSecureFont, mTop, Configuration::removeListeners(), setTop(), Window::setWindowContainer(), WindowContainer::slowLogic(), theme, top, Widget::widgetExists(), and windowContainer.

Member Function Documentation

◆ addGlobalFocusListener()

void Gui::addGlobalFocusListener ( FocusListener * focusListener )

Definition at line 1142 of file gui.cpp.

 {
     mFocusListeners.push_back(focusListener);
 }

References mFocusListeners.

Referenced by PopupList::postInit().

◆ addGlobalKeyListener()

void Gui::addGlobalKeyListener ( KeyListener *const keyListener )

Adds a global key listener to the Gui. A global key listener will receive all key events generated from the GUI and global key listeners will receive the events before key listeners of widgets.

Parameters

keyListener The key listener to add.

See also: removeGlobalKeyListener

Definition at line 1210 of file gui.cpp.

 {
     mKeyListeners.push_back(keyListener);
 }

References mKeyListeners.

◆ clearFonts()

void Gui::clearFonts ( )

Definition at line 372 of file gui.cpp.

 {
     if (mGuiFont != nullptr)
         mGuiFont->clear();
     if (mInfoParticleFont != nullptr)
         mInfoParticleFont->clear();
     if (mHelpFont != nullptr)
         mHelpFont->clear();
     if (mSecureFont != nullptr)
         mSecureFont->clear();
     if (boldFont != nullptr)
         boldFont->clear();
     if (mNpcFont != nullptr)
         mNpcFont->clear();
 }

References boldFont, Font::clear(), mGuiFont, mHelpFont, mInfoParticleFont, mNpcFont, and mSecureFont.

◆ createMouseEvent()

MouseEvent * Gui::createMouseEvent ( Window *const widget )

Definition at line 986 of file gui.cpp.

 {
     if ((viewport == nullptr) || (widget == nullptr))
         return nullptr;
  
     int x = 0;
     int y = 0;
     int mouseX = 0;
     int mouseY = 0;
  
     getAbsolutePosition(widget, x, y);
     getMouseState(mouseX, mouseY);
  
     return new MouseEvent(widget,
         MouseEventType::MOVED,
         MouseButton::EMPTY,
         mouseX - x,
         mouseY - y,
         mClickCount);
 }

References MouseButton::EMPTY, getAbsolutePosition(), getMouseState(), mClickCount, MouseEventType::MOVED, viewport, x, and y.

Referenced by Window::setVisible().

◆ distributeGlobalFocusGainedEvent()

void Gui::distributeGlobalFocusGainedEvent ( const Event & focusEvent )

Definition at line 1152 of file gui.cpp.

 {
     for (FocusListenerIterator iter = mFocusListeners.begin();
          iter != mFocusListeners.end();
          ++ iter)
     {
         (*iter)->focusGained(focusEvent);
     }
 }

References mFocusListeners.

Referenced by FocusHandler::distributeFocusGainedEvent().

◆ distributeKeyEvent()

void Gui::distributeKeyEvent ( KeyEvent & event ) const

protected

Distributes a key event.

Parameters

event The key event to distribute.

Definition at line 1320 of file gui.cpp.

 {
     Widget* parent = event.getSource();
     Widget* widget = parent;
  
     if (parent == nullptr)
         return;
     if (mFocusHandler->getModalFocused() != nullptr &&
         !widget->isModalFocused())
     {
         return;
     }
     if (mFocusHandler->getModalMouseInputFocused() != nullptr &&
         !widget->isModalMouseInputFocused())
     {
         return;
     }
  
     while (parent != nullptr)
     {
         // If the widget has been removed due to input
         // cancel the distribution.
         if (!Widget::widgetExists(widget))
             break;
  
         parent = widget->getParent();
  
         if (widget->isEnabled())
         {
             std::list<KeyListener*> keyListeners
                 = widget->getKeyListeners();
  
             const KeyEventTypeT eventType = event.getType();
             // Send the event to all key listeners of the source widget.
             FOR_EACH (std::list<KeyListener*>::const_iterator,
                  it, keyListeners)
             {
                 switch (eventType)
                 {
                     case KeyEventType::PRESSED:
                         (*it)->keyPressed(event);
                         break;
                     case KeyEventType::RELEASED:
                         (*it)->keyReleased(event);
                         break;
                     default:
                         break;
                 }
             }
         }
  
         const Widget *const swap = widget;
         widget = parent;
         parent = swap->getParent();
  
         // If a non modal focused widget has been reach
         // and we have modal focus cancel the distribution.
         if ((widget != nullptr) &&
             (mFocusHandler->getModalFocused() != nullptr) &&
             !widget->isModalFocused())
         {
             break;
         }
     }
 }

References FOR_EACH, Widget::getKeyListeners(), FocusHandler::getModalFocused(), FocusHandler::getModalMouseInputFocused(), Widget::getParent(), Widget::isEnabled(), Widget::isModalFocused(), Widget::isModalMouseInputFocused(), mFocusHandler, KeyEventType::PRESSED, KeyEventType::RELEASED, and Widget::widgetExists().

Referenced by handleKeyInput().

◆ distributeKeyEventToGlobalKeyListeners()

void Gui::distributeKeyEventToGlobalKeyListeners ( KeyEvent & event )

protected

Distributes a key event to the global key listeners.

Parameters

event The key event to distribute.

Definition at line 1386 of file gui.cpp.

 {
     BLOCK_START("Gui::distributeKeyEventToGlobalKeyListeners")
     const KeyEventTypeT eventType = event.getType();
     FOR_EACH (KeyListenerListIterator, it, mKeyListeners)
     {
         switch (eventType)
         {
             case KeyEventType::PRESSED:
                 (*it)->keyPressed(event);
                 break;
             case KeyEventType::RELEASED:
                 (*it)->keyReleased(event);
                 break;
             default:
                 break;
         }
  
         if (event.isConsumed())
             break;
     }
     BLOCK_END("Gui::distributeKeyEventToGlobalKeyListeners")
 }

References BLOCK_END, BLOCK_START, FOR_EACH, InputGuiEvent::isConsumed(), mKeyListeners, KeyEventType::PRESSED, and KeyEventType::RELEASED.

Referenced by handleKeyInput().

◆ distributeMouseEvent()

void Gui::distributeMouseEvent	(	Widget *const	source,
		const MouseEventTypeT	type,
		const MouseButtonT	button,
		const int	x,
		const int	y,
		const bool	force,
		const bool	toSourceOnly
	)

protected

Definition at line 854 of file gui.cpp.

 {
     if ((source == nullptr) || (mFocusHandler == nullptr))
         return;
  
     Widget *widget = source;
  
     if (!force)
     {
         if (mFocusHandler->getModalFocused() != nullptr
             && !widget->isModalFocused())
         {
             return;
         }
         if (mFocusHandler->getModalMouseInputFocused() != nullptr
             && !widget->isModalMouseInputFocused())
         {
             return;
         }
     }
  
     MouseEvent event(source,
         type, button,
         x, y, mClickCount);
  
     Widget* parent = source;
     while (parent != nullptr)
     {
         // If the widget has been removed due to input
         // cancel the distribution.
         if (!Widget::widgetExists(widget))
             break;
  
         parent = widget->getParent();
  
         if (widget->isEnabled() || force)
         {
             int widgetX;
             int widgetY;
             widget->getAbsolutePosition(widgetX, widgetY);
  
             event.setX(x - widgetX);
             event.setY(y - widgetY);
  
             std::list<MouseListener*> mouseListeners
                 = widget->getMouseListeners();
  
             const MouseEventTypeT mouseType = event.getType();
             // Send the event to all mouse listeners of the widget.
             FOR_EACH (std::list<MouseListener*>::const_iterator,
                  it, mouseListeners)
             {
                 switch (mouseType)
                 {
                     case MouseEventType::ENTERED:
                         (*it)->mouseEntered(event);
                         break;
                     case MouseEventType::EXITED:
                         (*it)->mouseExited(event);
                         break;
                     case MouseEventType::MOVED:
                         (*it)->mouseMoved(event);
                         break;
                     case MouseEventType::PRESSED:
                         (*it)->mousePressed(event);
                         break;
                     case MouseEventType::RELEASED:
                     case MouseEventType::RELEASED2:
                         (*it)->mouseReleased(event);
                         break;
                     case MouseEventType::WHEEL_MOVED_UP:
                         (*it)->mouseWheelMovedUp(event);
                         break;
                     case MouseEventType::WHEEL_MOVED_DOWN:
                         (*it)->mouseWheelMovedDown(event);
                         break;
                     case MouseEventType::DRAGGED:
                         (*it)->mouseDragged(event);
                         break;
                     case MouseEventType::CLICKED:
                         (*it)->mouseClicked(event);
                         break;
                     default:
                         break;
                 }
             }
  
             if (toSourceOnly)
                 break;
         }
  
         const Widget *const swap = widget;
         widget = parent;
         parent = swap->getParent();
  
 #ifndef DYECMD
         if (type == MouseEventType::RELEASED)
             dragDrop.clear();
 #endif  // DYECMD
  
         if ((widget == nullptr) || event.isConsumed())
             break;
  
         // If a non modal focused widget has been reach
         // and we have modal focus cancel the distribution.
         if ((mFocusHandler->getModalFocused() != nullptr)
             && !widget->isModalFocused())
         {
             break;
         }
  
         // If a non modal mouse input focused widget has been reach
         // and we have modal mouse input focus cancel the distribution.
         if ((mFocusHandler->getModalMouseInputFocused() != nullptr)
             && !widget->isModalMouseInputFocused())
         {
             break;
         }
     }
 }

References DragDrop::clear(), MouseEventType::CLICKED, dragDrop, MouseEventType::DRAGGED, MouseEventType::ENTERED, MouseEventType::EXITED, FOR_EACH, Widget::getAbsolutePosition(), FocusHandler::getModalFocused(), FocusHandler::getModalMouseInputFocused(), Widget::getMouseListeners(), Widget::getParent(), InputGuiEvent::isConsumed(), Widget::isEnabled(), Widget::isModalFocused(), Widget::isModalMouseInputFocused(), mClickCount, mFocusHandler, MouseEventType::MOVED, MouseEventType::PRESSED, MouseEventType::RELEASED, MouseEventType::RELEASED2, MouseEventType::WHEEL_MOVED_DOWN, MouseEventType::WHEEL_MOVED_UP, Widget::widgetExists(), x, and y.

Referenced by handleModalFocusGained(), handleModalFocusReleased(), handleMouseMoved(), handleMousePressed(), handleMouseReleased(), handleMouseWheelMovedDown(), and handleMouseWheelMovedUp().

◆ draw()

void Gui::draw ( )

Draws the whole Gui by calling draw functions down in the Gui hierarchy. It also draws the mouse pointer.

Definition at line 470 of file gui.cpp.

 {
     BLOCK_START("Gui::draw 1")
     Widget *const top = getTop();
     if (top == nullptr)
         return;
     mGraphics->pushClipArea(top->getDimension());
  
     if (isBatchDrawRenders(openGLMode))
     {
         top->draw(mGraphics);
         touchManager.draw();
     }
     else
     {
         top->safeDraw(mGraphics);
         touchManager.safeDraw();
     }
  
     int mouseX;
     int mouseY;
     const MouseStateType button = getMouseState(mouseX, mouseY);
  
     if ((settings.mouseFocused ||
         ((button & SDL_BUTTON(1)) != 0)) &&
         mMouseCursors != nullptr &&
         mCustomCursor &&
         mMouseCursorAlpha > 0.0F)
     {
 #ifndef DYECMD
         const Image *const image = dragDrop.getItemImage();
         if (mGuiFont != nullptr)
         {
             const std::string &str = dragDrop.getText();
             if (!str.empty())
             {
                 const int posX = mouseX - mGuiFont->getWidth(str) / 2;
                 const int posY = mouseY +
                     (image != nullptr ? image->mBounds.h / 2 : 0);
                 mGuiFont->drawString(mGraphics,
                     mForegroundColor, mForegroundColor2,
                     str,
                     posX, posY);
             }
         }
         if (image != nullptr)
         {
             const int posX = mouseX - (image->mBounds.w / 2);
             const int posY = mouseY - (image->mBounds.h / 2);
             mGraphics->drawImage(image, posX, posY);
         }
 #endif  // DYECMD
  
         Image *const mouseCursor = mMouseCursors->get(
             CAST_SIZE(mCursorType));
         if (mouseCursor != nullptr)
         {
             mouseCursor->setAlpha(mMouseCursorAlpha);
             mGraphics->drawImage(mouseCursor, mouseX - 15, mouseY - 17);
         }
     }
  
     mGraphics->popClipArea();
     BLOCK_END("Gui::draw 1")
 }

References BLOCK_END, BLOCK_START, CAST_SIZE, dragDrop, TouchManager::draw(), Graphics::drawImage(), Font::drawString(), ImageSet::get(), DragDrop::getItemImage(), getMouseState(), DragDrop::getText(), getTop(), Font::getWidth(), isBatchDrawRenders, mCursorType, mCustomCursor, mForegroundColor, mForegroundColor2, mGraphics, mGuiFont, mMouseCursorAlpha, mMouseCursors, Settings::mouseFocused, MouseStateType, openGLMode, Graphics::popClipArea(), Graphics::pushClipArea(), TouchManager::safeDraw(), settings, top, and touchManager.

Referenced by Game::createScreenshot(), Client::gameExec(), and WindowManager::resizeVideo().

◆ getAbsolutePosition()

void Gui::getAbsolutePosition	(	Widget *	widget,
		int &	x,
		int &	y
	)

static

Definition at line 1007 of file gui.cpp.

 {
     if (widget == nullptr)
         return;
     x = 0;
     y = 0;
     while (widget->getParent() != nullptr)
     {
         x += widget->getX();
         y += widget->getY();
         widget = widget->getParent();
     }
 }

References x, and y.

Referenced by createMouseEvent().

◆ getFocusHandler()

FocusHandler* Gui::getFocusHandler ( ) const

inline

Definition at line 154 of file gui.h.

155 { return mFocusHandler; }

References mFocusHandler.

Referenced by InputManager::updateConditionMask().

◆ getFont()

Font* Gui::getFont ( ) const

inline

Return game font.

Definition at line 160 of file gui.h.

161 { return mGuiFont; }

References mGuiFont.

Referenced by ProgressBar::draw(), FloorItem::draw(), MapItem::draw(), Being::drawPortalSpriteAt(), SetupItemSlider2::getMaxWidth(), ServerDialog::loadServers(), ProgressBar::safeDraw(), ServersListModel::setVersionString(), Being::updateBadgesPosition(), and Setup_Colors::valueChanged().

◆ getGraphics()

Graphics * Gui::getGraphics ( ) const

Gets the graphics object used for drawing.

Returns: The graphics object used for drawing. NULL if no graphics object has been set.

See also: setGraphics, AllegroGraphics, HGEGraphics, OpenLayerGraphics, OpenGLGraphics, SDLGraphics

Definition at line 1195 of file gui.cpp.

 {
     return mGraphics;
 }

References mGraphics.

◆ getHelpFont()

Font* Gui::getHelpFont ( ) const

inline

Return help font.

Definition at line 166 of file gui.h.

167 { return mHelpFont; }

References mHelpFont.

Referenced by DidYouKnowWindow::DidYouKnowWindow(), HelpWindow::HelpWindow(), ServerInfoWindow::ServerInfoWindow(), and Setup_Input::Setup_Input().

◆ getInfoParticleFont()

Font* Gui::getInfoParticleFont ( ) const

inline

Return the Font used for "Info Particles", i.e. ones showing, what you picked up, etc.

Definition at line 185 of file gui.h.

186 { return mInfoParticleFont; }

References mInfoParticleFont.

Referenced by LocalPlayer::logic(), and Being::takeDamage().

◆ getInput()

SDLInput * Gui::getInput ( ) const

Gets the input object being used for input handling.

Returns: The input object used for handling input. NULL if no input object has been set.

See also: setInput, AllegroInput, HGEInput, OpenLayerInput, SDLInput

Definition at line 1205 of file gui.cpp.

 {
     return mInput;
 }

References mInput.

◆ getKeyEventSource()

Widget * Gui::getKeyEventSource ( ) const

protected

Gets the source of the key event.

Returns: The source widget of the key event.

Definition at line 1306 of file gui.cpp.

 {
     Widget* widget = mFocusHandler->getFocused();
  
     while (widget != nullptr &&
            widget->getInternalFocusHandler() != nullptr &&
            widget->getInternalFocusHandler()->getFocused() != nullptr)
     {
         widget = widget->getInternalFocusHandler()->getFocused();
     }
  
     return widget;
 }

References FocusHandler::getFocused(), Widget::getInternalFocusHandler(), and mFocusHandler.

Referenced by handleKeyInput().

◆ getLastMouseX()

int Gui::getLastMouseX ( ) const

inline

Definition at line 224 of file gui.h.

225 { return mLastMouseX; }

References mLastMouseX.

Referenced by SDLInput::pushInput().

◆ getLastMouseY()

int Gui::getLastMouseY ( ) const

inline

Definition at line 227 of file gui.h.

228 { return mLastMouseY; }

References mLastMouseY.

Referenced by SDLInput::pushInput().

◆ getMouseEventSource()

Widget * Gui::getMouseEventSource	(	const int	x,
		const int	y
	)		const

protected

Gets the source of the mouse event.

Returns: The source widget of the mouse event.

Definition at line 1290 of file gui.cpp.

 {
     Widget *const widget = getWidgetAt(x, y);
     if (widget == nullptr)
         return nullptr;
  
     if (mFocusHandler != nullptr &&
         mFocusHandler->getModalMouseInputFocused() != nullptr &&
         !widget->isModalMouseInputFocused())
     {
         return mFocusHandler->getModalMouseInputFocused();
     }
  
     return widget;
 }

References FocusHandler::getModalMouseInputFocused(), getWidgetAt(), Widget::isModalMouseInputFocused(), mFocusHandler, x, and y.

Referenced by handleModalFocusReleased(), handleMouseMoved(), handleMousePressed(), handleMouseReleased(), handleMouseWheelMovedDown(), and handleMouseWheelMovedUp().

◆ getMousePressLength()

int Gui::getMousePressLength ( ) const

Definition at line 1530 of file gui.cpp.

 {
     if (mLastMousePressTimeStamp == 0U)
         return 0;
     unsigned int ticks = SDL_GetTicks();
     if (ticks > mLastMousePressTimeStamp)
         return ticks - mLastMousePressTimeStamp;
     return mLastMousePressTimeStamp - ticks;
 }

References mLastMousePressTimeStamp.

Referenced by isLongPress().

◆ getMouseState()

uint8_t Gui::getMouseState	(	int &	x,
		int &	y
	)

static

Definition at line 1171 of file gui.cpp.

 {
     const MouseStateType res = SDL_GetMouseState(&x, &y);
     const int scale = mainGraphics->getScale();
     x /= scale;
     y /= scale;
     return res;
 }

References Graphics::getScale(), mainGraphics, MouseStateType, x, and y.

Referenced by createMouseEvent(), draw(), Viewport::logic(), CharacterDisplay::mouseMoved(), ToolTipListener::mouseMoved(), PopupMenu::setMousePos(), PopupMenu::setMousePos2(), SDLInput::simulateMouseMove(), and ChatWindow::updateVisibility().

◆ getNpcFont()

Font* Gui::getNpcFont ( ) const

inline

Return npc font.

Definition at line 178 of file gui.h.

179 { return mNpcFont; }

References mNpcFont.

Referenced by NpcDialog::createSkinControls(), NpcDialog::NpcDialog(), and QuestsWindow::QuestsWindow().

◆ getSecureFont()

Font* Gui::getSecureFont ( ) const

inline

Return secure font.

Definition at line 172 of file gui.h.

173 { return mSecureFont; }

References mSecureFont.

Referenced by ChatWindow::addWhisperTab(), TradeWindow::initTrade(), BeingPopup::show(), and Being::showName().

◆ getTop()

Widget* Gui::getTop ( ) const

inline

Gets the top widget. The top widget is the root widget of the GUI.

Returns: The top widget. NULL if no top widget has been set.

Definition at line 248 of file gui.h.

249 { return mTop; }

References mTop.

Referenced by draw(), Game::Game(), Client::stateGame(), Client::stateGame1(), and videoResized().

◆ getWidgetAt()

Widget * Gui::getWidgetAt	(	const int	x,
		const int	y
	)		const

protected

Gets the widget at a certain position.

Returns: The widget at a certain position.

Definition at line 1268 of file gui.cpp.

 {
     // If the widget's parent has no child then we have found the widget..
     Widget* parent = mTop;
     Widget* child = mTop;
     Widget* selectable = mTop;
  
     while (child != nullptr)
     {
         Widget *const swap = child;
         int parentX;
         int parentY;
         parent->getAbsolutePosition(parentX, parentY);
         child = parent->getWidgetAt(x - parentX, y - parentY);
         parent = swap;
         if (parent->isSelectable())
             selectable = parent;
     }
  
     return selectable;
 }

References Widget::getAbsolutePosition(), Widget::getWidgetAt(), Widget::isSelectable(), mTop, x, and y.

Referenced by getMouseEventSource().

◆ handleInput()

bool Gui::handleInput ( )

Definition at line 388 of file gui.cpp.

 {
     if (mInput != nullptr)
         return handleKeyInput();
     return false;
 }

References handleKeyInput(), and mInput.

Referenced by Client::gameExec(), and InputManager::handleEvent().

◆ handleKeyInput()

bool Gui::handleKeyInput ( )

Definition at line 395 of file gui.cpp.

 {
     if (guiInput == nullptr)
         return false;
  
     BLOCK_START("Gui::handleKeyInput")
     bool consumed(false);
  
     while (!mInput->isKeyQueueEmpty())
     {
         const KeyInput keyInput = guiInput->dequeueKeyInput();
  
         KeyEvent eventToGlobalKeyListeners(nullptr,
             keyInput.getType(),
             keyInput.getActionId(), keyInput.getKey());
  
 #ifdef USE_SDL2
         if (!keyInput.getText().empty())
             eventToGlobalKeyListeners.setText(keyInput.getText());
 #endif  // USE_SDL2
  
         distributeKeyEventToGlobalKeyListeners(
             eventToGlobalKeyListeners);
  
         // If a global key listener consumes the event it will not be
         // sent further to the source of the event.
         if (eventToGlobalKeyListeners.isConsumed())
         {
             consumed = true;
             continue;
         }
  
         if (mFocusHandler != nullptr)
         {
             bool eventConsumed = false;
  
             // Send key inputs to the focused widgets
             if (mFocusHandler->getFocused() != nullptr)
             {
                 KeyEvent event(getKeyEventSource(),
                     keyInput.getType(),
                     keyInput.getActionId(), keyInput.getKey());
 #ifdef USE_SDL2
                 if (!keyInput.getText().empty())
                     event.setText(keyInput.getText());
 #endif  // USE_SDL2
  
                 if (!mFocusHandler->getFocused()->isFocusable())
                     mFocusHandler->focusNone();
                 else
                     distributeKeyEvent(event);
  
                 eventConsumed = event.isConsumed();
                 if (eventConsumed)
                     consumed = true;
             }
  
             // If the key event hasn't been consumed and
             // tabbing is enable check for tab press and
             // change focus.
             if (!eventConsumed && keyInput.getActionId()
                 == InputAction::GUI_TAB &&
                 keyInput.getType() == KeyEventType::PRESSED)
             {
                 if (inputManager.isActionActive(InputAction::GUI_MOD))
                     mFocusHandler->tabPrevious();
                 else
                     mFocusHandler->tabNext();
             }
         }
     }  // end while
     BLOCK_END("Gui::handleKeyInput")
     return consumed;
 }

References BLOCK_END, BLOCK_START, SDLInput::dequeueKeyInput(), distributeKeyEvent(), distributeKeyEventToGlobalKeyListeners(), FocusHandler::focusNone(), KeyInput::getActionId(), FocusHandler::getFocused(), KeyInput::getKey(), getKeyEventSource(), KeyInput::getType(), InputAction::GUI_MOD, InputAction::GUI_TAB, guiInput, inputManager, InputManager::isActionActive(), InputGuiEvent::isConsumed(), Widget::isFocusable(), SDLInput::isKeyQueueEmpty(), mFocusHandler, mInput, KeyEventType::PRESSED, FocusHandler::tabNext(), and FocusHandler::tabPrevious().

Referenced by handleInput().

◆ handleModalFocus()

void Gui::handleModalFocus ( )

protected

Handles modal focus. Modal focus needs to be checked at each logic iteration as it might be necessary to distribute mouse entered or mouse exited events.

Definition at line 1434 of file gui.cpp.

 {
     BLOCK_START("Gui::handleModalFocus")
     Widget *const lastModalWidget
         = mFocusHandler->getLastWidgetWithModalFocus();
     Widget *const modalWidget = mFocusHandler->getModalFocused();
  
     if (lastModalWidget != modalWidget)
     {
         // Check if modal focus has been gained by a widget.
         if (lastModalWidget == nullptr)
         {
             handleModalFocusGained();
             mFocusHandler->setLastWidgetWithModalFocus(modalWidget);
         }
         // Check if modal focus has been released.
         else
         {
             handleModalFocusReleased();
             mFocusHandler->setLastWidgetWithModalFocus(nullptr);
         }
     }
     BLOCK_END("Gui::handleModalFocus")
 }

References BLOCK_END, BLOCK_START, FocusHandler::getLastWidgetWithModalFocus(), FocusHandler::getModalFocused(), handleModalFocusGained(), handleModalFocusReleased(), mFocusHandler, and FocusHandler::setLastWidgetWithModalFocus().

Referenced by logic().

◆ handleModalFocusGained()

void Gui::handleModalFocusGained ( )

protected

Handles modal focus gained. If modal focus has been gained it might be necessary to distribute mouse entered or mouse exited events.

Definition at line 1459 of file gui.cpp.

 {
     // Distribute an event to all widgets in the "widget with mouse" queue.
     while (!mWidgetWithMouseQueue.empty())
     {
         Widget *const widget = mWidgetWithMouseQueue.front();
  
         if (Widget::widgetExists(widget))
         {
             distributeMouseEvent(widget,
                 MouseEventType::EXITED,
                 mLastMousePressButton,
                 mLastMouseX,
                 mLastMouseY,
                 true,
                 true);
         }
  
         mWidgetWithMouseQueue.pop_front();
     }
  
     mFocusHandler->setLastWidgetWithModalMouseInputFocus(
         mFocusHandler->getModalMouseInputFocused());
 }

References distributeMouseEvent(), MouseEventType::EXITED, FocusHandler::getModalMouseInputFocused(), mFocusHandler, mLastMousePressButton, mLastMouseX, mLastMouseY, mWidgetWithMouseQueue, FocusHandler::setLastWidgetWithModalMouseInputFocus(), and Widget::widgetExists().

Referenced by handleModalFocus(), and handleModalMouseInputFocus().

◆ handleModalFocusReleased()

void Gui::handleModalFocusReleased ( )

protected

Handles modal mouse input focus gained. If modal focus has been gained it might be necessary to distribute mouse entered or mouse exited events.

Definition at line 1484 of file gui.cpp.

 {
       // Check all widgets below the mouse to see if they are
     // present in the "widget with mouse" queue. If a widget
     // is not then it should be added and an entered event should
     // be sent to it.
     Widget* widget = getMouseEventSource(mLastMouseX, mLastMouseY);
     Widget* parent = widget;
  
     while (parent != nullptr &&
            widget != nullptr)
     {
         parent = widget->getParent();
  
         // Check if the widget is present in the "widget with mouse" queue.
         bool widgetIsPresentInQueue = false;
         FOR_EACH (std::deque<Widget*>::const_iterator,
                   iter, mWidgetWithMouseQueue)
         {
             if (*iter == widget)
             {
                 widgetIsPresentInQueue = true;
                 break;
             }
         }
  
         // Widget is not present, send an entered event and add
         // it to the "widget with mouse" queue.
         if (!widgetIsPresentInQueue && Widget::widgetExists(widget))
         {
             distributeMouseEvent(widget,
                 MouseEventType::ENTERED,
                 mLastMousePressButton,
                 mLastMouseX,
                 mLastMouseY,
                 false,
                 true);
             mWidgetWithMouseQueue.push_front(widget);
         }
  
         const Widget *const swap = widget;
         widget = parent;
         parent = swap->getParent();
     }
 }

References distributeMouseEvent(), MouseEventType::ENTERED, FOR_EACH, getMouseEventSource(), Widget::getParent(), mLastMousePressButton, mLastMouseX, mLastMouseY, mWidgetWithMouseQueue, and Widget::widgetExists().

Referenced by handleModalFocus(), and handleModalMouseInputFocus().

◆ handleModalMouseInputFocus()

void Gui::handleModalMouseInputFocus ( )

protected

Handles modal mouse input focus. Modal mouse input focus needs to be checked at each logic iteration as it might be necessary to distribute mouse entered or mouse exited events.

Definition at line 1410 of file gui.cpp.

 {
     BLOCK_START("Gui::handleModalMouseInputFocus")
     Widget *const lastModalWidget
         = mFocusHandler->getLastWidgetWithModalMouseInputFocus();
     Widget *const modalWidget = mFocusHandler->getModalMouseInputFocused();
     if (lastModalWidget != modalWidget)
     {
         // Check if modal mouse input focus has been gained by a widget.
         if (lastModalWidget == nullptr)
         {
             handleModalFocusGained();
             mFocusHandler->setLastWidgetWithModalMouseInputFocus(modalWidget);
         }
         // Check if modal mouse input focus has been released.
         else
         {
             handleModalFocusReleased();
             mFocusHandler->setLastWidgetWithModalMouseInputFocus(nullptr);
         }
     }
     BLOCK_END("Gui::handleModalMouseInputFocus")
 }

References BLOCK_END, BLOCK_START, FocusHandler::getLastWidgetWithModalMouseInputFocus(), FocusHandler::getModalMouseInputFocused(), handleModalFocusGained(), handleModalFocusReleased(), mFocusHandler, and FocusHandler::setLastWidgetWithModalMouseInputFocus().

Referenced by logic().

◆ handleMouseInput()

void Gui::handleMouseInput ( )

protected

Definition at line 1023 of file gui.cpp.

 {
     BLOCK_START("Gui::handleMouseInput")
     while (!mInput->isMouseQueueEmpty())
     {
         const MouseInput mouseInput = guiInput->dequeueMouseInput();
  
         if (touchManager.processEvent(mouseInput))
         {
 #ifdef ANDROID
 #ifndef USE_SDL2
             SDL_WarpMouse(mLastMouseX, mLastMouseY,
                 mLastMouseRealX, mLastMouseRealY);
 #endif  // USE_SDL2
 #endif  // ANDROID
  
             mMouseInactivityTimer = 0;
             continue;
         }
  
         // Save the current mouse state. It will be needed if modal focus
         // changes or modal mouse input focus changes.
         mLastMouseX = mouseInput.getX();
         mLastMouseY = mouseInput.getY();
 #ifdef ANDROID
         mLastMouseRealX = mouseInput.getRealX();
         mLastMouseRealY = mouseInput.getRealY();
 #endif  // ANDROID
  
         switch (mouseInput.getType())
         {
             case MouseEventType::PRESSED:
                 handleMousePressed(mouseInput);
                 break;
             case MouseEventType::RELEASED:
                 handleMouseReleased(mouseInput);
                 break;
             case MouseEventType::MOVED:
                 handleMouseMoved(mouseInput);
                 break;
             case MouseEventType::WHEEL_MOVED_DOWN:
                 handleMouseWheelMovedDown(mouseInput);
                 break;
             case MouseEventType::WHEEL_MOVED_UP:
                 handleMouseWheelMovedUp(mouseInput);
                 break;
             case MouseEventType::CLICKED:
             case MouseEventType::ENTERED:
             case MouseEventType::EXITED:
             case MouseEventType::DRAGGED:
             case MouseEventType::RELEASED2:
             default:
                 break;
         }
     }
     BLOCK_END("Gui::handleMouseInput")
 }

References BLOCK_END, BLOCK_START, MouseEventType::CLICKED, SDLInput::dequeueMouseInput(), MouseEventType::DRAGGED, MouseEventType::ENTERED, MouseEventType::EXITED, MouseInput::getRealX(), MouseInput::getRealY(), MouseInput::getType(), MouseInput::getX(), MouseInput::getY(), guiInput, handleMouseMoved(), handleMousePressed(), handleMouseReleased(), handleMouseWheelMovedDown(), handleMouseWheelMovedUp(), SDLInput::isMouseQueueEmpty(), mInput, mLastMouseX, mLastMouseY, mMouseInactivityTimer, MouseEventType::MOVED, MouseEventType::PRESSED, TouchManager::processEvent(), MouseEventType::RELEASED, MouseEventType::RELEASED2, touchManager, MouseEventType::WHEEL_MOVED_DOWN, and MouseEventType::WHEEL_MOVED_UP.

Referenced by logic().

◆ handleMouseMoved()

void Gui::handleMouseMoved ( const MouseInput & mouseInput )

protected

Definition at line 593 of file gui.cpp.

 {
     // Check if the mouse leaves the application window.
     if (mTop != nullptr &&
         !mWidgetWithMouseQueue.empty() &&
         (mouseInput.getX() < 0 ||
         mouseInput.getY() < 0 ||
         !mTop->getDimension().isPointInRect(mouseInput.getX(),
         mouseInput.getY())))
     {
         // Distribute an event to all widgets in the
         // "widget with mouse" queue.
         while (!mWidgetWithMouseQueue.empty())
         {
             Widget *const widget = mWidgetWithMouseQueue.front();
  
             if (Widget::widgetExists(widget))
             {
                 distributeMouseEvent(widget,
                     MouseEventType::EXITED,
                     mouseInput.getButton(),
                     mouseInput.getX(),
                     mouseInput.getY(),
                     true,
                     true);
             }
  
             mWidgetWithMouseQueue.pop_front();
         }
  
         mMouseInactivityTimer = 0;
         return;
     }
  
     const int mouseX = mouseInput.getX();
     const int mouseY = mouseInput.getY();
     const MouseButtonT button = mouseInput.getButton();
  
     // Check if there is a need to send mouse exited events by
     // traversing the "widget with mouse" queue.
     bool widgetWithMouseQueueCheckDone = mWidgetWithMouseQueue.empty();
     while (!widgetWithMouseQueueCheckDone)
     {
         unsigned int iterations = 0;
         for (std::deque<Widget*>::iterator
              iter = mWidgetWithMouseQueue.begin();
              iter != mWidgetWithMouseQueue.end();
              ++ iter)
         {
             Widget *const widget = *iter;
  
             // If a widget in the "widget with mouse queue" doesn't
             // exists anymore it should be removed from the queue.
             if (!Widget::widgetExists(widget))
             {
                 mWidgetWithMouseQueue.erase(iter);
                 break;
             }
             else
             {
                 int x;
                 int y;
                 widget->getAbsolutePosition(x, y);
  
                 if (x > mouseX
                     || y > mouseY
                     || x + widget->getWidth() <= mouseX
                     || y + widget->getHeight() <= mouseY
                     || !widget->isVisible())
                 {
                     distributeMouseEvent(widget,
                         MouseEventType::EXITED,
                         button,
                         mouseX,
                         mouseY,
                         true,
                         true);
                     mClickCount = 1;
                     mLastMousePressTimeStamp = 0U;
                     mWidgetWithMouseQueue.erase(iter);
                     break;
                 }
             }
  
             iterations++;
         }
  
         widgetWithMouseQueueCheckDone =
             (CAST_SIZE(iterations) == mWidgetWithMouseQueue.size());
     }
  
     // Check all widgets below the mouse to see if they are
     // present in the "widget with mouse" queue. If a widget
     // is not then it should be added and an entered event should
     // be sent to it.
     Widget* parent = getMouseEventSource(mouseX, mouseY);
     Widget* widget = parent;
  
     // If a widget has modal mouse input focus then it will
     // always be returned from getMouseEventSource, but we only wan't to
     // send mouse entered events if the mouse has actually entered the
     // widget with modal mouse input focus, hence we need to check if
     // that's the case. If it's not we should simply ignore to send any
     // mouse entered events.
     if ((mFocusHandler->getModalMouseInputFocused() != nullptr)
         && widget == mFocusHandler->getModalMouseInputFocused()
         && Widget::widgetExists(widget) &&
         (widget != nullptr))
     {
         int x;
         int y;
         widget->getAbsolutePosition(x, y);
  
         if (x > mouseX || y > mouseY
             || x + widget->getWidth() <= mouseX
             || y + widget->getHeight() <= mouseY)
         {
             parent = nullptr;
         }
     }
  
     while (parent != nullptr)
     {
         parent = widget->getParent();
  
         // Check if the widget is present in the "widget with mouse" queue.
         bool widgetIsPresentInQueue = false;
         FOR_EACH (std::deque<Widget*>::const_iterator,
                   iter, mWidgetWithMouseQueue)
         {
             if (*iter == widget)
             {
                 widgetIsPresentInQueue = true;
                 break;
             }
         }
  
         // Widget is not present, send an entered event and add
         // it to the "widget with mouse" queue.
         if (!widgetIsPresentInQueue
             && Widget::widgetExists(widget))
         {
             distributeMouseEvent(widget,
                 MouseEventType::ENTERED,
                 button,
                 mouseX,
                 mouseY,
                 true,
                 true);
             mWidgetWithMouseQueue.push_front(widget);
         }
  
         const Widget *const swap = widget;
         widget = parent;
         parent = swap->getParent();
     }
  
     if (mFocusHandler->getDraggedWidget() != nullptr)
     {
         distributeMouseEvent(mFocusHandler->getDraggedWidget(),
             MouseEventType::DRAGGED,
             mLastMouseDragButton,
             mouseX,
             mouseY,
             false,
             false);
     }
     else
     {
         Widget *const sourceWidget = getMouseEventSource(mouseX, mouseY);
         distributeMouseEvent(sourceWidget,
             MouseEventType::MOVED,
             button,
             mouseX,
             mouseY,
             false,
             false);
     }
     mMouseInactivityTimer = 0;
 }

References CAST_SIZE, distributeMouseEvent(), MouseEventType::DRAGGED, MouseEventType::ENTERED, MouseEventType::EXITED, FOR_EACH, Widget::getAbsolutePosition(), MouseInput::getButton(), Widget::getDimension(), FocusHandler::getDraggedWidget(), Widget::getHeight(), FocusHandler::getModalMouseInputFocused(), getMouseEventSource(), Widget::getParent(), Widget::getWidth(), MouseInput::getX(), MouseInput::getY(), Rect::isPointInRect(), Widget::isVisible(), mClickCount, mFocusHandler, mLastMouseDragButton, mLastMousePressTimeStamp, mMouseInactivityTimer, MouseEventType::MOVED, mTop, mWidgetWithMouseQueue, Widget::widgetExists(), x, and y.

Referenced by handleMouseInput().

◆ handleMousePressed()

void Gui::handleMousePressed ( const MouseInput & mouseInput )

protected

Definition at line 774 of file gui.cpp.

 {
     const int x = mouseInput.getX();
     const int y = mouseInput.getY();
     const MouseButtonT button = mouseInput.getButton();
     const unsigned int timeStamp = mouseInput.getTimeStamp();
  
     Widget *sourceWidget = getMouseEventSource(x, y);
  
     if (mFocusHandler->getDraggedWidget() != nullptr)
         sourceWidget = mFocusHandler->getDraggedWidget();
  
     if (sourceWidget == nullptr)
         return;
     int sourceWidgetX;
     int sourceWidgetY;
     sourceWidget->getAbsolutePosition(sourceWidgetX, sourceWidgetY);
  
     if (((mFocusHandler->getModalFocused() != nullptr)
         && sourceWidget->isModalFocused())
         || (mFocusHandler->getModalFocused() == nullptr))
     {
         sourceWidget->requestFocus();
     }
  
     if (mDoubleClick &&
         timeStamp - mLastMousePressTimeStamp < 250U &&
         mLastMousePressButton == button)
     {
         mClickCount ++;
     }
     else
     {
         mClickCount = 1;
     }
  
     distributeMouseEvent(sourceWidget,
         MouseEventType::PRESSED,
         button,
         x,
         y,
         false,
         false);
     mFocusHandler->setLastWidgetPressed(sourceWidget);
     mFocusHandler->setDraggedWidget(sourceWidget);
     mLastMouseDragButton = button;
     mLastMousePressButton = button;
     mLastMousePressTimeStamp = timeStamp;
 }

References distributeMouseEvent(), Widget::getAbsolutePosition(), MouseInput::getButton(), FocusHandler::getDraggedWidget(), FocusHandler::getModalFocused(), getMouseEventSource(), MouseInput::getTimeStamp(), MouseInput::getX(), MouseInput::getY(), Widget::isModalFocused(), mClickCount, mDoubleClick, mFocusHandler, mLastMouseDragButton, mLastMousePressButton, mLastMousePressTimeStamp, MouseEventType::PRESSED, Widget::requestFocus(), FocusHandler::setDraggedWidget(), FocusHandler::setLastWidgetPressed(), x, and y.

Referenced by handleMouseInput().

◆ handleMouseReleased()

void Gui::handleMouseReleased ( const MouseInput & mouseInput )

protected

Definition at line 1081 of file gui.cpp.

 {
     Widget *sourceWidget = getMouseEventSource(
         mouseInput.getX(), mouseInput.getY());
  
     int sourceWidgetX;
     int sourceWidgetY;
     if (mFocusHandler->getDraggedWidget() != nullptr)
     {
         if (sourceWidget != mFocusHandler->getLastWidgetPressed())
             mFocusHandler->setLastWidgetPressed(nullptr);
  
         Widget *const oldWidget = sourceWidget;
         sourceWidget = mFocusHandler->getDraggedWidget();
         if ((oldWidget != nullptr) && oldWidget != sourceWidget)
         {
             oldWidget->getAbsolutePosition(sourceWidgetX, sourceWidgetY);
             distributeMouseEvent(oldWidget,
                 MouseEventType::RELEASED2,
                 mouseInput.getButton(),
                 mouseInput.getX(),
                 mouseInput.getY(),
                 false,
                 false);
         }
     }
  
     if (sourceWidget == nullptr)
         return;
     sourceWidget->getAbsolutePosition(sourceWidgetX, sourceWidgetY);
     distributeMouseEvent(sourceWidget,
         MouseEventType::RELEASED,
         mouseInput.getButton(),
         mouseInput.getX(),
         mouseInput.getY(),
         false,
         false);
  
     if (mouseInput.getButton() == mLastMousePressButton
         && mFocusHandler->getLastWidgetPressed() == sourceWidget)
     {
         distributeMouseEvent(sourceWidget,
             MouseEventType::CLICKED,
             mouseInput.getButton(),
             mouseInput.getX(),
             mouseInput.getY(),
             false,
             false);
  
         mFocusHandler->setLastWidgetPressed(nullptr);
     }
     else
     {
         mLastMousePressButton = MouseButton::EMPTY;
         mClickCount = 0;
     }
  
     if (mFocusHandler->getDraggedWidget() != nullptr)
         mFocusHandler->setDraggedWidget(nullptr);
 }

References MouseEventType::CLICKED, distributeMouseEvent(), MouseButton::EMPTY, Widget::getAbsolutePosition(), MouseInput::getButton(), FocusHandler::getDraggedWidget(), FocusHandler::getLastWidgetPressed(), getMouseEventSource(), MouseInput::getX(), MouseInput::getY(), mClickCount, mFocusHandler, mLastMousePressButton, MouseEventType::RELEASED, MouseEventType::RELEASED2, FocusHandler::setDraggedWidget(), and FocusHandler::setLastWidgetPressed().

Referenced by handleMouseInput().

◆ handleMouseWheelMovedDown()

void Gui::handleMouseWheelMovedDown ( const MouseInput & mouseInput )

protected

Handles mouse wheel moved down input.

Parameters

mouseInput The mouse input to handle.

Definition at line 1220 of file gui.cpp.

 {
     Widget* sourceWidget = getMouseEventSource(
         mouseInput.getX(), mouseInput.getY());
  
     if (mFocusHandler->getDraggedWidget() != nullptr)
         sourceWidget = mFocusHandler->getDraggedWidget();
  
     if (sourceWidget != nullptr)
     {
         int sourceWidgetX = 0;
         int sourceWidgetY = 0;
  
         sourceWidget->getAbsolutePosition(sourceWidgetX, sourceWidgetY);
         distributeMouseEvent(sourceWidget,
             MouseEventType::WHEEL_MOVED_DOWN,
             mouseInput.getButton(),
             mouseInput.getX(),
             mouseInput.getY(),
             false,
             false);
     }
 }

References distributeMouseEvent(), Widget::getAbsolutePosition(), MouseInput::getButton(), FocusHandler::getDraggedWidget(), getMouseEventSource(), MouseInput::getX(), MouseInput::getY(), mFocusHandler, and MouseEventType::WHEEL_MOVED_DOWN.

Referenced by handleMouseInput().

◆ handleMouseWheelMovedUp()

void Gui::handleMouseWheelMovedUp ( const MouseInput & mouseInput )

protected

Handles mouse wheel moved up input.

Parameters

mouseInput The mouse input to handle.

Definition at line 1244 of file gui.cpp.

 {
     Widget* sourceWidget = getMouseEventSource(
         mouseInput.getX(), mouseInput.getY());
  
     if (mFocusHandler->getDraggedWidget() != nullptr)
         sourceWidget = mFocusHandler->getDraggedWidget();
  
     if (sourceWidget != nullptr)
     {
         int sourceWidgetX;
         int sourceWidgetY;
  
         sourceWidget->getAbsolutePosition(sourceWidgetX, sourceWidgetY);
         distributeMouseEvent(sourceWidget,
             MouseEventType::WHEEL_MOVED_UP,
             mouseInput.getButton(),
             mouseInput.getX(),
             mouseInput.getY(),
             false,
             false);
     }
 }

References distributeMouseEvent(), Widget::getAbsolutePosition(), MouseInput::getButton(), FocusHandler::getDraggedWidget(), getMouseEventSource(), MouseInput::getX(), MouseInput::getY(), mFocusHandler, and MouseEventType::WHEEL_MOVED_UP.

Referenced by handleMouseInput().

◆ isLongPress()

bool Gui::isLongPress ( ) const

inline

Definition at line 309 of file gui.h.

310 { return getMousePressLength() > 250; }

Gui::getMousePressLength

int getMousePressLength() const

Definition: gui.cpp:1530

References getMousePressLength().

Referenced by Viewport::mouseReleased().

◆ logic()

void Gui::logic ( )

Performs logic of the GUI. Overridden to track mouse pointer activity.

Definition at line 302 of file gui.cpp.

 {
     BLOCK_START("Gui::logic")
     ResourceManager::clearScheduled();
  
     if (mTop == nullptr)
     {
         BLOCK_END("Gui::logic")
         return;
     }
  
     handleModalFocus();
     handleModalMouseInputFocus();
  
     if (guiInput != nullptr)
         handleMouseInput();
  
     mTop->logic();
     BLOCK_END("Gui::logic")
 }

References BLOCK_END, BLOCK_START, ResourceManager::clearScheduled(), guiInput, handleModalFocus(), handleModalMouseInputFocus(), handleMouseInput(), Widget::logic(), and mTop.

Referenced by Client::gameExec().

◆ postInit()

void Gui::postInit ( Graphics *const graphics )

Definition at line 151 of file gui.cpp.

 {
     logger->log1("Initializing GUI...");
     // Set graphics
     setGraphics(graphics);
  
     // Set input
     guiInput = new SDLInput;
     setInput(guiInput);
  
     // Set focus handler
     delete mFocusHandler;
     mFocusHandler = new FocusHandler;
  
     // Initialize top GUI widget
     WindowContainer *const guiTop = new WindowContainer(nullptr);
     guiTop->setFocusable(true);
     guiTop->setSize(graphics->mWidth, graphics->mHeight);
     guiTop->setOpaque(Opaque_false);
     Window::setWindowContainer(guiTop);
     setTop(guiTop);
  
     const StringVect langs = getLang();
     const bool isJapan = (!langs.empty() && langs[0].size() > 3
         && langs[0].substr(0, 3) == "ja_");
     const bool isChinese = (!langs.empty() && langs[0].size() > 3
         && langs[0].substr(0, 3) == "zh_");
  
     // Set global font
     const int fontSize = config.getIntValue("fontSize");
     std::string fontFile = config.getValue("font", "");
     if (isJapan)
     {
         fontFile = config.getValue("japanFont", "");
         if (fontFile.empty())
             fontFile = branding.getStringValue("japanFont");
     }
     else if (isChinese)
     {
         fontFile = config.getValue("chinaFont", "");
         if (fontFile.empty())
             fontFile = branding.getStringValue("chinaFont");
     }
     if (fontFile.empty())
         fontFile = branding.getStringValue("font");
  
     mGuiFont = new Font(fontFile, fontSize, TTF_STYLE_NORMAL);
  
     // Set particle font
     fontFile = config.getValue("particleFont", "");
     if (isJapan)
     {
         fontFile = config.getValue("japanFont", "");
         if (fontFile.empty())
             fontFile = branding.getStringValue("japanFont");
     }
     else if (isChinese)
     {
         fontFile = config.getValue("chinaFont", "");
         if (fontFile.empty())
             fontFile = branding.getStringValue("chinaFont");
     }
     if (fontFile.empty())
         fontFile = branding.getStringValue("particleFont");
  
     mInfoParticleFont = new Font(fontFile, fontSize, TTF_STYLE_BOLD);
  
     // Set bold font
     fontFile = config.getValue("boldFont", "");
     if (fontFile.empty())
         fontFile = branding.getStringValue("boldFont");
  
     boldFont = new Font(fontFile, fontSize, TTF_STYLE_NORMAL);
  
     // Set help font
     fontFile = config.getValue("helpFont", "");
     if (fontFile.empty())
         fontFile = branding.getStringValue("helpFont");
  
     mHelpFont = new Font(fontFile, fontSize, TTF_STYLE_NORMAL);
  
     // Set secure font
     fontFile = config.getValue("secureFont", "");
     if (fontFile.empty())
         fontFile = branding.getStringValue("secureFont");
  
     mSecureFont = new Font(fontFile, fontSize, TTF_STYLE_NORMAL);
  
     // Set npc font
     const int npcFontSize = config.getIntValue("npcfontSize");
     fontFile = config.getValue("npcFont", "");
     if (isJapan)
     {
         fontFile = config.getValue("japanFont", "");
         if (fontFile.empty())
             fontFile = branding.getStringValue("japanFont");
     }
     else if (isChinese)
     {
         fontFile = config.getValue("chinaFont", "");
         if (fontFile.empty())
             fontFile = branding.getStringValue("chinaFont");
     }
     if (fontFile.empty())
         fontFile = branding.getStringValue("npcFont");
  
     mNpcFont = new Font(fontFile, npcFontSize, TTF_STYLE_NORMAL);
  
     Widget::setGlobalFont(mGuiFont);
  
     // Initialize mouse cursor and listen for changes to the option
     setUseCustomCursor(config.getBoolValue("customcursor"));
     setDoubleClick(config.getBoolValue("doubleClick"));
     config.addListener("customcursor", mConfigListener);
     config.addListener("doubleClick", mConfigListener);
 }

References Configuration::addListener(), boldFont, branding, config, Configuration::getBoolValue(), Configuration::getIntValue(), getLang(), Configuration::getStringValue(), ConfigurationObject::getValue(), guiInput, Logger::log1(), logger, mConfigListener, mFocusHandler, mGuiFont, Graphics::mHeight, mHelpFont, mInfoParticleFont, mNpcFont, mSecureFont, Graphics::mWidth, Opaque_false, setDoubleClick(), Widget::setFocusable(), Widget::setGlobalFont(), setGraphics(), setInput(), BasicContainer2::setOpaque(), Widget::setSize(), setTop(), setUseCustomCursor(), and Window::setWindowContainer().

Referenced by Client::gameInit().

◆ removeDragged()

void Gui::removeDragged ( const Widget *const widget )

Definition at line 1162 of file gui.cpp.

 {
     if (mFocusHandler == nullptr)
         return;
  
     if (mFocusHandler->getDraggedWidget() == widget)
         mFocusHandler->setDraggedWidget(nullptr);
 }

References FocusHandler::getDraggedWidget(), mFocusHandler, and FocusHandler::setDraggedWidget().

Referenced by BrowserBox::~BrowserBox(), Button::~Button(), CheckBox::~CheckBox(), Container::~Container(), DropDown::~DropDown(), GuiTable::~GuiTable(), Icon::~Icon(), ItemContainer::~ItemContainer(), Label::~Label(), ListBox::~ListBox(), Pincode::~Pincode(), PlayerBox::~PlayerBox(), ProgressBar::~ProgressBar(), ProgressIndicator::~ProgressIndicator(), RadioButton::~RadioButton(), ScrollArea::~ScrollArea(), ShortcutContainer::~ShortcutContainer(), Slider::~Slider(), StaticBrowserBox::~StaticBrowserBox(), Tab::~Tab(), TabbedArea::~TabbedArea(), TextBox::~TextBox(), TextField::~TextField(), TextPreview::~TextPreview(), and Window::~Window().

◆ removeGlobalFocusListener()

void Gui::removeGlobalFocusListener ( FocusListener * focusListener )

Definition at line 1147 of file gui.cpp.

 {
     mFocusListeners.remove(focusListener);
 }

References mFocusListeners.

Referenced by PopupList::~PopupList().

◆ removeGlobalKeyListener()

void Gui::removeGlobalKeyListener ( KeyListener *const keyListener )

Removes global key listener from the Gui.

Parameters

keyListener The key listener to remove.

Exceptions

Exception if the key listener hasn't been added.

See also: addGlobalKeyListener

Definition at line 1215 of file gui.cpp.

 {
     mKeyListeners.remove(keyListener);
 }

References mKeyListeners.

◆ resetClickCount()

void Gui::resetClickCount ( )

Definition at line 980 of file gui.cpp.

 {
     mClickCount = 1;
     mLastMousePressTimeStamp = 0;
 }

References mClickCount, and mLastMousePressTimeStamp.

Referenced by NpcDialog::action(), InventoryWindow::mouseClicked(), ChatWindow::mousePressed(), ListBox::mouseReleased(), and Viewport::mouseReleased().

◆ setCursorType()

void Gui::setCursorType ( const CursorT index )

inline

Sets which cursor should be used.

Definition at line 196 of file gui.h.

197 { mCursorType = index; }

References mCursorType.

Referenced by Window::mouseExited(), Window::mouseReleased(), Window::setModal(), Window::updateResizeHandler(), Window::widgetHidden(), and Window::Window().

◆ setDoubleClick()

void Gui::setDoubleClick ( const bool b )

inline

Definition at line 199 of file gui.h.

200 { mDoubleClick = b; }

References mDoubleClick.

Referenced by GuiConfigListener::optionChanged(), and postInit().

◆ setGraphics()

void Gui::setGraphics ( Graphics *const graphics )

Sets the graphics object to use for drawing.

Parameters

graphics The graphics object to use for drawing.

See also: getGraphics, AllegroGraphics, HGEGraphics, OpenLayerGraphics, OpenGLGraphics, SDLGraphics

Definition at line 1190 of file gui.cpp.

 {
     mGraphics = graphics;
 }

References mGraphics.

Referenced by postInit().

◆ setInput()

void Gui::setInput ( SDLInput *const input )

Sets the input object to use for input handling.

Parameters

input The input object to use for input handling.

See also: getInput, AllegroInput, HGEInput, OpenLayerInput, SDLInput

Definition at line 1200 of file gui.cpp.

 {
     mInput = input;
 }

References mInput.

Referenced by postInit().

◆ setTop()

void Gui::setTop ( Widget *const top )

Sets the top widget. The top widget is the root widget of the GUI. If you want a GUI to be able to contain more than one widget the top widget should be a container.

Parameters

top	The top widget.

See also: Container

Definition at line 1180 of file gui.cpp.

 {
     if (mTop != nullptr)
         mTop->setFocusHandler(nullptr);
     if (top != nullptr)
         top->setFocusHandler(mFocusHandler);
  
     mTop = top;
 }

References mFocusHandler, mTop, Widget::setFocusHandler(), and top.

Referenced by postInit(), and ~Gui().

◆ setUseCustomCursor()

void Gui::setUseCustomCursor ( const bool customCursor )

Sets whether a custom cursor should be rendered.

Definition at line 554 of file gui.cpp.

 {
     if (settings.options.hideCursor)
     {
         SDL::showCursor(false);
         return;
     }
     if (customCursor != mCustomCursor)
     {
         mCustomCursor = customCursor;
  
         if (mCustomCursor)
         {
             // Hide the SDL mouse cursor
             SDL::showCursor(false);
  
             // Load the mouse cursor
             if (mMouseCursors != nullptr)
                 mMouseCursors->decRef();
             mMouseCursors = Theme::getImageSetFromTheme("mouse.png", 40, 40);
  
             if (mMouseCursors == nullptr)
                 logger->log("Error: Unable to load mouse cursors.");
         }
         else
         {
             // Show the SDL mouse cursor
             SDL::showCursor(true);
  
             // Unload the mouse cursor
             if (mMouseCursors != nullptr)
             {
                 mMouseCursors->decRef();
                 mMouseCursors = nullptr;
             }
         }
     }
 }

References Resource::decRef(), Theme::getImageSetFromTheme(), Options::hideCursor, Logger::log(), logger, mCustomCursor, mMouseCursors, Settings::options, settings, and SDL::showCursor().

Referenced by GuiConfigListener::optionChanged(), and postInit().

◆ slowLogic()

void Gui::slowLogic ( )

Definition at line 323 of file gui.cpp.

 {
     BLOCK_START("Gui::slowLogic")
     Palette::advanceGradients();
  
     // Fade out mouse cursor after extended inactivity
     if (mMouseInactivityTimer < 100 * 15)
     {
         ++mMouseInactivityTimer;
         mMouseCursorAlpha = std::min(1.0F, mMouseCursorAlpha + 0.05F);
     }
     else
     {
         mMouseCursorAlpha = std::max(0.0F, mMouseCursorAlpha - 0.005F);
     }
     if (mGuiFont != nullptr)
         mGuiFont->slowLogic(0);
     if (mInfoParticleFont != nullptr)
         mInfoParticleFont->slowLogic(1);
     if (mHelpFont != nullptr)
         mHelpFont->slowLogic(2);
     if (mSecureFont != nullptr)
         mSecureFont->slowLogic(3);
     if (boldFont != nullptr)
         boldFont->slowLogic(4);
     if (mNpcFont != nullptr)
         mNpcFont->slowLogic(5);
     if (windowContainer != nullptr)
         windowContainer->slowLogic();
  
     const time_t time = cur_time;
     if (mTime != time)
     {
         logger->flush();
         if (ipc != nullptr)
             ipc->flush();
         mTime = time;
  
         if (time > mTime10 || mTime10 - time > 10)
         {
             mTime10 = time + 10;
             ResourceManager::cleanOrphans(false);
             guiInput->simulateMouseMove();
         }
     }
  
     BLOCK_END("Gui::slowLogic")
 }

References Palette::advanceGradients(), BLOCK_END, BLOCK_START, boldFont, ResourceManager::cleanOrphans(), cur_time, Logger::flush(), IPC::flush(), guiInput, ipc, logger, mGuiFont, mHelpFont, mInfoParticleFont, mMouseCursorAlpha, mMouseInactivityTimer, mNpcFont, mSecureFont, mTime, mTime10, SDLInput::simulateMouseMove(), WindowContainer::slowLogic(), Font::slowLogic(), and windowContainer.

Referenced by Client::gameExec().

◆ updateFonts()

void Gui::updateFonts ( )

Definition at line 824 of file gui.cpp.

 {
     const int fontSize = config.getIntValue("fontSize");
     std::string fontFile = config.getValue("font", "");
     if (fontFile.empty())
         fontFile = branding.getStringValue("font");
  
     mGuiFont->loadFont(fontFile, fontSize, TTF_STYLE_NORMAL);
  
     fontFile = config.getValue("particleFont", "");
     if (fontFile.empty())
         fontFile = branding.getStringValue("particleFont");
  
     mInfoParticleFont->loadFont(fontFile, fontSize, TTF_STYLE_BOLD);
  
     fontFile = config.getValue("boldFont", "");
     if (fontFile.empty())
         fontFile = branding.getStringValue("boldFont");
  
     boldFont->loadFont(fontFile, fontSize, TTF_STYLE_NORMAL);
  
     const int npcFontSize = config.getIntValue("npcfontSize");
  
     fontFile = config.getValue("npcFont", "");
     if (fontFile.empty())
         fontFile = branding.getStringValue("npcFont");
  
     mNpcFont->loadFont(fontFile, npcFontSize, TTF_STYLE_NORMAL);
 }

References boldFont, branding, config, Configuration::getIntValue(), Configuration::getStringValue(), ConfigurationObject::getValue(), Font::loadFont(), mGuiFont, mInfoParticleFont, and mNpcFont.

Referenced by Setup_Theme::apply().

◆ videoResized()

void Gui::videoResized ( ) const

Called when the application window has been resized.

Definition at line 536 of file gui.cpp.

 {
     WindowContainer *const top = static_cast<WindowContainer *>(getTop());
  
     if (top != nullptr)
     {
         const int oldWidth = top->getWidth();
         const int oldHeight = top->getHeight();
  
         top->setSize(mainGraphics->mWidth, mainGraphics->mHeight);
         top->adjustAfterResize(oldWidth, oldHeight);
     }
  
     if (viewport != nullptr)
         viewport->videoResized();
     Widget::distributeWindowResizeEvent();
 }

References Widget::distributeWindowResizeEvent(), getTop(), mainGraphics, Graphics::mHeight, Graphics::mWidth, top, Viewport::videoResized(), and viewport.

Referenced by WindowManager::resizeVideo().

Field Documentation

◆ mClickCount

int Gui::mClickCount

private

Holds the current click count. Used to keep track of clicks for a the last pressed button.

Definition at line 474 of file gui.h.

Referenced by createMouseEvent(), distributeMouseEvent(), handleMouseMoved(), handleMousePressed(), handleMouseReleased(), and resetClickCount().

◆ mConfigListener

GuiConfigListener* Gui::mConfigListener

private

Definition at line 489 of file gui.h.

Referenced by postInit(), and ~Gui().

◆ mCursorType

CursorT Gui::mCursorType

private

Definition at line 504 of file gui.h.

Referenced by draw(), and setCursorType().

◆ mCustomCursor

bool Gui::mCustomCursor

private

Show custom cursor

Definition at line 517 of file gui.h.

Referenced by draw(), and setUseCustomCursor().

◆ mDoubleClick

bool Gui::mDoubleClick

private

Definition at line 518 of file gui.h.

Referenced by handleMousePressed(), and setDoubleClick().

◆ mFocusHandler

FocusHandler* Gui::mFocusHandler

private

Holds the focus handler for the Gui.

Definition at line 433 of file gui.h.

Referenced by distributeKeyEvent(), distributeMouseEvent(), getFocusHandler(), getKeyEventSource(), getMouseEventSource(), handleKeyInput(), handleModalFocus(), handleModalFocusGained(), handleModalMouseInputFocus(), handleMouseMoved(), handleMousePressed(), handleMouseReleased(), handleMouseWheelMovedDown(), handleMouseWheelMovedUp(), postInit(), removeDragged(), setTop(), and ~Gui().

◆ mFocusListeners

FocusListenerList Gui::mFocusListeners

private

Definition at line 512 of file gui.h.

Referenced by addGlobalFocusListener(), distributeGlobalFocusGainedEvent(), and removeGlobalFocusListener().

◆ mForegroundColor

Color Gui::mForegroundColor

private

Definition at line 513 of file gui.h.

Referenced by draw().

◆ mForegroundColor2

Color Gui::mForegroundColor2

private

Definition at line 514 of file gui.h.

Referenced by draw().

◆ mGraphics

Graphics* Gui::mGraphics

private

Holds the graphics implementation used.

Definition at line 423 of file gui.h.

Referenced by draw(), getGraphics(), and setGraphics().

◆ mGuiFont

Font* Gui::mGuiFont

private

The global GUI font

Definition at line 491 of file gui.h.

Referenced by clearFonts(), draw(), getFont(), postInit(), slowLogic(), updateFonts(), and ~Gui().

◆ mHelpFont

Font* Gui::mHelpFont

private

Font for Help Window

Definition at line 495 of file gui.h.

Referenced by clearFonts(), getHelpFont(), postInit(), slowLogic(), and ~Gui().

◆ mInfoParticleFont

Font* Gui::mInfoParticleFont

private

Font for Info Particles

Definition at line 493 of file gui.h.

Referenced by clearFonts(), getInfoParticleFont(), postInit(), slowLogic(), updateFonts(), and ~Gui().

◆ mInput

SDLInput* Gui::mInput

private

Holds the input implementation used.

Definition at line 428 of file gui.h.

Referenced by getInput(), handleInput(), handleKeyInput(), handleMouseInput(), and setInput().

◆ mKeyListeners

KeyListenerList Gui::mKeyListeners

private

Holds the global key listeners of the Gui.

Definition at line 448 of file gui.h.

Referenced by addGlobalKeyListener(), distributeKeyEventToGlobalKeyListeners(), and removeGlobalKeyListener().

◆ mLastMouseDragButton

MouseButtonT Gui::mLastMouseDragButton

private

Holds the last button used when a drag of a widget was initiated. Used to be able to release a drag when the same button is released.

Definition at line 481 of file gui.h.

Referenced by handleMouseMoved(), and handleMousePressed().

◆ mLastMousePressButton

MouseButtonT Gui::mLastMousePressButton

private

Holds the last mouse button pressed.

Definition at line 453 of file gui.h.

Referenced by handleModalFocusGained(), handleModalFocusReleased(), handleMousePressed(), and handleMouseReleased().

◆ mLastMousePressTimeStamp

unsigned int Gui::mLastMousePressTimeStamp

private

Holds the last mouse press time stamp.

Definition at line 458 of file gui.h.

Referenced by getMousePressLength(), handleMouseMoved(), handleMousePressed(), and resetClickCount().

◆ mLastMouseX

int Gui::mLastMouseX

private

Holds the last mouse x coordinate.

Definition at line 463 of file gui.h.

Referenced by getLastMouseX(), handleModalFocusGained(), handleModalFocusReleased(), and handleMouseInput().

◆ mLastMouseY

int Gui::mLastMouseY

private

Holds the last mouse y coordinate.

Definition at line 468 of file gui.h.

Referenced by getLastMouseY(), handleModalFocusGained(), handleModalFocusReleased(), and handleMouseInput().

◆ mMouseCursorAlpha

float Gui::mMouseCursorAlpha

private

Definition at line 502 of file gui.h.

Referenced by draw(), and slowLogic().

◆ mMouseCursors

ImageSet* Gui::mMouseCursors

private

Mouse cursor images

Definition at line 501 of file gui.h.

Referenced by draw(), setUseCustomCursor(), and ~Gui().

◆ mMouseInactivityTimer

int Gui::mMouseInactivityTimer

private

Definition at line 503 of file gui.h.

Referenced by handleMouseInput(), handleMouseMoved(), and slowLogic().

◆ mNpcFont

Font* Gui::mNpcFont

private

Font for npc text

Definition at line 499 of file gui.h.

Referenced by clearFonts(), getNpcFont(), postInit(), slowLogic(), updateFonts(), and ~Gui().

◆ mSecureFont

Font* Gui::mSecureFont

private

Font for secure labels

Definition at line 497 of file gui.h.

Referenced by clearFonts(), getSecureFont(), postInit(), slowLogic(), and ~Gui().

◆ mTime

time_t Gui::mTime

private

Definition at line 515 of file gui.h.

Referenced by slowLogic().

◆ mTime10

time_t Gui::mTime10

private

Definition at line 516 of file gui.h.

Referenced by slowLogic().

◆ mTop

Widget* Gui::mTop

private

Holds the top widget.

Definition at line 418 of file gui.h.

Referenced by getTop(), getWidgetAt(), handleMouseMoved(), logic(), setTop(), and ~Gui().

◆ mWidgetWithMouseQueue

std::deque<Widget*> Gui::mWidgetWithMouseQueue

private

Holds a stack with all the widgets with the mouse. Used to properly distribute mouse events.

Definition at line 487 of file gui.h.

Referenced by handleModalFocusGained(), handleModalFocusReleased(), and handleMouseMoved().

The documentation for this class was generated from the following files:

src/gui/gui.h (986a3bf)
src/gui/gui.cpp (986a3bf)

Public Member Functions

Static Public Member Functions

Protected Member Functions

Private Types

Private Attributes

Detailed Description

Member Typedef Documentation

◆ FocusListenerIterator

◆ FocusListenerList

◆ KeyListenerList

◆ KeyListenerListIterator

Constructor & Destructor Documentation

◆ Gui()

◆ ~Gui()

Member Function Documentation

◆ addGlobalFocusListener()

◆ addGlobalKeyListener()

◆ clearFonts()

◆ createMouseEvent()

◆ distributeGlobalFocusGainedEvent()

◆ distributeKeyEvent()

◆ distributeKeyEventToGlobalKeyListeners()

◆ distributeMouseEvent()

◆ draw()

◆ getAbsolutePosition()

◆ getFocusHandler()

◆ getFont()

◆ getGraphics()

◆ getHelpFont()

◆ getInfoParticleFont()

◆ getInput()

◆ getKeyEventSource()

◆ getLastMouseX()

◆ getLastMouseY()

◆ getMouseEventSource()

◆ getMousePressLength()

◆ getMouseState()

◆ getNpcFont()

◆ getSecureFont()

◆ getTop()

◆ getWidgetAt()

◆ handleInput()

◆ handleKeyInput()

◆ handleModalFocus()

◆ handleModalFocusGained()

◆ handleModalFocusReleased()

◆ handleModalMouseInputFocus()

◆ handleMouseInput()

◆ handleMouseMoved()

◆ handleMousePressed()

◆ handleMouseReleased()

◆ handleMouseWheelMovedDown()

◆ handleMouseWheelMovedUp()

◆ isLongPress()

◆ logic()

◆ postInit()

◆ removeDragged()

◆ removeGlobalFocusListener()

◆ removeGlobalKeyListener()

◆ resetClickCount()

◆ setCursorType()

◆ setDoubleClick()

◆ setGraphics()

◆ setInput()

◆ setTop()

◆ setUseCustomCursor()

◆ slowLogic()

◆ updateFonts()

◆ videoResized()

Field Documentation

◆ mClickCount

◆ mConfigListener

◆ mCursorType

◆ mCustomCursor

◆ mDoubleClick

◆ mFocusHandler

◆ mFocusListeners

◆ mForegroundColor

◆ mForegroundColor2

◆ mGraphics