DropDown Class Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/Widgets/DropDown.hpp>

Inheritance diagram for DropDown:

Collaboration diagram for DropDown:

Classes
struct	Item

Public Member Functions
	DropDown (std::vector< Item > &items)
	DropDown (wxWindow *parent, std::vector< Item > &items, long style=0)
void	Create (wxWindow *parent, long style=0)
void	Invalidate (bool clear=false)
int	GetSelection () const
void	SetSelection (int n)
wxString	GetValue () const
void	SetValue (const wxString &value)
void	SetCornerRadius (double radius)
void	SetBorderColor (StateColor const &color)
void	SetSelectorBorderColor (StateColor const &color)
void	SetTextColor (StateColor const &color)
void	SetSelectorBackgroundColor (StateColor const &color)
void	SetUseContentWidth (bool use, bool limit_max_content_width=false)
void	SetAlignIcon (bool align)
void	Rescale ()
bool	HasDismissLongTime ()
void	Popup (wxWindow *focus=nullptr) override
bool	Create (wxWindow *parent, int flags=wxBORDER_NONE)

Protected Member Functions
void	Dismiss () override
void	OnDismiss () override
bool	ShouldDismissOnTopWindowDeactivate () override

Private Member Functions
void	paintEvent (wxPaintEvent &evt)
void	paintNow ()
void	render (wxDC &dc)
int	hoverIndex ()
int	selectedItem ()
std::pair< int, int >	actionColumn () const
void	messureSize ()
void	autoPosition ()
void	mouseDown (wxMouseEvent &event)
void	mouseReleased (wxMouseEvent &event)
void	mouseCaptureLost (wxMouseCaptureLostEvent &event)
void	mouseMove (wxMouseEvent &event)
void	mouseWheelMoved (wxMouseEvent &event)
void	sendDropDownEvent ()
void	sendDropDownActionEvent (int index)

Private Attributes
std::vector< Item > &	items
size_t	count = 0
wxString	group
bool	need_sync = false
int	selection = -1
int	hover_item = -1
DropDown *	subDropDown { nullptr }
DropDown *	mainDropDown { nullptr }
double	radius = 0
bool	use_content_width = false
bool	limit_max_content_width = false
bool	align_icon = false
bool	text_off = false
wxSize	textSize
wxSize	iconSize
int	actionIconWidth = 0
wxSize	rowSize
StateHandler	state_handler
StateColor	text_color
StateColor	border_color
StateColor	selector_border_color
StateColor	selector_background_color
ScalableBitmap	check_bitmap
ScalableBitmap	arrow_bitmap
bool	pressedDown = false
boost::posix_time::ptime	dismissTime
wxPoint	offset
wxPoint	dragStart

Friends
class	ComboBox

Detailed Description

---

Class Documentation

DropDown::Item

struct DropDown::Item

Class Members
wxBitmap	action_icon
wxString	alias {}
void *	data {nullptr}
int	flag {0}
wxString	group_key {}
wxString	group_label {}
wxBitmap	icon
wxBitmap	icon_textctrl
int	style { 0 }
wxString	text
wxString	text_static_tips
wxString	tip {}

Constructor & Destructor Documentation

DropDown() [1/2]

DropDown::DropDown

(

std::vector< Item > &

items

)

    : items(items)
    , state_handler(this)
    , border_color(0xDBDBDB)
    , text_color(std::make_pair(0x909090, (int) StateColor::Disabled),
        std::make_pair(0x363636, (int) StateColor::Normal))
    , selector_border_color(std::make_pair(0x009688, (int) StateColor::Hovered),
        std::make_pair(*wxWHITE, (int) StateColor::Normal))
    , selector_background_color(std::make_pair(0xBFE1DE, (int) StateColor::Checked), // ORCA updated background color for checked item
        std::make_pair(*wxWHITE, (int) StateColor::Normal))
{
}

References DropDown(), border_color, items, selector_background_color, selector_border_color, state_handler, and text_color.

Referenced by DropDown(), DropDown(), and messureSize().

Here is the call graph for this function:

Here is the caller graph for this function:

DropDown() [2/2]

DropDown::DropDown	(	wxWindow *	parent,
		std::vector< Item > &	items,
		long	style = 0 )

    : DropDown(items)
{
    Create(parent, style);
}

References DropDown(), Create(), items, and style.

Here is the call graph for this function:

Member Function Documentation

actionColumn()

std::pair< int, int > DropDown::actionColumn ( ) const

private

{
    if (actionIconWidth <= 0)
        return {0, 0};
    int right = rowSize.x;
    if (rowSize.y * count > GetSize().y) // position bar
        right -= 6;
    return {right - actionIconWidth - FromDIP(16), right};
}

References actionIconWidth, count, and rowSize.

Referenced by mouseReleased(), and render().

Here is the caller graph for this function:

autoPosition()

void DropDown::autoPosition ( )

private

