ManaPlus
Public Member Functions | Static Public Member Functions | Protected Member Functions | Private Types | Private Attributes

#include <gui.h>

Public Member Functions

 Gui ()
 
 ~Gui ()
 
void postInit (Graphics *const graphics)
 
void logic ()
 
void slowLogic ()
 
void clearFonts ()
 
void draw ()
 
void videoResized () const
 
FocusHandlergetFocusHandler () const
 
FontgetFont () const
 
FontgetHelpFont () const
 
FontgetSecureFont () const
 
FontgetNpcFont () const
 
FontgetInfoParticleFont () const
 
void setUseCustomCursor (const bool customCursor)
 
void setCursorType (const CursorT index)
 
void setDoubleClick (const bool b)
 
void updateFonts ()
 
bool handleInput ()
 
bool handleKeyInput ()
 
void resetClickCount ()
 
MouseEventcreateMouseEvent (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)
 
WidgetgetTop () const
 
void setGraphics (Graphics *const graphics)
 
GraphicsgetGraphics () const
 
void setInput (SDLInput *const input)
 
SDLInputgetInput () 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=false, const bool toSourceOnly=false)
 
void handleMouseWheelMovedDown (const MouseInput &mouseInput)
 
void handleMouseWheelMovedUp (const MouseInput &mouseInput)
 
WidgetgetWidgetAt (const int x, const int y) const
 
WidgetgetMouseEventSource (const int x, const int y) const
 
WidgetgetKeyEventSource () 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

WidgetmTop
 
GraphicsmGraphics
 
SDLInputmInput
 
FocusHandlermFocusHandler
 
KeyListenerList mKeyListeners
 
MouseButtonT mLastMousePressButton
 
unsigned int mLastMousePressTimeStamp
 
int mLastMouseX
 
int mLastMouseY
 
int mClickCount
 
MouseButtonT mLastMouseDragButton
 
std::deque< Widget * > mWidgetWithMouseQueue
 
GuiConfigListenermConfigListener
 
FontmGuiFont
 
FontmInfoParticleFont
 
FontmHelpFont
 
FontmSecureFont
 
FontmNpcFont
 
ImageSetmMouseCursors
 
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 115 of file gui.h.

Member Typedef Documentation

◆ FocusListenerIterator

typedef FocusListenerList::iterator Gui::FocusListenerIterator
private

Definition at line 510 of file gui.h.

◆ FocusListenerList

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

Definition at line 509 of file gui.h.

◆ KeyListenerList

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

Typedef.

Definition at line 437 of file gui.h.

◆ KeyListenerListIterator

typedef KeyListenerList::iterator Gui::KeyListenerListIterator
private

Typedef.

Definition at line 442 of file gui.h.

Constructor & Destructor Documentation

◆ Gui()

Gui::Gui ( )

Constructor.

Definition at line 113 of file gui.cpp.

113  :
114  mTop(nullptr),
115  mGraphics(nullptr),
116  mInput(nullptr),
118  mKeyListeners(),
121  mLastMouseX(0),
122  mLastMouseY(0),
123  mClickCount(1),
127  mGuiFont(nullptr),
128  mInfoParticleFont(nullptr),
129  mHelpFont(nullptr),
130  mSecureFont(nullptr),
131  mNpcFont(nullptr),
132  mMouseCursors(nullptr),
133  mMouseCursorAlpha(1.0F),
136 #ifdef ANDROID
137  mLastMouseRealX(0),
138  mLastMouseRealY(0),
139 #endif // ANDROID
140  mFocusListeners(),
143  mTime(0),
144  mTime10(0),
145  mCustomCursor(false),
146  mDoubleClick(true)
147 {
148 }
CursorT mCursorType
Definition: gui.h:503
Color mForegroundColor
Definition: gui.h:512
int mLastMouseY
Definition: gui.h:467
FocusListenerList mFocusListeners
Definition: gui.h:511
ImageSet * mMouseCursors
Definition: gui.h:500
Color mForegroundColor2
Definition: gui.h:513
Widget * mTop
Definition: gui.h:417
GuiConfigListener * mConfigListener
Definition: gui.h:488
MouseButtonT mLastMousePressButton
Definition: gui.h:452
int mMouseInactivityTimer
Definition: gui.h:502
Graphics * mGraphics
Definition: gui.h:422
Font * mInfoParticleFont
Definition: gui.h:492
unsigned int mLastMousePressTimeStamp
Definition: gui.h:457
FocusHandler * mFocusHandler
Definition: gui.h:432
const Color & getColor(ThemeColorIdT type, const unsigned int alpha=255U)
Definition: theme.h:136
Font * mNpcFont
Definition: gui.h:498
std::deque< Widget * > mWidgetWithMouseQueue
Definition: gui.h:486
time_t mTime10
Definition: gui.h:515
int mClickCount
Definition: gui.h:473
Theme * theme
Definition: theme.cpp:61
SDLInput * mInput
Definition: gui.h:427
Font * mGuiFont
Definition: gui.h:490
time_t mTime
Definition: gui.h:514
float mMouseCursorAlpha
Definition: gui.h:501
int mLastMouseX
Definition: gui.h:462
Font * mHelpFont
Definition: gui.h:494
bool mDoubleClick
Definition: gui.h:517
MouseButtonT mLastMouseDragButton
Definition: gui.h:480
bool mCustomCursor
Definition: gui.h:516
Font * mSecureFont
Definition: gui.h:496
KeyListenerList mKeyListeners
Definition: gui.h:447

◆ ~Gui()

Gui::~Gui ( )

Destructor.

Definition at line 267 of file gui.cpp.

References 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.

268 {
271 
272  if (mMouseCursors != nullptr)
273  {
275  mMouseCursors = nullptr;
276  }
277 
278  if (windowContainer != nullptr)
280  Widget *top = mTop;
282  setTop(nullptr);
284  delete top;
285 
286  delete2(mGuiFont);
287  delete2(boldFont);
291  delete2(mNpcFont);
292  delete2(guiInput);
293  delete2(theme);
294 
299 }
Font * boldFont
Definition: gui.cpp:111
static void cleanGlobalFont()
Definition: widget.h:649
WindowContainer * windowContainer
virtual void decRef()
Definition: resource.cpp:49
ImageSet * mMouseCursors
Definition: gui.h:500
Configuration config
Widget * mTop
Definition: gui.h:417
#define delete2(var)
Definition: delete2.h:24
const Image *restrict const top
static void finalCleanup()
Definition: label.cpp:289
GuiConfigListener * mConfigListener
Definition: gui.h:488
Font * mInfoParticleFont
Definition: gui.h:492
FocusHandler * mFocusHandler
Definition: gui.h:432
Font * mNpcFont
Definition: gui.h:498
static void finalCleanup()
Definition: tab.cpp:482
void setTop(Widget *const top)
Definition: gui.cpp:1162
Theme * theme
Definition: theme.cpp:61
Definition: widget.h:97
void removeListeners(ConfigListener *const listener)
static bool widgetExists(const Widget *const widget)
Definition: widget.cpp:360
Font * mGuiFont
Definition: gui.h:490
static void setWindowContainer(WindowContainer *const windowContainer)
Definition: window.cpp:298
Font * mHelpFont
Definition: gui.h:494
SDLInput * guiInput
Definition: sdlinput.cpp:96
Font * mSecureFont
Definition: gui.h:496

Member Function Documentation

◆ addGlobalFocusListener()

void Gui::addGlobalFocusListener ( FocusListener focusListener)

Definition at line 1124 of file gui.cpp.

References mFocusListeners.

Referenced by PopupList::postInit(), and setDoubleClick().

1125 {
1126  mFocusListeners.push_back(focusListener);
1127 }
FocusListenerList mFocusListeners
Definition: gui.h:511

◆ 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
keyListenerThe key listener to add.
See also
removeGlobalKeyListener

Definition at line 1192 of file gui.cpp.

References mKeyListeners.

Referenced by getTop().

1193 {
1194  mKeyListeners.push_back(keyListener);
1195 }
KeyListenerList mKeyListeners
Definition: gui.h:447

◆ clearFonts()

void Gui::clearFonts ( )

Definition at line 371 of file gui.cpp.

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

Referenced by Actions::doSit().

372 {
373  if (mGuiFont != nullptr)
374  mGuiFont->clear();
375  if (mInfoParticleFont != nullptr)
377  if (mHelpFont != nullptr)
378  mHelpFont->clear();
379  if (mSecureFont != nullptr)
380  mSecureFont->clear();
381  if (boldFont != nullptr)
382  boldFont->clear();
383  if (mNpcFont != nullptr)
384  mNpcFont->clear();
385 }
Font * boldFont
Definition: gui.cpp:111
void clear()
Definition: font.cpp:247
Font * mInfoParticleFont
Definition: gui.h:492
Font * mNpcFont
Definition: gui.h:498
Font * mGuiFont
Definition: gui.h:490
Font * mHelpFont
Definition: gui.h:494
Font * mSecureFont
Definition: gui.h:496

◆ createMouseEvent()

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

Definition at line 974 of file gui.cpp.

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

Referenced by setDoubleClick(), and Window::setVisible().

975 {
976  if ((viewport == nullptr) || (widget == nullptr))
977  return nullptr;
978 
979  int x = 0;
980  int y = 0;
981  int mouseX = 0;
982  int mouseY = 0;
983 
984  getAbsolutePosition(widget, x, y);
985  getMouseState(mouseX, mouseY);
986 
987  return new MouseEvent(widget,
990  mouseX - x,
991  mouseY - y,
992  mClickCount);
993 }
static uint8_t getMouseState(int &x, int &y)
Definition: gui.cpp:1153
int mClickCount
Definition: gui.h:473
static void getAbsolutePosition(Widget *widget, int &x, int &y)
Definition: gui.cpp:995
Viewport * viewport
Definition: viewport.cpp:35

