FocusHandler Class Reference

#include <focushandler.h>

Public Member Functions
	FocusHandler ()
void	requestFocus (const Widget *const widget)
void	requestModalFocus (Widget *const widget)
void	requestModalMouseInputFocus (Widget *const widget)
void	releaseModalFocus (Widget *const widget)
void	releaseModalMouseInputFocus (const Widget *const widget)
bool	isFocused (const Widget *const widget) const
Widget *	getFocused () const
Widget *	getModalFocused () const
Widget *	getModalMouseInputFocused () const
void	focusNext ()
void	focusPrevious ()
void	add (Widget *const widget)
void	remove (Widget *const widget)
void	focusNone ()
void	tabNext ()
void	tabPrevious ()
Widget *	getDraggedWidget () const
void	setDraggedWidget (Widget *const draggedWidget)
Widget *	getLastWidgetWithMouse () const
void	setLastWidgetWithMouse (Widget *const lastWidgetWithMouse)
Widget *	getLastWidgetWithModalFocus () const
void	setLastWidgetWithModalFocus (Widget *const widget)
Widget *	getLastWidgetWithModalMouseInputFocus () const
void	setLastWidgetWithModalMouseInputFocus (Widget *const widget)
Widget *	getLastWidgetPressed () const
void	setLastWidgetPressed (Widget *const lastWidgetPressed)

Private Types
typedef std::vector< Widget * >	WidgetVector
typedef WidgetVector::iterator	WidgetIterator

Private Member Functions
void	checkForWindow () const

Static Private Member Functions
static void	distributeFocusLostEvent (const Event &focusEvent)
static void	distributeFocusGainedEvent (const Event &focusEvent)

Private Attributes
WidgetVector	mWidgets
Widget *	mFocusedWidget
Widget *	mModalFocusedWidget
Widget *	mModalMouseInputFocusedWidget
Widget *	mDraggedWidget
Widget *	mLastWidgetWithMouse
Widget *	mLastWidgetWithModalFocus
Widget *	mLastWidgetWithModalMouseInputFocus
Widget *	mLastWidgetPressed
std::list< Widget * >	mModalStack

Detailed Description

The focus handler. This focus handler does exactly the same as the Guichan focus handler, but keeps a stack of modal widgets to be able to handle multiple modal focus requests.

Definition at line 84 of file focushandler.h.

Member Typedef Documentation

WidgetIterator

typedef WidgetVector::iterator FocusHandler::WidgetIterator

private

Typedef.

Definition at line 354 of file focushandler.h.

WidgetVector

typedef std::vector<Widget*> FocusHandler::WidgetVector

private

Typedef.

Definition at line 349 of file focushandler.h.

Constructor & Destructor Documentation

FocusHandler()

FocusHandler::FocusHandler

(

)

Definition at line 79 of file focushandler.cpp.

                           :
    mWidgets(),
    mFocusedWidget(nullptr),
    mModalFocusedWidget(nullptr),
    mModalMouseInputFocusedWidget(nullptr),
    mDraggedWidget(nullptr),
    mLastWidgetWithMouse(nullptr),
    mLastWidgetWithModalFocus(nullptr),
    mLastWidgetWithModalMouseInputFocus(nullptr),
    mLastWidgetPressed(nullptr),
    mModalStack()
{
}

Member Function Documentation

add()

void FocusHandler::add

(

Widget *const

widget

)

Adds a widget to by handles by the focus handler.

Parameters

widget

The widget to add.

See also

remove

Definition at line 538 of file focushandler.cpp.

{
    mWidgets.push_back(widget);
}

References mWidgets.

Referenced by Widget::setFocusHandler().

checkForWindow()

void FocusHandler::checkForWindow ( ) const

private

Checks to see if the widget tabbed to is in a window, and if it is, it requests the window be moved to the top.

Definition at line 317 of file focushandler.cpp.