{
    messureSize();
    wxPoint pos;
    wxSize  off;
    if (mainDropDown) {
        pos = mainDropDown->ClientToScreen(wxPoint(0, 0));
        off = mainDropDown->GetSize();
        pos.x += 6;
        pos.y += mainDropDown->hover_item * rowSize.y + rowSize.y + mainDropDown->offset.y;
        off.x -= 12;
        off.y = -rowSize.y;
    } else {
        pos = GetParent()->ClientToScreen(wxPoint(0, 0));
        off = GetParent()->GetSize();
        pos.y -= 6;
        off.x = 0;
        off.y += 12;
    }
    wxPoint old = GetPosition();
    wxSize size = GetSize();
    Position(pos, off);
    if (old != GetPosition()) {
        size = rowSize;
        size.y *= std::min((size_t) 15, count);
        size.y += count > 15 ? rowSize.y / 2 : 0;
        if (size != GetSize()) {
            wxWindow::SetSize(size);
            offset = wxPoint();
            Position(pos, off);
        }
    }
    if (GetPosition().y > pos.y) {
        // may exceed
        auto drect = wxDisplay(GetParent()).GetGeometry();
        if (GetPosition().y + size.y + 10 > drect.GetBottom()) {
            int available_height = drect.GetBottom() - GetPosition().y - 10;
            if (available_height < rowSize.y * 2)
                return;
            if (use_content_width && count <= 15) size.x += 6;
            size.y = available_height;
            wxWindow::SetSize(size);
            if (selection >= 0) {
                if (offset.y + rowSize.y * (selection + 1) > size.y)
                    offset.y = size.y - rowSize.y * (selection + 1);
                else if (offset.y + rowSize.y * selection < 0)
                    offset.y = -rowSize.y * selection;
            }
        }
    }
}

References count, mainDropDown, messureSize(), offset, rowSize, selection, and use_content_width.

Here is the call graph for this function:

Create() [1/2]

void DropDown::Create	(	wxWindow *	parent,
		long	style = 0 )

{
    PopupWindow::Create(parent, wxPU_CONTAINS_CONTROLS);
    SetBackgroundStyle(wxBG_STYLE_PAINT);
    SetBackgroundColour(*wxWHITE);
    state_handler.attach({&border_color, &text_color, &selector_border_color, &selector_background_color});
    state_handler.update_binds();
    if ((style & DD_NO_CHECK_ICON) == 0)
        check_bitmap = ScalableBitmap(this, "checked", 16);
    arrow_bitmap = ScalableBitmap(this, "hms_arrow", 16);
    text_off = style & DD_NO_TEXT;
 
    // BBS set default font
    SetFont(Label::Body_14);
#ifdef __WXOSX__
    // PopupWindow releases mouse on idle, which may cause various problems,
    //  such as losting mouse move, and dismissing soon on first LEFT_DOWN event.
    Bind(wxEVT_IDLE, [] (wxIdleEvent & evt) {});
#endif
}

References arrow_bitmap, Label::Body_14, border_color, check_bitmap, PopupWindow::Create(), DD_NO_CHECK_ICON, DD_NO_TEXT, selector_background_color, selector_border_color, state_handler, style, text_color, and text_off.

Referenced by DropDown().

Here is the call graph for this function:

Here is the caller graph for this function:

Create() [2/2]

bool PopupWindow::Create ( wxWindow * parent, int flags = wxBORDER_NONE )

inherited

{
    if (!wxPopupTransientWindow::Create(parent, style))
        return false;
#ifdef __WXGTK__
    GetTopParent(parent)->Bind(wxEVT_ACTIVATE, &PopupWindow::topWindowActiavate, this);
#endif
#ifdef __WXOSX__
    if (style & wxPU_CONTAINS_CONTROLS)
    for (auto evt : {wxEVT_LEFT_DOWN, wxEVT_LEFT_UP, wxEVT_LEFT_DCLICK, wxEVT_MOTION, wxEVT_MOUSEWHEEL})
        Bind(evt, &PopupWindow::OnMouseEvent2, this);
#endif
    return true;
}

References GetTopParent(), and style.

Referenced by PopupWindow(), and DropDown::Create().

Here is the call graph for this function:

Here is the caller graph for this function:

Dismiss()

void DropDown::Dismiss ( )

overrideprotected

{
    if (subDropDown && subDropDown->IsShown())
        return;
    PopupWindow::Dismiss();
}

References subDropDown.

GetSelection()

int DropDown::GetSelection ( ) const

inline

{ return selection; }

References selection.

GetValue()

wxString DropDown::GetValue

(

)

const

{
    return selection >= 0 ? items[selection].text : wxString();
}

References items, and selection.

HasDismissLongTime()

bool DropDown::HasDismissLongTime

(

)

{
    auto now = boost::posix_time::microsec_clock::universal_time();
    return !IsShown() &&
        (now - dismissTime).total_milliseconds() >= 20;
}

References dismissTime.

hoverIndex()

int DropDown::hoverIndex ( )

private

{
    if (hover_item < 0)
        return -1;
    // BUG FIX: Can't take the shortcut if subDropDown exists (which means there are groups)
    // because we need to detect group headers which return negative indices
    if (count == items.size() && subDropDown == nullptr)
        return hover_item;
    int index = -1;
    std::set<wxString> groups;
    for (int i = 0; i < items.size(); ++i) {
        auto &item = items[i];
        // Skip by group
        if (group.IsEmpty()) {
            if (!item.group_key.IsEmpty()) {
                if (groups.find(item.group_key) == groups.end())
                    groups.insert(item.group_key);
                else
                    continue;
            }
        } else {
            if (item.group_key != group)
                continue;
        }
        if (++index == hover_item)
            return (item.group_key.IsEmpty() || !group.IsEmpty()) ? i : -i - 2;
    }
    return -1;
}

References count, group, hover_item, items, and subDropDown.

Referenced by mouseMove(), mouseReleased(), mouseWheelMoved(), render(), and sendDropDownEvent().

Here is the caller graph for this function:

Invalidate()

void DropDown::Invalidate

(

bool

clear = false

)

{
    if (clear) {
        selection = hover_item = -1;
        offset = wxPoint();
    }
    assert(selection < (int) items.size());
    need_sync = true;
}

References hover_item, items, need_sync, offset, and selection.

messureSize()

void DropDown::messureSize ( )

private

