自学教程：C++ GTK_PIZZA函数代码示例

void wxMiniFrame::SetTitle( const wxString &title ){    wxFrame::SetTitle( title );    if (GTK_PIZZA(m_mainWidget)->bin_window)        gdk_window_invalidate_rect( GTK_PIZZA(m_mainWidget)->bin_window, NULL, true );}

static void wxInsertChildInTopLevelWindow( wxTopLevelWindowGTK* parent, wxWindow* child ){    wxASSERT( GTK_IS_WIDGET(child->m_widget) );    if (!parent->m_insertInClientArea)    {        // these are outside the client area        wxTopLevelWindowGTK* frame = (wxTopLevelWindowGTK*) parent;        gtk_pizza_put( GTK_PIZZA(frame->m_mainWidget),                         GTK_WIDGET(child->m_widget),                         child->m_x,                         child->m_y,                         child->m_width,                         child->m_height );    }    else    {        // these are inside the client area        gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow),                         GTK_WIDGET(child->m_widget),                         child->m_x,                         child->m_y,                         child->m_width,                         child->m_height );    }    // resize on OnInternalIdle    parent->GtkUpdateSize();}

void wxStatusBarGeneric::OnPaint(wxPaintEvent& WXUNUSED(event) ){    wxPaintDC dc(this);    dc.SetTextForeground(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT));#ifdef __WXGTK20__    // Draw grip first    if (HasFlag( wxST_SIZEGRIP ))    {        int width, height;        GetClientSize(&width, &height);        if (GetLayoutDirection() == wxLayout_RightToLeft)        {            gtk_paint_resize_grip( m_widget->style,                               GTK_PIZZA(m_wxwindow)->bin_window,                               (GtkStateType) GTK_WIDGET_STATE (m_widget),                               NULL,                               m_widget,                               "statusbar",                               GDK_WINDOW_EDGE_SOUTH_WEST,                               2, 2, height-2, height-4 );        }        else        {            gtk_paint_resize_grip( m_widget->style,                               GTK_PIZZA(m_wxwindow)->bin_window,                               (GtkStateType) GTK_WIDGET_STATE (m_widget),                               NULL,                               m_widget,                               "statusbar",                               GDK_WINDOW_EDGE_SOUTH_EAST,                               width-height-2, 2, height-2, height-4 );        }    }#endif    if (GetFont().Ok())        dc.SetFont(GetFont());    dc.SetBackgroundMode(wxTRANSPARENT);#ifdef __WXPM__    wxColour vColor;    vColor = wxSystemSettings::GetColour(wxSYS_COLOUR_MENUBAR);    ::WinFillRect(dc.m_hPS, &dc.m_vRclPaint, vColor.GetPixel());#endif    for (int i = 0; i < m_nFields; i ++)        DrawField(dc, i);}

static void wxInsertChildInScrolledWindow( wxWindow* parent, wxWindow* child ){    // The window might have been scrolled already, do we    // have to adapt the position.    GtkPizza *pizza = GTK_PIZZA(parent->m_wxwindow);    child->m_x += pizza->xoffset;    child->m_y += pizza->yoffset;    gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow),                     GTK_WIDGET(child->m_widget),                     child->m_x,                     child->m_y,                     child->m_width,                     child->m_height );}

static voidgtk_pizza_map (GtkWidget *widget){    GtkPizza *pizza;    GtkPizzaChild *child;    GList *children;    g_return_if_fail (widget != NULL);    g_return_if_fail (GTK_IS_PIZZA (widget));    GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);    pizza = GTK_PIZZA (widget);    children = pizza->children;    while (children)    {        child = children->data;        children = children->next;        if ( GTK_WIDGET_VISIBLE (child->widget) &&            !GTK_WIDGET_MAPPED (child->widget) &&            !GTK_WIDGET_IS_OFFSCREEN (child->widget))        {            gtk_widget_map (child->widget);        }    }    gdk_window_show (widget->window);    gdk_window_show (pizza->bin_window);}

static voidgtk_pizza_forall (GtkContainer *container,                  gboolean      include_internals,                  GtkCallback   callback,                  gpointer      callback_data){    GtkPizza *pizza;    GtkPizzaChild *child;    GList *children;    g_return_if_fail (container != NULL);    g_return_if_fail (GTK_IS_PIZZA (container));    g_return_if_fail (callback != (GtkCallback)NULL);    pizza = GTK_PIZZA (container);    children = pizza->children;    while (children)    {        child = children->data;        children = children->next;        (* callback) (child->widget, callback_data);    }}

void wxFrame::AttachMenuBar( wxMenuBar *menuBar ){    wxFrameBase::AttachMenuBar(menuBar);    if (m_frameMenuBar)    {        m_frameMenuBar->SetParent(this);        gtk_pizza_put( GTK_PIZZA(m_mainWidget),                m_frameMenuBar->m_widget,                m_frameMenuBar->m_x,                m_frameMenuBar->m_y,                m_frameMenuBar->m_width,                m_frameMenuBar->m_height );        if (menuBar->GetWindowStyle() & wxMB_DOCKABLE)        {            gtk_signal_connect( GTK_OBJECT(menuBar->m_widget), "child_attached",                GTK_SIGNAL_FUNC(gtk_menu_attached_callback), (gpointer)this );            gtk_signal_connect( GTK_OBJECT(menuBar->m_widget), "child_detached",                GTK_SIGNAL_FUNC(gtk_menu_detached_callback), (gpointer)this );        }        gtk_widget_show( m_frameMenuBar->m_widget );        UpdateMenuBarSize();    }    else    {        m_menuBarHeight = 2;        GtkUpdateSize();        // resize window in OnInternalIdle    }}

void wxStatusBarGeneric::OnRightDown(wxMouseEvent& event){#ifdef __WXGTK20__    int width, height;    GetClientSize(&width, &height);    if (HasFlag( wxST_SIZEGRIP ) && (event.GetX() > width-height))    {        GtkWidget *ancestor = gtk_widget_get_toplevel( m_widget );        if (!GTK_IS_WINDOW (ancestor))            return;        GdkWindow *source = GTK_PIZZA(m_wxwindow)->bin_window;        int org_x = 0;        int org_y = 0;        gdk_window_get_origin( source, &org_x, &org_y );        gtk_window_begin_move_drag (GTK_WINDOW (ancestor),                                2,                                org_x + event.GetX(),                                org_y + event.GetY(),                                0);    }    else    {        event.Skip( true );    }#else    event.Skip( true );#endif}

static voidgtk_pizza_size_request (GtkWidget      *widget,                        GtkRequisition *requisition){    GtkPizza *pizza;    GtkPizzaChild *child;    GList *children;    GtkRequisition child_requisition;    g_return_if_fail (widget != NULL);    g_return_if_fail (GTK_IS_PIZZA (widget));    g_return_if_fail (requisition != NULL);    pizza = GTK_PIZZA (widget);    children = pizza->children;    while (children)    {        child = children->data;        children = children->next;        if (GTK_WIDGET_VISIBLE (child->widget))        {            gtk_widget_size_request (child->widget, &child_requisition);        }    }    /* request very little, I'm not sure if requesting nothing       will always have positive effects on stability... */    requisition->width = 2;    requisition->height = 2;}

static voidgtk_pizza_draw (GtkWidget    *widget,                GdkRectangle *area){    GtkPizza *pizza;    GtkPizzaChild *child;    GdkRectangle child_area;    GList *children;    g_return_if_fail (widget != NULL);    g_return_if_fail (GTK_IS_PIZZA (widget));    pizza = GTK_PIZZA (widget);    /* Sometimes, We handle all expose events in window.cpp now. */    if (pizza->external_expose)        return;    children = pizza->children;    if ( !(GTK_WIDGET_APP_PAINTABLE (widget)) &&         (pizza->clear_on_draw))    {        gdk_window_clear_area( pizza->bin_window,                                area->x, area->y, area->width, area->height);    }    while (children)    {        child = children->data;        children = children->next;        if (gtk_widget_intersect (child->widget, area, &child_area))            gtk_widget_draw (child->widget, &child_area);    }}

static void wxInsertChildInFrame( wxFrame* parent, wxWindow* child ){    wxASSERT( GTK_IS_WIDGET(child->m_widget) );    if (!parent->m_insertInClientArea)    {        // These are outside the client area        wxFrame* frame = (wxFrame*) parent;        gtk_pizza_put( GTK_PIZZA(frame->m_mainWidget),                         GTK_WIDGET(child->m_widget),                         child->m_x,                         child->m_y,                         child->m_width,                         child->m_height );#if wxUSE_TOOLBAR_NATIVE        // We connect to these events for recalculating the client area        // space when the toolbar is floating        if (wxIS_KIND_OF(child,wxToolBar))        {            wxToolBar *toolBar = (wxToolBar*) child;            if (toolBar->GetWindowStyle() & wxTB_DOCKABLE)            {                gtk_signal_connect( GTK_OBJECT(toolBar->m_widget), "child_attached",                    GTK_SIGNAL_FUNC(gtk_toolbar_attached_callback), (gpointer)parent );                gtk_signal_connect( GTK_OBJECT(toolBar->m_widget), "child_detached",                    GTK_SIGNAL_FUNC(gtk_toolbar_detached_callback), (gpointer)parent );            }        }#endif // wxUSE_TOOLBAR    }    else    {        // These are inside the client area        gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow),                         GTK_WIDGET(child->m_widget),                         child->m_x,                         child->m_y,                         child->m_width,                         child->m_height );    }    // Resize on OnInternalIdle    parent->GtkUpdateSize();}

void wxMiniFrame::SetTitle( const wxString &title ){    wxFrame::SetTitle( title );    #ifdef __WXGTK20__    gdk_window_invalidate_rect( GTK_PIZZA(m_mainWidget)->bin_window, NULL, true );#else    gtk_widget_draw( m_mainWidget, (GdkRectangle*) NULL );#endif}

static voidgtk_pizza_add (GtkContainer *container,               GtkWidget    *widget){    g_return_if_fail (container != NULL);    g_return_if_fail (GTK_IS_PIZZA (container));    g_return_if_fail (widget != NULL);    gtk_pizza_put (GTK_PIZZA (container), widget, 0, 0, 20, 20 );}

static voidgtk_pizza_style_set(GtkWidget *widget, GtkStyle  *previous_style){    if (GTK_WIDGET_REALIZED(widget))    {        gtk_style_set_background(widget->style, widget->window, GTK_STATE_NORMAL);        gtk_style_set_background(widget->style, GTK_PIZZA(widget)->bin_window, GTK_STATE_NORMAL );    }    (* GTK_WIDGET_CLASS (pizza_parent_class)->style_set) (widget, previous_style);}

static void gtk_window_draw_callback( GtkWidget *widget, GdkRectangle *rect, wxWindow *win ){    GtkPizza *pizza = GTK_PIZZA(widget);    gtk_paint_flat_box (win->m_widget->style,                        pizza->bin_window, GTK_STATE_NORMAL,                        GTK_SHADOW_NONE,                        rect,                        win->m_widget,                        (char *)"base",                        0, 0, -1, -1);}

bool wxTopLevelWindowGTK::SetShape(const wxRegion& region){    wxCHECK_MSG( HasFlag(wxFRAME_SHAPED), false,                 wxT("Shaped windows must be created with the wxFRAME_SHAPED style."));    GdkWindow *window = NULL;    if (m_wxwindow)    {        window = GTK_PIZZA(m_wxwindow)->bin_window;        do_shape_combine_region(window, region);    }    window = m_widget->window;    return do_shape_combine_region(window, region);}

static int gtk_window_expose_callback( GtkWidget *widget, GdkEventExpose *gdk_event, wxWindow *win ){    GtkPizza *pizza = GTK_PIZZA(widget);    gtk_paint_flat_box (win->m_widget->style,                        pizza->bin_window, GTK_STATE_NORMAL,                        GTK_SHADOW_NONE,                        &gdk_event->area,                        win->m_widget,                        (char *)"base",                        0, 0, -1, -1);    return FALSE;}

static void gtk_window_own_expose_callback( GtkWidget *widget, GdkEventExpose *gdk_event, wxMiniFrame *win ){    // don't need to install idle handler, its done from "event" signal    if (!win->m_hasVMT) return;    if (gdk_event->count > 0) return;    GtkPizza *pizza = GTK_PIZZA(widget);    gtk_paint_shadow (widget->style,                      pizza->bin_window,                      GTK_STATE_NORMAL,                      GTK_SHADOW_OUT,                      NULL, NULL, NULL, // FIXME: No clipping?                      0, 0,                      win->m_width, win->m_height);    int style = win->GetWindowStyle();    wxClientDC dc(win);    // Hack alert    dc.m_window = pizza->bin_window;    if (style & wxRESIZE_BORDER)    {        dc.SetBrush( *wxGREY_BRUSH );        dc.SetPen( *wxTRANSPARENT_PEN );        dc.DrawRectangle( win->m_width - 14, win->m_height-14, 14, 14 );    }    if (!win->GetTitle().empty() &&        ((style & wxCAPTION) ||         (style & wxTINY_CAPTION_HORIZ) ||         (style & wxTINY_CAPTION_VERT)))    {        dc.SetFont( *wxSMALL_FONT );        int height = dc.GetCharHeight();        wxBrush brush( LightContrastColour( wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT) ) );        dc.SetBrush( brush );        dc.SetPen( *wxTRANSPARENT_PEN );        dc.DrawRectangle( 3, 3, win->m_width - 7, height );        dc.SetTextForeground( *wxWHITE );        dc.DrawText( win->GetTitle(), 6, 3 );        if (style & wxCLOSE_BOX)            dc.DrawBitmap( win->m_closeButton, win->m_width-19, 2, true );    }}

void wxGLContext::SetCurrent(const wxGLCanvas& win) const{    if (m_glContext)    {        GdkWindow *window = GTK_PIZZA(win.m_wxwindow)->bin_window;        if (window == NULL)            return;        if (wxGLCanvas::GetGLXVersion() >= 13)            // GLX >= 1.3            glXMakeContextCurrent( GDK_DISPLAY(), GDK_WINDOW_XWINDOW(window), GDK_WINDOW_XWINDOW(window), m_glContext );        else            // GLX <= 1.2            glXMakeCurrent( GDK_DISPLAY(), GDK_WINDOW_XWINDOW(window), m_glContext );    }}

static void wxInsertChildInDialog( wxPopupWindow* parent, wxWindow* child ){    gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow),                   GTK_WIDGET(child->m_widget),                   child->m_x,                   child->m_y,                   child->m_width,                   child->m_height );    if (parent->HasFlag(wxTAB_TRAVERSAL))    {        /* we now allow a window to get the focus as long as it           doesn't have any children. */        GTK_WIDGET_UNSET_FLAGS( parent->m_wxwindow, GTK_CAN_FOCUS );    }}

static voidgtk_pizza_size_allocate (GtkWidget     *widget,                         GtkAllocation *allocation){    GtkPizza *pizza;    gint border;    gint x,y,w,h;    GtkPizzaChild *child;    GList *children;    g_return_if_fail (widget != NULL);    g_return_if_fail (GTK_IS_PIZZA(widget));    g_return_if_fail (allocation != NULL);    pizza = GTK_PIZZA (widget);    widget->allocation = *allocation;    if (pizza->shadow_type == GTK_MYSHADOW_NONE)        border = 0;    else    if (pizza->shadow_type == GTK_MYSHADOW_THIN)        border = 1;    else        border = 2;    x = allocation->x + border;    y = allocation->y + border;    w = allocation->width - border*2;    h = allocation->height - border*2;    if (GTK_WIDGET_REALIZED (widget))    {        gdk_window_move_resize( widget->window, x, y, w, h );        gdk_window_move_resize( pizza->bin_window, 0, 0, w, h );    }    children = pizza->children;    while (children)    {        child = children->data;        children = children->next;        gtk_pizza_position_child (pizza, child);        gtk_pizza_allocate_child (pizza, child);    }}

//------------------------------------------------------------------------------std::string wxOgreRenderWindow::getOgreHandle () const{  Ogre::String handle;#ifdef __WXMSW__  // Handle for Windows systems  handle = Ogre::StringConverter::toString((size_t)((HWND)GetHandle()));#elif defined(__WXGTK__)  // Handle for GTK-based systems  GtkWidget *widget = m_wxwindow;  gtk_widget_set_double_buffered (widget, FALSE);  gtk_widget_realize( widget );      // fake a timer event so we redraw  // Grab the window object  GdkWindow *gdkWin = GTK_PIZZA (widget)->bin_window;  Display* display = GDK_WINDOW_XDISPLAY(gdkWin);  Window wid = GDK_WINDOW_XWINDOW(gdkWin);  std::stringstream str;  // Display  str << (unsigned long)display << ':';  // Screen (returns "display.screen")  std::string screenStr = DisplayString(display);  std::string::size_type dotPos = screenStr.find(".");  screenStr = screenStr.substr(dotPos+1, screenStr.size());  str << screenStr << ':';  // XID  str << wid << ':';  // Retrieve XVisualInfo  int attrlist[] = { GLX_RGBA, GLX_DOUBLEBUFFER, GLX_DEPTH_SIZE, 16, GLX_STENCIL_SIZE, 8, None };  XVisualInfo* vi = glXChooseVisual(display, DefaultScreen(display), attrlist);  str << (unsigned long)vi;  handle = str.str();#else  // Any other unsupported system    #error Not supported on this platform.#endif  return handle;}

void wxOgre::getWindowParams(Ogre::NameValuePairList* params){    Ogre::String handle;#ifdef __WXMSW__    mContainer = this;	handle = Ogre::StringConverter::toString((size_t)((HWND)GetHandle()));	(*params)["externalWindowHandle"] = handle;#elif defined(__WXGTK__)    // Should help reduce flickering    SetBackgroundStyle(wxBG_STYLE_CUSTOM);    std::stringstream handleStream;    // wxWidgets uses serverl internal GtkWidgets, the GetHandle method returns    // a different one then this, but wxWidgets GLCanvas uses this one to    // interact with GLX with, so we will do the same.    GtkWidget* private_handle =  m_wxwindow;    // Prevents flicker    gtk_widget_set_double_buffered( private_handle, FALSE );    // Grabs the window for use in the below macros    GdkWindow *window = GTK_PIZZA(private_handle)->bin_window;    Display* display = GDK_WINDOW_XDISPLAY(window);    Window wid = GDK_WINDOW_XWINDOW(window);    // Display    handleStream << (unsigned long)display << ':';/*#if OGRE_PATCH_VERSION == 0    // Screen (returns ":display.screen   ")    std::string screenStr = DisplayString(display);    int dotpos = screenStr.find(".", 0);    screenStr = screenStr.substr(dotpos + 1, screenStr.length() - dotpos);    handleStream << screenStr << ':';#endif*/    // XID (typedef of an unsigned int)    handleStream << wid;    handle = handleStream.str();    (*params)["externalWindowHandle"] = handle;#else	#error External/Parent Window handle not supported on this platform#endif}

static voidgtk_pizza_unrealize (GtkWidget *widget){    GtkPizza *pizza;    g_return_if_fail (widget != NULL);    g_return_if_fail (GTK_IS_PIZZA (widget));    pizza = GTK_PIZZA (widget);    gdk_window_set_user_data (pizza->bin_window, NULL);    gdk_window_destroy (pizza->bin_window);    pizza->bin_window = NULL;    if (GTK_WIDGET_CLASS (pizza_parent_class)->unrealize)       (* GTK_WIDGET_CLASS (pizza_parent_class)->unrealize) (widget);}

void wxMDIChildFrame::SetMenuBar( wxMenuBar *menu_bar ){    wxASSERT_MSG( m_menuBar == NULL, wxT("Only one menubar allowed") );    m_menuBar = menu_bar;    if (m_menuBar)    {        wxMDIParentFrame *mdi_frame = (wxMDIParentFrame*)m_parent->GetParent();        m_menuBar->SetParent( mdi_frame );        /* insert the invisible menu bar into the _parent_ mdi frame */        gtk_pizza_put( GTK_PIZZA(mdi_frame->m_mainWidget),                         m_menuBar->m_widget,                         0, 0,  mdi_frame->m_width, wxMENU_HEIGHT );    }}

static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxMiniFrame *win ){    if (g_isIdle) wxapp_install_idle_handler();    if (!win->m_hasVMT) return FALSE;    if (g_blockEventsOnDrag) return TRUE;    if (g_blockEventsOnScroll) return TRUE;    if (win->m_isDragging) return TRUE;    GtkPizza *pizza = GTK_PIZZA(widget);    if (gdk_event->window != pizza->bin_window) return TRUE;    wxClientDC dc(win);    dc.SetFont( *wxSMALL_FONT );    int height = dc.GetCharHeight() + 1;    if (gdk_event->y > height) return TRUE;    gdk_window_raise( win->m_widget->window );    gdk_pointer_grab( widget->window, FALSE,                      (GdkEventMask)                         (GDK_BUTTON_PRESS_MASK |                          GDK_BUTTON_RELEASE_MASK |                          GDK_POINTER_MOTION_MASK        |                          GDK_POINTER_MOTION_HINT_MASK  |                          GDK_BUTTON_MOTION_MASK        |                          GDK_BUTTON1_MOTION_MASK),                      NULL,                      NULL,                      (unsigned int) GDK_CURRENT_TIME );    win->m_diffX = (int)gdk_event->x;    win->m_diffY = (int)gdk_event->y;    DrawFrame( widget, 0, 0, win->m_width, win->m_height );    win->m_oldX = 0;    win->m_oldY = 0;    win->m_isDragging = true;    return TRUE;}

void wxMDIParentFrame::GtkOnSize( int x, int y, int width, int height ){    wxFrame::GtkOnSize( x, y, width, height );    wxMDIChildFrame *child_frame = GetActiveChild();    if (!child_frame) return;    wxMenuBar *menu_bar = child_frame->m_menuBar;    if (!menu_bar) return;    if (!menu_bar->m_widget) return;    menu_bar->m_x = 0;    menu_bar->m_y = 0;    menu_bar->m_width = m_width;    menu_bar->m_height = wxMENU_HEIGHT;    gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),                          menu_bar->m_widget,                          0, 0, m_width, wxMENU_HEIGHT );}