{
    if (mFocusedWidget != nullptr)
    {
        Widget *widget = mFocusedWidget->getParent();
 
        while (widget != nullptr)
        {
            Window *const window = dynamic_cast<Window*>(widget);
 
            if (window != nullptr)
            {
                window->requestMoveToTop();
                break;
            }
 
            widget = widget->getParent();
        }
    }
}

References Widget::getParent(), mFocusedWidget, and Widget::requestMoveToTop().

Referenced by tabNext(), and tabPrevious().

distributeFocusGainedEvent()

void FocusHandler::distributeFocusGainedEvent ( const Event &  focusEvent )

staticprivate

Distributes a focus gained event.

Parameters

focusEvent

the event to distribute.

Definition at line 338 of file focushandler.cpp.

{
    if (gui != nullptr)
        gui->distributeGlobalFocusGainedEvent(focusEvent);
 
    const Widget *const sourceWidget = focusEvent.getSource();
 
    if (sourceWidget == nullptr)
        return;
    std::list<FocusListener*> focusListeners
        = sourceWidget->getFocusListeners();
 
    // Send the event to all focus listeners of the widget.
    for (std::list<FocusListener*>::const_iterator
          it = focusListeners.begin();
          it != focusListeners.end();
          ++ it)
    {
        (*it)->focusGained(focusEvent);
    }
}

References Gui::distributeGlobalFocusGainedEvent(), Widget::getFocusListeners(), Event::getSource(), and gui.

Referenced by focusNext(), focusPrevious(), requestFocus(), tabNext(), and tabPrevious().

distributeFocusLostEvent()

void FocusHandler::distributeFocusLostEvent ( const Event &  focusEvent )

staticprivate

Distributes a focus lost event.

Parameters

focusEvent

the event to distribute.

Definition at line 555 of file focushandler.cpp.

{
    const Widget *const sourceWidget = focusEvent.getSource();
    if (sourceWidget == nullptr)
        return;
 
    std::list<FocusListener*> focusListeners
        = sourceWidget->getFocusListeners();
 
    // Send the event to all focus listeners of the widget.
    for (std::list<FocusListener*>::const_iterator
          it = focusListeners.begin();
          it != focusListeners.end();
          ++ it)
    {
        (*it)->focusLost(focusEvent);
    }
}

References Widget::getFocusListeners(), and Event::getSource().

Referenced by focusNext(), focusNone(), focusPrevious(), requestFocus(), tabNext(), and tabPrevious().

focusNext()

void FocusHandler::focusNext

(

)

Focuses the next widget added to a conainer. If no widget has focus the first widget gets focus. The order in which the widgets are focused is determined by the order they were added to a container.

See also

focusPrevious

Definition at line 428 of file focushandler.cpp.

{
    int i;
    int focusedWidget = -1;
    const int sz = CAST_S32(mWidgets.size());
    for (i = 0; i < sz; ++i)
    {
        if (mWidgets[i] == mFocusedWidget)
            focusedWidget = i;
    }
    const int focused = focusedWidget;
 
    // i is a counter that ensures that the following loop
    // won't get stuck in an infinite loop
    i = sz;
    do
    {
        ++ focusedWidget;
 
        if (i == 0)
        {
            focusedWidget = -1;
            break;
        }
 
        -- i;
 
        if (focusedWidget >= sz)
            focusedWidget = 0;
 
        if (focusedWidget == focused)
            return;
    }
    while (!mWidgets.at(focusedWidget)->isFocusable());
 
    if (focusedWidget >= 0)
    {
        mFocusedWidget = mWidgets.at(focusedWidget);
 
        Event focusEvent(mFocusedWidget);
        distributeFocusGainedEvent(focusEvent);
    }
 
    if (focused >= 0)
    {
        Event focusEvent(mWidgets.at(focused));
        distributeFocusLostEvent(focusEvent);
    }
}

References CAST_S32, distributeFocusGainedEvent(), distributeFocusLostEvent(), mFocusedWidget, and mWidgets.

