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 void gtk_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 void gtk_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 void gtk_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 void gtk_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); } }
void wxGLContext::SwapBuffers() { if (m_glContext) { GdkWindow *window = GTK_PIZZA(m_widget)->bin_window; glXSwapBuffers( GDK_DISPLAY(), GDK_WINDOW_XWINDOW( window ) ); } }
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 void gtk_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 void gtk_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); }
void wxGLContext::SetCurrent() { if (m_glContext) { GdkWindow *window = GTK_PIZZA(m_widget)->bin_window; 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 ); } }
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 void gtk_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 wxStatusBarGeneric::OnLeftDown(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 ); if (GetLayoutDirection() == wxLayout_RightToLeft) { gtk_window_begin_resize_drag (GTK_WINDOW (ancestor), GDK_WINDOW_EDGE_SOUTH_WEST, 1, org_x - event.GetX() + GetSize().x , org_y + event.GetY(), 0); } else { gtk_window_begin_resize_drag (GTK_WINDOW (ancestor), GDK_WINDOW_EDGE_SOUTH_EAST, 1, org_x + event.GetX(), org_y + event.GetY(), 0); } } else { event.Skip( true ); } #else event.Skip( true ); #endif }
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 void gtk_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 ); }