◆ distributeGlobalFocusGainedEvent()

void Gui::distributeGlobalFocusGainedEvent ( const Event focusEvent)

Definition at line 1134 of file gui.cpp.

References mFocusListeners.

Referenced by FocusHandler::distributeFocusGainedEvent(), and setDoubleClick().

1135 {
1136  for (FocusListenerIterator iter = mFocusListeners.begin();
1137  iter != mFocusListeners.end();
1138  ++ iter)
1139  {
1140  (*iter)->focusGained(focusEvent);
1141  }
1142 }
FocusListenerList mFocusListeners
Definition: gui.h:511
FocusListenerList::iterator FocusListenerIterator
Definition: gui.h:510

◆ distributeKeyEvent()

void Gui::distributeKeyEvent ( KeyEvent event) const
protected

Distributes a key event.

Parameters
eventThe key event to distribute.

Definition at line 1297 of file gui.cpp.

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(), and isLongPress().

1298 {
1299  Widget* parent = event.getSource();
1300  Widget* widget = parent;
1301 
1302  if (parent == nullptr)
1303  return;
1304  if (mFocusHandler->getModalFocused() != nullptr &&
1305  !widget->isModalFocused())
1306  {
1307  return;
1308  }
1309  if (mFocusHandler->getModalMouseInputFocused() != nullptr &&
1310  !widget->isModalMouseInputFocused())
1311  {
1312  return;
1313  }
1314 
1315  while (parent != nullptr)
1316  {
1317  // If the widget has been removed due to input
1318  // cancel the distribution.
1319  if (!Widget::widgetExists(widget))
1320  break;
1321 
1322  parent = widget->getParent();
1323 
1324  if (widget->isEnabled())
1325  {
1326  std::list<KeyListener*> keyListeners
1327  = widget->getKeyListeners();
1328 
1329  const KeyEventTypeT eventType = event.getType();
1330  // Send the event to all key listeners of the source widget.
1331  FOR_EACH (std::list<KeyListener*>::const_iterator,
1332  it, keyListeners)
1333  {
1334  switch (eventType)
1335  {
1336  case KeyEventType::PRESSED:
1337  (*it)->keyPressed(event);
1338  break;
1340  (*it)->keyReleased(event);
1341  break;
1342  default:
1343  break;
1344  }
1345  }
1346  }
1347 
1348  const Widget *const swap = widget;
1349  widget = parent;
1350  parent = swap->getParent();
1351 
1352  // If a non modal focused widget has been reach
1353  // and we have modal focus cancel the distribution.
1354  if ((widget != nullptr) &&
1355  (mFocusHandler->getModalFocused() != nullptr) &&
1356  !widget->isModalFocused())
1357  {
1358  break;
1359  }
1360  }
1361 }
#define FOR_EACH(type, iter, array)
Definition: foreach.h:24
KeyEventType ::T KeyEventTypeT
Definition: keyeventtype.h:74
Widget * getModalMouseInputFocused() const
virtual bool isModalFocused() const
Definition: widget.cpp:407
FocusHandler * mFocusHandler
Definition: gui.h:432
bool isEnabled() const
Definition: widget.cpp:374
virtual bool isModalMouseInputFocused() const
Definition: widget.cpp:421
Widget * getParent() const
Definition: widget.h:201
Definition: widget.h:97
static bool widgetExists(const Widget *const widget)
Definition: widget.cpp:360
Widget * getModalFocused() const
const std::list< KeyListener * > & getKeyListeners() const A_CONST
Definition: widget.cpp:440

◆ distributeKeyEventToGlobalKeyListeners()

void Gui::distributeKeyEventToGlobalKeyListeners ( KeyEvent event)
protected

Distributes a key event to the global key listeners.

Parameters
eventThe key event to distribute.

Definition at line 1363 of file gui.cpp.

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

Referenced by handleKeyInput(), and isLongPress().

1364 {
1365  BLOCK_START("Gui::distributeKeyEventToGlobalKeyListeners")
1366  const KeyEventTypeT eventType = event.getType();
1368  {
1369  switch (eventType)
1370  {
1371  case KeyEventType::PRESSED:
1372  (*it)->keyPressed(event);
1373  break;
1375  (*it)->keyReleased(event);
1376  break;
1377  default:
1378  break;
1379  }
1380 
1381  if (event.isConsumed())
1382  break;
1383  }
1384  BLOCK_END("Gui::distributeKeyEventToGlobalKeyListeners")
1385 }
#define FOR_EACH(type, iter, array)
Definition: foreach.h:24
KeyEventType ::T KeyEventTypeT
Definition: keyeventtype.h:74
#define BLOCK_START(name)
Definition: perfomance.h:78
#define BLOCK_END(name)
Definition: perfomance.h:79
bool isConsumed() const
KeyListenerList::iterator KeyListenerListIterator
Definition: gui.h:442
KeyListenerList mKeyListeners
Definition: gui.h:447

◆ distributeMouseEvent()

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

Definition at line 842 of file gui.cpp.

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, and Widget::widgetExists().

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

848 {
849  if ((source == nullptr) || (mFocusHandler == nullptr))
850  return;
851 
852  Widget *widget = source;
853 
854  if (!force)
855  {
856  if (mFocusHandler->getModalFocused() != nullptr
857  && !widget->isModalFocused())
858  {
859  return;
860  }
861  if (mFocusHandler->getModalMouseInputFocused() != nullptr
862  && !widget->isModalMouseInputFocused())
863  {
864  return;
865  }
866  }
867 
868  MouseEvent event(source,
869  type, button,
870  x, y, mClickCount);
871 
872  Widget* parent = source;
873  while (parent != nullptr)
874  {
875  // If the widget has been removed due to input
876  // cancel the distribution.
877  if (!Widget::widgetExists(widget))
878  break;
879 
880  parent = widget->getParent();
881 
882  if (widget->isEnabled() || force)
883  {
884  int widgetX;
885  int widgetY;
886  widget->getAbsolutePosition(widgetX, widgetY);
887 
888  event.setX(x - widgetX);
889  event.setY(y - widgetY);
890 
891  std::list<MouseListener*> mouseListeners
892  = widget->getMouseListeners();
893 
894  const MouseEventTypeT mouseType = event.getType();
895  // Send the event to all mouse listeners of the widget.
896  FOR_EACH (std::list<MouseListener*>::const_iterator,
897  it, mouseListeners)
898  {
899  switch (mouseType)
900  {
902  (*it)->mouseEntered(event);
903  break;
905  (*it)->mouseExited(event);
906  break;
908  (*it)->mouseMoved(event);
909  break;
911  (*it)->mousePressed(event);
912  break;
915  (*it)->mouseReleased(event);
916  break;
918  (*it)->mouseWheelMovedUp(event);
919  break;
921  (*it)->mouseWheelMovedDown(event);
922  break;
924  (*it)->mouseDragged(event);
925  break;
927  (*it)->mouseClicked(event);
928  break;
929  default:
930  break;
931  }
932  }
933 
934  if (toSourceOnly)
935  break;
936  }
937 
938  const Widget *const swap = widget;
939  widget = parent;
940  parent = swap->getParent();
941 
942 #ifndef DYECMD
943  if (type == MouseEventType::RELEASED)
944  dragDrop.clear();
945 #endif // DYECMD
946 
947  if ((widget == nullptr) || event.isConsumed())
948  break;
949 
950  // If a non modal focused widget has been reach
951  // and we have modal focus cancel the distribution.
952  if ((mFocusHandler->getModalFocused() != nullptr)
953  && !widget->isModalFocused())
954  {
955  break;
956  }
957 
958  // If a non modal mouse input focused widget has been reach
959  // and we have modal mouse input focus cancel the distribution.
960  if ((mFocusHandler->getModalMouseInputFocused() != nullptr)
961  && !widget->isModalMouseInputFocused())
962  {
963  break;
964  }
965  }
966 }
#define FOR_EACH(type, iter, array)
Definition: foreach.h:24
void clear()
Definition: dragdrop.h:182
Widget * getModalMouseInputFocused() const
DragDrop dragDrop
virtual bool isModalFocused() const
Definition: widget.cpp:407
FocusHandler * mFocusHandler
Definition: gui.h:432
bool isEnabled() const
Definition: widget.cpp:374
virtual void getAbsolutePosition(int &x, int &y) const
Definition: widget.cpp:311
virtual bool isModalMouseInputFocused() const
Definition: widget.cpp:421
int mClickCount
Definition: gui.h:473
Widget * getParent() const
Definition: widget.h:201
Definition: widget.h:97
static bool widgetExists(const Widget *const widget)
Definition: widget.cpp:360
Widget * getModalFocused() const
MouseEventType ::T MouseEventTypeT
const std::list< MouseListener * > & getMouseListeners() const A_CONST
Definition: widget.cpp:435

◆ 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 469 of file gui.cpp.

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

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

