C++ TBWidget类代码示例

bool TBPopupWindow::Show(const TBPopupAlignment &alignment)
{
    // Calculate and set a good size for the popup window
    SetRect(alignment.GetAlignedRect(this, m_target.Get()));

    TBWidget *root = m_target.Get()->GetParentRoot();
    root->AddChild(this);
    return true;
}

void ProgressModal::Show()
{
    assert(!dimmer_->GetParent());
    TBUI* tbui = GetSubsystem<TBUI>();
    TBWidget* root = tbui->GetRootWidget();
    root->AddChild(dimmer_);
    root->AddChild(delegate_);

}

TBWidget *TBSelectList::GetItemWidget(int index)
{
    if (index == -1)
        return nullptr;
    for (TBWidget *tmp = m_layout.GetContentRoot()->GetFirstChild(); tmp; tmp = tmp->GetNext())
        if (tmp->data.GetInt() == index)
            return tmp;
    return nullptr;
}

void ProgressModal::Center()
{
    UI* tbui = GetSubsystem<UI>();
    TBRect rect = window_->GetRect();
    TBWidget* root = tbui->GetRootWidget();
    TBRect bounds(0, 0, root->GetRect().w, root->GetRect().h);
    window_->SetRect(rect.CenterIn(bounds).MoveIn(bounds).Clip(bounds));
    delegate_->SetRect(bounds);

}

bool ImageWindow::OnEvent(const TBWidgetEvent &ev)
{
	if (ev.type == EVENT_TYPE_CLICK && ev.target->GetID() == TBIDC("remove"))
	{
		TBWidget *image = ev.target->GetParent();
		image->GetParent()->RemoveChild(image);
		delete image;
		return true;
	}
	return DemoWindow::OnEvent(ev);
}

int TBTabContainer::GetNumPages()
{
	int count = 0;
	for (TBWidget *tab = m_tab_layout.GetFirstChild(); tab; tab = tab->GetNext())
		count++;

    if (!count)
        m_current_page = -1;

	return count;
}

void JSUI::GatherWidgets(tb::TBWidget* widget, PODVector<tb::TBWidget*>& widgets)
{
    if (widget->GetID() != TBID())
        widgets.Push(widget);

    for (TBWidget *n = widget->GetFirstChild(); n; n = n->GetNext())
    {
        GatherWidgets(n, widgets);
    }

}

TBRect TBPopupAlignment::GetAlignedRect(TBWidget *popup, TBWidget *target) const
{
    TBWidget *root = target->GetParentRoot();

    SizeConstraints sc(root->GetRect().w, root->GetRect().h);

    PreferredSize ps = popup->GetPreferredSize(sc);

    TBRect target_rect;
    TBPoint pos;
    int w = MIN(ps.pref_w, root->GetRect().w);
    int h = MIN(ps.pref_h, root->GetRect().h);
    if (pos_in_root.x != UNSPECIFIED &&
            pos_in_root.y != UNSPECIFIED)
    {
        pos = pos_in_root;
    }
    else
    {
        target->ConvertToRoot(pos.x, pos.y);

        if (align == TB_ALIGN_TOP || align == TB_ALIGN_BOTTOM)
        {
            if (expand_to_target_width)
                w = MAX(w, target->GetRect().w);

            // If the menu is aligned top or bottom, limit its height to the worst case available height.
            // Being in the center of the root, that is half the root height minus the target rect.
            h = MIN(h, root->GetRect().h / 2 - target->GetRect().h);
        }
        target_rect = target->GetRect();
    }

    int x, y;
    if (align == TB_ALIGN_BOTTOM)
    {
        x = pos.x;
        y = pos.y + target_rect.h + h > root->GetRect().h ? pos.y - h : pos.y + target_rect.h;
    }
    else if (align == TB_ALIGN_TOP)
    {
        x = pos.x;
        y = pos.y - h < 0 ? pos.y + target_rect.h : pos.y - h;
    }
    else if (align == TB_ALIGN_RIGHT)
    {
        x = pos.x + target_rect.w + w > root->GetRect().w ? pos.x - w : pos.x + target_rect.w;
        y = MIN(pos.y, root->GetRect().h - h);
    }
    else //if (align == TB_ALIGN_LEFT)
    {
        x = pos.x - w < 0 ? pos.x + target_rect.w : pos.x - w;
        y = MIN(pos.y, root->GetRect().h - h);
    }

    return TBRect(x, y, w, h);
}

