Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Remove GTK2 stuff from src/gtk1. Rename wx/gtk includes to wx/gtk1.

Browse Source 
57 files changed, 394 insertions(+), 6767 deletions(-)


git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@37063 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Mart Raudsepp
2006-01-23 01:14:32 +00:00
parent 9fa72bd2a6
commit 3cbab64109
57 changed files with 403 additions and 6777 deletions
Download Patch File Download Diff File Expand all files Collapse all files

579
src/gtk1/window.cpp
View File

@@ -55,7 +55,7 @@
#include "wx/math.h"
#include <ctype.h>
#include "wx/gtk/private.h"
#include "wx/gtk1/private.h"
#include <gdk/gdkprivate.h>
#include <gdk/gdkkeysyms.h>
#include <gdk/gdkx.h>
@@ -63,22 +63,7 @@
#include <gtk/gtk.h>
#include <gtk/gtkprivate.h>
#include "wx/gtk/win_gtk.h"
#ifdef __WXGTK20__
#include <pango/pangox.h>
#endif
#ifdef __WXGTK20__
#ifdef HAVE_XIM
#undef HAVE_XIM
#endif
#endif
#ifdef __WXGTK20__
extern GtkContainerClass *pizza_parent_class;
#endif
#include "wx/gtk1/win_gtk.h"
//-----------------------------------------------------------------------------
// documentation on internals
@@ -239,9 +224,7 @@ wxWindowGTK *g_delayedFocus = (wxWindowGTK*) NULL;
// hack: we need something to pass to gtk_menu_popup, so we store the time of
// the last click here (extern: used from gtk/menu.cpp)
#ifndef __WXGTK20__
guint32 wxGtkTimeLastClick = 0;
#endif
extern bool g_mainThreadLocked;
@@ -272,23 +255,11 @@ gdk_window_warp_pointer (GdkWindow *window,
gint x,
gint y)
{
#ifndef __WXGTK20__
GdkWindowPrivate *priv;
#endif
if (!window)
window = GDK_ROOT_PARENT();
#ifdef __WXGTK20__
if (!GDK_WINDOW_DESTROYED(window))
{
XWarpPointer (GDK_WINDOW_XDISPLAY(window),
None, /* not source window -> move from anywhere */
GDK_WINDOW_XID(window), /* dest window */
0, 0, 0, 0, /* not source window -> move from anywhere */
x, y );
}
#else
priv = (GdkWindowPrivate*) window;
if (!priv->destroyed)
@@ -299,7 +270,6 @@ gdk_window_warp_pointer (GdkWindow *window,
0, 0, 0, 0, /* not source window -> move from anywhere */
x, y );
}
#endif
}
//-----------------------------------------------------------------------------
@@ -433,11 +403,6 @@ static gint gtk_window_own_expose_callback( GtkWidget *widget, GdkEventExpose *g
draw_frame( widget, win );
#ifdef __WXGTK20__
(* GTK_WIDGET_CLASS (pizza_parent_class)->expose_event) (widget, gdk_event);
#endif
return TRUE;
}
}
@@ -446,8 +411,6 @@ static gint gtk_window_own_expose_callback( GtkWidget *widget, GdkEventExpose *g
// "draw" of m_widget
//-----------------------------------------------------------------------------
#ifndef __WXGTK20__
extern "C" {
static void gtk_window_own_draw_callback( GtkWidget *widget, GdkRectangle *WXUNUSED(rect), wxWindowGTK *win )
{
@@ -455,8 +418,6 @@ static void gtk_window_own_draw_callback( GtkWidget *widget, GdkRectangle *WXUNU
}
}
#endif // GTK+ < 2.0
//-----------------------------------------------------------------------------
// "size_request" of m_widget
//-----------------------------------------------------------------------------
@@ -522,47 +483,6 @@ static int gtk_window_expose_callback( GtkWidget *widget,
if (g_isIdle)
wxapp_install_idle_handler();
#ifdef __WXGTK20__
// This callback gets called in drawing-idle time under
// GTK 2.0, so we don't need to defer anything to idle
// time anymore.
GtkPizza *pizza = GTK_PIZZA( widget );
if (gdk_event->window != pizza->bin_window) return FALSE;
#if 0
if (win->GetName())
{
wxPrintf( wxT("OnExpose from ") );
if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
wxPrintf( win->GetClassInfo()->GetClassName() );
wxPrintf( wxT(" %d %d %d %d\n"), (int)gdk_event->area.x,
(int)gdk_event->area.y,
(int)gdk_event->area.width,
(int)gdk_event->area.height );
}
gtk_paint_box
(
win->m_wxwindow->style,
pizza->bin_window,
GTK_STATE_NORMAL,
GTK_SHADOW_OUT,
(GdkRectangle*) NULL,
win->m_wxwindow,
(char *)"button", // const_cast
20,20,24,24
);
#endif
win->GetUpdateRegion() = wxRegion( gdk_event->region );
win->GtkSendPaintEvents();
// Let parent window draw window-less widgets
(* GTK_WIDGET_CLASS (pizza_parent_class)->expose_event) (widget, gdk_event);
#else
// This gets called immediately after an expose event
// under GTK 1.2 so we collect the calls and wait for
// the idle handler to pick things up.
@@ -578,7 +498,6 @@ static int gtk_window_expose_callback( GtkWidget *widget,
// Actual redrawing takes place in idle time.
// win->GtkUpdate();
#endif
return FALSE;
}
@@ -588,8 +507,6 @@ static int gtk_window_expose_callback( GtkWidget *widget,
// "event" of m_wxwindow
//-----------------------------------------------------------------------------
#ifndef __WXGTK20__
// GTK thinks it is clever and filters out a certain amount of "unneeded"
// expose events. We need them, of course, so we override the main event
// procedure in GtkWidget by giving our own handler for all system events.
@@ -612,14 +529,10 @@ gint gtk_window_event_event_callback( GtkWidget *widget,
}
}
#endif // !GTK+ 2
//-----------------------------------------------------------------------------
// "draw" of m_wxwindow
//-----------------------------------------------------------------------------
#ifndef __WXGTK20__
// This callback is a complete replacement of the gtk_pizza_draw() function,
// which is disabled.
@@ -701,8 +614,6 @@ static void gtk_window_draw_callback( GtkWidget *widget,
}
}
#endif
//-----------------------------------------------------------------------------
// "key_press_event" from any window
//-----------------------------------------------------------------------------
@@ -1125,24 +1036,6 @@ wxTranslateGTKKeyEventToWx(wxKeyEvent& event,
}
#ifdef __WXGTK20__
struct wxGtkIMData
{
GtkIMContext *context;
GdkEventKey *lastKeyEvent;
wxGtkIMData()
{
context = gtk_im_multicontext_new();
lastKeyEvent = NULL;
}
~wxGtkIMData()
{
g_object_unref(context);
}
};
#endif
extern "C" {
static gint gtk_window_key_press_callback( GtkWidget *widget,
GdkEventKey *gdk_event,
@@ -1170,39 +1063,12 @@ static gint gtk_window_key_press_callback( GtkWidget *widget,
return_after_IM = true;
}
#ifdef __WXGTK20__
// 2005.01.26 modified by Hong Jen Yee (hzysoft@sina.com.tw):
// When we get a key_press event here, it could be originate
// from the current widget or its child widgets. However, only the widget
// with the INPUT FOCUS can generate the INITIAL key_press event. That is,
// if the CURRENT widget doesn't have the FOCUS at all, this event definitely
// originated from its child widgets and shouldn't be passed to IM context.
// In fact, what a GTK+ IM should do is filtering keyEvents and convert them
// into text input ONLY WHEN THE WIDGET HAS INPUT FOCUS. Besides, when current
// widgets has both IM context and input focus, the event should be filtered
// by gtk_im_context_filter_keypress().
// Then, we should, according to GTK+ 2.0 API doc, return whatever it returns.
if ((!ret) && (win->m_imData != NULL) && ( wxWindow::FindFocus() == win ))
{
// We should let GTK+ IM filter key event first. According to GTK+ 2.0 API
// docs, if IM filter returns true, no further processing should be done.
// we should send the key_down event anyway.
bool intercepted_by_IM = gtk_im_context_filter_keypress(win->m_imData->context, gdk_event);
win->m_imData->lastKeyEvent = NULL;
if (intercepted_by_IM)
{
wxLogTrace(TRACE_KEYS, _T("Key event intercepted by IM"));
return true;
}
}
#endif
if (return_after_IM)
return false;
// Emit KEY_DOWN event
ret = win->GetEventHandler()->ProcessEvent( event );
#ifndef __WXGTK20__
// This is for GTK+ 1.2 only. The char event generatation for GTK+ 2.0 is done
// in the "commit" handler.
@@ -1261,8 +1127,6 @@ static gint gtk_window_key_press_callback( GtkWidget *widget,
return true;
}
#endif // #ifndef __WXGTK20__
#if wxUSE_ACCEL
if (!ret)
{
@@ -1404,65 +1268,6 @@ static gint gtk_window_key_press_callback( GtkWidget *widget,
}
}
#ifdef __WXGTK20__
extern "C" {
static void gtk_wxwindow_commit_cb (GtkIMContext *context,
const gchar *str,
wxWindow *window)
{
wxKeyEvent event( wxEVT_KEY_DOWN );
// take modifiers, cursor position, timestamp etc. from the last
// key_press_event that was fed into Input Method:
if (window->m_imData->lastKeyEvent)
{
wxFillOtherKeyEventFields(event,
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 )
return;
bool ret = false;
// Implement OnCharHook by checking ancestor top level windows
wxWindow *parent = window;
while (parent && !parent->IsTopLevel())
parent = parent->GetParent();
for( const wxChar* pstr = data; *pstr; pstr++ )
{
#if wxUSE_UNICODE
event.m_uniChar = *pstr;
// Backward compatible for ISO-8859-1
event.m_keyCode = *pstr < 256 ? event.m_uniChar : 0;
wxLogTrace(TRACE_KEYS, _T("IM sent character '%c'"), event.m_uniChar);
#else
event.m_keyCode = *pstr;
#endif // wxUSE_UNICODE
if (parent)
{
event.SetEventType( wxEVT_CHAR_HOOK );
ret = parent->GetEventHandler()->ProcessEvent( event );
}
if (!ret)
{
event.SetEventType(wxEVT_CHAR);
ret = window->GetEventHandler()->ProcessEvent( event );
}
}
}
}
#endif
//-----------------------------------------------------------------------------
// "key_release_event" from any window
//-----------------------------------------------------------------------------
@@ -1696,21 +1501,6 @@ static gint gtk_window_button_press_callback( GtkWidget *widget,
wxEventType event_type = wxEVT_NULL;
// GdkDisplay is a GTK+ 2.2.0 thing
#if defined(__WXGTK20__) && GTK_CHECK_VERSION(2, 2, 0)
if ( gdk_event->type == GDK_2BUTTON_PRESS &&
!gtk_check_version(2,2,0) &&
gdk_event->button >= 1 && gdk_event->button <= 3 )
{
// Reset GDK internal timestamp variables in order to disable GDK
// triple click events. GDK will then next time believe no button has
// been clicked just before, and send a normal button click event.
GdkDisplay* display = gtk_widget_get_display (widget);
display->button_click_time[1] = 0;
display->button_click_time[0] = 0;
}
#endif // GTK 2+
if (gdk_event->button == 1)
{
// note that GDK generates triple click events which are not supported
@@ -1799,7 +1589,6 @@ static gint gtk_window_button_press_callback( GtkWidget *widget,
if ( !g_captureWindow )
win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
#ifndef __WXGTK20__
wxGtkTimeLastClick = gdk_event->time;
if (event_type == wxEVT_LEFT_DCLICK)
@@ -1813,7 +1602,6 @@ static gint gtk_window_button_press_callback( GtkWidget *widget,
return FALSE;
}
}
#endif // !__WXGTK20__
if (win->GetEventHandler()->ProcessEvent( event ))
{
@@ -1980,80 +1768,6 @@ static gint gtk_window_motion_notify_callback( GtkWidget *widget,
}
}
#ifdef __WXGTK20__
//-----------------------------------------------------------------------------
// "mouse_wheel_event"
//-----------------------------------------------------------------------------
extern "C" {
static gint gtk_window_wheel_callback (GtkWidget * widget,
GdkEventScroll * gdk_event,
wxWindowGTK * win)
{
DEBUG_MAIN_THREAD
if (g_isIdle)
wxapp_install_idle_handler();
wxEventType event_type = wxEVT_NULL;
if (gdk_event->direction == GDK_SCROLL_UP)
event_type = wxEVT_MOUSEWHEEL;
else if (gdk_event->direction == GDK_SCROLL_DOWN)
event_type = wxEVT_MOUSEWHEEL;
else
return FALSE;
wxMouseEvent event( event_type );
// Can't use InitMouse macro because scroll events don't have button
event.SetTimestamp( gdk_event->time );
event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
event.m_altDown = (gdk_event->state & GDK_MOD1_MASK);
event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK);
event.m_leftDown = (gdk_event->state & GDK_BUTTON1_MASK);
event.m_middleDown = (gdk_event->state & GDK_BUTTON2_MASK);
event.m_rightDown = (gdk_event->state & GDK_BUTTON3_MASK);
event.m_linesPerAction = 3;
event.m_wheelDelta = 120;
if (gdk_event->direction == GDK_SCROLL_UP)
event.m_wheelRotation = 120;
else
event.m_wheelRotation = -120;
wxPoint pt = win->GetClientAreaOrigin();
event.m_x = (wxCoord)gdk_event->x - pt.x;
event.m_y = (wxCoord)gdk_event->y - pt.y;
event.SetEventObject( win );
event.SetId( win->GetId() );
event.SetTimestamp( gdk_event->time );
if (win->GetEventHandler()->ProcessEvent( event ))
{
gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "scroll_event" );
return TRUE;
}
return FALSE;
}
}
//-----------------------------------------------------------------------------
// "popup-menu"
//-----------------------------------------------------------------------------
extern "C" {
static gboolean wxgtk_window_popup_menu_callback(GtkWidget*, wxWindowGTK* win)
{
wxContextMenuEvent event(
wxEVT_CONTEXT_MENU,
win->GetId(),
wxPoint(-1, -1));
event.SetEventObject(win);
return win->GetEventHandler()->ProcessEvent(event);
}
}
#endif // __WXGTK20__
//-----------------------------------------------------------------------------
// "focus_in_event"
//-----------------------------------------------------------------------------
@@ -2083,11 +1797,6 @@ static gint gtk_window_focus_in_callback( GtkWidget *widget,
if (g_isIdle)
wxapp_install_idle_handler();
#ifdef __WXGTK20__
if (win->m_imData)
gtk_im_context_focus_in(win->m_imData->context);
#endif
g_focusWindowLast =
g_focusWindow = win;
@@ -2137,11 +1846,6 @@ static gint gtk_window_focus_out_callback( GtkWidget *widget, GdkEventFocus *gdk
if (g_isIdle)
wxapp_install_idle_handler();
#ifdef __WXGTK20__
if (win->m_imData)
gtk_im_context_focus_out(win->m_imData->context);
#endif
wxLogTrace( TRACE_FOCUS,
_T("%s: focus out"), win->GetName().c_str() );
@@ -2306,9 +2010,7 @@ static void gtk_window_vscroll_callback( GtkAdjustment *adjust,
win->m_oldVerticalPos = adjust->value;
#ifndef __WXGTK20__
GtkScrolledWindow *sw = GTK_SCROLLED_WINDOW(win->m_widget);
#endif
wxEventType command = GtkScrollWinTypeToWx(GET_SCROLL_TYPE(sw->vscrollbar));
int value = (int)(adjust->value+0.5);
@@ -2339,9 +2041,7 @@ static void gtk_window_hscroll_callback( GtkAdjustment *adjust,
float diff = adjust->value - win->m_oldHorizontalPos;
if (fabs(diff) < 0.2) return;
#ifndef __WXGTK20__
GtkScrolledWindow *sw = GTK_SCROLLED_WINDOW(win->m_widget);
#endif
wxEventType command = GtkScrollWinTypeToWx(GET_SCROLL_TYPE(sw->hscrollbar));
win->m_oldHorizontalPos = adjust->value;
@@ -2372,9 +2072,7 @@ static gint gtk_scrollbar_button_press_callback( GtkRange *widget,
g_blockEventsOnScroll = true;
// FIXME: there is no 'slider' field in GTK+ 2.0 any more
#ifndef __WXGTK20__
win->m_isScrolling = (gdk_event->window == widget->slider);
#endif
return FALSE;
}
@@ -2454,15 +2152,6 @@ gtk_window_realized_callback( GtkWidget *m_widget, wxWindow *win )
if (g_isIdle)
wxapp_install_idle_handler();
#ifdef __WXGTK20__
if (win->m_imData)
{
GtkPizza *pizza = GTK_PIZZA( m_widget );
gtk_im_context_set_client_window( win->m_imData->context,
pizza->bin_window );
}
#endif
wxWindowCreateEvent event( win );
event.SetEventObject( win );
win->GetEventHandler()->ProcessEvent( event );
@@ -2751,15 +2440,10 @@ void wxWindowGTK::Init()
m_cursor = *wxSTANDARD_CURSOR;
#ifdef __WXGTK20__
m_imData = NULL;
m_dirtyTabOrder = false;
#else
#ifdef HAVE_XIM
m_ic = (GdkIC*) NULL;
m_icattr = (GdkICAttr*) NULL;
#endif
#endif
}
wxWindowGTK::wxWindowGTK()
@@ -2925,11 +2609,6 @@ wxWindowGTK::~wxWindowGTK()
gdk_ic_attr_destroy (m_icattr);
#endif
#ifdef __WXGTK20__
// delete before the widgets to avoid a crash on solaris
delete m_imData;
#endif
if (m_wxwindow)
{
gtk_widget_destroy( m_wxwindow );
@@ -2973,7 +2652,6 @@ void wxWindowGTK::PostCreation()
gtk_signal_connect( GTK_OBJECT(m_wxwindow), "expose_event",
GTK_SIGNAL_FUNC(gtk_window_expose_callback), (gpointer)this );
#ifndef __WXGTK20__
gtk_signal_connect( GTK_OBJECT(m_wxwindow), "draw",
GTK_SIGNAL_FUNC(gtk_window_draw_callback), (gpointer)this );
@@ -2982,30 +2660,14 @@ void wxWindowGTK::PostCreation()
gtk_signal_connect( GTK_OBJECT(m_wxwindow), "event",
GTK_SIGNAL_FUNC(gtk_window_event_event_callback), (gpointer)this );
}
#else
// gtk_widget_set_redraw_on_allocate( GTK_WIDGET(m_wxwindow), !HasFlag( wxFULL_REPAINT_ON_RESIZE ) );
#endif
}
#ifdef __WXGTK20__
// Create input method handler
m_imData = new wxGtkIMData;
// Cannot handle drawing preedited text yet
gtk_im_context_set_use_preedit( m_imData->context, FALSE );
g_signal_connect (G_OBJECT (m_imData->context), "commit",
G_CALLBACK (gtk_wxwindow_commit_cb), this);
#endif
// these are called when the "sunken" or "raised" borders are drawn
gtk_signal_connect( GTK_OBJECT(m_widget), "expose_event",
GTK_SIGNAL_FUNC(gtk_window_own_expose_callback), (gpointer)this );
#ifndef __WXGTK20__
gtk_signal_connect( GTK_OBJECT(m_widget), "draw",
GTK_SIGNAL_FUNC(gtk_window_own_draw_callback), (gpointer)this );
#endif
}
// focus handling
@@ -3094,13 +2756,6 @@ void wxWindowGTK::ConnectWidget( GtkWidget *widget )
gtk_signal_connect( GTK_OBJECT(widget), "motion_notify_event",
GTK_SIGNAL_FUNC(gtk_window_motion_notify_callback), (gpointer)this );
#ifdef __WXGTK20__
gtk_signal_connect( GTK_OBJECT(widget), "scroll_event",
GTK_SIGNAL_FUNC(gtk_window_wheel_callback), (gpointer)this );
g_signal_connect(widget, "popup_menu",
G_CALLBACK(wxgtk_window_popup_menu_callback), this);
#endif
gtk_signal_connect( GTK_OBJECT(widget), "enter_notify_event",
GTK_SIGNAL_FUNC(gtk_window_enter_callback), (gpointer)this );
@@ -3198,23 +2853,10 @@ void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags
/* the default button has a border around it */
if (GTK_WIDGET_CAN_DEFAULT(m_widget))
{
#ifdef __WXGTK20__
GtkBorder *default_border = NULL;
gtk_widget_style_get( m_widget, "default_border", &default_border, NULL );
if (default_border)
{
left_border += default_border->left;
right_border += default_border->right;
top_border += default_border->top;
bottom_border += default_border->bottom;
g_free( default_border );
}
#else
left_border = 6;
right_border = 6;
top_border = 6;
bottom_border = 5;
#endif
}
DoMoveWindow( m_x-top_border,
@@ -3253,10 +2895,6 @@ void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags
void wxWindowGTK::OnInternalIdle()
{
#ifdef __WXGTK20__
if ( m_dirtyTabOrder )
RealizeTabOrder();
#endif
// Update style if the window was not yet realized
// and SetBackgroundStyle(wxBG_STYLE_CUSTOM) was called
if (m_needsStyleChange)
@@ -3590,31 +3228,9 @@ int wxWindowGTK::GetCharHeight() const
wxFont font = GetFont();
wxCHECK_MSG( font.Ok(), 12, wxT("invalid font") );
#ifdef __WXGTK20__
PangoContext *context = NULL;
if (m_widget)
context = gtk_widget_get_pango_context( m_widget );
if (!context)
return 0;
PangoFontDescription *desc = font.GetNativeFontInfo()->description;
PangoLayout *layout = pango_layout_new(context);
pango_layout_set_font_description(layout, desc);
pango_layout_set_text(layout, "H", 1);
PangoLayoutLine *line = (PangoLayoutLine *)pango_layout_get_lines(layout)->data;
PangoRectangle rect;
pango_layout_line_get_extents(line, NULL, &rect);
g_object_unref( G_OBJECT( layout ) );
return (int) PANGO_PIXELS(rect.height);
#else
GdkFont *gfont = font.GetInternalFont( 1.0 );
return gfont->ascent + gfont->descent;
#endif
}
int wxWindowGTK::GetCharWidth() const
@@ -3624,31 +3240,9 @@ int wxWindowGTK::GetCharWidth() const
wxFont font = GetFont();
wxCHECK_MSG( font.Ok(), 8, wxT("invalid font") );
#ifdef __WXGTK20__
PangoContext *context = NULL;
if (m_widget)
context = gtk_widget_get_pango_context( m_widget );
if (!context)
return 0;
PangoFontDescription *desc = font.GetNativeFontInfo()->description;
PangoLayout *layout = pango_layout_new(context);
pango_layout_set_font_description(layout, desc);
pango_layout_set_text(layout, "g", 1);
PangoLayoutLine *line = (PangoLayoutLine *)pango_layout_get_lines(layout)->data;
PangoRectangle rect;
pango_layout_line_get_extents(line, NULL, &rect);
g_object_unref( G_OBJECT( layout ) );
return (int) PANGO_PIXELS(rect.width);
#else
GdkFont *gfont = font.GetInternalFont( 1.0 );
return gdk_string_width( gfont, "g" );
#endif
}
void wxWindowGTK::GetTextExtent( const wxString& string,
@@ -3669,54 +3263,11 @@ void wxWindowGTK::GetTextExtent( const wxString& string,
return;
}
#ifdef __WXGTK20__
PangoContext *context = NULL;
if (m_widget)
context = gtk_widget_get_pango_context( m_widget );
if (!context)
{
if (x) (*x) = 0;
if (y) (*y) = 0;
return;
}
PangoFontDescription *desc = fontToUse.GetNativeFontInfo()->description;
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
}
PangoRectangle rect;
pango_layout_get_extents(layout, NULL, &rect);
if (x) (*x) = (wxCoord) PANGO_PIXELS(rect.width);
if (y) (*y) = (wxCoord) PANGO_PIXELS(rect.height);
if (descent)
{
PangoLayoutIter *iter = pango_layout_get_iter(layout);
int baseline = pango_layout_iter_get_baseline(iter);
pango_layout_iter_free(iter);
*descent = *y - PANGO_PIXELS(baseline);
}
if (externalLeading) (*externalLeading) = 0; // ??
g_object_unref( G_OBJECT( layout ) );
#else
GdkFont *font = fontToUse.GetInternalFont( 1.0 );
if (x) (*x) = gdk_string_width( font, wxGTK_CONV( string ) );
if (y) (*y) = font->ascent + font->descent;
if (descent) (*descent) = font->descent;
if (externalLeading) (*externalLeading) = 0; // ??
#endif
}
void wxWindowGTK::SetFocus()
@@ -3737,13 +3288,6 @@ void wxWindowGTK::SetFocus()
}
else if (m_widget)
{
#ifdef __WXGTK20__
if (GTK_IS_CONTAINER(m_widget))
{
gtk_widget_child_focus( m_widget, GTK_DIR_TAB_FORWARD );
}
else
#endif
if (GTK_WIDGET_CAN_FOCUS(m_widget) && !GTK_WIDGET_HAS_FOCUS (m_widget) )
{
@@ -3768,13 +3312,11 @@ void wxWindowGTK::SetFocus()
}
}
else
#ifndef __WXGTK20__
if (GTK_IS_CONTAINER(m_widget))
{
gtk_container_focus( GTK_CONTAINER(m_widget), GTK_DIR_TAB_FORWARD );
}
else
#endif
{
wxLogTrace(TRACE_FOCUS,
_T("Can't set focus to %s(%s)"),
@@ -3839,62 +3381,6 @@ void wxWindowGTK::DoAddChild(wxWindowGTK *child)
(*m_insertCallback)(this, child);
}
#ifdef __WXGTK20__
void wxWindowGTK::AddChild(wxWindowBase *child)
{
wxWindowBase::AddChild(child);
m_dirtyTabOrder = true;
if (g_isIdle)
wxapp_install_idle_handler();
}
void wxWindowGTK::RemoveChild(wxWindowBase *child)
{
wxWindowBase::RemoveChild(child);
m_dirtyTabOrder = true;
if (g_isIdle)
wxapp_install_idle_handler();
}
void wxWindowGTK::DoMoveInTabOrder(wxWindow *win, MoveKind move)
{
wxWindowBase::DoMoveInTabOrder(win, move);
m_dirtyTabOrder = true;
if (g_isIdle)
wxapp_install_idle_handler();
}
void wxWindowGTK::RealizeTabOrder()
{
if (m_wxwindow)
{
if (m_children.size() > 0)
{
GList *chain = NULL;
for (wxWindowList::const_iterator i = m_children.begin();
i != m_children.end(); ++i)
{
chain = g_list_prepend(chain, (*i)->m_widget);
}
chain = g_list_reverse(chain);
gtk_container_set_focus_chain(GTK_CONTAINER(m_wxwindow), chain);
g_list_free(chain);
}
else
{
gtk_container_unset_focus_chain(GTK_CONTAINER(m_wxwindow));
}
}
m_dirtyTabOrder = false;
}
#endif // __WXGTK20__
void wxWindowGTK::Raise()
{
wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
@@ -3964,7 +3450,6 @@ void wxWindowGTK::Refresh( bool eraseBackground, const wxRect *rect )
if (!m_widget->window)
return;
#ifndef __WXGTK20__
if (g_isIdle)
wxapp_install_idle_handler();
@@ -4024,27 +3509,6 @@ void wxWindowGTK::Refresh( bool eraseBackground, const wxRect *rect )
gtk_widget_draw( m_widget, (GdkRectangle*) NULL );
}
}
#else // GTK+ 2
if (m_wxwindow)
{
GdkRectangle gdk_rect,
*p;
if (rect)
{
gdk_rect.x = rect->x;
gdk_rect.y = rect->y;
gdk_rect.width = rect->width;
gdk_rect.height = rect->height;
p = &gdk_rect;
}
else // invalidate everything
{
p = NULL;
}
gdk_window_invalidate_rect( GTK_PIZZA(m_wxwindow)->bin_window, p, TRUE );
}
#endif // GTK+ 1/2
}
void wxWindowGTK::Update()
@@ -4060,13 +3524,8 @@ void wxWindowGTK::Update()
void wxWindowGTK::GtkUpdate()
{
#ifdef __WXGTK20__
if (m_wxwindow && GTK_PIZZA(m_wxwindow)->bin_window)
gdk_window_process_updates( GTK_PIZZA(m_wxwindow)->bin_window, FALSE );
#else
if (!m_updateRegion.IsEmpty())
GtkSendPaintEvents();
#endif
// for consistency with other platforms (and also because it's convenient
// to be able to update an entire TLW by calling Update() only once), we
@@ -4083,9 +3542,7 @@ void wxWindowGTK::GtkSendPaintEvents()
{
if (!m_wxwindow)
{
#ifndef __WXGTK20__
m_clearRegion.Clear();
#endif
m_updateRegion.Clear();
return;
}
@@ -4129,17 +3586,6 @@ void wxWindowGTK::GtkSendPaintEvents()
}
else
#ifdef __WXGTK20__
{
wxWindowDC dc( (wxWindow*)this );
dc.SetClippingRegion( m_updateRegion );
wxEraseEvent erase_event( GetId(), &dc );
erase_event.SetEventObject( this );
GetEventHandler()->ProcessEvent(erase_event);
}
#else
// if (!m_clearRegion.IsEmpty()) // Always send an erase event under GTK 1.2
{
wxWindowDC dc( (wxWindow*)this );
@@ -4170,7 +3616,6 @@ void wxWindowGTK::GtkSendPaintEvents()
}
m_clearRegion.Clear();
}
#endif
wxNcPaintEvent nc_paint_event( GetId() );
nc_paint_event.SetEventObject( this );
@@ -4182,7 +3627,7 @@ void wxWindowGTK::GtkSendPaintEvents()
m_clipPaintRegion = false;
#if !defined(__WXUNIVERSAL__) && !defined(__WXGTK20__)
#if !defined(__WXUNIVERSAL__)
// The following code will result in all window-less widgets
// being redrawn because the wxWidgets class is allowed to
// paint over the window-less widgets.
@@ -4232,7 +3677,6 @@ void wxWindowGTK::ClearBackground()
{
wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
#ifndef __WXGTK20__
if (m_wxwindow && m_wxwindow->window)
{
m_clearRegion.Clear();
@@ -4242,7 +3686,6 @@ void wxWindowGTK::ClearBackground()
// Better do this in idle?
GtkUpdate();
}
#endif
}
#if wxUSE_TOOLTIPS
@@ -4304,13 +3747,6 @@ bool wxWindowGTK::SetForegroundColour( const wxColour &colour )
return true;
}
#ifdef __WXGTK20__
PangoContext *wxWindowGTK::GtkGetPangoDefaultContext()
{
return gtk_widget_get_pango_context( m_widget );
}
#endif
GtkRcStyle *wxWindowGTK::CreateWidgetStyle(bool forceStyle)
{
// do we need to apply any changes at all?
@@ -4325,13 +3761,8 @@ GtkRcStyle *wxWindowGTK::CreateWidgetStyle(bool forceStyle)
if ( m_font.Ok() )
{
#ifdef __WXGTK20__
style->font_desc =
pango_font_description_copy( m_font.GetNativeFontInfo()->description );
#else
wxString xfontname = m_font.GetNativeFontInfo()->GetXFontName();
style->fontset_name = g_strdup(xfontname.c_str());
#endif
}
if ( m_foregroundColour.Ok() )
@@ -4687,7 +4118,6 @@ void wxWindowGTK::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
// No scrolling requested.
if ((dx == 0) && (dy == 0)) return;
#ifndef __WXGTK20__
if (!m_updateRegion.IsEmpty())
{
m_updateRegion.Offset( dx, dy );
@@ -4707,7 +4137,6 @@ void wxWindowGTK::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
GetClientSize( &cw, &ch );
m_clearRegion.Intersect( 0, 0, cw, ch );
}
#endif
m_clipPaintRegion = true;