470 {
471  BLOCK_START("Gui::draw 1")
472  Widget *const top = getTop();
473  if (top == nullptr)
474  return;
475  mGraphics->pushClipArea(top->getDimension());
476 
478  {
479  top->draw(mGraphics);
480  touchManager.draw();
481  }
482  else
483  {
484  top->safeDraw(mGraphics);
486  }
487 
488  int mouseX;
489  int mouseY;
490  const MouseStateType button = getMouseState(mouseX, mouseY);
491 
492  if ((settings.mouseFocused ||
493  ((button & SDL_BUTTON(1)) != 0)) &&
494  mMouseCursors != nullptr &&
495  mCustomCursor &&
496  mMouseCursorAlpha > 0.0F)
497  {
498 #ifndef DYECMD
499  const Image *const image = dragDrop.getItemImage();
500  if (mGuiFont != nullptr)
501  {
502  const std::string &str = dragDrop.getText();
503  if (!str.empty())
504  {
505  const int posX = mouseX - mGuiFont->getWidth(str) / 2;
506  const int posY = mouseY +
507  (image != nullptr ? image->mBounds.h / 2 : 0);
510  str,
511  posX, posY);
512  }
513  }
514  if (image != nullptr)
515  {
516  const int posX = mouseX - (image->mBounds.w / 2);
517  const int posY = mouseY - (image->mBounds.h / 2);
518  mGraphics->drawImage(image, posX, posY);
519  }
520 #endif // DYECMD
521 
522  Image *const mouseCursor = mMouseCursors->get(
524  if (mouseCursor != nullptr)
525  {
526  mouseCursor->setAlpha(mMouseCursorAlpha);
527  mGraphics->drawImage(mouseCursor, mouseX - 15, mouseY - 17);
528  }
529  }
530 
532  BLOCK_END("Gui::draw 1")
533 }
CursorT mCursorType
Definition: gui.h:503
Color mForegroundColor
Definition: gui.h:512
Image * get(const size_type i) const
Definition: imageset.cpp:66
#define MouseStateType
Definition: gui.h:99
const std::string & getText() const
Definition: dragdrop.h:231
void pushClipArea(const Rect &restrict area) restrict2 override final
Image * getItemImage()
Definition: dragdrop.h:74
#define BLOCK_START(name)
Definition: perfomance.h:78
ImageSet * mMouseCursors
Definition: gui.h:500
Color mForegroundColor2
Definition: gui.h:513
if(!vert) return
DragDrop dragDrop
#define BLOCK_END(name)
Definition: perfomance.h:79
RenderType openGLMode
virtual void popClipArea()
Definition: graphics.cpp:738
const Image *restrict const top
Graphics * mGraphics
Definition: gui.h:422
Settings settings
Definition: settings.cpp:31
virtual void setAlpha(const float alpha)
Definition: image.cpp:285
void drawString(Graphics *const graphics, Color col, const Color &col2, const std::string &text, const int x, const int y)
Definition: font.cpp:253
static uint8_t getMouseState(int &x, int &y)
Definition: gui.cpp:1153
virtual void drawImage(const Image *const image, int dstX, int dstY)=0
Widget * getTop() const
Definition: gui.h:247
Definition: widget.h:97
int getWidth(const std::string &text) const
Definition: font.cpp:333
Font * mGuiFont
Definition: gui.h:490
Definition: image.h:61
float mMouseCursorAlpha
Definition: gui.h:501
#define CAST_SIZE
Definition: cast.h:33
SDL_Rect mBounds
Definition: image.h:210
TouchManager touchManager
#define isBatchDrawRenders(val)
Definition: renderers.h:30
bool mouseFocused
Definition: settings.h:153
bool mCustomCursor
Definition: gui.h:516

◆ getAbsolutePosition()

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

Definition at line 995 of file gui.cpp.

Referenced by createMouseEvent(), and setDoubleClick().

998 {
999  if (widget == nullptr)
1000  return;
1001  x = 0;
1002  y = 0;
1003  while (widget->getParent() != nullptr)
1004  {
1005  x += widget->getX();
1006  y += widget->getY();
1007  widget = widget->getParent();
1008  }
1009 }
int getY() const
Definition: widget.h:287
int getX() const
Definition: widget.h:268
Widget * getParent() const
Definition: widget.h:201

◆ getFocusHandler()

FocusHandler* Gui::getFocusHandler ( ) const
inline

Definition at line 153 of file gui.h.

References mFocusHandler.

Referenced by InputManager::updateConditionMask().

154  { return mFocusHandler; }
FocusHandler * mFocusHandler
Definition: gui.h:432

◆ getFont()

Font* Gui::getFont ( ) const
inline

◆ 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 1177 of file gui.cpp.

References mGraphics.

Referenced by getTop().

1178 {
1179  return mGraphics;
1180 }
Graphics * mGraphics
Definition: gui.h:422

◆ getHelpFont()

Font* Gui::getHelpFont ( ) const
inline

Return help font.

Definition at line 165 of file gui.h.

References mHelpFont.

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

166  { return mHelpFont; }
Font * mHelpFont
Definition: gui.h:494

◆ 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 184 of file gui.h.

References mInfoParticleFont, and setUseCustomCursor().

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

185  { return mInfoParticleFont; }
Font * mInfoParticleFont
Definition: gui.h:492

◆ 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 1187 of file gui.cpp.

References mInput.

Referenced by getTop().

1188 {
1189  return mInput;
1190 }
SDLInput * mInput
Definition: gui.h:427

◆ getKeyEventSource()

Widget * Gui::getKeyEventSource ( ) const
protected

Gets the source of the key event.

Returns
The source widget of the key event.

Definition at line 1283 of file gui.cpp.

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

Referenced by handleKeyInput(), and isLongPress().

1284 {
1285  Widget* widget = mFocusHandler->getFocused();
1286 
1287  while (widget != nullptr &&
1288  widget->getInternalFocusHandler() != nullptr &&
1289  widget->getInternalFocusHandler()->getFocused() != nullptr)
1290  {
1291  widget = widget->getInternalFocusHandler()->getFocused();
1292  }
1293 
1294  return widget;
1295 }
virtual FocusHandler * getInternalFocusHandler()
Definition: widget.cpp:455
FocusHandler * mFocusHandler
Definition: gui.h:432
Widget * getFocused() const
Definition: widget.h:97

◆ getLastMouseX()

int Gui::getLastMouseX ( ) const
inline

Definition at line 223 of file gui.h.

References mLastMouseX.

Referenced by SDLInput::pushInput().

224  { return mLastMouseX; }
int mLastMouseX
Definition: gui.h:462

◆ getLastMouseY()

int Gui::getLastMouseY ( ) const
inline

Definition at line 226 of file gui.h.

References getMouseState(), mLastMouseY, MouseStateType, setTop(), and top.

Referenced by SDLInput::pushInput().

227  { return mLastMouseY; }
int mLastMouseY
Definition: gui.h:467

◆ 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 1267 of file gui.cpp.

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

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

1268 {
1269  Widget *const widget = getWidgetAt(x, y);
1270  if (widget == nullptr)
1271  return nullptr;
1272 
1273  if (mFocusHandler != nullptr &&
1274  mFocusHandler->getModalMouseInputFocused() != nullptr &&
1275  !widget->isModalMouseInputFocused())
1276  {
1278  }
1279 
1280  return widget;
1281 }
Widget * getModalMouseInputFocused() const
FocusHandler * mFocusHandler
Definition: gui.h:432
Widget * getWidgetAt(const int x, const int y) const
Definition: gui.cpp:1246
virtual bool isModalMouseInputFocused() const
Definition: widget.cpp:421
Definition: widget.h:97

◆ getMousePressLength()

int Gui::getMousePressLength ( ) const

Definition at line 1507 of file gui.cpp.

References mLastMousePressTimeStamp.

Referenced by isLongPress().

1508 {
1509  if (mLastMousePressTimeStamp == 0u)
1510  return 0;
1511  unsigned int ticks = SDL_GetTicks();
1512  if (ticks > mLastMousePressTimeStamp)
1513  return ticks - mLastMousePressTimeStamp;
1514  return mLastMousePressTimeStamp - ticks;
1515 }
unsigned int mLastMousePressTimeStamp
Definition: gui.h:457

◆ getMouseState()

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

Definition at line 1153 of file gui.cpp.

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

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

1154 {
1155  const MouseStateType res = SDL_GetMouseState(&x, &y);
1156  const int scale = mainGraphics->getScale();
1157  x /= scale;
1158  y /= scale;
1159  return res;
1160 }
#define MouseStateType
Definition: gui.h:99
Graphics * mainGraphics
Definition: graphics.cpp:108
int getScale() const
Definition: graphics.h:365

◆ getNpcFont()

Font* Gui::getNpcFont ( ) const
inline

Return npc font.

Definition at line 177 of file gui.h.

References mNpcFont.

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

178  { return mNpcFont; }
Font * mNpcFont
Definition: gui.h:498

◆ getSecureFont()

Font* Gui::getSecureFont ( ) const
inline

Return secure font.

Definition at line 171 of file gui.h.

References mSecureFont.

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

172  { return mSecureFont; }
Font * mSecureFont
Definition: gui.h:496

◆ 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 247 of file gui.h.

References A_NONNULL, A_WARN_UNUSED, addGlobalKeyListener(), getGraphics(), getInput(), mTop, removeGlobalKeyListener(), RETURNS_NONNULL, setGraphics(), and setInput().

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

248  { return mTop; }
Widget * mTop
Definition: gui.h:417

◆ 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 1246 of file gui.cpp.

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

Referenced by getMouseEventSource(), and isLongPress().

1247 {
1248  // If the widget's parent has no child then we have found the widget..
1249  Widget* parent = mTop;
1250  Widget* child = mTop;
1251  Widget* selectable = mTop;
1252 
1253  while (child != nullptr)
1254  {
1255  Widget *const swap = child;
1256  int parentX, parentY;
1257  parent->getAbsolutePosition(parentX, parentY);
1258  child = parent->getWidgetAt(x - parentX, y - parentY);
1259  parent = swap;
1260  if (parent->isSelectable())
1261  selectable = parent;
1262  }
1263 
1264  return selectable;
1265 }
virtual bool isSelectable() const
Definition: widget.h:944
Widget * mTop
Definition: gui.h:417
virtual void getAbsolutePosition(int &x, int &y) const
Definition: widget.cpp:311
Definition: widget.h:97
virtual Widget * getWidgetAt(int x, int y)
Definition: widget.h:791

◆ handleInput()

bool Gui::handleInput ( )

Definition at line 387 of file gui.cpp.

References handleKeyInput(), and mInput.

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

388 {
389  if (mInput != nullptr)
390  return handleKeyInput();
391  return false;
392 }
SDLInput * mInput
Definition: gui.h:427
bool handleKeyInput()
Definition: gui.cpp:394

