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 );
}