{
    if (!need_sync) return;
    textSize = wxSize();
    iconSize = wxSize();
    actionIconWidth = 0;
    count = 0;
    wxClientDC dc(GetParent() ? GetParent() : this);
    dc.SetFont(GetFont());
    std::set<wxString> groups;
    for (size_t i = 0; i < items.size(); ++i) {
        auto &item = items[i];
        // Skip by group
        if (group.IsEmpty()) {
            if (!item.group_key.IsEmpty()) {
                if (groups.find(item.group_key) == groups.end())
                    groups.insert(item.group_key);
                else
                    continue;
            }
        } else {
            if (item.group_key != group)
                continue;
        }
        ++count;
        wxSize size1;
        if (!text_off) {
            auto text = group.IsEmpty()
                        ? (item.group_key.IsEmpty() ? item.text : item.group_label)
                        : item.text;
            size1 = dc.GetMultiLineTextExtent(text);
            if (group.IsEmpty() && !item.group_key.IsEmpty())
                size1.x += 5 + arrow_bitmap.GetBmpWidth();
        }
        if (item.icon.IsOk()) {
            wxSize size2 = GetBmpSize(item.icon);
            if (size2.x > iconSize.x)
                iconSize = size2;
            if (!align_icon) {
                size1.x += size2.x + (text_off ? 0 : 5);
            }
        }
        if (item.action_icon.IsOk())
            actionIconWidth = std::max(actionIconWidth, GetBmpSize(item.action_icon).x);
        if (size1.x > textSize.x) textSize = size1;
    }
    // Every row leaves room for the action column, as render() and actionColumn() lay it out.
    if (actionIconWidth > 0)
        textSize.x += actionIconWidth + FromDIP(16);
    if (!align_icon) iconSize.x = 0;
    wxSize szContent = textSize;
    if (szContent.x < FromDIP(120) && !use_content_width)
        szContent.x = FromDIP(120);
    szContent.x += 10;
    if (check_bitmap.bmp().IsOk()) {
        auto szBmp = check_bitmap.GetBmpSize();
        szContent.x += szBmp.x + 5;
    }
    if (iconSize.x > 0) szContent.x += iconSize.x + (text_off ? 0 : 5);
    if (iconSize.y > szContent.y) szContent.y = iconSize.y;
    szContent.y += 10;
    if (count > 15) szContent.x += 6;
    if (GetParent() && group.IsEmpty()) {
        auto x = GetParent()->GetSize().x;
        if (x > 0 && (!use_content_width || x > szContent.x))
            szContent.x = x;
    }
    rowSize = szContent;
    if (limit_max_content_width) {
        wxSize parent_size = GetParent()->GetSize();
        if (rowSize.x > parent_size.x * 2) {
            rowSize.x = 2 * parent_size.x;
            szContent = rowSize;
        }
    }
    szContent.y *= std::min((size_t) 15, std::max(count, (size_t) 1));
    szContent.y += items.size() > 15 ? rowSize.y / 2 : 0;
    wxWindow::SetSize(szContent);
#ifdef __WXGTK__
    // Gtk has a wrapper window for popup widget
    if (szContent.x > 0 && szContent.y > 0)
        gtk_window_resize (GTK_WINDOW (m_widget), szContent.x, szContent.y);
#endif
    if (!groups.empty() && subDropDown == nullptr) {
        subDropDown = new DropDown(items);
        subDropDown->mainDropDown = this;
        subDropDown->check_bitmap      = check_bitmap;
        subDropDown->text_off          = text_off;
        subDropDown->use_content_width = true;
        subDropDown->Create(GetParent());
#ifdef __WXGTK__
        // Orca: On Wayland, while the sub holds an xdg_popup grab, motion events for
        // the cursor over main may not be delivered (Mutter drops motion
        // outside the grabbing surface). Poll on idle and synthesize a
        // mouseMove on main so its hover highlight tracks and it can dismiss
        // the sub when the cursor leaves the parent (group) item.
        DropDown* sub = subDropDown;
        sub->Bind(wxEVT_IDLE, [sub](wxIdleEvent& e) {
            e.Skip();
            if (!sub->IsShown() || !sub->mainDropDown->IsShown())
                return;
            wxPoint screen_pt = wxGetMousePosition();
            if (sub->GetScreenRect().Contains(screen_pt) || !sub->mainDropDown->GetScreenRect().Contains(screen_pt))
                return;
            wxPoint main_pt = sub->mainDropDown->ScreenToClient(screen_pt);
            wxMouseEvent ev(wxEVT_MOTION);
            ev.SetEventObject(sub->mainDropDown);
            ev.m_x = main_pt.x;
            ev.m_y = main_pt.y;
            sub->mainDropDown->mouseMove(ev);
            e.RequestMore();
        });
        // Orca: the submenu holds the GTK grab, so GTK gives it the wheel events of the whole
        // chain. GDK names the window under the cursor, so re-emit main's events on main.
        g_signal_connect(sub->m_widget, "event", G_CALLBACK(+[](GtkWidget *, GdkEvent *event, gpointer data) -> gboolean {
            auto *sub = static_cast<DropDown *>(data);
            DropDown *main = sub->mainDropDown;
            if (event->type != GDK_SCROLL || !main || !main->IsShown() || !sub->IsShown())
                return FALSE;
            gpointer owner = nullptr;
            if (event->any.window)
                gdk_window_get_user_data(event->any.window, &owner);
            GtkWidget *widget   = (owner && GTK_IS_WIDGET(owner)) ? GTK_WIDGET(owner) : nullptr;
            bool       for_main = widget && (widget == main->m_widget || gtk_widget_is_ancestor(widget, main->m_widget));
            bool       for_sub  = widget && (widget == sub->m_widget || gtk_widget_is_ancestor(widget, sub->m_widget));
            if (!for_main && for_sub) {
                // The compositor may keep the pointer focus on the submenu while the cursor is over main.
                wxPoint pt((int) event->scroll.x, (int) event->scroll.y);
                if (sub->GetClientRect().Contains(pt))
                    return FALSE;
                wxPoint off = sub->GetScreenRect().GetTopLeft() - main->GetScreenRect().GetTopLeft();
                event->scroll.x += off.x;
                event->scroll.y += off.y;
                for_main = true;
            }
            if (!for_main)
                return FALSE;
            // wx connects its mouse handlers to GetConnectWidget(), the inner widget of the popup.
            gtk_propagate_event(main->GetConnectWidget(), event);
            return TRUE;
        }), sub);
#endif
        subDropDown->Bind(wxEVT_COMBOBOX, [this](wxCommandEvent &e) {
            e.SetEventObject(this);
            e.SetId(GetId());
            GetEventHandler()->ProcessEvent(e);
        });
        subDropDown->Bind(EVT_DROPDOWN_ITEM_ACTION, [this](wxCommandEvent &e) {
            e.SetEventObject(this);
            e.SetId(GetId());
            GetEventHandler()->ProcessEvent(e);
        });
    }
    need_sync = false;
}