◆ handleKeyInput()

bool Gui::handleKeyInput ( )

Definition at line 394 of file gui.cpp.

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(), Widget::isFocusable(), SDLInput::isKeyQueueEmpty(), mFocusHandler, mInput, KeyEventType::PRESSED, FocusHandler::tabNext(), and FocusHandler::tabPrevious().

Referenced by handleInput(), and setDoubleClick().

395 {
396  if (guiInput == nullptr)
397  return false;
398 
399  BLOCK_START("Gui::handleKeyInput")
400  bool consumed(false);
401 
402  while (!mInput->isKeyQueueEmpty())
403  {
404  const KeyInput keyInput = guiInput->dequeueKeyInput();
405 
406  KeyEvent eventToGlobalKeyListeners(nullptr,
407  keyInput.getType(),
408  keyInput.getActionId(), keyInput.getKey());
409 
410 #ifdef USE_SDL2
411  if (!keyInput.getText().empty())
412  eventToGlobalKeyListeners.setText(keyInput.getText());
413 #endif // USE_SDL2
414 
416  eventToGlobalKeyListeners);
417 
418  // If a global key listener consumes the event it will not be
419  // sent further to the source of the event.
420  if (eventToGlobalKeyListeners.isConsumed())
421  {
422  consumed = true;
423  continue;
424  }
425 
426  if (mFocusHandler != nullptr)
427  {
428  bool eventConsumed = false;
429 
430  // Send key inputs to the focused widgets
431  if (mFocusHandler->getFocused() != nullptr)
432  {
433  KeyEvent event(getKeyEventSource(),
434  keyInput.getType(),
435  keyInput.getActionId(), keyInput.getKey());
436 #ifdef USE_SDL2
437  if (!keyInput.getText().empty())
438  event.setText(keyInput.getText());
439 #endif // USE_SDL2
440 
443  else
444  distributeKeyEvent(event);
445 
446  eventConsumed = event.isConsumed();
447  if (eventConsumed)
448  consumed = true;
449  }
450 
451  // If the key event hasn't been consumed and
452  // tabbing is enable check for tab press and
453  // change focus.
454  if (!eventConsumed && keyInput.getActionId()
456  keyInput.getType() == KeyEventType::PRESSED)
457  {
460  else
462  }
463  }
464  } // end while
465  BLOCK_END("Gui::handleKeyInput")
466  return consumed;
467 }
void distributeKeyEvent(KeyEvent &event) const
Definition: gui.cpp:1297
#define BLOCK_START(name)
Definition: perfomance.h:78
KeyEventTypeT getType() const
Definition: keyinput.h:122
#define BLOCK_END(name)
Definition: perfomance.h:79
bool isActionActive(const InputActionT index) const
void tabPrevious()
InputActionT getActionId() const
Definition: keyinput.h:142
const Key & getKey() const
Definition: keyinput.h:132
FocusHandler * mFocusHandler
Definition: gui.h:432
Widget * getKeyEventSource() const
Definition: gui.cpp:1283
KeyInput dequeueKeyInput()
Definition: sdlinput.cpp:107
Widget * getFocused() const
SDLInput * mInput
Definition: gui.h:427
bool isFocusable() const
Definition: widget.cpp:198
InputManager inputManager
void distributeKeyEventToGlobalKeyListeners(KeyEvent &event)
Definition: gui.cpp:1363
SDLInput * guiInput
Definition: sdlinput.cpp:96

◆ 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 1411 of file gui.cpp.

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

Referenced by isLongPress(), and logic().

1412 {
1413  BLOCK_START("Gui::handleModalFocus")
1414  Widget *const lastModalWidget
1415  = mFocusHandler->getLastWidgetWithModalFocus();
1416  Widget *const modalWidget = mFocusHandler->getModalFocused();
1417 
1418  if (lastModalWidget != modalWidget)
1419  {
1420  // Check if modal focus has been gained by a widget.
1421  if (lastModalWidget == nullptr)
1422  {
1425  }
1426  // Check if modal focus has been released.
1427  else
1428  {
1431  }
1432  }
1433  BLOCK_END("Gui::handleModalFocus")
1434 }
void handleModalFocusReleased()
Definition: gui.cpp:1461
#define BLOCK_START(name)
Definition: perfomance.h:78
if(!vert) return
void handleModalFocusGained()
Definition: gui.cpp:1436
#define BLOCK_END(name)
Definition: perfomance.h:79
FocusHandler * mFocusHandler
Definition: gui.h:432
Definition: widget.h:97
void setLastWidgetWithModalFocus(Widget *const widget)

◆ 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 1436 of file gui.cpp.

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

Referenced by handleModalFocus(), handleModalMouseInputFocus(), and isLongPress().

1437 {
1438  // Distribute an event to all widgets in the "widget with mouse" queue.
1439  while (!mWidgetWithMouseQueue.empty())
1440  {
1441  Widget *const widget = mWidgetWithMouseQueue.front();
1442 
1443  if (Widget::widgetExists(widget))
1444  {
1445  distributeMouseEvent(widget,
1448  mLastMouseX,
1449  mLastMouseY,
1450  true,
1451  true);
1452  }
1453 
1454  mWidgetWithMouseQueue.pop_front();
1455  }
1456 
1459 }
int mLastMouseY
Definition: gui.h:467
Widget * getModalMouseInputFocused() const
MouseButtonT mLastMousePressButton
Definition: gui.h:452
FocusHandler * mFocusHandler
Definition: gui.h:432
std::deque< Widget * > mWidgetWithMouseQueue
Definition: gui.h:486
Definition: widget.h:97
static bool widgetExists(const Widget *const widget)
Definition: widget.cpp:360
int mLastMouseX
Definition: gui.h:462
void setLastWidgetWithModalMouseInputFocus(Widget *const widget)
void distributeMouseEvent(Widget *const source, const MouseEventTypeT type, const MouseButtonT button, const int x, const int y, const bool force=false, const bool toSourceOnly=false)
Definition: gui.cpp:842

◆ 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 1461 of file gui.cpp.

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

Referenced by handleModalFocus(), handleModalMouseInputFocus(), and isLongPress().

1462 {
1463  // Check all widgets below the mouse to see if they are
1464  // present in the "widget with mouse" queue. If a widget
1465  // is not then it should be added and an entered event should
1466  // be sent to it.
1468  Widget* parent = widget;
1469 
1470  while (parent != nullptr &&
1471  widget != nullptr)
1472  {
1473  parent = widget->getParent();
1474 
1475  // Check if the widget is present in the "widget with mouse" queue.
1476  bool widgetIsPresentInQueue = false;
1477  FOR_EACH (std::deque<Widget*>::const_iterator,
1478  iter, mWidgetWithMouseQueue)
1479  {
1480  if (*iter == widget)
1481  {
1482  widgetIsPresentInQueue = true;
1483  break;
1484  }
1485  }
1486 
1487  // Widget is not present, send an entered event and add
1488  // it to the "widget with mouse" queue.
1489  if (!widgetIsPresentInQueue && Widget::widgetExists(widget))
1490  {
1491  distributeMouseEvent(widget,
1494  mLastMouseX,
1495  mLastMouseY,
1496  false,
1497  true);
1498  mWidgetWithMouseQueue.push_front(widget);
1499  }
1500 
1501  const Widget *const swap = widget;
1502  widget = parent;
1503  parent = swap->getParent();
1504  }
1505 }
#define FOR_EACH(type, iter, array)
Definition: foreach.h:24
int mLastMouseY
Definition: gui.h:467
Widget * getMouseEventSource(const int x, const int y) const
Definition: gui.cpp:1267
MouseButtonT mLastMousePressButton
Definition: gui.h:452
std::deque< Widget * > mWidgetWithMouseQueue
Definition: gui.h:486
Widget * getParent() const
Definition: widget.h:201
Definition: widget.h:97
static bool widgetExists(const Widget *const widget)
Definition: widget.cpp:360
int mLastMouseX
Definition: gui.h:462
void distributeMouseEvent(Widget *const source, const MouseEventTypeT type, const MouseButtonT button, const int x, const int y, const bool force=false, const bool toSourceOnly=false)
Definition: gui.cpp:842

◆ 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 1387 of file gui.cpp.

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

Referenced by isLongPress(), and logic().

1388 {
1389  BLOCK_START("Gui::handleModalMouseInputFocus")
1390  Widget *const lastModalWidget
1391  = mFocusHandler->getLastWidgetWithModalMouseInputFocus();
1392  Widget *const modalWidget = mFocusHandler->getModalMouseInputFocused();
1393  if (lastModalWidget != modalWidget)
1394  {
1395  // Check if modal mouse input focus has been gained by a widget.
1396  if (lastModalWidget == nullptr)
1397  {
1400  }
1401  // Check if modal mouse input focus has been released.
1402  else
1403  {
1406  }
1407  }
1408  BLOCK_END("Gui::handleModalMouseInputFocus")
1409 }
void handleModalFocusReleased()
Definition: gui.cpp:1461
#define BLOCK_START(name)
Definition: perfomance.h:78
if(!vert) return
void handleModalFocusGained()
Definition: gui.cpp:1436
#define BLOCK_END(name)
Definition: perfomance.h:79
FocusHandler * mFocusHandler
Definition: gui.h:432
Definition: widget.h:97
void setLastWidgetWithModalMouseInputFocus(Widget *const widget)

◆ handleMouseInput()

void Gui::handleMouseInput ( )
protected

Definition at line 1011 of file gui.cpp.

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 isLongPress(), and logic().