focusNone()

void FocusHandler::focusNone

(

)

Focuses nothing. A focus event will also be sent to the focused widget's focus listeners if a widget has focus.

Definition at line 543 of file focushandler.cpp.

{
    if (mFocusedWidget != nullptr)
    {
        Widget *const focused = mFocusedWidget;
        mFocusedWidget = nullptr;
 
        Event focusEvent(focused);
        distributeFocusLostEvent(focusEvent);
    }
}

References distributeFocusLostEvent(), and mFocusedWidget.

Referenced by ChatWindow::action(), Gui::handleKeyInput(), requestModalFocus(), Widget::setFocusable(), Widget::setVisible(), and Window::widgetHidden().

focusPrevious()

void FocusHandler::focusPrevious

(

)

Focuses the previous widget added to a contaienr. If no widget has focus the first widget gets focus. The order in which the widgets are focused is determined by the order they were added to a container.

See also

focusNext

Definition at line 478 of file focushandler.cpp.

{
    if (mWidgets.empty())
    {
        mFocusedWidget = nullptr;
        return;
    }
 
    int i;
    int focusedWidget = -1;
    const int sz = CAST_S32(mWidgets.size());
    for (i = 0; i < sz; ++ i)
    {
        if (mWidgets[i] == mFocusedWidget)
            focusedWidget = i;
    }
    const int focused = focusedWidget;
 
    // i is a counter that ensures that the following loop
    // won't get stuck in an infinite loop
    i = sz;
    do
    {
        -- focusedWidget;
 
        if (i == 0)
        {
            focusedWidget = -1;
            break;
        }
 
        -- i;
 
        if (focusedWidget <= 0)
            focusedWidget = sz - 1;
 
        if (focusedWidget == focused)
            return;
    }
    while (!mWidgets.at(focusedWidget)->isFocusable());
 
    if (focusedWidget >= 0)
    {
        mFocusedWidget = mWidgets.at(focusedWidget);
        Event focusEvent(mFocusedWidget);
        distributeFocusGainedEvent(focusEvent);
    }
 
    if (focused >= 0)
    {
        Event focusEvent(mWidgets.at(focused));
        distributeFocusLostEvent(focusEvent);
    }
}

References CAST_S32, distributeFocusGainedEvent(), distributeFocusLostEvent(), mFocusedWidget, and mWidgets.

getDraggedWidget()

Widget * FocusHandler::getDraggedWidget

(

)

const

Gets the widget being dragged. Used by the Gui class to keep track of the dragged widget.

Returns

the widget being dragged.

See also

setDraggedWidget

Definition at line 574 of file focushandler.cpp.

{
    return mDraggedWidget;
}

References mDraggedWidget.

Referenced by Gui::handleMouseMoved(), Gui::handleMousePressed(), Gui::handleMouseReleased(), Gui::handleMouseWheelMovedDown(), Gui::handleMouseWheelMovedUp(), and Gui::removeDragged().

getFocused()

Widget * FocusHandler::getFocused

(

)

const

Gets the widget with focus.

Returns

The widget with focus. NULL if no widget has focus.

Definition at line 413 of file focushandler.cpp.

{
    return mFocusedWidget;
}

References mFocusedWidget.

Referenced by Gui::getKeyEventSource(), and Gui::handleKeyInput().

getLastWidgetPressed()

Widget * FocusHandler::getLastWidgetPressed

(

)

const

Gets the last widget pressed. Used by the Gui class to keep track of pressed widgets.

Returns

The last widget pressed.

See also

setLastWidgetPressed

Definition at line 614 of file focushandler.cpp.

{
    return mLastWidgetPressed;
}

References mLastWidgetPressed.

Referenced by Gui::handleMouseReleased().

getLastWidgetWithModalFocus()

Widget * FocusHandler::getLastWidgetWithModalFocus

(

)

const

Gets the last widget with modal focus.

Returns