References DropDown(), actionIconWidth, align_icon, arrow_bitmap, check_bitmap, count, GetBmpSize(), group, iconSize, items, limit_max_content_width, main(), mainDropDown, mouseMove(), need_sync, rowSize, subDropDown, text_off, textSize, and use_content_width.

Referenced by autoPosition(), SetSelection(), and SetUseContentWidth().

Here is the call graph for this function:

Here is the caller graph for this function:

mouseCaptureLost()

void DropDown::mouseCaptureLost ( wxMouseCaptureLostEvent & event )

private

{
    wxMouseEvent evt;
    mouseReleased(evt);
}

References mouseReleased().

Referenced by wxDEFINE_EVENT().

Here is the call graph for this function:

Here is the caller graph for this function:

mouseDown()

void DropDown::mouseDown ( wxMouseEvent & event )

private

{
    // Receivce unexcepted LEFT_DOWN on Mac after OnDismiss
    if (!IsShown())
        return;
    // force calc hover item again
    mouseMove(event);
    pressedDown = true;
    CaptureMouse();
    dragStart   = event.GetPosition();
}

References dragStart, mouseMove(), and pressedDown.

Referenced by wxDEFINE_EVENT().

Here is the call graph for this function:

Here is the caller graph for this function:

mouseMove()

void DropDown::mouseMove ( wxMouseEvent & event )

private

{
    wxPoint pt  = event.GetPosition();
#ifdef __WXOSX__
    if (mainDropDown) {
        auto size = GetSize();
        if (pt.x < 0 || pt.y < 0 || pt.x >= size.x || pt.y >= size.y) {
            auto diff = GetPosition() - mainDropDown->GetPosition();
            event.SetX(pt.x + diff.x);
            event.SetY(pt.y + diff.y);
            mainDropDown->mouseMove(event);
            return;
        }
    }
#endif
    if (pressedDown) {
        wxPoint pt2 = offset + pt - dragStart;
        wxSize  size = GetSize();
        dragStart    = pt;
        if (pt2.y > 0)
            pt2.y = 0;
        else if (pt2.y + rowSize.y * int(count) < size.y)
            pt2.y = size.y - rowSize.y * int(count);
        if (pt2.y != offset.y) {
            offset = pt2;
            hover_item = -1; // moved
        } else {
            return;
        }
    }
    if (!pressedDown || hover_item >= 0) {
        int hover = (pt.y - offset.y) / rowSize.y;
        if (hover >= (int) count) hover = -1;
        if (hover == hover_item) return;
        hover_item = hover;
        int index  = hoverIndex();
        if (index < -1) {
            auto & drop = *subDropDown;
            drop.group  = items[-index - 2].group_key;
            drop.need_sync = true;
            drop.messureSize();
#ifdef __WXGTK__
            // wxGTK wraps popup contents in a native GtkWindow. Make the submenu
            // transient for the currently mapped parent popup window before
            // positioning/showing it, so wlroots/Hyprland sees the topmost parent.
            if (m_widget && drop.m_widget)
                gtk_window_set_transient_for(GTK_WINDOW(drop.m_widget), GTK_WINDOW(m_widget));
#endif
            drop.autoPosition();
            drop.paintNow();
            if (!drop.IsShown())
                drop.Popup(&drop);
        } else if (index >= 0) {
            if (subDropDown) {
                subDropDown->group.clear();
                if (subDropDown->IsShown())
                    subDropDown->Dismiss();
            }
            SetToolTip(items[index].tip);
        }
    }
    paintNow();
}

References count, dragStart, hover_item, hoverIndex(), items, mainDropDown, offset, paintNow(), pressedDown, rowSize, and subDropDown.

Referenced by messureSize(), mouseDown(), and wxDEFINE_EVENT().

Here is the call graph for this function:

Here is the caller graph for this function:

mouseReleased()

void DropDown::mouseReleased ( wxMouseEvent & event )

private

{
    if (pressedDown) {
        dragStart = wxPoint();
        pressedDown = false;
        if (HasCapture())
            ReleaseMouse();
        if (hover_item < 0)
            return;
        if (hover_item >= 0 && (subDropDown == nullptr || subDropDown->group.empty())) { // not moved
            int index = hoverIndex();
            if (index >= 0 && items[index].action_icon.IsOk()) {
                const auto action_column = actionColumn();
                if (event.GetX() >= action_column.first && event.GetX() < action_column.second) {
                    sendDropDownActionEvent(index);
                    paintNow();
                    return;
                }
            }
            sendDropDownEvent();
            if (mainDropDown)
                mainDropDown->hover_item = -1; // To Dismiss mainDropDown
            DismissAndNotify();
        } else if (subDropDown)
            subDropDown->Popup(subDropDown);
    }
}