1012 {
1013  BLOCK_START("Gui::handleMouseInput")
1014  while (!mInput->isMouseQueueEmpty())
1015  {
1016  const MouseInput mouseInput = guiInput->dequeueMouseInput();
1017 
1018  if (touchManager.processEvent(mouseInput))
1019  {
1020 #ifdef ANDROID
1021 #ifndef USE_SDL2
1022  SDL_WarpMouse(mLastMouseX, mLastMouseY,
1023  mLastMouseRealX, mLastMouseRealY);
1024 #endif // USE_SDL2
1025 #endif // ANDROID
1026 
1028  continue;
1029  }
1030 
1031  // Save the current mouse state. It will be needed if modal focus
1032  // changes or modal mouse input focus changes.
1033  mLastMouseX = mouseInput.getX();
1034  mLastMouseY = mouseInput.getY();
1035 #ifdef ANDROID
1036  mLastMouseRealX = mouseInput.getRealX();
1037  mLastMouseRealY = mouseInput.getRealY();
1038 #endif // ANDROID
1039 
1040  switch (mouseInput.getType())
1041  {
1043  handleMousePressed(mouseInput);
1044  break;
1046  handleMouseReleased(mouseInput);
1047  break;
1048  case MouseEventType::MOVED:
1049  handleMouseMoved(mouseInput);
1050  break;
1052  handleMouseWheelMovedDown(mouseInput);
1053  break;
1055  handleMouseWheelMovedUp(mouseInput);
1056  break;
1062  default:
1063  break;
1064  }
1065  }
1066  BLOCK_END("Gui::handleMouseInput")
1067 }
int mLastMouseY
Definition: gui.h:467
MouseInput dequeueMouseInput()
Definition: sdlinput.cpp:118
#define BLOCK_START(name)
Definition: perfomance.h:78
#define BLOCK_END(name)
Definition: perfomance.h:79
int mMouseInactivityTimer
Definition: gui.h:502
void handleMouseMoved(const MouseInput &mouseInput)
Definition: gui.cpp:592
MouseEventTypeT getType() const
Definition: mouseinput.h:118
void handleMouseWheelMovedUp(const MouseInput &mouseInput)
Definition: gui.cpp:1224
void handleMousePressed(const MouseInput &mouseInput)
Definition: gui.cpp:768
int getRealY() const
Definition: mouseinput.h:169
int getX() const
Definition: mouseinput.h:148
int getRealX() const
Definition: mouseinput.h:166
void handleMouseWheelMovedDown(const MouseInput &mouseInput)
Definition: gui.cpp:1202
SDLInput * mInput
Definition: gui.h:427
bool processEvent(const MouseInput &mouseInput)
void handleMouseReleased(const MouseInput &mouseInput)
Definition: gui.cpp:1069
int mLastMouseX
Definition: gui.h:462
TouchManager touchManager
int getY() const
Definition: mouseinput.h:158
SDLInput * guiInput
Definition: sdlinput.cpp:96

◆ handleMouseMoved()

void Gui::handleMouseMoved ( const MouseInput mouseInput)
protected

Definition at line 592 of file gui.cpp.

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(), and isLongPress().

593 {
594  // Check if the mouse leaves the application window.
595  if (mTop != nullptr &&
596  !mWidgetWithMouseQueue.empty() &&
597  (mouseInput.getX() < 0 ||
598  mouseInput.getY() < 0 ||
599  !mTop->getDimension().isPointInRect(mouseInput.getX(),
600  mouseInput.getY())))
601  {
602  // Distribute an event to all widgets in the
603  // "widget with mouse" queue.
604  while (!mWidgetWithMouseQueue.empty())
605  {
606  Widget *const widget = mWidgetWithMouseQueue.front();
607 
608  if (Widget::widgetExists(widget))
609  {
610  distributeMouseEvent(widget,
612  mouseInput.getButton(),
613  mouseInput.getX(),
614  mouseInput.getY(),
615  true,
616  true);
617  }
618 
619  mWidgetWithMouseQueue.pop_front();
620  }
621 
623  return;
624  }
625 
626  const int mouseX = mouseInput.getX();
627  const int mouseY = mouseInput.getY();
628  const MouseButtonT button = mouseInput.getButton();
629 
630  // Check if there is a need to send mouse exited events by
631  // traversing the "widget with mouse" queue.
632  bool widgetWithMouseQueueCheckDone = mWidgetWithMouseQueue.empty();
633  while (!widgetWithMouseQueueCheckDone)
634  {
635  unsigned int iterations = 0;
636  for (std::deque<Widget*>::iterator
637  iter = mWidgetWithMouseQueue.begin();
638  iter != mWidgetWithMouseQueue.end();
639  ++ iter)
640  {
641  Widget *const widget = *iter;
642 
643  // If a widget in the "widget with mouse queue" doesn't
644  // exists anymore it should be removed from the queue.
645  if (!Widget::widgetExists(widget))
646  {
647  mWidgetWithMouseQueue.erase(iter);
648  break;
649  }
650  else
651  {
652  int x;
653  int y;
654  widget->getAbsolutePosition(x, y);
655 
656  if (x > mouseX
657  || y > mouseY
658  || x + widget->getWidth() <= mouseX
659  || y + widget->getHeight() <= mouseY
660  || !widget->isVisible())
661  {
662  distributeMouseEvent(widget,
664  button,
665  mouseX,
666  mouseY,
667  true,
668  true);
669  mClickCount = 1;
671  mWidgetWithMouseQueue.erase(iter);
672  break;
673  }
674  }
675 
676  iterations++;
677  }
678 
679  widgetWithMouseQueueCheckDone =
680  (CAST_SIZE(iterations) == mWidgetWithMouseQueue.size());
681  }
682 
683  // Check all widgets below the mouse to see if they are
684  // present in the "widget with mouse" queue. If a widget
685  // is not then it should be added and an entered event should
686  // be sent to it.
687  Widget* parent = getMouseEventSource(mouseX, mouseY);
688  Widget* widget = parent;
689 
690  // If a widget has modal mouse input focus then it will
691  // always be returned from getMouseEventSource, but we only wan't to
692  // send mouse entered events if the mouse has actually entered the
693  // widget with modal mouse input focus, hence we need to check if
694  // that's the case. If it's not we should simply ignore to send any
695  // mouse entered events.
696  if ((mFocusHandler->getModalMouseInputFocused() != nullptr)
698  && Widget::widgetExists(widget) &&
699  (widget != nullptr))
700  {
701  int x, y;
702  widget->getAbsolutePosition(x, y);
703 
704  if (x > mouseX || y > mouseY
705  || x + widget->getWidth() <= mouseX
706  || y + widget->getHeight() <= mouseY)
707  {
708  parent = nullptr;
709  }
710  }
711 
712  while (parent != nullptr)
713  {
714  parent = widget->getParent();
715 
716  // Check if the widget is present in the "widget with mouse" queue.
717  bool widgetIsPresentInQueue = false;
718  FOR_EACH (std::deque<Widget*>::const_iterator,
719  iter, mWidgetWithMouseQueue)
720  {
721  if (*iter == widget)
722  {
723  widgetIsPresentInQueue = true;
724  break;
725  }
726  }
727 
728  // Widget is not present, send an entered event and add
729  // it to the "widget with mouse" queue.
730  if (!widgetIsPresentInQueue
731  && Widget::widgetExists(widget))
732  {
733  distributeMouseEvent(widget,
735  button,
736  mouseX,
737  mouseY,
738  true,
739  true);
740  mWidgetWithMouseQueue.push_front(widget);
741  }
742 
743  const Widget *const swap = widget;
744  widget = parent;
745  parent = swap->getParent();
746  }
747 
748  if (mFocusHandler->getDraggedWidget() != nullptr)
749  {
753  mouseX,
754  mouseY);
755  }
756  else
757  {
758  Widget *const sourceWidget = getMouseEventSource(mouseX, mouseY);
759  distributeMouseEvent(sourceWidget,
761  button,
762  mouseX,
763  mouseY);
764  }
766 }
#define FOR_EACH(type, iter, array)
Definition: foreach.h:24
int getWidth() const
Definition: widget.h:220
MouseButtonT getButton() const
Definition: mouseinput.h:128
Widget * getModalMouseInputFocused() const
bool isPointInRect(const int x_, const int y_) const
Definition: rect.h:196
Widget * mTop
Definition: gui.h:417
Widget * getMouseEventSource(const int x, const int y) const
Definition: gui.cpp:1267
int mMouseInactivityTimer
Definition: gui.h:502
Widget * getDraggedWidget() const
unsigned int mLastMousePressTimeStamp
Definition: gui.h:457
int getX() const
Definition: mouseinput.h:148
FocusHandler * mFocusHandler
Definition: gui.h:432
std::deque< Widget * > mWidgetWithMouseQueue
Definition: gui.h:486
virtual void getAbsolutePosition(int &x, int &y) const
Definition: widget.cpp:311
const Rect & getDimension() const
Definition: widget.h:316
int mClickCount
Definition: gui.h:473
Widget * getParent() const
Definition: widget.h:201
bool isVisible() const
Definition: widget.h:377
Definition: widget.h:97
static bool widgetExists(const Widget *const widget)
Definition: widget.cpp:360
int getHeight() const
Definition: widget.h:239
#define CAST_SIZE
Definition: cast.h:33
MouseButton ::T MouseButtonT
Definition: mousebutton.h:77
int getY() const
Definition: mouseinput.h:158
void distributeMouseEvent(Widget *const source, const MouseEventTypeT type, const MouseButtonT button, const int x, const int y, const bool force=false, const bool toSourceOnly=false)
Definition: gui.cpp:842
MouseButtonT mLastMouseDragButton
Definition: gui.h:480

◆ handleMousePressed()

void Gui::handleMousePressed ( const MouseInput mouseInput)
protected

Definition at line 768 of file gui.cpp.

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(), and isLongPress().