The last widget with modal focus.

See also

setLastWidgetWithModalFocus

Definition at line 594 of file focushandler.cpp.

{
    return mLastWidgetWithModalFocus;
}

References mLastWidgetWithModalFocus.

Referenced by Gui::handleModalFocus().

getLastWidgetWithModalMouseInputFocus()

Widget * FocusHandler::getLastWidgetWithModalMouseInputFocus

(

)

const

Gets the last widget with modal mouse input focus.

Returns

The last widget with modal mouse input focus.

See also

setLastWidgetWithModalMouseInputFocus

Definition at line 604 of file focushandler.cpp.

{
    return mLastWidgetWithModalMouseInputFocus;
}

References mLastWidgetWithModalMouseInputFocus.

Referenced by Gui::handleModalMouseInputFocus().

getLastWidgetWithMouse()

Widget * FocusHandler::getLastWidgetWithMouse

(

)

const

Gets the last widget with the mouse. Used by the Gui class to keep track the last widget with the mouse.

Returns

The last widget with the mouse.

See also

setLastWidgetWithMouse

Definition at line 584 of file focushandler.cpp.

{
    return mLastWidgetWithMouse;
}

References mLastWidgetWithMouse.

getModalFocused()

Widget * FocusHandler::getModalFocused

(

)

const

Gets the widget with modal focus.

Returns

The widget with modal focus. NULL if no widget has modal focus.

Definition at line 418 of file focushandler.cpp.

{
    return mModalFocusedWidget;
}

References mModalFocusedWidget.

Referenced by Gui::distributeKeyEvent(), Gui::distributeMouseEvent(), Gui::handleModalFocus(), Gui::handleMousePressed(), Widget::isModalFocused(), and InputManager::updateConditionMask().

getModalMouseInputFocused()

Widget * FocusHandler::getModalMouseInputFocused

(

)

const

Gets the widget with modal mouse input focus.

Returns

The widget with modal mouse input focus. NULL if no widget has modal mouse input focus.

Definition at line 423 of file focushandler.cpp.

{
    return mModalMouseInputFocusedWidget;
}

References mModalMouseInputFocusedWidget.

Referenced by Gui::distributeKeyEvent(), Gui::distributeMouseEvent(), Gui::getMouseEventSource(), Gui::handleModalFocusGained(), Gui::handleModalMouseInputFocus(), Gui::handleMouseMoved(), and Widget::isModalMouseInputFocused().

isFocused()

bool FocusHandler::isFocused

(

const Widget *const

widget

)

const

Checks if a widget is focused.

Parameters

widget

The widget to check.

Returns

True if the widget is focused, false otherwise.

See also

Widget::isFocused

Definition at line 533 of file focushandler.cpp.

{
    return mFocusedWidget == widget;
}

References mFocusedWidget.

Referenced by Widget::isFocused(), remove(), and Window::widgetHidden().

releaseModalFocus()

void FocusHandler::releaseModalFocus

(

Widget *const

widget

)

Releases modal focus if the widget has modal focus. If the widget doesn't have modal focus no relase will occur.

Parameters

widget

The widget to release modal focus for.

See also

reuqestModalFocus, Widget::releaseModalFocus

Definition at line 109 of file focushandler.cpp.

{
    mModalStack.remove(widget);
 
    if (mModalFocusedWidget == widget)
    {
        mModalFocusedWidget = nullptr;
 
        /* Check if there were any previously modal widgets that'd still like
         * to regain their modal focus.
         */
        if (!mModalStack.empty())
        {
            requestModalFocus(mModalStack.front());
            mModalStack.pop_front();
        }
    }
}

References mModalFocusedWidget, mModalStack, and requestModalFocus().

Referenced by Widget::releaseModalFocus(), and remove().

releaseModalMouseInputFocus()

void FocusHandler::releaseModalMouseInputFocus

(

const Widget *const

widget

)

