C++ display_t::insert方法代码示例

platform_display_type insert<reveal_t>(display_t&             display,
                                       platform_display_type& parent,
                                       reveal_t&              element)
{
    assert(!element.control_m);

    boost::shared_ptr<GG::StyleFactory> style = GG::GUI::GetGUI()->GetStyleFactory();
    element.control_m = style->NewButton(GG::X0, GG::Y0, GG::X(100), GG::Y(100),
                                         "", style->DefaultFont(), GG::CLR_GRAY);

    const GG::SubTexture& subtexture =
        element.current_value_m == element.show_value_m ? showing_image() : hidden_image();
    element.control_m->SetUnpressedGraphic(subtexture);
    element.control_m->SetPressedGraphic(subtexture);
    element.control_m->SetRolloverGraphic(subtexture);

    GG::Connect(element.control_m->ClickedSignal,
                boost::bind(&reveal_clicked, boost::ref(element)));

    if (!element.alt_text_m.empty())
        implementation::set_control_alt_text(element.control_m, element.alt_text_m);

    platform_display_type result(display.insert(parent, element.control_m));

    if (element.using_label_m)
        display.insert(parent, get_display(element.name_m));

    return result;
}

    platform_display_type insert<color_button_t>(display_t& display,
                                                 platform_display_type& parent,
                                                 color_button_t& element)
    {
        if (element.using_label_m)
            insert(display, parent, element.name_m);

        assert(!element.control_m);

        ColorButton* button = new ColorButton(GG::X(element.width_m),
                                              GG::Y(element.height_m),
                                              element.border_color_m,
                                              2,
                                              element.dialog_color_m,
                                              element.dialog_border_color_m,
                                              element.dialog_text_color_m);
        element.original_size_m = GG::Pt(button->Width(), button->Height());

        element.control_m = button;

        GG::Connect(button->ColorChanged, boost::bind(&color_changed, boost::ref(element)));

        if (!element.alt_text_m.empty())
            adobe::implementation::set_control_alt_text(element.control_m, element.alt_text_m);

        return display.insert(parent, element.control_m);
    }

platform_display_type insert<toggle_t>(display_t&             display,
                                       platform_display_type& parent,
                                       toggle_t&              element)
{
    assert(!element.control_m);

    element.control_m = ::CreateWindowExW(  WS_EX_COMPOSITED | WS_EX_TRANSPARENT, L"STATIC",
                                    NULL,
                                    WS_CHILD | WS_VISIBLE | SS_BITMAP | SS_NOTIFY,
                                    0, 0, 100, 20,
                                    parent,
                                    0,
                                    ::GetModuleHandle(NULL),
                                    NULL);

    if (element.control_m == NULL)
        ADOBE_THROW_LAST_ERROR;

    set_font(element.control_m, EP_EDITTEXT); // REVISIT (fbrereto) : a better type?

    ::SetWindowSubclass(element.control_m, &toggle_subclass_proc, reinterpret_cast<UINT_PTR>(&element), 0);

    if (!element.alt_text_m.empty())
        implementation::set_control_alt_text(element.control_m, element.alt_text_m);

    return display.insert(parent, element.control_m);
}

template <> platform_display_type insert<presets_t>(display_t&             display,
                                                    platform_display_type& parent,
                                                    presets_t&             element)
{
    assert(!element.control_m);

    insert(display, parent, element.category_popup_m);

    insert(display, parent, element.popup_m);

    GG::X width(26);
    GG::Y height(21);
    boost::shared_ptr<GG::StyleFactory> style = GG::GUI::GetGUI()->GetStyleFactory();
    element.control_m = style->NewButton(GG::X0, GG::Y0, width, height,
                                         "", style->DefaultFont(), GG::CLR_GRAY);
    reset_textures(element);

    GG::Connect(element.control_m->ClickedSignal,
                boost::bind(&presets_button_clicked, boost::ref(element)));

    element.popup_m.monitor(boost::bind(&presets_t::do_imbue, boost::ref(element), _1));

    if (!element.alt_text_m.empty())
        adobe::implementation::set_control_alt_text(element.control_m, element.alt_text_m);

    return display.insert(parent, element.control_m);
}

platform_display_type insert<group_t>(display_t&             display,
                                             platform_display_type& parent,
                                             group_t&        element)
{
    HWND parent_hwnd(parent);

    element.control_m = ::CreateWindowExW(WS_EX_CONTROLPARENT | WS_EX_COMPOSITED | WS_EX_TRANSPARENT,
                                          L"BUTTON",
                                          hackery::convert_utf(element.name_m).c_str(),
                                          WS_CHILD | WS_VISIBLE | BS_GROUPBOX,
                                          0, 0, 10, 10,
                                          parent_hwnd,
                                          0,
                                          ::GetModuleHandle(NULL),
                                          NULL);

    if (element.control_m == NULL)
        ADOBE_THROW_LAST_ERROR;

    set_font(element.control_m, BP_GROUPBOX);

    ::SetWindowSubclass(element.control_m, &group_subclass_proc, reinterpret_cast<UINT_PTR>(&element), 0);

    return display.insert(parent, element.control_m);
}

platform_display_type insert<image_t>(display_t&             display,
                                      platform_display_type& parent,
                                      image_t&               element)
{
    initialize(element, parent);

    return display.insert(parent, element.control_m.get());
}

platform_display_type insert<display_number_t>(display_t& display,
                                             platform_display_type& parent,
                                             display_number_t& element)
{
    HWND parent_hwnd(parent);
    element.initialize(parent_hwnd);
    return display.insert(parent, get_display(element));
}