769 {
770  const int x = mouseInput.getX();
771  const int y = mouseInput.getY();
772  const MouseButtonT button = mouseInput.getButton();
773  const unsigned int timeStamp = mouseInput.getTimeStamp();
774 
775  Widget *sourceWidget = getMouseEventSource(x, y);
776 
777  if (mFocusHandler->getDraggedWidget() != nullptr)
778  sourceWidget = mFocusHandler->getDraggedWidget();
779 
780  if (sourceWidget == nullptr)
781  return;
782  int sourceWidgetX;
783  int sourceWidgetY;
784  sourceWidget->getAbsolutePosition(sourceWidgetX, sourceWidgetY);
785 
786  if (((mFocusHandler->getModalFocused() != nullptr)
787  && sourceWidget->isModalFocused())
788  || (mFocusHandler->getModalFocused() == nullptr))
789  {
790  sourceWidget->requestFocus();
791  }
792 
793  if (mDoubleClick &&
794  timeStamp - mLastMousePressTimeStamp < 250U &&
795  mLastMousePressButton == button)
796  {
797  mClickCount ++;
798  }
799  else
800  {
801  mClickCount = 1;
802  }
803 
804  distributeMouseEvent(sourceWidget, MouseEventType::PRESSED, button, x, y);
805  mFocusHandler->setLastWidgetPressed(sourceWidget);
806  mFocusHandler->setDraggedWidget(sourceWidget);
807  mLastMouseDragButton = button;
808  mLastMousePressButton = button;
809  mLastMousePressTimeStamp = timeStamp;
810 }
void setLastWidgetPressed(Widget *const lastWidgetPressed)
MouseButtonT getButton() const
Definition: mouseinput.h:128
int getTimeStamp() const
Definition: mouseinput.h:133
Widget * getMouseEventSource(const int x, const int y) const
Definition: gui.cpp:1267
MouseButtonT mLastMousePressButton
Definition: gui.h:452
virtual bool isModalFocused() const
Definition: widget.cpp:407
Widget * getDraggedWidget() const
virtual void requestFocus()
Definition: widget.cpp:203
unsigned int mLastMousePressTimeStamp
Definition: gui.h:457
int getX() const
Definition: mouseinput.h:148
FocusHandler * mFocusHandler
Definition: gui.h:432
virtual void getAbsolutePosition(int &x, int &y) const
Definition: widget.cpp:311
int mClickCount
Definition: gui.h:473
Definition: widget.h:97
Widget * getModalFocused() const
void setDraggedWidget(Widget *const draggedWidget)
bool mDoubleClick
Definition: gui.h:517
MouseButton ::T MouseButtonT
Definition: mousebutton.h:77
int getY() const
Definition: mouseinput.h:158
void distributeMouseEvent(Widget *const source, const MouseEventTypeT type, const MouseButtonT button, const int x, const int y, const bool force=false, const bool toSourceOnly=false)
Definition: gui.cpp:842
MouseButtonT mLastMouseDragButton
Definition: gui.h:480

◆ handleMouseReleased()

void Gui::handleMouseReleased ( const MouseInput mouseInput)
protected

Definition at line 1069 of file gui.cpp.

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(), and isLongPress().

1070 {
1071  Widget *sourceWidget = getMouseEventSource(
1072  mouseInput.getX(), mouseInput.getY());
1073 
1074  int sourceWidgetX;
1075  int sourceWidgetY;
1076  if (mFocusHandler->getDraggedWidget() != nullptr)
1077  {
1078  if (sourceWidget != mFocusHandler->getLastWidgetPressed())
1080 
1081  Widget *const oldWidget = sourceWidget;
1082  sourceWidget = mFocusHandler->getDraggedWidget();
1083  if ((oldWidget != nullptr) && oldWidget != sourceWidget)
1084  {
1085  oldWidget->getAbsolutePosition(sourceWidgetX, sourceWidgetY);
1086  distributeMouseEvent(oldWidget,
1088  mouseInput.getButton(),
1089  mouseInput.getX(),
1090  mouseInput.getY());
1091  }
1092  }
1093 
1094  if (sourceWidget == nullptr)
1095  return;
1096  sourceWidget->getAbsolutePosition(sourceWidgetX, sourceWidgetY);
1097  distributeMouseEvent(sourceWidget,
1099  mouseInput.getButton(),
1100  mouseInput.getX(),
1101  mouseInput.getY());
1102 
1103  if (mouseInput.getButton() == mLastMousePressButton
1104  && mFocusHandler->getLastWidgetPressed() == sourceWidget)
1105  {
1106  distributeMouseEvent(sourceWidget,
1108  mouseInput.getButton(),
1109  mouseInput.getX(),
1110  mouseInput.getY());
1111 
1113  }
1114  else
1115  {
1117  mClickCount = 0;
1118  }
1119 
1120  if (mFocusHandler->getDraggedWidget() != nullptr)
1121  mFocusHandler->setDraggedWidget(nullptr);
1122 }
void setLastWidgetPressed(Widget *const lastWidgetPressed)
MouseButtonT getButton() const
Definition: mouseinput.h:128
Widget * getMouseEventSource(const int x, const int y) const
Definition: gui.cpp:1267
MouseButtonT mLastMousePressButton
Definition: gui.h:452
Widget * getDraggedWidget() const
int getX() const
Definition: mouseinput.h:148
FocusHandler * mFocusHandler
Definition: gui.h:432
virtual void getAbsolutePosition(int &x, int &y) const
Definition: widget.cpp:311
int mClickCount
Definition: gui.h:473
Definition: widget.h:97
void setDraggedWidget(Widget *const draggedWidget)
Widget * getLastWidgetPressed() const
int getY() const
Definition: mouseinput.h:158
void distributeMouseEvent(Widget *const source, const MouseEventTypeT type, const MouseButtonT button, const int x, const int y, const bool force=false, const bool toSourceOnly=false)
Definition: gui.cpp:842

◆ handleMouseWheelMovedDown()

void Gui::handleMouseWheelMovedDown ( const MouseInput mouseInput)
protected

Handles mouse wheel moved down input.

Parameters
mouseInputThe mouse input to handle.

Definition at line 1202 of file gui.cpp.

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

Referenced by handleMouseInput(), and isLongPress().

1203 {
1204  Widget* sourceWidget = getMouseEventSource(
1205  mouseInput.getX(), mouseInput.getY());
1206 
1207  if (mFocusHandler->getDraggedWidget() != nullptr)
1208  sourceWidget = mFocusHandler->getDraggedWidget();
1209 
1210  if (sourceWidget != nullptr)
1211  {
1212  int sourceWidgetX = 0;
1213  int sourceWidgetY = 0;
1214 
1215  sourceWidget->getAbsolutePosition(sourceWidgetX, sourceWidgetY);
1216  distributeMouseEvent(sourceWidget,
1218  mouseInput.getButton(),
1219  mouseInput.getX(),
1220  mouseInput.getY());
1221  }
1222 }
MouseButtonT getButton() const
Definition: mouseinput.h:128
Widget * getMouseEventSource(const int x, const int y) const
Definition: gui.cpp:1267
Widget * getDraggedWidget() const
int getX() const
Definition: mouseinput.h:148
FocusHandler * mFocusHandler
Definition: gui.h:432
virtual void getAbsolutePosition(int &x, int &y) const
Definition: widget.cpp:311
Definition: widget.h:97
int getY() const
Definition: mouseinput.h:158
void distributeMouseEvent(Widget *const source, const MouseEventTypeT type, const MouseButtonT button, const int x, const int y, const bool force=false, const bool toSourceOnly=false)
Definition: gui.cpp:842

◆ handleMouseWheelMovedUp()

void Gui::handleMouseWheelMovedUp ( const MouseInput mouseInput)
protected

Handles mouse wheel moved up input.

Parameters
mouseInputThe mouse input to handle.

Definition at line 1224 of file gui.cpp.

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

Referenced by handleMouseInput(), and isLongPress().

1225 {
1226  Widget* sourceWidget = getMouseEventSource(
1227  mouseInput.getX(), mouseInput.getY());
1228 
1229  if (mFocusHandler->getDraggedWidget() != nullptr)
1230  sourceWidget = mFocusHandler->getDraggedWidget();
1231 
1232  if (sourceWidget != nullptr)
1233  {
1234  int sourceWidgetX;
1235  int sourceWidgetY;
1236 
1237  sourceWidget->getAbsolutePosition(sourceWidgetX, sourceWidgetY);
1238  distributeMouseEvent(sourceWidget,
1240  mouseInput.getButton(),
1241  mouseInput.getX(),
1242  mouseInput.getY());
1243  }
1244 }
MouseButtonT getButton() const
Definition: mouseinput.h:128
Widget * getMouseEventSource(const int x, const int y) const
Definition: gui.cpp:1267
Widget * getDraggedWidget() const
int getX() const
Definition: mouseinput.h:148
FocusHandler * mFocusHandler
Definition: gui.h:432
virtual void getAbsolutePosition(int &x, int &y) const
Definition: widget.cpp:311
Definition: widget.h:97
int getY() const
Definition: mouseinput.h:158
void distributeMouseEvent(Widget *const source, const MouseEventTypeT type, const MouseButtonT button, const int x, const int y, const bool force=false, const bool toSourceOnly=false)
Definition: gui.cpp:842

◆ isLongPress()

bool Gui::isLongPress ( ) const
inline

◆ logic()

void Gui::logic ( )

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

Definition at line 301 of file gui.cpp.

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

Referenced by Client::gameExec(), and Client::stateSwitchLogin1().

302 {
303  BLOCK_START("Gui::logic")
305 
306  if (mTop == nullptr)
307  {
308  BLOCK_END("Gui::logic")
309  return;
310  }
311 
314 
315  if (guiInput != nullptr)
317 
318  mTop->logic();
319  BLOCK_END("Gui::logic")
320 }
void logic()
Definition: gui.cpp:301
#define BLOCK_START(name)
Definition: perfomance.h:78
Widget * mTop
Definition: gui.h:417
if(!vert) return
#define BLOCK_END(name)
Definition: perfomance.h:79
Definition: gui.h:115
void handleModalMouseInputFocus()
Definition: gui.cpp:1387
void handleMouseInput()
Definition: gui.cpp:1011
SDLInput * guiInput
Definition: sdlinput.cpp:96
void handleModalFocus()
Definition: gui.cpp:1411