Releases modal mouse input focus if the widget has modal mouse input focus. If the widget doesn't have modal mouse input focus no relase will occur.

Parameters

widget

the widget to release modal mouse input focus for.

See also

requestModalMouseInputFocus, Widget::releaseModalMouseInputFocus

Definition at line 407 of file focushandler.cpp.

{
    if (mModalMouseInputFocusedWidget == widget)
        mModalMouseInputFocusedWidget = nullptr;
}

References mModalMouseInputFocusedWidget.

Referenced by Widget::releaseModalMouseInputFocus().

remove()

void FocusHandler::remove

(

Widget *const

widget

)

Removes a widget from the focus handler.

Parameters

widget

The widget to remove.

See also

add

Definition at line 128 of file focushandler.cpp.

{
    releaseModalFocus(widget);
 
    if (isFocused(widget))
        mFocusedWidget = nullptr;
 
    FOR_EACH (WidgetIterator, iter, mWidgets)
    {
        if ((*iter) == widget)
        {
            mWidgets.erase(iter);
            break;
        }
    }
 
    if (mDraggedWidget == widget)
    {
        mDraggedWidget = nullptr;
        return;
    }
 
    if (mLastWidgetWithMouse == widget)
    {
        mLastWidgetWithMouse = nullptr;
        return;
    }
 
    if (mLastWidgetWithModalFocus == widget)
    {
        mLastWidgetWithModalFocus = nullptr;
        return;
    }
 
    if (mLastWidgetWithModalMouseInputFocus == widget)
    {
        mLastWidgetWithModalMouseInputFocus = nullptr;
        return;
    }
 
    if (mLastWidgetPressed == widget)
    {
        mLastWidgetPressed = nullptr;
        return;
    }
}

References FOR_EACH, isFocused(), mDraggedWidget, mFocusedWidget, mLastWidgetPressed, mLastWidgetWithModalFocus, mLastWidgetWithModalMouseInputFocus, mLastWidgetWithMouse, mWidgets, and releaseModalFocus().

Referenced by Widget::setFocusHandler().

requestFocus()

void FocusHandler::requestFocus

(

const Widget *const

widget

)

Requests focus for a widget. Focus will only be granted to a widget if it's focusable and if no other widget has modal focus. If a widget receives focus a focus event will be sent to the focus listeners of the widget.

Parameters

widget

The widget to request focus for.

See also

isFocused, Widget::requestFocus

Definition at line 360 of file focushandler.cpp.

{
    if ((widget == nullptr) || widget == mFocusedWidget)
        return;
 
    int toBeFocusedIndex = -1;
    for (unsigned int i = 0, fsz = CAST_U32(
         mWidgets.size()); i < fsz; ++i)
    {
        if (mWidgets[i] == widget)
        {
            toBeFocusedIndex = i;
            break;
        }
    }
 
    if (toBeFocusedIndex < 0)
        return;
 
    Widget *const oldFocused = mFocusedWidget;
 
    if (oldFocused != widget)
    {
        mFocusedWidget = mWidgets.at(toBeFocusedIndex);
 
        Event focusEvent(mFocusedWidget);
        distributeFocusGainedEvent(focusEvent);
 
        if (oldFocused != nullptr)
        {
            Event oldFocusEvent(oldFocused);
            distributeFocusLostEvent(oldFocusEvent);
        }
    }
}

References CAST_U32, distributeFocusGainedEvent(), distributeFocusLostEvent(), mFocusedWidget, and mWidgets.

Referenced by ListBox::refocus(), and Widget::requestFocus().

requestModalFocus()

void FocusHandler::requestModalFocus

(

Widget *const

widget

)

Requests modal focus for a widget. Focus will only be granted to a widget if it's focusable and if no other widget has modal focus.

Parameters

widget

The widget to request modal focus for.

Exceptions

Exception

when another widget already has modal focus.

See also

releaseModalFocus, Widget::requestModalFocus

Definition at line 93 of file focushandler.cpp.