platform_display_type insert<tab_group_t>(display_t&             display,
        platform_display_type&  parent,
        tab_group_t&     element)
{
    HWND parent_hwnd(parent);

    element.initialize(parent_hwnd);

    return display.insert(parent, element.control_m);
}

platform_display_type insert<checkbox_t>(display_t&             display,
                                                platform_display_type& parent,
                                                checkbox_t&     element)
{
    HWND parent_hwnd(parent);

    initialize(element, parent_hwnd);

    return display.insert(parent, element.control_m);
}

platform_display_type insert<checkbox_t>(display_t&             display,
                                         platform_display_type& parent,
                                         checkbox_t&            element)
{
    ::HIViewRef parent_ref(parent);

    initialize(element, parent_ref);

    return display.insert(parent, element.control_m);
}

platform_display_type insert<window_t>(display_t&             display,
                                       platform_display_type& parent,
                                       window_t&              element)
{
    assert(!element.window_m);
    assert(!parent);

    element.window_m = new GG::EveDialog(element, element.color_m, element.text_color_m);

    return display.insert(parent, element.window_m);
}

platform_display_type insert<link_t>(display_t&             display,
                                            platform_display_type& parent,
                                            link_t&         element)
{
    HWND parent_hwnd(parent);

    element.control_m = ::CreateWindowExW(WS_EX_COMPOSITED, L"STATIC",
                                          NULL,
                                          WS_CHILD | WS_VISIBLE,
                                          0, 0, 50, 50,
                                          parent_hwnd,
                                          0,
                                          ::GetModuleHandle(NULL),
                                          NULL);

    if (element.control_m == NULL)
        ADOBE_THROW_LAST_ERROR;

    if (!element.alt_text_m.empty())
        implementation::set_control_alt_text(element.control_m, element.alt_text_m);

    ::SetWindowSubclass(element.control_m, link_subclass_proc, reinterpret_cast<UINT_PTR>(&element), 0);

    element.link_icon_m = ::CreateWindowExW(WS_EX_COMPOSITED | WS_EX_TRANSPARENT, L"STATIC",
                                            NULL,
                                            WS_CHILD | WS_VISIBLE | SS_BITMAP | SS_NOTIFY,
                                            0, 0, 9, 16,
                                            parent_hwnd,
                                            0,
                                            ::GetModuleHandle(NULL),
                                            NULL);

    if (element.link_icon_m == NULL)
        ADOBE_THROW_LAST_ERROR;
    ::SendMessage(element.link_icon_m, STM_SETIMAGE, IMAGE_BITMAP, (LPARAM) link_bitmap());

    display.insert(parent, element.link_icon_m);

    return display.insert(parent, element.control_m);
}

platform_display_type insert<tab_group_t>(display_t&             display,
                                          platform_display_type& parent,
                                          tab_group_t&           element)
{
    assert (!element.control_m);

    // This probably looks odd.  The interface of tab groups in Eve is wildly
    // different from that of GG's TabWnd.  The most expedient way to get all
    // the Wnds in the right styles and still match the Eve interface was to
    // replace the built-in TabBar inside of TabWnd with one created here.

    boost::shared_ptr<GG::StyleFactory> style = GG::GUI::GetGUI()->GetStyleFactory();
    element.tab_bar_m = style->NewTabBar(GG::X0, GG::Y0, GG::X(100),
                                         style->DefaultFont(), element.color_m, element.text_color_m,
                                         element.style_m);
    element.tab_bar_m->SetMinSize(GG::Pt(element.tab_bar_m->MinSize().x, element.tab_bar_m->Height()));

    element.control_m = style->NewTabWnd(GG::X0, GG::Y0, GG::X(100), element.tab_bar_m->Height() + 20,
                                         style->DefaultFont(), element.color_m, element.text_color_m,
                                         element.style_m);

    GG::Layout* layout = element.control_m->DetachLayout();
    delete layout;

    layout = new GG::Layout(GG::X0, GG::Y0,
                            element.control_m->Width(), element.control_m->Height(),
                            2, 1);
    layout->SetRowStretch(1, 1.0);
    layout->Add(element.tab_bar_m, 0, 0);
    layout->Add(new Placeholder, 1, 0);
    element.control_m->SetLayout(layout);

    GG::Connect(element.tab_bar_m->TabChangedSignal,
                boost::bind(&tab_changed, boost::ref(element), _1));

    for (tab_group_t::tab_set_t::iterator
             first(element.items_m.begin()), last(element.items_m.end());
         first != last;
         ++first) {
        element.tab_bar_m->AddTab(first->name_m);
    }

    element.color_proxy_m.initialize(
        boost::bind(&GG::TabBar::SetColor, element.tab_bar_m, _1)
    );
    element.text_color_proxy_m.initialize(
        boost::bind(&GG::TabBar::SetTextColor, element.tab_bar_m, _1)
    );

    return display.insert(parent, element.control_m);
}

platform_display_type insert<popup_t>(display_t& display, platform_display_type& parent, popup_t& element)
{
    HWND parent_hwnd(parent);

    if (element.using_label_m)
        insert(display, parent, element.name_m);

    ::initialize(element, parent_hwnd);
    ::message_menu_item_set(element);

    platform_display_type result(display.insert(parent, element.control_m));

    return result;
}

platform_display_type insert<edit_text_t>(display_t&             display,
                                                 platform_display_type& parent,
                                                 edit_text_t&    element)
{
    HWND parent_hwnd(parent);

    if (element.using_label_m)
    {
        insert(display, parent, element.get_label());
    }

   element.initialize(parent_hwnd);

   return display.insert(parent, get_display(element));
}