◆ postInit()

void Gui::postInit ( Graphics *const  graphics)

Definition at line 150 of file gui.cpp.

References Configuration::addListener(), 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 anonymous_namespace{client.cpp}::LoginListener::action(), and Client::gameInit().

151 {
152  logger->log1("Initializing GUI...");
153  // Set graphics
154  setGraphics(graphics);
155 
156  // Set input
157  guiInput = new SDLInput;
159 
160  // Set focus handler
161  delete mFocusHandler;
163 
164  // Initialize top GUI widget
165  WindowContainer *const guiTop = new WindowContainer(nullptr);
166  guiTop->setFocusable(true);
167  guiTop->setSize(graphics->mWidth, graphics->mHeight);
168  guiTop->setOpaque(Opaque_false);
170  setTop(guiTop);
171 
172  const StringVect langs = getLang();
173  const bool isJapan = (!langs.empty() && langs[0].size() > 3
174  && langs[0].substr(0, 3) == "ja_");
175  const bool isChinese = (!langs.empty() && langs[0].size() > 3
176  && langs[0].substr(0, 3) == "zh_");
177 
178  // Set global font
179  const int fontSize = config.getIntValue("fontSize");
180  std::string fontFile = config.getValue("font", "");
181  if (isJapan)
182  {
183  fontFile = config.getValue("japanFont", "");
184  if (fontFile.empty())
185  fontFile = branding.getStringValue("japanFont");
186  }
187  else if (isChinese)
188  {
189  fontFile = config.getValue("chinaFont", "");
190  if (fontFile.empty())
191  fontFile = branding.getStringValue("chinaFont");
192  }
193  if (fontFile.empty())
194  fontFile = branding.getStringValue("font");
195 
196  mGuiFont = new Font(fontFile, fontSize, TTF_STYLE_NORMAL);
197 
198  // Set particle font
199  fontFile = config.getValue("particleFont", "");
200  if (isJapan)
201  {
202  fontFile = config.getValue("japanFont", "");
203  if (fontFile.empty())
204  fontFile = branding.getStringValue("japanFont");
205  }
206  else if (isChinese)
207  {
208  fontFile = config.getValue("chinaFont", "");
209  if (fontFile.empty())
210  fontFile = branding.getStringValue("chinaFont");
211  }
212  if (fontFile.empty())
213  fontFile = branding.getStringValue("particleFont");
214 
215  mInfoParticleFont = new Font(fontFile, fontSize, TTF_STYLE_BOLD);
216 
217  // Set bold font
218  fontFile = config.getValue("boldFont", "");
219  if (fontFile.empty())
220  fontFile = branding.getStringValue("boldFont");
221 
222  boldFont = new Font(fontFile, fontSize, TTF_STYLE_NORMAL);
223 
224  // Set help font
225  fontFile = config.getValue("helpFont", "");
226  if (fontFile.empty())
227  fontFile = branding.getStringValue("helpFont");
228 
229  mHelpFont = new Font(fontFile, fontSize, TTF_STYLE_NORMAL);
230 
231  // Set secure font
232  fontFile = config.getValue("secureFont", "");
233  if (fontFile.empty())
234  fontFile = branding.getStringValue("secureFont");
235 
236  mSecureFont = new Font(fontFile, fontSize, TTF_STYLE_NORMAL);
237 
238  // Set npc font
239  const int npcFontSize = config.getIntValue("npcfontSize");
240  fontFile = config.getValue("npcFont", "");
241  if (isJapan)
242  {
243  fontFile = config.getValue("japanFont", "");
244  if (fontFile.empty())
245  fontFile = branding.getStringValue("japanFont");
246  }
247  else if (isChinese)
248  {
249  fontFile = config.getValue("chinaFont", "");
250  if (fontFile.empty())
251  fontFile = branding.getStringValue("chinaFont");
252  }
253  if (fontFile.empty())
254  fontFile = branding.getStringValue("npcFont");
255 
256  mNpcFont = new Font(fontFile, npcFontSize, TTF_STYLE_NORMAL);
257 
259 
260  // Initialize mouse cursor and listen for changes to the option
261  setUseCustomCursor(config.getBoolValue("customcursor"));
262  setDoubleClick(config.getBoolValue("doubleClick"));
263  config.addListener("customcursor", mConfigListener);
264  config.addListener("doubleClick", mConfigListener);
265 }
void setSize(const int width, const int height)
Definition: widget.cpp:366
Configuration branding
std::string getStringValue(const std::string &key) const
void log1(const char *const log_text)
Definition: logger.cpp:222
Font * boldFont
Definition: gui.cpp:111
Definition: font.h:88
void setDoubleClick(const bool b)
Definition: gui.h:198
static void setGlobalFont(Font *const font)
Definition: widget.cpp:337
int mWidth
Definition: graphics.h:483
Configuration config
int getIntValue(const std::string &key) const
LangVect getLang()
Definition: langs.cpp:41
std::vector< std::string > StringVect
Definition: stringvector.h:28
GuiConfigListener * mConfigListener
Definition: gui.h:488
void addListener(const std::string &key, ConfigListener *const listener)
Logger * logger
Definition: logger.cpp:95
bool getBoolValue(const std::string &key) const
Font * mInfoParticleFont
Definition: gui.h:492
void setInput(SDLInput *const input)
Definition: gui.cpp:1182
FocusHandler * mFocusHandler
Definition: gui.h:432
Font * mNpcFont
Definition: gui.h:498
const bool Opaque_false
Definition: opaque.h:29
int mHeight
Definition: graphics.h:484
void setOpaque(Opaque opaque)
void setTop(Widget *const top)
Definition: gui.cpp:1162
void setGraphics(Graphics *const graphics)
Definition: gui.cpp:1172
std::string getValue(const std::string &key, const std::string &deflt) const
void setFocusable(const bool focusable)
Definition: widget.cpp:191
void setUseCustomCursor(const bool customCursor)
Definition: gui.cpp:553
Font * mGuiFont
Definition: gui.h:490
static void setWindowContainer(WindowContainer *const windowContainer)
Definition: window.cpp:298
Font * mHelpFont
Definition: gui.h:494
SDLInput * guiInput
Definition: sdlinput.cpp:96
Font * mSecureFont
Definition: gui.h:496

◆ removeDragged()

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

◆ removeGlobalFocusListener()

void Gui::removeGlobalFocusListener ( FocusListener focusListener)

Definition at line 1129 of file gui.cpp.

References mFocusListeners.

Referenced by setDoubleClick(), and PopupList::~PopupList().

1130 {
1131  mFocusListeners.remove(focusListener);
1132 }
FocusListenerList mFocusListeners
Definition: gui.h:511

◆ removeGlobalKeyListener()

void Gui::removeGlobalKeyListener ( KeyListener *const  keyListener)

Removes global key listener from the Gui.

Parameters
keyListenerThe key listener to remove.
Exceptions
Exceptionif the key listener hasn't been added.
See also
addGlobalKeyListener

Definition at line 1197 of file gui.cpp.

References mKeyListeners.

Referenced by getTop().

1198 {
1199  mKeyListeners.remove(keyListener);
1200 }
KeyListenerList mKeyListeners
Definition: gui.h:447

◆ resetClickCount()

void Gui::resetClickCount ( )

◆ setCursorType()

void Gui::setCursorType ( const CursorT  index)
inline

Sets which cursor should be used.

Definition at line 195 of file gui.h.

References mCursorType.

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

196  { mCursorType = index; }
CursorT mCursorType
Definition: gui.h:503

◆ setDoubleClick()

void Gui::setDoubleClick ( const bool  b)
inline

◆ setGraphics()

void Gui::setGraphics ( Graphics *const  graphics)

Sets the graphics object to use for drawing.

Parameters
graphicsThe graphics object to use for drawing.
See also
getGraphics, AllegroGraphics, HGEGraphics, OpenLayerGraphics, OpenGLGraphics, SDLGraphics

Definition at line 1172 of file gui.cpp.

References mGraphics.

Referenced by getTop(), and postInit().

1173 {
1174  mGraphics = graphics;
1175 }
Graphics * mGraphics
Definition: gui.h:422

◆ setInput()

void Gui::setInput ( SDLInput *const  input)

Sets the input object to use for input handling.

Parameters
inputThe input object to use for input handling.
See also
getInput, AllegroInput, HGEInput, OpenLayerInput, SDLInput

Definition at line 1182 of file gui.cpp.

References mInput.

Referenced by getTop(), and postInit().

1183 {
1184  mInput = input;
1185 }
SDLInput * mInput
Definition: gui.h:427

◆ 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
topThe top widget.
See also
Container

Definition at line 1162 of file gui.cpp.

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

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

1163 {
1164  if (mTop != nullptr)
1165  mTop->setFocusHandler(nullptr);
1166  if (top != nullptr)
1168 
1169  mTop = top;
1170 }
Widget * mTop
Definition: gui.h:417
const Image *restrict const top
FocusHandler * mFocusHandler
Definition: gui.h:432
virtual void setFocusHandler(FocusHandler *const focusHandler)
Definition: widget.cpp:237

◆ setUseCustomCursor()

void Gui::setUseCustomCursor ( const bool  customCursor)

Sets whether a custom cursor should be rendered.

Definition at line 553 of file gui.cpp.

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

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