{
    /* If there is another widget with modal focus, remove its modal focus
     * and put it on the modal widget stack.
     */
    if ((mModalFocusedWidget != nullptr) && mModalFocusedWidget != widget)
    {
        mModalStack.push_front(mModalFocusedWidget);
        mModalFocusedWidget = nullptr;
    }
 
    mModalFocusedWidget = widget;
    if ((mFocusedWidget != nullptr) && !mFocusedWidget->isModalFocused())
        focusNone();
}

References focusNone(), Widget::isModalFocused(), mFocusedWidget, mModalFocusedWidget, and mModalStack.

Referenced by releaseModalFocus(), and Widget::requestModalFocus().

requestModalMouseInputFocus()

void FocusHandler::requestModalMouseInputFocus

(

Widget *const

widget

)

Requests modal mouse input focus for a widget. Focus will only be granted to a widget if it's focusable and if no other widget has modal mouse input focus.

Modal mouse input focus means no other widget then the widget with modal mouse input focus will receive mouse input. The widget with modal mouse input focus will also receive mouse input no matter what the mouse input is or where the mouse input occurs.

Parameters

widget

The widget to focus for modal mouse input focus.

Exceptions

Exception

when another widget already has modal mouse input focus.

See also

releaseModalMouseInputFocus, Widget::requestModalMouseInputFocus

Definition at line 396 of file focushandler.cpp.

{
    if ((mModalMouseInputFocusedWidget != nullptr)
        && mModalMouseInputFocusedWidget != widget)
    {
        return;
    }
 
    mModalMouseInputFocusedWidget = widget;
}

References mModalMouseInputFocusedWidget.

Referenced by Widget::requestModalMouseInputFocus().

setDraggedWidget()

void FocusHandler::setDraggedWidget

(

Widget *const

draggedWidget

)

Sets the widget being dragged. Used by the Gui class to keep track of the dragged widget.

Parameters

draggedWidget

The widget being dragged.

See also

getDraggedWidget

Definition at line 579 of file focushandler.cpp.

{
    mDraggedWidget = draggedWidget;
}

References mDraggedWidget.

Referenced by Gui::handleMousePressed(), Gui::handleMouseReleased(), and Gui::removeDragged().

setLastWidgetPressed()

void FocusHandler::setLastWidgetPressed

(

Widget *const

lastWidgetPressed

)

Sets the last widget pressed. Used by the Gui class to keep track of pressed widgets.

Parameters

lastWidgetPressed

The last widget pressed.

See also

getLastWidgetPressed

Definition at line 619 of file focushandler.cpp.

{
    mLastWidgetPressed = lastWidgetPressed;
}

References mLastWidgetPressed.

Referenced by Gui::handleMousePressed(), and Gui::handleMouseReleased().

setLastWidgetWithModalFocus()

void FocusHandler::setLastWidgetWithModalFocus

(

Widget *const

widget

)

Sets the last widget with modal focus.

Parameters

widget

The last widget with modal focus.

See also

getLastWidgetWithModalFocus

Definition at line 599 of file focushandler.cpp.

{
    mLastWidgetWithModalFocus = widget;
}

References mLastWidgetWithModalFocus.

Referenced by Gui::handleModalFocus().

setLastWidgetWithModalMouseInputFocus()

void FocusHandler::setLastWidgetWithModalMouseInputFocus

(

Widget *const

widget

)

Sets the last widget with modal mouse input focus.

Parameters

widget

The last widget with modal mouse input focus.

See also

getLastWidgetWithModalMouseInputFocus

Definition at line 609 of file focushandler.cpp.

{
    mLastWidgetWithModalMouseInputFocus = widget;
}

References mLastWidgetWithModalMouseInputFocus.

Referenced by Gui::handleModalFocusGained(), and Gui::handleModalMouseInputFocus().

setLastWidgetWithMouse()

void FocusHandler::setLastWidgetWithMouse