void TBScroller::GetTargetScrollXY(int &x, int &y) const
{
	x = 0;
	y = 0;
	TBWidget *tmp = m_target->GetScrollRoot();
	while (tmp)
	{
		TBWidget::ScrollInfo info = tmp->GetScrollInfo();
		x += info.x;
		y += info.y;
		tmp = tmp->GetParent();
	}
}

void UIWidget::Center()
{
    if (!widget_)
        return;

    // this should center on parent widget, not root
    UI* ui = GetSubsystem<UI>();
    TBRect rect = widget_->GetRect();
    TBWidget* root = ui->GetRootWidget();
    TBRect bounds(0, 0, root->GetRect().w, root->GetRect().h);
    widget_->SetRect(rect.CenterIn(bounds).MoveIn(bounds).Clip(bounds));

}

static void drop_callback(GLFWwindow *window, int count, const char **files_utf8)
{
	ApplicationBackendGLFW *backend = GetBackend(window);
	TBWidget *target = TBWidget::hovered_widget;
	if (!target)
		target = TBWidget::focused_widget;
	if (!target)
		target = backend->GetRoot();
	if (target)
	{
		TBWidgetEventFileDrop ev;
		for (int i = 0; i < count; i++)
			ev.files.Add(new TBStr(files_utf8[i]));
		target->InvokeEvent(ev);
	}
}

TBWindow *TBWindow::GetTopMostOtherWindow(bool only_activable_windows)
{
	TBWindow *other_window = nullptr;
	TBWidget *sibling = GetParent()->GetLastChild();
	while (sibling && !other_window)
	{
		if (sibling != this)
			other_window = TBSafeCast<TBWindow>(sibling);

		if (only_activable_windows && other_window && !(other_window->m_settings & WINDOW_SETTINGS_CAN_ACTIVATE))
			other_window = nullptr;

		sibling = sibling->GetPrev();
	}
	return other_window;
}

void UIWidget::Center()
{
    if (!widget_)
        return;

    TBRect rect = widget_->GetRect();
    TBWidget* root = widget_->GetParent();
    if (!root)
    {
        UI* ui = GetSubsystem<UI>();
        root = ui->GetRootWidget();
    }

    TBRect bounds(0, 0, root->GetRect().w, root->GetRect().h);
    widget_->SetRect(rect.CenterIn(bounds).MoveIn(bounds).Clip(bounds));

}

void UIDragDrop::HandleMouseDown(StringHash eventType, VariantMap& eventData)
{
    using namespace MouseButtonDown;

    Input* input = GetSubsystem<Input>();

    if (!input->IsMouseVisible())
        return;

    if ((eventData[P_BUTTONS].GetUInt() & MOUSEB_LEFT) && TBWidget::hovered_widget)
    {
        // see if we have a widget with a drag object

        TBWidget* tbw = TBWidget::hovered_widget;
        UIWidget* widget = nullptr;

        while(tbw)
        {
            if (tbw->GetDelegate())
            {
                widget = (UIWidget*) tbw->GetDelegate();

                if (widget->GetDragObject())
                {
                    // TODO: check if we're in widget bounds
                    // this is going to need to be updated for drag/drop multiselect
                    break;
                }

                widget = nullptr;
            }

            tbw = tbw->GetParent();
        }

        if (!widget)
            return;

        currentTargetWidget_ = widget;
        dragSourceWidget_ = widget;
        mouseDownPosition_ = input->GetMousePosition();

    }

}

void ResourceEditWindow::AddWidgetListItemsRecursive(TBWidget *widget, int depth)
{
	if (depth > 0) // Ignore the root
	{
		// Add a new ResourceItem for this widget
		TBStr str;
		const char *classname = widget->GetClassName();
		if (!*classname)
			classname = "<Unknown widget type>";
		str.SetFormatted("% *s%s", depth - 1, "", classname);

		if (ResourceItem *item = new ResourceItem(widget, str))
			m_widget_list_source.AddItem(item);
	}

	for (TBWidget *child = widget->GetFirstChild(); child; child = child->GetNext())
		AddWidgetListItemsRecursive(child, depth + 1);
}