554 {
556  {
557  SDL::showCursor(false);
558  return;
559  }
560  if (customCursor != mCustomCursor)
561  {
562  mCustomCursor = customCursor;
563 
564  if (mCustomCursor)
565  {
566  // Hide the SDL mouse cursor
567  SDL::showCursor(false);
568 
569  // Load the mouse cursor
570  if (mMouseCursors != nullptr)
572  mMouseCursors = Theme::getImageSetFromTheme("mouse.png", 40, 40);
573 
574  if (mMouseCursors == nullptr)
575  logger->log("Error: Unable to load mouse cursors.");
576  }
577  else
578  {
579  // Show the SDL mouse cursor
580  SDL::showCursor(true);
581 
582  // Unload the mouse cursor
583  if (mMouseCursors != nullptr)
584  {
586  mMouseCursors = nullptr;
587  }
588  }
589  }
590 }
Options options
Definition: settings.h:128
virtual void decRef()
Definition: resource.cpp:49
ImageSet * mMouseCursors
Definition: gui.h:500
Logger * logger
Definition: logger.cpp:95
Settings settings
Definition: settings.cpp:31
static ImageSet * getImageSetFromTheme(const std::string &path, const int w, const int h)
Definition: theme.cpp:659
bool hideCursor
Definition: options.h:100
void showCursor(const bool show)
void log(const char *const log_text,...)
Definition: logger.cpp:243
bool mCustomCursor
Definition: gui.h:516

◆ slowLogic()

void Gui::slowLogic ( )

Definition at line 322 of file gui.cpp.

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

Referenced by Client::gameExec(), and Client::stateSwitchLogin1().

323 {
324  BLOCK_START("Gui::slowLogic")
325  Palette::advanceGradients();
326 
327  // Fade out mouse cursor after extended inactivity
328  if (mMouseInactivityTimer < 100 * 15)
329  {
331  mMouseCursorAlpha = std::min(1.0F, mMouseCursorAlpha + 0.05F);
332  }
333  else
334  {
335  mMouseCursorAlpha = std::max(0.0F, mMouseCursorAlpha - 0.005F);
336  }
337  if (mGuiFont != nullptr)
338  mGuiFont->slowLogic(0);
339  if (mInfoParticleFont != nullptr)
341  if (mHelpFont != nullptr)
342  mHelpFont->slowLogic(2);
343  if (mSecureFont != nullptr)
345  if (boldFont != nullptr)
346  boldFont->slowLogic(4);
347  if (mNpcFont != nullptr)
348  mNpcFont->slowLogic(5);
349  if (windowContainer != nullptr)
351 
352  const time_t time = cur_time;
353  if (mTime != time)
354  {
355  logger->flush();
356  if (ipc != nullptr)
357  ipc->flush();
358  mTime = time;
359 
360  if (time > mTime10 || mTime10 - time > 10)
361  {
362  mTime10 = time + 10;
365  }
366  }
367 
368  BLOCK_END("Gui::slowLogic")
369 }
Font * boldFont
Definition: gui.cpp:111
WindowContainer * windowContainer
#define BLOCK_START(name)
Definition: perfomance.h:78
void simulateMouseMove()
Definition: sdlinput.cpp:361
if(!vert) return
#define BLOCK_END(name)
Definition: perfomance.h:79
IPC * ipc
Definition: ipc.cpp:36
void flush()
Definition: logger.cpp:365
int mMouseInactivityTimer
Definition: gui.h:502
Logger * logger
Definition: logger.cpp:95
Font * mInfoParticleFont
Definition: gui.h:492
Font * mNpcFont
Definition: gui.h:498
void flush()
Definition: ipc.cpp:189
volatile time_t cur_time
Definition: timer.cpp:57
time_t mTime10
Definition: gui.h:515
void slowLogic(const int rnd)
Definition: font.cpp:318
Font * mGuiFont
Definition: gui.h:490
time_t mTime
Definition: gui.h:514
float mMouseCursorAlpha
Definition: gui.h:501
Font * mHelpFont
Definition: gui.h:494
bool cleanOrphans(const bool always)
SDLInput * guiInput
Definition: sdlinput.cpp:96
Font * mSecureFont
Definition: gui.h:496

◆ updateFonts()

void Gui::updateFonts ( )

Definition at line 812 of file gui.cpp.

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

Referenced by Setup_Theme::apply(), and setDoubleClick().

813 {
814  const int fontSize = config.getIntValue("fontSize");
815  std::string fontFile = config.getValue("font", "");
816  if (fontFile.empty())
817  fontFile = branding.getStringValue("font");
818 
819  mGuiFont->loadFont(fontFile, fontSize, TTF_STYLE_NORMAL);
820 
821  fontFile = config.getValue("particleFont", "");
822  if (fontFile.empty())
823  fontFile = branding.getStringValue("particleFont");
824 
825  mInfoParticleFont->loadFont(fontFile, fontSize, TTF_STYLE_BOLD);
826 
827  fontFile = config.getValue("boldFont", "");
828  if (fontFile.empty())
829  fontFile = branding.getStringValue("boldFont");
830 
831  boldFont->loadFont(fontFile, fontSize, TTF_STYLE_NORMAL);
832 
833  const int npcFontSize = config.getIntValue("npcfontSize");
834 
835  fontFile = config.getValue("npcFont", "");
836  if (fontFile.empty())
837  fontFile = branding.getStringValue("npcFont");
838 
839  mNpcFont->loadFont(fontFile, npcFontSize, TTF_STYLE_NORMAL);
840 }
Configuration branding
std::string getStringValue(const std::string &key) const
Font * boldFont
Definition: gui.cpp:111
Configuration config
int getIntValue(const std::string &key) const
Font * mInfoParticleFont
Definition: gui.h:492
void loadFont(std::string filename, const int size, const int style)
Definition: font.cpp:218
Font * mNpcFont
Definition: gui.h:498
std::string getValue(const std::string &key, const std::string &deflt) const
Font * mGuiFont
Definition: gui.h:490

◆ videoResized()

void Gui::videoResized ( ) const

Called when the application window has been resized.

Definition at line 535 of file gui.cpp.

References WindowContainer::adjustAfterResize(), Widget::distributeWindowResizeEvent(), Widget::getHeight(), getTop(), Widget::getWidth(), mainGraphics, Graphics::mHeight, Graphics::mWidth, Widget::setSize(), top, Viewport::videoResized(), and viewport.

Referenced by WindowManager::resizeVideo().

536 {
537  WindowContainer *const top = static_cast<WindowContainer *>(getTop());
538 
539  if (top != nullptr)
540  {
541  const int oldWidth = top->getWidth();
542  const int oldHeight = top->getHeight();
543 
545  top->adjustAfterResize(oldWidth, oldHeight);
546  }
547 
548  if (viewport != nullptr)
551 }
void setSize(const int width, const int height)
Definition: widget.cpp:366
int getWidth() const
Definition: widget.h:220
int mWidth
Definition: graphics.h:483
const Image *restrict const top
void videoResized()
Definition: viewport.cpp:270
void adjustAfterResize(const int oldScreenWidth, const int oldScreenHeight)
static void distributeWindowResizeEvent()
Definition: widget.cpp:354
Graphics * mainGraphics
Definition: graphics.cpp:108
int mHeight
Definition: graphics.h:484
Widget * getTop() const
Definition: gui.h:247
int getHeight() const
Definition: widget.h:239
Viewport * viewport
Definition: viewport.cpp:35

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 473 of file gui.h.

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

◆ mConfigListener

GuiConfigListener* Gui::mConfigListener
private

Definition at line 488 of file gui.h.

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

◆ mCursorType

CursorT Gui::mCursorType
private

Definition at line 503 of file gui.h.

Referenced by draw(), and setCursorType().

◆ mCustomCursor

bool Gui::mCustomCursor
private

Show custom cursor

Definition at line 516 of file gui.h.

Referenced by draw(), and setUseCustomCursor().

◆ mDoubleClick

bool Gui::mDoubleClick
private

Definition at line 517 of file gui.h.

Referenced by handleMousePressed(), and setDoubleClick().

◆ mFocusHandler

FocusHandler* Gui::mFocusHandler
private

◆ mFocusListeners

FocusListenerList Gui::mFocusListeners
private

◆ mForegroundColor

Color Gui::mForegroundColor
private

Definition at line 512 of file gui.h.

Referenced by draw().

◆ mForegroundColor2

Color Gui::mForegroundColor2
private

Definition at line 513 of file gui.h.

Referenced by draw().

◆ mGraphics

Graphics* Gui::mGraphics
private

Holds the graphics implementation used.

Definition at line 422 of file gui.h.

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

◆ mGuiFont

Font* Gui::mGuiFont
private

The global GUI font

Definition at line 490 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 494 of file gui.h.

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

◆ mInfoParticleFont

Font* Gui::mInfoParticleFont
private

Font for Info Particles

Definition at line 492 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 427 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 447 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 480 of file gui.h.

Referenced by handleMouseMoved(), and handleMousePressed().

◆ mLastMousePressButton

MouseButtonT Gui::mLastMousePressButton
private

Holds the last mouse button pressed.

Definition at line 452 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 457 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 462 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 467 of file gui.h.

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

◆ mMouseCursorAlpha

float Gui::mMouseCursorAlpha
private

Definition at line 501 of file gui.h.

Referenced by draw(), and slowLogic().

◆ mMouseCursors

ImageSet* Gui::mMouseCursors
private

Mouse cursor images

Definition at line 500 of file gui.h.

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

◆ mMouseInactivityTimer

int Gui::mMouseInactivityTimer
private

Definition at line 502 of file gui.h.

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

◆ mNpcFont

Font* Gui::mNpcFont
private

Font for npc text

Definition at line 498 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 496 of file gui.h.

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

◆ mTime

time_t Gui::mTime
private

Definition at line 514 of file gui.h.

Referenced by slowLogic().

◆ mTime10

time_t Gui::mTime10
private

Definition at line 515 of file gui.h.

Referenced by slowLogic().

◆ mTop

Widget* Gui::mTop
private

Holds the top widget.

Definition at line 417 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 486 of file gui.h.

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


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