/////////////////////////////////////////////////////////////////////////////
-// Name: gtk/window.cpp
+// Name: src/gtk/window.cpp
// Purpose:
// Author: Robert Roebling
// Id: $Id$
#endif
#include "wx/window.h"
+
+#ifndef WX_PRECOMP
+ #include "wx/intl.h"
+ #include "wx/log.h"
+ #include "wx/app.h"
+ #include "wx/utils.h"
+ #include "wx/frame.h"
+#endif
+
#include "wx/dcclient.h"
-#include "wx/frame.h"
-#include "wx/app.h"
#include "wx/layout.h"
-#include "wx/utils.h"
#include "wx/dialog.h"
#include "wx/msgdlg.h"
#include "wx/module.h"
#include "wx/combobox.h"
+#if wxUSE_TOOLBAR_NATIVE
+#include "wx/toolbar.h"
+#endif
#if wxUSE_DRAG_AND_DROP
#include "wx/dnd.h"
#include "wx/menu.h"
#include "wx/statusbr.h"
-#include "wx/intl.h"
#include "wx/settings.h"
-#include "wx/log.h"
#include "wx/fontutil.h"
-#include "wx/stattext.h"
#ifdef __WXDEBUG__
#include "wx/thread.h"
gint y)
{
if (!window)
- window = GDK_ROOT_PARENT();
+ window = gdk_get_default_root_window();
if (!GDK_WINDOW_DESTROYED(window))
{
}
}
-//-----------------------------------------------------------------------------
-// idle system
-//-----------------------------------------------------------------------------
-
-extern void wxapp_install_idle_handler();
-extern bool g_isIdle;
-
//-----------------------------------------------------------------------------
// local code (see below)
//-----------------------------------------------------------------------------
return (wxWindow *)NULL;
}
+static void GetScrollbarWidth(GtkWidget* widget, int& w, int& h)
+{
+ GtkScrolledWindow* scroll_window = GTK_SCROLLED_WINDOW(widget);
+ GtkScrolledWindowClass* scroll_class = GTK_SCROLLED_WINDOW_CLASS(GTK_OBJECT_GET_CLASS(scroll_window));
+ GtkRequisition scroll_req;
+
+ w = 0;
+ if (scroll_window->vscrollbar_visible)
+ {
+ scroll_req.width = 2;
+ scroll_req.height = 2;
+ (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->vscrollbar) )->size_request )
+ (scroll_window->vscrollbar, &scroll_req );
+ w = scroll_req.width +
+ scroll_class->scrollbar_spacing;
+ }
+
+ h = 0;
+ if (scroll_window->hscrollbar_visible)
+ {
+ scroll_req.width = 2;
+ scroll_req.height = 2;
+ (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->hscrollbar) )->size_request )
+ (scroll_window->hscrollbar, &scroll_req );
+ h = scroll_req.height +
+ scroll_class->scrollbar_spacing;
+ }
+}
+
static void draw_frame( GtkWidget *widget, wxWindowGTK *win )
{
// wxUniversal widgets draw the borders and scrollbars themselves
if (win->m_hasScrolling)
{
- GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(widget);
-
- GtkRequisition vscroll_req;
- vscroll_req.width = 2;
- vscroll_req.height = 2;
- (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->vscrollbar) )->size_request )
- (scroll_window->vscrollbar, &vscroll_req );
-
- GtkRequisition hscroll_req;
- hscroll_req.width = 2;
- hscroll_req.height = 2;
- (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->hscrollbar) )->size_request )
- (scroll_window->hscrollbar, &hscroll_req );
-
- GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(widget) );
-
- if (scroll_window->vscrollbar_visible)
- {
- dw += vscroll_req.width;
- dw += scroll_class->scrollbar_spacing;
- }
-
- if (scroll_window->hscrollbar_visible)
- {
- dh += hscroll_req.height;
- dh += scroll_class->scrollbar_spacing;
- }
+ GetScrollbarWidth(widget, dw, dh);
}
int dx = 0;
gdk_draw_rectangle( widget->window, gc, FALSE,
dx, dy,
widget->allocation.width-dw-1, widget->allocation.height-dh-1 );
- gdk_gc_unref( gc );
+ g_object_unref (G_OBJECT (gc));
return;
}
#endif // __WXUNIVERSAL__
//-----------------------------------------------------------------------------
extern "C" {
-static gint gtk_window_own_expose_callback( GtkWidget *widget, GdkEventExpose *gdk_event, wxWindowGTK *win )
+static gboolean
+gtk_window_own_expose_callback( GtkWidget *widget,
+ GdkEventExpose *gdk_event,
+ wxWindowGTK *win )
{
if (gdk_event->count > 0) return FALSE;
//-----------------------------------------------------------------------------
extern "C" {
-static int gtk_window_expose_callback( GtkWidget *widget,
- GdkEventExpose *gdk_event,
- wxWindow *win )
+static gboolean
+gtk_window_expose_callback( GtkWidget *widget,
+ GdkEventExpose *gdk_event,
+ wxWindow *win )
{
DEBUG_MAIN_THREAD
break;
case GDK_Prior: // == GDK_Page_Up
- key_code = WXK_PRIOR;
+ key_code = WXK_PAGEUP;
break;
case GDK_Next: // == GDK_Page_Down
- key_code = WXK_NEXT;
+ key_code = WXK_PAGEDOWN;
break;
case GDK_End:
break;
case GDK_KP_Prior: // == GDK_KP_Page_Up
- key_code = isChar ? WXK_PRIOR : WXK_NUMPAD_PRIOR;
+ key_code = isChar ? WXK_PAGEUP : WXK_NUMPAD_PAGEUP;
break;
case GDK_KP_Next: // == GDK_KP_Page_Down
- key_code = isChar ? WXK_NEXT : WXK_NUMPAD_NEXT;
+ key_code = isChar ? WXK_PAGEDOWN : WXK_NUMPAD_PAGEDOWN;
break;
case GDK_KP_End:
event.m_rawFlags = 0;
#if wxUSE_UNICODE
event.m_uniChar = gdk_keyval_to_unicode(gdk_event->keyval);
- if ( gdk_event->type == GDK_KEY_PRESS || gdk_event->type == GDK_KEY_RELEASE )
- {
- event.m_uniChar = toupper(event.m_uniChar);
- }
#endif
wxGetMousePosition( &x, &y );
win->ScreenToClient( &x, &y );
wxFillOtherKeyEventFields(event, win, gdk_event);
event.m_keyCode = key_code;
+#if wxUSE_UNICODE
+ if ( gdk_event->type == GDK_KEY_PRESS || gdk_event->type == GDK_KEY_RELEASE )
+ {
+ event.m_uniChar = key_code;
+ }
+#endif
return true;
}
};
extern "C" {
-static gint gtk_window_key_press_callback( GtkWidget *widget,
- GdkEventKey *gdk_event,
- wxWindow *win )
+static gboolean
+gtk_window_key_press_callback( GtkWidget *widget,
+ GdkEventKey *gdk_event,
+ wxWindow *win )
{
DEBUG_MAIN_THREAD
if (intercepted_by_IM)
{
wxLogTrace(TRACE_KEYS, _T("Key event intercepted by IM"));
- return true;
+ return TRUE;
}
}
if (return_after_IM)
- return false;
+ return FALSE;
#if wxUSE_ACCEL
if (!ret)
#if wxUSE_UNICODE
event.m_uniChar = event.m_keyCode;
#endif
- }
+ }
// Implement OnCharHook by checking ancestor top level windows
wxWindow *parent = win;
}
extern "C" {
-static void gtk_wxwindow_commit_cb (GtkIMContext *context,
- const gchar *str,
- wxWindow *window)
+static void
+gtk_wxwindow_commit_cb (GtkIMContext *context,
+ const gchar *str,
+ wxWindow *window)
{
wxKeyEvent event( wxEVT_KEY_DOWN );
window, window->m_imData->lastKeyEvent);
}
-#if wxUSE_UNICODE
- const wxWCharBuffer data = wxConvUTF8.cMB2WC( (char*)str );
-#else
- const wxWCharBuffer wdata = wxConvUTF8.cMB2WC( (char*)str );
- const wxCharBuffer data = wxConvLocal.cWC2MB( wdata );
-#endif // wxUSE_UNICODE
- if( !(const wxChar*)data )
+ const wxWxCharBuffer data(wxGTK_CONV_BACK(str));
+ if( !data )
return;
bool ret = false;
event.m_keyCode = *pstr - 'a' + 1;
#if wxUSE_UNICODE
event.m_uniChar = event.m_keyCode;
-#endif
- }
+#endif
+ }
if (parent)
{
//-----------------------------------------------------------------------------
extern "C" {
-static gint gtk_window_key_release_callback( GtkWidget *widget,
- GdkEventKey *gdk_event,
- wxWindowGTK *win )
+static gboolean
+gtk_window_key_release_callback( GtkWidget *widget,
+ GdkEventKey *gdk_event,
+ wxWindowGTK *win )
{
DEBUG_MAIN_THREAD
//-----------------------------------------------------------------------------
extern "C" {
-static gint gtk_window_button_press_callback( GtkWidget *widget,
- GdkEventButton *gdk_event,
- wxWindowGTK *win )
+static gboolean
+gtk_window_button_press_callback( GtkWidget *widget,
+ GdkEventButton *gdk_event,
+ wxWindowGTK *win )
{
DEBUG_MAIN_THREAD
if ( !g_captureWindow )
win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
+ // reset the event object and id in case win changed.
+ event.SetEventObject( win );
+ event.SetId( win->GetId() );
+
if (win->GetEventHandler()->ProcessEvent( event ))
{
g_signal_stop_emission_by_name (widget, "button_press_event");
//-----------------------------------------------------------------------------
extern "C" {
-static gint gtk_window_button_release_callback( GtkWidget *widget,
- GdkEventButton *gdk_event,
- wxWindowGTK *win )
+static gboolean
+gtk_window_button_release_callback( GtkWidget *widget,
+ GdkEventButton *gdk_event,
+ wxWindowGTK *win )
{
DEBUG_MAIN_THREAD
if ( !g_captureWindow )
win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
+ // reset the event object and id in case win changed.
+ event.SetEventObject( win );
+ event.SetId( win->GetId() );
+
if (win->GetEventHandler()->ProcessEvent( event ))
{
g_signal_stop_emission_by_name (widget, "button_release_event");
//-----------------------------------------------------------------------------
extern "C" {
-static gint gtk_window_motion_notify_callback( GtkWidget *widget,
- GdkEventMotion *gdk_event,
- wxWindowGTK *win )
+static gboolean
+gtk_window_motion_notify_callback( GtkWidget *widget,
+ GdkEventMotion *gdk_event,
+ wxWindowGTK *win )
{
DEBUG_MAIN_THREAD
else // no capture
{
win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
+
+ // reset the event object and id in case win changed.
+ event.SetEventObject( win );
+ event.SetId( win->GetId() );
}
if ( !g_captureWindow )
// Rewrite cursor handling here (away from idle).
}
}
-
+
if (win->GetEventHandler()->ProcessEvent( event ))
{
g_signal_stop_emission_by_name (widget, "motion_notify_event");
//-----------------------------------------------------------------------------
extern "C" {
-static gint gtk_window_wheel_callback (GtkWidget * widget,
- GdkEventScroll * gdk_event,
- wxWindowGTK * win)
+static gboolean
+gtk_window_wheel_callback (GtkWidget * widget,
+ GdkEventScroll * gdk_event,
+ wxWindowGTK * win)
{
DEBUG_MAIN_THREAD
}
extern "C" {
-static gboolean gtk_window_focus_in_callback( GtkWidget *widget,
- GdkEvent *WXUNUSED(event),
- wxWindow *win )
+static gboolean
+gtk_window_focus_in_callback( GtkWidget *widget,
+ GdkEventFocus *WXUNUSED(event),
+ wxWindow *win )
{
DEBUG_MAIN_THREAD
win->m_hasFocus = true;
(void)DoSendFocusEvents(win);
-
- ret = true;
+
+ ret = TRUE;
}
// Disable default focus handling for custom windows
// since the default GTK+ handler issues a repaint
if (win->m_wxwindow)
return ret;
-
- return false;
+
+ return FALSE;
}
}
//-----------------------------------------------------------------------------
extern "C" {
-static gboolean gtk_window_focus_out_callback( GtkWidget *widget,
- GdkEventFocus *gdk_event,
- wxWindowGTK *win )
+static gboolean
+gtk_window_focus_out_callback( GtkWidget *widget,
+ GdkEventFocus *gdk_event,
+ wxWindowGTK *win )
{
DEBUG_MAIN_THREAD
event.SetEventObject( win );
(void)win->GetEventHandler()->ProcessEvent( event );
-
- ret = true;
+
+ ret = TRUE;
}
-
+
// Disable default focus handling for custom windows
// since the default GTK+ handler issues a repaint
if (win->m_wxwindow)
return ret;
-
- return false;
+
+ return FALSE;
}
}
// Rewrite cursor handling here (away from idle).
}
}
-
+
if (win->GetEventHandler()->ProcessEvent( event ))
{
g_signal_stop_emission_by_name (widget, "enter_notify_event");
//-----------------------------------------------------------------------------
extern "C" {
-static gint gtk_scrollbar_button_press_callback( GtkRange *widget,
- GdkEventButton *gdk_event,
- wxWindowGTK *win)
+static gboolean
+gtk_scrollbar_button_press_callback( GtkWidget *widget,
+ GdkEventButton *gdk_event,
+ wxWindowGTK *win)
{
DEBUG_MAIN_THREAD
//-----------------------------------------------------------------------------
extern "C" {
-static gint gtk_scrollbar_button_release_callback( GtkRange *widget,
- GdkEventButton *WXUNUSED(gdk_event),
- wxWindowGTK *win)
+static gboolean
+gtk_scrollbar_button_release_callback( GtkRange *widget,
+ GdkEventButton *WXUNUSED(gdk_event),
+ wxWindowGTK *win)
{
DEBUG_MAIN_THREAD
been realized, so we do this directly after realization. */
extern "C" {
-static gint
+static void
gtk_window_realized_callback( GtkWidget *m_widget, wxWindow *win )
{
DEBUG_MAIN_THREAD
wxWindowCreateEvent event( win );
event.SetEventObject( win );
win->GetEventHandler()->ProcessEvent( event );
-
- return FALSE;
}
}
{
gint width, height;
- gdk_window_get_size (widget->window, &width, &height);
+ gdk_drawable_get_size (widget->window, &width, &height);
win->m_icattr->preedit_area.width = width;
win->m_icattr->preedit_area.height = height;
gdk_ic_set_attr (win->m_ic, win->m_icattr, GDK_IC_PREEDIT_AREA);
/* Initialize XIM support */
extern "C" {
-static gint
+static void
gtk_wxwindow_realized_callback( GtkWidget * WXUNUSED_UNLESS_XIM(widget),
wxWindowGTK * WXUNUSED_UNLESS_XIM(win) )
{
wxapp_install_idle_handler();
#ifdef HAVE_XIM
- if (win->m_ic) return FALSE;
- if (!widget) return FALSE;
- if (!gdk_im_ready()) return FALSE;
+ if (win->m_ic) return;
+ if (!widget) return;
+ if (!gdk_im_ready()) return;
win->m_icattr = gdk_ic_attr_new();
- if (!win->m_icattr) return FALSE;
+ if (!win->m_icattr) return;
gint width, height;
GdkEventMask mask;
break;
}
- gdk_window_get_size (widget->window, &width, &height);
+ gdk_drawable_get_size (widget->window, &width, &height);
attrmask |= GDK_IC_PREEDIT_POSITION_REQ;
attr->spot_location.x = 0;
gdk_im_begin (win->m_ic, widget->window);
}
#endif // HAVE_XIM
-
- return FALSE;
}
}
y = currentY;
AdjustForParentClientOrigin(x, y, sizeFlags);
- if (m_parent->m_wxwindow == NULL) /* i.e. wxNotebook */
+ // calculate the best size if we should auto size the window
+ if ( ((sizeFlags & wxSIZE_AUTO_WIDTH) && width == -1) ||
+ ((sizeFlags & wxSIZE_AUTO_HEIGHT) && height == -1) )
{
- /* don't set the size for children of wxNotebook, just take the values. */
+ const wxSize sizeBest = GetBestSize();
+ if ( (sizeFlags & wxSIZE_AUTO_WIDTH) && width == -1 )
+ width = sizeBest.x;
+ if ( (sizeFlags & wxSIZE_AUTO_HEIGHT) && height == -1 )
+ height = sizeBest.y;
+ }
+
+ if (width != -1)
+ m_width = width;
+ if (height != -1)
+ m_height = height;
+
+ int minWidth = GetMinWidth(),
+ minHeight = GetMinHeight(),
+ maxWidth = GetMaxWidth(),
+ maxHeight = GetMaxHeight();
+
+ if ((minWidth != -1) && (m_width < minWidth )) m_width = minWidth;
+ if ((minHeight != -1) && (m_height < minHeight)) m_height = minHeight;
+ if ((maxWidth != -1) && (m_width > maxWidth )) m_width = maxWidth;
+ if ((maxHeight != -1) && (m_height > maxHeight)) m_height = maxHeight;
+
+#if wxUSE_TOOLBAR_NATIVE
+ if (wxDynamicCast(GetParent(), wxToolBar))
+ {
+ // don't take the x,y values, they're wrong because toolbar sets them
+ GtkWidget *widget = GTK_WIDGET(m_widget);
+ gtk_widget_set_size_request (widget, m_width, m_height);
+ if (GTK_WIDGET_VISIBLE (widget))
+ gtk_widget_queue_resize (widget);
+ }
+ else
+#endif
+ if (m_parent->m_wxwindow == NULL) // i.e. wxNotebook
+ {
+ // don't set the size for children of wxNotebook, just take the values.
m_x = x;
m_y = y;
m_width = width;
m_y = y + pizza->yoffset;
}
- // calculate the best size if we should auto size the window
- if ( ((sizeFlags & wxSIZE_AUTO_WIDTH) && width == -1) ||
- ((sizeFlags & wxSIZE_AUTO_HEIGHT) && height == -1) )
- {
- const wxSize sizeBest = GetBestSize();
- if ( (sizeFlags & wxSIZE_AUTO_WIDTH) && width == -1 )
- width = sizeBest.x;
- if ( (sizeFlags & wxSIZE_AUTO_HEIGHT) && height == -1 )
- height = sizeBest.y;
- }
-
- if (width != -1)
- m_width = width;
- if (height != -1)
- m_height = height;
-
- int minWidth = GetMinWidth(),
- minHeight = GetMinHeight(),
- maxWidth = GetMaxWidth(),
- maxHeight = GetMaxHeight();
-
- if ((minWidth != -1) && (m_width < minWidth)) m_width = minWidth;
- if ((minHeight != -1) && (m_height < minHeight)) m_height = minHeight;
- if ((maxWidth != -1) && (m_width > maxWidth)) m_width = maxWidth;
- if ((maxHeight != -1) && (m_height > maxHeight)) m_height = maxHeight;
-
int left_border = 0;
int right_border = 0;
int top_border = 0;
{
wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
- if (!m_wxwindow)
- {
- SetSize( width, height );
- }
- else
+ if (m_wxwindow)
{
int dw = 0;
int dh = 0;
+ if (m_hasScrolling)
+ {
+ GetScrollbarWidth(m_widget, dw, dh);
+ }
+
#ifndef __WXUNIVERSAL__
if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
{
- /* when using GTK 1.2 we set the shadow border size to 2 */
+ // shadow border size is 2
dw += 2 * 2;
dh += 2 * 2;
}
if (HasFlag(wxSIMPLE_BORDER))
{
- /* when using GTK 1.2 we set the simple border size to 1 */
+ // simple border size is 1
dw += 1 * 2;
dh += 1 * 2;
}
#endif // __WXUNIVERSAL__
- if (m_hasScrolling)
- {
- GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
-
- GtkRequisition vscroll_req;
- vscroll_req.width = 2;
- vscroll_req.height = 2;
- (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->vscrollbar) )->size_request )
- (scroll_window->vscrollbar, &vscroll_req );
-
- GtkRequisition hscroll_req;
- hscroll_req.width = 2;
- hscroll_req.height = 2;
- (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->hscrollbar) )->size_request )
- (scroll_window->hscrollbar, &hscroll_req );
-
- GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
-
- if (scroll_window->vscrollbar_visible)
- {
- dw += vscroll_req.width;
- dw += scroll_class->scrollbar_spacing;
- }
-
- if (scroll_window->hscrollbar_visible)
- {
- dh += hscroll_req.height;
- dh += scroll_class->scrollbar_spacing;
- }
- }
-
- SetSize( width+dw, height+dh );
+ width += dw;
+ height += dh;
}
+
+ SetSize(width, height);
}
void wxWindowGTK::DoGetClientSize( int *width, int *height ) const
{
wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
- if (!m_wxwindow)
- {
- if (width) (*width) = m_width;
- if (height) (*height) = m_height;
- }
- else
+ int w = m_width;
+ int h = m_height;
+
+ if (m_wxwindow)
{
int dw = 0;
int dh = 0;
+ if (m_hasScrolling)
+ {
+ GetScrollbarWidth(m_widget, dw, dh);
+ }
+
#ifndef __WXUNIVERSAL__
if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
{
- /* when using GTK 1.2 we set the shadow border size to 2 */
+ // shadow border size is 2
dw += 2 * 2;
dh += 2 * 2;
}
if (HasFlag(wxSIMPLE_BORDER))
{
- /* when using GTK 1.2 we set the simple border size to 1 */
+ // simple border size is 1
dw += 1 * 2;
dh += 1 * 2;
}
#endif // __WXUNIVERSAL__
- if (m_hasScrolling)
- {
- GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
-
- GtkRequisition vscroll_req;
- vscroll_req.width = 2;
- vscroll_req.height = 2;
- (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->vscrollbar) )->size_request )
- (scroll_window->vscrollbar, &vscroll_req );
-
- GtkRequisition hscroll_req;
- hscroll_req.width = 2;
- hscroll_req.height = 2;
- (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->hscrollbar) )->size_request )
- (scroll_window->hscrollbar, &hscroll_req );
-
- GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
-
- if (scroll_window->vscrollbar_visible)
- {
- dw += vscroll_req.width;
- dw += scroll_class->scrollbar_spacing;
- }
-
- if (scroll_window->hscrollbar_visible)
- {
- dh += hscroll_req.height;
- dh += scroll_class->scrollbar_spacing;
- }
- }
-
- if (width) (*width) = m_width - dw;
- if (height) (*height) = m_height - dh;
+ w -= dw;
+ h -= dh;
}
-/*
- printf( "GetClientSize, name %s ", GetName().c_str() );
- if (width) printf( " width = %d", (*width) );
- if (height) printf( " height = %d", (*height) );
- printf( "\n" );
-*/
+ if (width) *width = w;
+ if (height) *height = h;
}
void wxWindowGTK::DoGetPosition( int *x, int *y ) const
PangoLayout *layout = pango_layout_new(context);
pango_layout_set_font_description(layout, desc);
{
-#if wxUSE_UNICODE
- const wxCharBuffer data = wxConvUTF8.cWC2MB( string );
- pango_layout_set_text(layout, (const char*) data, strlen( (const char*) data ));
-#else
- const wxWCharBuffer wdata = wxConvLocal.cMB2WC( string );
- const wxCharBuffer data = wxConvUTF8.cWC2MB( wdata );
- pango_layout_set_text(layout, (const char*) data, strlen( (const char*) data ));
-#endif
+ const wxCharBuffer data = wxGTK_CONV( string );
+ if ( data )
+ pango_layout_set_text(layout, data, strlen(data));
}
PangoRectangle rect;
wxapp_install_idle_handler();
}
+bool wxWindowGTK::GTKWidgetNeedsMnemonic() const
+{
+ // none needed by default
+ return false;
+}
+
+void wxWindowGTK::GTKWidgetDoSetMnemonic(GtkWidget* WXUNUSED(w))
+{
+ // nothing to do by default since none is needed
+}
+
void wxWindowGTK::RealizeTabOrder()
{
if (m_wxwindow)
{
if ( !m_children.empty() )
{
-#if wxUSE_STATTEXT
// we don't only construct the correct focus chain but also use
- // this opportunity to update the mnemonic widgets for all labels
- //
- // it would be nice to extract this code from here and put it in
- // stattext.cpp to reduce dependencies but there is no really easy
- // way to do it unfortunately
- wxStaticText *lastLabel = NULL;
-#endif // wxUSE_STATTEXT
+ // this opportunity to update the mnemonic widgets for the widgets
+ // that need them
GList *chain = NULL;
+ wxWindowGTK* mnemonicWindow = NULL;
for ( wxWindowList::const_iterator i = m_children.begin();
i != m_children.end();
++i )
{
wxWindowGTK *win = *i;
-#if wxUSE_STATTEXT
- if ( lastLabel )
+
+ if ( mnemonicWindow )
{
if ( win->AcceptsFocusFromKeyboard() )
{
- GtkLabel *l = GTK_LABEL(lastLabel->m_widget);
- gtk_label_set_mnemonic_widget(l, win->m_widget);
- lastLabel = NULL;
+ // wxComboBox et al. needs to focus on on a different
+ // widget than m_widget, so if the main widget isn't
+ // focusable try the connect widget
+ GtkWidget* w = win->m_widget;
+ if ( !GTK_WIDGET_CAN_FOCUS(w) )
+ {
+ w = win->GetConnectWidget();
+ if ( !GTK_WIDGET_CAN_FOCUS(w) )
+ w = NULL;
+ }
+
+ if ( w )
+ {
+ mnemonicWindow->GTKWidgetDoSetMnemonic(w);
+ mnemonicWindow = NULL;
+ }
}
}
- else // check if this one is a label
+ else if ( win->GTKWidgetNeedsMnemonic() )
{
- lastLabel = wxDynamicCast(win, wxStaticText);
+ mnemonicWindow = win;
}
-#endif // wxUSE_STATTEXT
chain = g_list_prepend(chain, win->m_widget);
}
wxCHECK_RET( window, _T("CaptureMouse() failed") );
- wxCursor* cursor = & m_cursor;
+ const wxCursor* cursor = &m_cursor;
if (!cursor->Ok())
cursor = wxSTANDARD_CURSOR;
m_clipPaintRegion = false;
}
+void wxWindowGTK::GtkScrolledWindowSetBorder(GtkWidget* w, int wxstyle)
+{
+ //RN: Note that static controls usually have no border on gtk, so maybe
+ //it makes sense to treat that as simply no border at the wx level
+ //as well...
+ if (!(wxstyle & wxNO_BORDER) && !(wxstyle & wxBORDER_STATIC))
+ {
+ GtkShadowType gtkstyle;
+
+ if(wxstyle & wxBORDER_RAISED)
+ gtkstyle = GTK_SHADOW_OUT;
+ else if (wxstyle & wxBORDER_SUNKEN)
+ gtkstyle = GTK_SHADOW_IN;
+ else if (wxstyle & wxBORDER_DOUBLE)
+ gtkstyle = GTK_SHADOW_ETCHED_IN;
+ else //default
+ gtkstyle = GTK_SHADOW_IN;
+
+ gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW(w),
+ gtkstyle );
+ }
+}
+
void wxWindowGTK::SetWindowStyleFlag( long style )
{
// Updates the internal variable. NB: Now m_windowStyle bits carry the _new_ style values already
bool wxWinModule::OnInit()
{
- // g_eraseGC = gdk_gc_new( GDK_ROOT_PARENT() );
+ // g_eraseGC = gdk_gc_new( gdk_get_default_root_window() );
// gdk_gc_set_fill( g_eraseGC, GDK_SOLID );
return true;
void wxWinModule::OnExit()
{
if (g_eraseGC)
- gdk_gc_unref( g_eraseGC );
+ g_object_unref (G_OBJECT (g_eraseGC));
}
-
projects / wxWidgets.git / blobdiff