(

Widget *const

lastWidgetWithMouse

)

Sets the last widget with the mouse. Used by the Gui class to keep track the last widget with the mouse.

Parameters

lastWidgetWithMouse

The last widget with the mouse.

See also

getLastWidgetWithMouse

Definition at line 589 of file focushandler.cpp.

{
    mLastWidgetWithMouse = lastWidgetWithMouse;
}

References mLastWidgetWithMouse.

tabNext()

void FocusHandler::tabNext

(

)

Focuses the next widget which allows tabbing in unless the current focused Widget disallows tabbing out.

See also

tabPrevious

Definition at line 175 of file focushandler.cpp.

{
    if (mFocusedWidget != nullptr)
    {
        if (!mFocusedWidget->isTabOutEnabled())
            return;
    }
 
    if (mWidgets.empty())
    {
        mFocusedWidget = nullptr;
        return;
    }
 
    int i;
    int focusedWidget = -1;
    const int sz = CAST_S32(mWidgets.size());
    for (i = 0; i < sz; ++ i)
    {
        if (mWidgets[i] == mFocusedWidget)
            focusedWidget = i;
    }
    const int focused = focusedWidget;
    bool done = false;
 
    // i is a counter that ensures that the following loop
    // won't get stuck in an infinite loop
    i = sz;
    do
    {
        ++ focusedWidget;
 
        if (i == 0)
        {
            focusedWidget = -1;
            break;
        }
 
        -- i;
 
        if (focusedWidget >= sz)
            focusedWidget = 0;
 
        if (focusedWidget == focused)
            return;
 
        const Widget *const widget = mWidgets.at(focusedWidget);
        if (widget->isFocusable() && widget->isTabInEnabled() &&
            ((mModalFocusedWidget == nullptr) || widget->isModalFocused()))
        {
            done = true;
        }
    }
    while (!done);
 
    if (focusedWidget >= 0)
    {
        mFocusedWidget = mWidgets.at(focusedWidget);
        Event focusEvent(mFocusedWidget);
        distributeFocusGainedEvent(focusEvent);
    }
 
    if (focused >= 0)
    {
        Event focusEvent(mWidgets.at(focused));
        distributeFocusLostEvent(focusEvent);
    }
 
    checkForWindow();
}

References CAST_S32, checkForWindow(), distributeFocusGainedEvent(), distributeFocusLostEvent(), Widget::isFocusable(), Widget::isModalFocused(), Widget::isTabInEnabled(), Widget::isTabOutEnabled(), mFocusedWidget, mModalFocusedWidget, and mWidgets.

Referenced by Gui::handleKeyInput().

tabPrevious()

void FocusHandler::tabPrevious

(

)

Focuses the previous widget which allows tabbing in unless current focused widget disallows tabbing out.

See also

tabNext

Definition at line 246 of file focushandler.cpp.

{
    if (mFocusedWidget != nullptr)
    {
        if (!mFocusedWidget->isTabOutEnabled())
            return;
    }
 
    if (mWidgets.empty())
    {
        mFocusedWidget = nullptr;
        return;
    }
 
    int i;
    int focusedWidget = -1;
    const int sz = CAST_S32(mWidgets.size());
    for (i = 0; i < sz; ++ i)
    {
        if (mWidgets[i] == mFocusedWidget)
            focusedWidget = i;
    }
    const int focused = focusedWidget;
    bool done = false;
 
    // i is a counter that ensures that the following loop
    // won't get stuck in an infinite loop
    i = sz;
    do
    {
        -- focusedWidget;
 
        if (i == 0)
        {
            focusedWidget = -1;
            break;
        }
 
        -- i;
 
        if (focusedWidget <= 0)
            focusedWidget = sz - 1;
 
        if (focusedWidget == focused)
            return;
 
        const Widget *const widget = mWidgets.at(focusedWidget);
        if (widget->isFocusable() && widget->isTabInEnabled() &&
            ((mModalFocusedWidget == nullptr) || widget->isModalFocused()))
        {
            done = true;
        }
    }
    while (!done);
 
    if (focusedWidget >= 0)
    {
        mFocusedWidget = mWidgets.at(focusedWidget);
        Event focusEvent(mFocusedWidget);
        distributeFocusGainedEvent(focusEvent);
    }
 
    if (focused >= 0)
    {
        Event focusEvent(mWidgets.at(focused));
        distributeFocusLostEvent(focusEvent);
    }
 
    checkForWindow();
}