References actionColumn(), dragStart, hover_item, hoverIndex(), items, mainDropDown, paintNow(), pressedDown, sendDropDownActionEvent(), sendDropDownEvent(), and subDropDown.

Referenced by mouseCaptureLost(), and wxDEFINE_EVENT().

Here is the call graph for this function:

Here is the caller graph for this function:

mouseWheelMoved()

void DropDown::mouseWheelMoved ( wxMouseEvent & event )

private

{
    auto delta = event.GetWheelRotation();
    wxSize  size  = GetSize();
    wxPoint pt2   = offset + wxPoint{0, delta};
    if (pt2.y > 0)
        pt2.y = 0;
    else if (pt2.y + rowSize.y * int(count) < size.y)
        pt2.y = size.y - rowSize.y * int(count);
    if (pt2.y != offset.y) {
        offset = pt2;
    } else {
        return;
    }
    int hover = (event.GetPosition().y - offset.y) / rowSize.y;
    if (hover >= (int) count) hover = -1;
    if (hover != hover_item) {
        hover_item = hover;
        if (auto index = hoverIndex(); index >= 0)
            SetToolTip(items[index].tip);
    }
    paintNow();
}

References count, hover_item, hoverIndex(), items, offset, paintNow(), and rowSize.

Referenced by wxDEFINE_EVENT().

Here is the call graph for this function:

Here is the caller graph for this function:

OnDismiss()

void DropDown::OnDismiss ( )

overrideprotected

{
    if (mainDropDown) {
 
        const wxPoint& mouse_pos = wxGetMousePosition();
        if (!mainDropDown->GetScreenRect().Contains(mouse_pos))
            mainDropDown->DismissAndNotify();
        else
#ifdef __WIN32__
            SetActiveWindow(mainDropDown->GetHandle());
#else
            ;
#endif
        return;
    }
    if (subDropDown && subDropDown->IsShown())
        return;
    dismissTime = boost::posix_time::microsec_clock::universal_time();
    hover_item  = -1;
    wxCommandEvent e(EVT_DISMISS);
    GetEventHandler()->ProcessEvent(e);
}

References dismissTime, hover_item, mainDropDown, and subDropDown.

paintEvent()

void DropDown::paintEvent ( wxPaintEvent & evt )

private

{
    // depending on your system you may need to look at double-buffered dcs
    wxBufferedPaintDC dc(this);
    render(dc);
}

References render().

Referenced by wxDEFINE_EVENT().

Here is the call graph for this function:

Here is the caller graph for this function:

paintNow()

void DropDown::paintNow ( )

private

{
    // depending on your system you may need to look at double-buffered dcs
    //wxClientDC dc(this);
    //render(dc);
    Refresh();
}

Referenced by mouseMove(), mouseReleased(), mouseWheelMoved(), SetBorderColor(), SetCornerRadius(), SetSelection(), SetSelectorBackgroundColor(), SetSelectorBorderColor(), and SetTextColor().

Here is the caller graph for this function:

Popup()

void DropDown::Popup ( wxWindow * focus = nullptr )

override

{
#ifdef __WXGTK__
    if (!mainDropDown && m_widget) {
        // Data-view cell editors can receive focus before wxGTK infers a
        // native popup parent, so provide the current toplevel explicitly.
        GtkWindow *transient_parent = nullptr;
        for (wxWindow *win = GetParent(); win; win = win->GetParent()) {
            GtkWidget *widget = static_cast<GtkWidget *>(win->GetHandle());
            if (!widget)
                continue;
            GtkWidget *top = gtk_widget_get_toplevel(widget);
            if (GTK_IS_WINDOW(top)) {
                transient_parent = GTK_WINDOW(top);
                break;
            }
        }
        if (transient_parent)
            gtk_window_set_transient_for(GTK_WINDOW(m_widget), transient_parent);
    }
#endif
    PopupWindow::Popup(focus);
}

References mainDropDown.

render()

void DropDown::render ( wxDC & dc )

private