References CAST_S32, checkForWindow(), distributeFocusGainedEvent(), distributeFocusLostEvent(), Widget::isFocusable(), Widget::isModalFocused(), Widget::isTabInEnabled(), Widget::isTabOutEnabled(), mFocusedWidget, mModalFocusedWidget, and mWidgets.

Referenced by Gui::handleKeyInput().

Field Documentation

mDraggedWidget

Widget* FocusHandler::mDraggedWidget

private

Holds the dragged widget. NULL if no widget is being dragged.

Definition at line 383 of file focushandler.h.

Referenced by getDraggedWidget(), remove(), and setDraggedWidget().

mFocusedWidget

Widget* FocusHandler::mFocusedWidget

private

Holds the focused widget. NULL if no widget has focus.

Definition at line 365 of file focushandler.h.

Referenced by checkForWindow(), focusNext(), focusNone(), focusPrevious(), getFocused(), isFocused(), remove(), requestFocus(), requestModalFocus(), tabNext(), and tabPrevious().

mLastWidgetPressed

Widget* FocusHandler::mLastWidgetPressed

private

Holds the last widget pressed.

Definition at line 403 of file focushandler.h.

Referenced by getLastWidgetPressed(), remove(), and setLastWidgetPressed().

mLastWidgetWithModalFocus

Widget* FocusHandler::mLastWidgetWithModalFocus

private

Holds the last widget with modal focus.

Definition at line 393 of file focushandler.h.

Referenced by getLastWidgetWithModalFocus(), remove(), and setLastWidgetWithModalFocus().

mLastWidgetWithModalMouseInputFocus

Widget* FocusHandler::mLastWidgetWithModalMouseInputFocus

private

Holds the last widget with modal mouse input focus.

Definition at line 398 of file focushandler.h.

Referenced by getLastWidgetWithModalMouseInputFocus(), remove(), and setLastWidgetWithModalMouseInputFocus().

mLastWidgetWithMouse

Widget* FocusHandler::mLastWidgetWithMouse

private

Holds the last widget with the mouse.

Definition at line 388 of file focushandler.h.

Referenced by getLastWidgetWithMouse(), remove(), and setLastWidgetWithMouse().

mModalFocusedWidget

Widget* FocusHandler::mModalFocusedWidget

private

Holds the modal focused widget. NULL if no widget has modal focused.

Definition at line 371 of file focushandler.h.

Referenced by getModalFocused(), releaseModalFocus(), requestModalFocus(), tabNext(), and tabPrevious().

mModalMouseInputFocusedWidget

Widget* FocusHandler::mModalMouseInputFocusedWidget

private

Holds the modal mouse input focused widget. NULL if no widget is being dragged.

Definition at line 377 of file focushandler.h.

Referenced by getModalMouseInputFocused(), releaseModalMouseInputFocus(), and requestModalMouseInputFocus().

mModalStack

std::list<Widget*> FocusHandler::mModalStack

private

Stack of widgets that have requested modal forcus.

Definition at line 408 of file focushandler.h.

Referenced by releaseModalFocus(), and requestModalFocus().

mWidgets

WidgetVector FocusHandler::mWidgets

private

Holds the widgets currently being handled by the focus handler.

Definition at line 360 of file focushandler.h.

Referenced by add(), focusNext(), focusPrevious(), remove(), requestFocus(), tabNext(), and tabPrevious().

---

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

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