{
    if (items.size() == 0) return;
    int states = state_handler.states();
    if (subDropDown)
        states |= subDropDown->state_handler.states();
    dc.SetPen(wxPen(border_color.colorForStates(states)));
    dc.SetBrush(wxBrush(StateColor::darkModeColorFor(GetBackgroundColour())));
    // if (GetWindowStyle() & wxBORDER_NONE)
    //    dc.SetPen(wxNullPen);
 
    // draw background
    wxSize size = GetSize();
    if (radius == 0)
        dc.DrawRectangle(0, 0, size.x, size.y);
    else
        dc.DrawRoundedRectangle(0, 0, size.x, size.y, radius);
 
    int selected_item = selectedItem();
    int hover_index   = hoverIndex();
 
    // draw hover rectangle
    wxRect rcContent = {{0, offset.y}, rowSize};
    if (hover_item >= 0 && (states & StateColor::Hovered) && (hover_index < 0 || !(items[hover_index].style & DD_ITEM_STYLE_SPLIT_ITEM))) {
        rcContent.y += rowSize.y * hover_item;
        if (rcContent.GetBottom() > 0 && rcContent.y < size.y) {
            if (selected_item == hover_item)
                dc.SetBrush(wxBrush(selector_background_color.colorForStates(states | StateColor::Checked)));
            dc.SetPen(wxPen(selector_border_color.colorForStates(states)));
            rcContent.Deflate(4, 1);
            dc.DrawRectangle(rcContent);
            rcContent.Inflate(4, 1);
        }
        rcContent.y = offset.y;
    }
    // draw checked rectangle
    if (selected_item >= 0 && (selected_item != hover_item || (states & StateColor::Hovered) == 0)) {
        rcContent.y += rowSize.y * selected_item;
        if (rcContent.GetBottom() > 0 && rcContent.y < size.y) {
            dc.SetBrush(wxBrush(selector_background_color.colorForStates(states | StateColor::Checked)));
            dc.SetPen(wxPen(selector_background_color.colorForStates(states)));
            rcContent.Deflate(4, 1);
            dc.DrawRectangle(rcContent);
            rcContent.Inflate(4, 1);
        }
        rcContent.y = offset.y;
    }
    dc.SetBrush(*wxTRANSPARENT_BRUSH);
    {
        wxSize offset = (rowSize - textSize) / 2;
        rcContent.Deflate(0, offset.y);
    }
 
    // draw position bar
    if (rowSize.y * count > size.y) {
        int    height = rowSize.y * count;
        wxRect rect = {size.x - 6, -offset.y * size.y / height, 4,
                       size.y * size.y / height};
        dc.SetPen(wxPen(border_color.defaultColor()));
        dc.SetBrush(wxBrush(*wxLIGHT_GREY));
        dc.DrawRoundedRectangle(rect, 2);
        rcContent.width -= 6;
    }
 
    // draw check icon
    rcContent.x += 5;
    rcContent.width -= 5;
    if (check_bitmap.bmp().IsOk()) {
        auto szBmp = check_bitmap.GetBmpSize();
        if (selected_item >= 0) {
            wxPoint pt = rcContent.GetLeftTop();
            pt.y += (rcContent.height - szBmp.y) / 2;
            pt.y += rowSize.y * selected_item;
            if (pt.y + szBmp.y > 0 && pt.y < size.y)
                dc.DrawBitmap(check_bitmap.bmp(), pt);
        }
        rcContent.x += szBmp.x + 5;
        rcContent.width -= szBmp.x + 5;
    }
 
    const auto action_column = actionColumn();
    if (action_column.second > action_column.first)
        rcContent.width = action_column.first - rcContent.x;
 
    std::set<wxString> groups;
    // draw texts & icons
    int index = 0;
    for (int i = 0; i < items.size(); ++i) {
        auto &item = items[i];
        int states2 = states;
        if ((item.style & DD_ITEM_STYLE_DISABLED) != 0)
            states2 &= ~StateColor::Enabled;
        // Skip by group
        if (group.IsEmpty()) {
            if (!item.group_key.IsEmpty()) {
                if (groups.find(item.group_key) != groups.end())
                    continue;
                groups.insert(item.group_key);
                if (!item.group_key.IsEmpty()) {
                    bool disabled = true;
                    for (int j = i + 1; j < items.size(); ++j) {
                        if (items[j].group_key == item.group_key && (items[j].style & DD_ITEM_STYLE_DISABLED) == 0) {
                            disabled = false;
                            break;
                        }
                    }
                    if (!disabled)
                        states2 |= StateColor::Enabled;
                }
            }
        } else {
            if (item.group_key != group)
                continue;
        }
        bool is_hover = index == hover_item;
        ++index;
        if (rcContent.GetBottom() < 0) {
            rcContent.y += rowSize.y;
            continue;
        }
        if (rcContent.y > size.y) break;
        wxPoint pt   = rcContent.GetLeftTop();
 
        if (item.style & DD_ITEM_STYLE_SPLIT_ITEM) {
            _DrawSplitItem(this, dc, item.text, pt, rowSize.GetWidth(), rowSize.GetHeight());
            rcContent.y += rowSize.GetHeight();
            continue;
        }
 
        auto &  icon  = item.icon;
        auto size2 = GetBmpSize(icon);
        if (iconSize.x > 0) {
            if (icon.IsOk()) {
                pt.y += (rcContent.height - size2.y) / 2;
                dc.DrawBitmap(icon, pt);
            }
            pt.x += iconSize.x + 5;
            pt.y = rcContent.y;
        } else if (icon.IsOk()) {
            pt.y += (rcContent.height - size2.y) / 2;
            dc.DrawBitmap(icon, pt);
            pt.x += size2.x + 5;
            pt.y = rcContent.y;
        }
        auto text = group.IsEmpty()
                        ? (item.group_key.IsEmpty() ? item.text : item.group_label)
                        : item.text;
        if (item.action_icon.IsOk()) {
            auto action_size = GetBmpSize(item.action_icon);
            wxPoint action_pt(action_column.second - action_size.x - FromDIP(8),
                              rcContent.y + (rcContent.height - action_size.y) / 2);
            dc.DrawBitmap(item.action_icon, action_pt);
        }
 
        if (!text_off && !text.IsEmpty()) {
            wxSize tSize = dc.GetMultiLineTextExtent(text);
            if (pt.x + tSize.x > rcContent.GetRight()) {
                int max_text_width = rcContent.GetRight() - pt.x;
                if (max_text_width <= 0) {
                    text.clear();
                } else {
                    if (is_hover && item.tip.IsEmpty())
                        SetToolTip(text);
                    text = wxControl::Ellipsize(text, dc, wxELLIPSIZE_END, max_text_width);
                }
            }
            pt.y += (rcContent.height - textSize.y) / 2;
            dc.SetFont(GetFont());
            // Dimmed items stay selectable, so they only borrow the disabled text tone rather
            // than taking the disabled state itself.
            const int text_states = (item.style & DD_ITEM_STYLE_DIMMED) ? (states2 & ~StateColor::Enabled) : states2;
            dc.SetTextForeground(text_color.colorForStates(text_states));
            dc.DrawText(text, pt);
            if (group.IsEmpty() && !item.group_key.IsEmpty()) {
                auto szBmp = arrow_bitmap.GetBmpSize();
                pt.x = rcContent.GetRight() - szBmp.x - 5;
                pt.y = rcContent.y + (rcContent.height - szBmp.y) / 2;
                dc.DrawBitmap(arrow_bitmap.bmp(), pt);
            }
        }
        rcContent.y += rowSize.y;
    }
}

References _DrawSplitItem(), actionColumn(), arrow_bitmap, border_color, check_bitmap, StateColor::Checked, count, StateColor::darkModeColorFor(), DD_ITEM_STYLE_DIMMED, DD_ITEM_STYLE_DISABLED, DD_ITEM_STYLE_SPLIT_ITEM, StateColor::Enabled, GetBmpSize(), group, hover_item, StateColor::Hovered, hoverIndex(), iconSize, items, offset, radius, rowSize, selectedItem(), selector_background_color, selector_border_color, state_handler, style, subDropDown, text_color, text_off, and textSize.

Referenced by paintEvent().

Here is the call graph for this function:

Here is the caller graph for this function:

Rescale()

void DropDown::Rescale

(

)

{
    need_sync = true;
}

References need_sync.

selectedItem()

int DropDown::selectedItem ( )

private

{
    if (selection < 0)
        return -1;
    // BUG FIX: Can't take the shortcut if subDropDown exists (which means there are groups)
    // because the visual position differs from the actual item index when groups are shown
    if (count == items.size() && subDropDown == nullptr)
        return selection;
    auto & sel = items[selection];
    if (group.IsEmpty() ? !sel.group_key.IsEmpty() : sel.group_key != group)
        return -1;
    if (selection == 0)
        return 0;
    int                index = 0;
    std::set<wxString> groups;
    for (size_t i = 0; i < selection; ++i) {
        auto &item = items[i];
        // Skip by group
        if (group.IsEmpty()) {
            if (!item.group_key.IsEmpty()) {
                if (groups.find(item.group_key) == groups.end())
                    groups.insert(item.group_key);
                else
                    continue;
            }
        } else {
            if (item.group_key != group)
                continue;
        }
        ++index;
    }
    return index;
}

References count, group, items, selection, and subDropDown.

Referenced by render().

Here is the caller graph for this function:

sendDropDownActionEvent()

void DropDown::sendDropDownActionEvent ( int index )

private

{
    if (index < 0 || index >= int(items.size()) || (items[index].style & DD_ITEM_STYLE_DISABLED))
        return;
    wxCommandEvent event(EVT_DROPDOWN_ITEM_ACTION, GetId());
    event.SetEventObject(this);
    event.SetInt(index);
    event.SetString(items[index].text);
    GetEventHandler()->ProcessEvent(event);
}

References DD_ITEM_STYLE_DISABLED, and items.

Referenced by mouseReleased().

Here is the caller graph for this function:

sendDropDownEvent()

void DropDown::sendDropDownEvent ( )

private

{
    int index = hoverIndex();
    if (index < 0 || (items[index].style & DD_ITEM_STYLE_DISABLED))
        return;
    wxCommandEvent event(wxEVT_COMBOBOX, GetId());
    event.SetEventObject(this);
    event.SetInt(index);
    event.SetString(items[index].text);
    GetEventHandler()->ProcessEvent(event);
}

References DD_ITEM_STYLE_DISABLED, hoverIndex(), items, and style.

Referenced by mouseReleased().

Here is the call graph for this function:

Here is the caller graph for this function:

SetAlignIcon()

void DropDown::SetAlignIcon

(

bool

align

)

{ align_icon = align; }

References align_icon.

SetBorderColor()

void DropDown::SetBorderColor

(

StateColor const &

color

)

{
    border_color = color;
    state_handler.update_binds();
    paintNow();
}

References border_color, paintNow(), and state_handler.

Here is the call graph for this function:

SetCornerRadius()

void DropDown::SetCornerRadius

(

double

radius

)

{
    this->radius = radius;
    paintNow();
}

References paintNow(), and radius.

Here is the call graph for this function:

SetSelection()

void DropDown::SetSelection

(

int

n

)

{
    if (n >= (int) items.size())
        n = -1;
    if (selection == n) return;
    selection = n;
    if (need_sync) { // for icon Size
        messureSize();
        need_sync = true;
    }
    if (subDropDown)
        subDropDown->SetSelection(n);
    paintNow();
}

References items, messureSize(), need_sync, paintNow(), selection, and subDropDown.

Here is the call graph for this function:

SetSelectorBackgroundColor()

void DropDown::SetSelectorBackgroundColor

(

StateColor const &

color

)

{
    selector_background_color = color;
    state_handler.update_binds();
    paintNow();
}

References paintNow(), selector_background_color, and state_handler.

Here is the call graph for this function:

SetSelectorBorderColor()

void DropDown::SetSelectorBorderColor

(

StateColor const &

color

)

{
    selector_border_color = color;
    state_handler.update_binds();
    paintNow();
}

References paintNow(), selector_border_color, and state_handler.

Here is the call graph for this function:

SetTextColor()

void DropDown::SetTextColor

(

StateColor const &

color

)

{
    text_color = color;
    state_handler.update_binds();
    paintNow();
}

References paintNow(), state_handler, and text_color.

Here is the call graph for this function:

SetUseContentWidth()

void DropDown::SetUseContentWidth	(	bool	use,
		bool	limit_max_content_width = false )

{
    if (use_content_width == use)
        return;
    use_content_width = use;
    this->limit_max_content_width = limit_max_content_width;
    need_sync = true;
    messureSize();
}

References limit_max_content_width, messureSize(), need_sync, and use_content_width.

Referenced by Slic3r::GUI::PlaterPresetComboBox::PlaterPresetComboBox(), Slic3r::GUI::TabPresetComboBox::TabPresetComboBox(), Slic3r::GUI::Choice::BUILD(), Slic3r::GUI::PrinterAgentChoice::BUILD(), and BitmapChoiceRenderer::CreateEditorCtrl().

Here is the call graph for this function:

Here is the caller graph for this function:

SetValue()

void DropDown::SetValue

(

const wxString &

value

)

{
    auto i    = std::find_if(items.begin(), items.end(), [&value](Item & item) { return item.text == value; });
    selection = i == items.end() ? -1 : std::distance(items.begin(), i);
}

References items, and selection.

ShouldDismissOnTopWindowDeactivate()

bool DropDown::ShouldDismissOnTopWindowDeactivate ( )

overrideprotectedvirtual

Reimplemented from PopupWindow.

{
    // On Wayland, mapping a chained xdg_popup with grab makes the parent
    // toplevel inactive, which would otherwise cascade-dismiss the whole
    // chain. Skip when our chain peer is shown.
    return !((mainDropDown && mainDropDown->IsShown()) ||
             (subDropDown  && subDropDown->IsShown()));
}

References mainDropDown, and subDropDown.

Friends And Related Symbol Documentation

ComboBox

friend class ComboBox

friend

References ComboBox.

Referenced by ComboBox.

Member Data Documentation

actionIconWidth

int DropDown::actionIconWidth = 0

private

Referenced by actionColumn(), and messureSize().

align_icon

bool DropDown::align_icon = false

private

Referenced by messureSize(), and SetAlignIcon().

arrow_bitmap

ScalableBitmap DropDown::arrow_bitmap

private

Referenced by Create(), messureSize(), and render().

border_color

StateColor DropDown::border_color

private

Referenced by DropDown(), Create(), render(), and SetBorderColor().

check_bitmap

ScalableBitmap DropDown::check_bitmap

private

Referenced by Create(), messureSize(), and render().

count

size_t DropDown::count = 0

private

Referenced by actionColumn(), autoPosition(), hoverIndex(), messureSize(), mouseMove(), mouseWheelMoved(), render(), and selectedItem().

dismissTime

boost::posix_time::ptime DropDown::dismissTime

private

Referenced by HasDismissLongTime(), and OnDismiss().

dragStart

wxPoint DropDown::dragStart

private

Referenced by mouseDown(), mouseMove(), and mouseReleased().

group

wxString DropDown::group

private

Referenced by hoverIndex(), messureSize(), render(), and selectedItem().

hover_item

int DropDown::hover_item = -1

private

Referenced by hoverIndex(), Invalidate(), mouseMove(), mouseReleased(), mouseWheelMoved(), OnDismiss(), and render().

iconSize

wxSize DropDown::iconSize

private

Referenced by messureSize(), and render().

items

std::vector<Item>& DropDown::items

private

Referenced by DropDown(), DropDown(), GetValue(), hoverIndex(), Invalidate(), messureSize(), mouseMove(), mouseReleased(), mouseWheelMoved(), render(), selectedItem(), sendDropDownActionEvent(), sendDropDownEvent(), SetSelection(), and SetValue().

limit_max_content_width

bool DropDown::limit_max_content_width = false

private

Referenced by messureSize(), and SetUseContentWidth().

mainDropDown

DropDown* DropDown::mainDropDown { nullptr }

private

{ nullptr };

Referenced by autoPosition(), messureSize(), mouseMove(), mouseReleased(), OnDismiss(), Popup(), and ShouldDismissOnTopWindowDeactivate().

need_sync

bool DropDown::need_sync = false

private

Referenced by Invalidate(), messureSize(), Rescale(), SetSelection(), and SetUseContentWidth().

offset

wxPoint DropDown::offset

private

Referenced by autoPosition(), Invalidate(), mouseMove(), mouseWheelMoved(), and render().

pressedDown

bool DropDown::pressedDown = false

private

Referenced by mouseDown(), mouseMove(), and mouseReleased().

radius

double DropDown::radius = 0

private

Referenced by render(), and SetCornerRadius().

rowSize

wxSize DropDown::rowSize

private

Referenced by actionColumn(), autoPosition(), messureSize(), mouseMove(), mouseWheelMoved(), and render().

selection

int DropDown::selection = -1

private

Referenced by autoPosition(), GetSelection(), GetValue(), Invalidate(), selectedItem(), SetSelection(), and SetValue().

selector_background_color

StateColor DropDown::selector_background_color

private

Referenced by DropDown(), Create(), render(), and SetSelectorBackgroundColor().

selector_border_color

StateColor DropDown::selector_border_color

private

Referenced by DropDown(), Create(), render(), and SetSelectorBorderColor().

state_handler

StateHandler DropDown::state_handler

private

Referenced by DropDown(), Create(), render(), SetBorderColor(), SetSelectorBackgroundColor(), SetSelectorBorderColor(), and SetTextColor().

subDropDown

DropDown* DropDown::subDropDown { nullptr }

private

{ nullptr };

Referenced by Dismiss(), hoverIndex(), messureSize(), mouseMove(), mouseReleased(), OnDismiss(), render(), selectedItem(), SetSelection(), and ShouldDismissOnTopWindowDeactivate().

text_color

StateColor DropDown::text_color

private

Referenced by DropDown(), Create(), render(), and SetTextColor().

text_off

bool DropDown::text_off = false

private

Referenced by Create(), messureSize(), and render().

textSize

wxSize DropDown::textSize

private

Referenced by messureSize(), and render().

use_content_width

bool DropDown::use_content_width = false

private

Referenced by autoPosition(), messureSize(), and SetUseContentWidth().

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/Widgets/DropDown.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/Widgets/DropDown.cpp