#include "wx/dcclient.h"
#include "wx/menu.h"
#include "wx/dialog.h"
+ #include "wx/settings.h"
+ #include "wx/msgdlg.h"
+ #include "wx/textctrl.h"
+ #include "wx/combobox.h"
+ #include "wx/layout.h"
+ #include "wx/statusbr.h"
+ #include "wx/math.h"
+ #include "wx/module.h"
#endif
-#include "wx/layout.h"
-#include "wx/msgdlg.h"
-#include "wx/module.h"
-#include "wx/combobox.h"
-
#if wxUSE_DRAG_AND_DROP
#include "wx/dnd.h"
#endif
#include "wx/caret.h"
#endif // wxUSE_CARET
-#if wxUSE_TEXTCTRL
- #include "wx/textctrl.h"
-#endif
-
-#include "wx/statusbr.h"
-#include "wx/settings.h"
#include "wx/fontutil.h"
-#ifdef __WXDEBUG__
+#if wxDEBUG_LEVEL
#include "wx/thread.h"
#endif
-#include "wx/math.h"
#include <ctype.h>
#include "wx/gtk1/private.h"
// data
//-----------------------------------------------------------------------------
-extern wxList wxPendingDelete;
extern bool g_blockEventsOnDrag;
extern bool g_blockEventsOnScroll;
extern wxCursor g_globalCursor;
// mouse capture state: the window which has it and if the mouse is currently
// inside it
-static wxWindowGTK *g_captureWindow = (wxWindowGTK*) NULL;
+static wxWindowGTK *g_captureWindow = NULL;
static bool g_captureWindowHasMouse = false;
-wxWindowGTK *g_focusWindow = (wxWindowGTK*) NULL;
+wxWindowGTK *g_focusWindow = NULL;
// the last window which had the focus - this is normally never NULL (except
// if we never had focus at all) as even when g_focusWindow is NULL it still
// keeps its previous value
-wxWindowGTK *g_focusWindowLast = (wxWindowGTK*) NULL;
+wxWindowGTK *g_focusWindowLast = NULL;
// If a window get the focus set but has not been realized
// yet, defer setting the focus to idle time.
-wxWindowGTK *g_delayedFocus = (wxWindowGTK*) NULL;
+wxWindowGTK *g_delayedFocus = 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)
guint32 wxGtkTimeLastClick = 0;
+// global variables because GTK+ DnD want to have the
+// mouse event that caused it
+GdkEvent *g_lastMouseEvent = NULL;
+int g_lastButtonNumber = 0;
+
extern bool g_mainThreadLocked;
//-----------------------------------------------------------------------------
// debug
//-----------------------------------------------------------------------------
-#ifdef __WXDEBUG__
-
#if wxUSE_THREADS
-# define DEBUG_MAIN_THREAD if (wxThread::IsMain() && g_mainThreadLocked) printf("gui reentrance");
+# define DEBUG_MAIN_THREAD \
+ wxASSERT_MSG( !g_mainThreadLocked || !wxThread::IsMain(), \
+ "GUI reentrancy detected" );
#else
# define DEBUG_MAIN_THREAD
#endif
-#else
-#define DEBUG_MAIN_THREAD
-#endif // Debug
// the trace mask used for the focus debugging messages
-#define TRACE_FOCUS _T("focus")
+#define TRACE_FOCUS wxT("focus")
//-----------------------------------------------------------------------------
// missing gdk functions
{
wxWindow *winFocus = wxWindowGTK::FindFocus();
if ( !winFocus )
- return (wxWindow *)NULL;
+ return NULL;
if ( winFocus == win )
return (wxWindow *)win;
return child;
}
- return (wxWindow *)NULL;
+ return NULL;
}
static void draw_frame( GtkWidget *widget, wxWindowGTK *win )
return;
}
- if (win->HasFlag(wxSUNKEN_BORDER))
+ if (win->HasFlag(wxSUNKEN_BORDER) || win->HasFlag(wxBORDER_THEME))
{
gtk_draw_shadow( widget->style,
widget->window,
// make it extern because wxStaticText needs to disconnect this one
extern "C" {
-void wxgtk_window_size_request_callback(GtkWidget *widget,
+void wxgtk_window_size_request_callback(GtkWidget *WXUNUSED(widget),
GtkRequisition *requisition,
wxWindow *win)
{
extern "C" {
static
-void wxgtk_combo_size_request_callback(GtkWidget *widget,
+void wxgtk_combo_size_request_callback(GtkWidget *WXUNUSED(widget),
GtkRequisition *requisition,
wxComboBox *win)
{
//-----------------------------------------------------------------------------
extern "C" {
-static int gtk_window_expose_callback( GtkWidget *widget,
+static int gtk_window_expose_callback( GtkWidget *WXUNUSED(widget),
GdkEventExpose *gdk_event,
wxWindow *win )
{
GdkRectangle child_area;
if (gtk_widget_intersect (child->widget, rect, &child_area))
{
- gtk_widget_draw (child->widget, &child_area /* (GdkRectangle*) NULL*/ );
+ gtk_widget_draw (child->widget, &child_area /* NULL*/ );
}
}
#endif
//-----------------------------------------------------------------------------
// set WXTRACE to this to see the key event codes on the console
-#define TRACE_KEYS _T("keyevent")
+#define TRACE_KEYS wxT("keyevent")
// translates an X key symbol to WXK_XXX value
//
break;
case GDK_KP_Next: // == GDK_KP_Page_Down
- key_code = isChar ? WXK_NEXT : WXK_NUMPAD_PAGEDOWN;
+ key_code = isChar ? WXK_PAGEDOWN : WXK_NUMPAD_PAGEDOWN;
break;
case GDK_KP_End:
event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK) != 0;
event.m_altDown = (gdk_event->state & GDK_MOD1_MASK) != 0;
event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK) != 0;
- event.m_scanCode = gdk_event->keyval;
event.m_rawCode = (wxUint32) gdk_event->keyval;
event.m_rawFlags = 0;
#if wxUSE_UNICODE
- event.m_uniChar = gdk_keyval_to_unicode(gdk_event->keyval);
+#if 0
+ // this is not gtk1.x
+ event.m_uniChar = gdk_keyval_to_unicode(gdk_event->keyval);
+#endif
#endif
wxGetMousePosition( &x, &y );
win->ScreenToClient( &x, &y );
KeySym keysym = gdk_event->keyval;
- wxLogTrace(TRACE_KEYS, _T("Key %s event: keysym = %ld"),
- event.GetEventType() == wxEVT_KEY_UP ? _T("release")
- : _T("press"),
+ wxLogTrace(TRACE_KEYS, wxT("Key %s event: keysym = %ld"),
+ event.GetEventType() == wxEVT_KEY_UP ? wxT("release")
+ : wxT("press"),
keysym);
long key_code = wxTranslateKeySymToWXKey(keysym, false /* !isChar */);
Display *dpy = (Display *)wxGetDisplay();
KeyCode keycode = XKeysymToKeycode(dpy, keysym);
- wxLogTrace(TRACE_KEYS, _T("\t-> keycode %d"), keycode);
+ wxLogTrace(TRACE_KEYS, wxT("\t-> keycode %d"), keycode);
KeySym keysymNormalized = XKeycodeToKeysym(dpy, keycode, 0);
}
}
- wxLogTrace(TRACE_KEYS, _T("\t-> wxKeyCode %ld"), key_code);
+ wxLogTrace(TRACE_KEYS, wxT("\t-> wxKeyCode %ld"), key_code);
// sending unknown key events doesn't really make sense
if ( !key_code )
bool ret = false;
bool return_after_IM = false;
- if( wxTranslateGTKKeyEventToWx(event, win, gdk_event) == false )
+ if ( wxTranslateGTKKeyEventToWx(event, win, gdk_event) )
{
// Emit KEY_DOWN event
- ret = win->GetEventHandler()->ProcessEvent( event );
+ ret = win->HandleWindowEvent( event );
}
else
{
if (parent)
{
event.SetEventType( wxEVT_CHAR_HOOK );
- ret = parent->GetEventHandler()->ProcessEvent( event );
+ ret = parent->HandleWindowEvent( event );
}
if (!ret)
{
event.SetEventType(wxEVT_CHAR);
- win->GetEventHandler()->ProcessEvent( event );
+ win->HandleWindowEvent( event );
}
}
return true;
if (command != -1)
{
wxCommandEvent command_event( wxEVT_COMMAND_MENU_SELECTED, command );
- ret = ancestor->GetEventHandler()->ProcessEvent( command_event );
+ ret = ancestor->HandleWindowEvent( command_event );
break;
}
if (ancestor->IsTopLevel())
if ( key_code )
{
- wxLogTrace(TRACE_KEYS, _T("Char event: %ld"), key_code);
+ wxLogTrace(TRACE_KEYS, wxT("Char event: %ld"), key_code);
event.m_keyCode = key_code;
if (parent)
{
event.SetEventType( wxEVT_CHAR_HOOK );
- ret = parent->GetEventHandler()->ProcessEvent( event );
+ ret = parent->HandleWindowEvent( event );
}
if (!ret)
{
event.SetEventType(wxEVT_CHAR);
- ret = win->GetEventHandler()->ProcessEvent( event );
+ ret = win->HandleWindowEvent( event );
}
}
}
// CTRL-TAB changes the (parent) window, i.e. switch notebook page
new_event.SetWindowChange( (gdk_event->state & GDK_CONTROL_MASK) );
new_event.SetCurrentFocus( win );
- ret = win->GetParent()->GetEventHandler()->ProcessEvent( new_event );
+ ret = win->GetParent()->HandleWindowEvent( new_event );
}
// generate wxID_CANCEL if <esc> has been pressed (typically in dialogs)
{
wxCommandEvent eventClick(wxEVT_COMMAND_BUTTON_CLICKED, wxID_CANCEL);
eventClick.SetEventObject(btnCancel);
- ret = btnCancel->GetEventHandler()->ProcessEvent(eventClick);
+ ret = btnCancel->HandleWindowEvent(eventClick);
}
}
return FALSE;
}
- if ( !win->GetEventHandler()->ProcessEvent( event ) )
+ if ( !win->HandleWindowEvent( event ) )
return FALSE;
gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_release_event" );
}
else
{
- if ((child->m_wxwindow == (GtkWidget*) NULL) &&
+ if ((child->m_wxwindow == NULL) &&
(child->m_x <= xx) &&
(child->m_y <= yy) &&
(child->m_x+child->m_width >= xx) &&
if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
- if (win->m_wxwindow && (g_focusWindow != win) && win->AcceptsFocus())
+ g_lastButtonNumber = gdk_event->button;
+
+ if (win->m_wxwindow && (g_focusWindow != win) && win->IsFocusable())
{
gtk_widget_grab_focus( win->m_wxwindow );
/*
return FALSE;
}
+ g_lastMouseEvent = (GdkEvent*) gdk_event;
+
wxMouseEvent event( event_type );
InitMouseEvent( win, event, gdk_event );
}
}
- if (win->GetEventHandler()->ProcessEvent( event ))
+ if (win->HandleWindowEvent( event ))
{
gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "button_press_event" );
+ g_lastMouseEvent = NULL;
return TRUE;
}
+ g_lastMouseEvent = NULL;
if (event_type == wxEVT_RIGHT_DOWN)
{
win->GetId(),
win->ClientToScreen(event.GetPosition()));
evtCtx.SetEventObject(win);
- return win->GetEventHandler()->ProcessEvent(evtCtx);
+ return win->HandleWindowEvent(evtCtx);
}
return FALSE;
if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
+ g_lastButtonNumber = 0;
+
wxEventType event_type = wxEVT_NULL;
switch (gdk_event->button)
return FALSE;
}
+ g_lastMouseEvent = (GdkEvent*) gdk_event;
+
wxMouseEvent event( event_type );
InitMouseEvent( win, event, gdk_event );
if ( !g_captureWindow )
win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
- if (win->GetEventHandler()->ProcessEvent( event ))
+ if (win->HandleWindowEvent( event ))
{
gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "button_release_event" );
return TRUE;
gdk_event->y = y;
}
+ g_lastMouseEvent = (GdkEvent*) gdk_event;
+
/*
printf( "OnMotion from " );
if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
: wxEVT_LEAVE_WINDOW);
InitMouseEvent(win, eventM, gdk_event);
eventM.SetEventObject(win);
- win->GetEventHandler()->ProcessEvent(eventM);
+ win->HandleWindowEvent(eventM);
}
}
else // no capture
win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
}
- if (win->GetEventHandler()->ProcessEvent( event ))
+ bool ret = win->HandleWindowEvent( event );
+ g_lastMouseEvent = NULL;
+
+ if ( ret )
{
gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "motion_notify_event" );
- return TRUE;
}
- return FALSE;
+ return ret ? TRUE : FALSE;
}
}
// Notify the parent keeping track of focus for the kbd navigation
// purposes that we got it.
wxChildFocusEvent eventChildFocus(win);
- (void)win->GetEventHandler()->ProcessEvent(eventChildFocus);
+ (void)win->HandleWindowEvent(eventChildFocus);
wxFocusEvent eventFocus(wxEVT_SET_FOCUS, win->GetId());
eventFocus.SetEventObject(win);
- return win->GetEventHandler()->ProcessEvent(eventFocus);
+ return win->HandleWindowEvent(eventFocus);
}
extern "C" {
g_focusWindow = win;
wxLogTrace(TRACE_FOCUS,
- _T("%s: focus in"), win->GetName().c_str());
+ wxT("%s: focus in"), win->GetName().c_str());
#ifdef HAVE_XIM
if (win->m_ic)
//-----------------------------------------------------------------------------
extern "C" {
-static gint gtk_window_focus_out_callback( GtkWidget *widget, GdkEventFocus *gdk_event, wxWindowGTK *win )
+static gint gtk_window_focus_out_callback( GtkWidget *WXUNUSED(widget),
+ GdkEventFocus *WXUNUSED(gdk_event),
+ wxWindowGTK *win )
{
DEBUG_MAIN_THREAD
wxapp_install_idle_handler();
wxLogTrace( TRACE_FOCUS,
- _T("%s: focus out"), win->GetName().c_str() );
+ wxT("%s: focus out"), win->GetName().c_str() );
wxWindowGTK *winFocus = wxFindFocusedChild(win);
if ( winFocus )
win = winFocus;
- g_focusWindow = (wxWindowGTK *)NULL;
+ g_focusWindow = NULL;
#ifdef HAVE_XIM
if (win->m_ic)
// process it too as otherwise bad things happen, especially in GTK2
// where the text control simply aborts the program if it doesn't get
// the matching focus out event
- (void)win->GetEventHandler()->ProcessEvent( event );
+ (void)win->HandleWindowEvent( event );
}
return FALSE;
event.m_x = x + pt.x;
event.m_y = y + pt.y;
- if (win->GetEventHandler()->ProcessEvent( event ))
+ if (win->HandleWindowEvent( event ))
{
gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "enter_notify_event" );
return TRUE;
event.m_x = x + pt.x;
event.m_y = y + pt.y;
- if (win->GetEventHandler()->ProcessEvent( event ))
+ if (win->HandleWindowEvent( event ))
{
gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "leave_notify_event" );
return TRUE;
wxScrollWinEvent event( command, value, wxVERTICAL );
event.SetEventObject( win );
- win->GetEventHandler()->ProcessEvent( event );
+ win->HandleWindowEvent( event );
}
}
wxScrollWinEvent event( command, value, wxHORIZONTAL );
event.SetEventObject( win );
- win->GetEventHandler()->ProcessEvent( event );
+ win->HandleWindowEvent( event );
}
}
wxScrollWinEvent event( command, value, dir );
event.SetEventObject( win );
- win->GetEventHandler()->ProcessEvent( event );
+ win->HandleWindowEvent( event );
}
win->m_isScrolling = false;
extern "C" {
static gint
-gtk_window_realized_callback( GtkWidget *m_widget, wxWindow *win )
+gtk_window_realized_callback( GtkWidget *WXUNUSED(widget), wxWindow *win )
{
DEBUG_MAIN_THREAD
wxWindowCreateEvent event( win );
event.SetEventObject( win );
- win->GetEventHandler()->ProcessEvent( event );
+ win->HandleWindowEvent( event );
return FALSE;
}
{
wxSizeEvent event( win->GetSize(), win->GetId() );
event.SetEventObject( win );
- win->GetEventHandler()->ProcessEvent( event );
+ win->HandleWindowEvent( event );
}
}
}
extern "C" {
static
void gtk_wxwindow_size_callback( GtkWidget* WXUNUSED_UNLESS_XIM(widget),
- GtkAllocation* WXUNUSED_UNLESS_XIM(alloc),
+ GtkAllocation* WXUNUSED(alloc),
wxWindowGTK* WXUNUSED_UNLESS_XIM(win) )
{
if (g_isIdle)
void wxWindowGTK::Init()
{
// GTK specific
- m_widget = (GtkWidget *) NULL;
- m_wxwindow = (GtkWidget *) NULL;
- m_focusWidget = (GtkWidget *) NULL;
+ m_widget = NULL;
+ m_wxwindow = NULL;
+ m_focusWidget = NULL;
// position/size
m_x = 0;
m_sizeSet = false;
m_hasVMT = false;
m_needParent = true;
- m_isBeingDeleted = false;
m_noExpose = false;
m_nativeSizeEvent = false;
m_hasScrolling = false;
m_isScrolling = false;
- m_hAdjust = (GtkAdjustment*) NULL;
- m_vAdjust = (GtkAdjustment*) NULL;
+ m_hAdjust = NULL;
+ m_vAdjust = NULL;
m_oldHorizontalPos =
m_oldVerticalPos = 0.0;
m_oldClientWidth =
m_cursor = *wxSTANDARD_CURSOR;
#ifdef HAVE_XIM
- m_ic = (GdkIC*) NULL;
- m_icattr = (GdkICAttr*) NULL;
+ m_ic = NULL;
+ m_icattr = NULL;
#endif
}
long style,
const wxString &name )
{
+ // Get default border
+ wxBorder border = GetBorder(style);
+ style &= ~wxBORDER_MASK;
+ style |= border;
+
if (!PreCreation( parent, pos, size ) ||
!CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
{
m_insertCallback = wxInsertChildInWindow;
- m_widget = gtk_scrolled_window_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL );
+ m_widget = gtk_scrolled_window_new( NULL, NULL );
GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(m_widget);
{
gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_OUT );
}
- else if (HasFlag(wxSUNKEN_BORDER))
+ else if (HasFlag(wxSUNKEN_BORDER) || HasFlag(wxBORDER_THEME))
{
gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_IN );
}
if ( g_delayedFocus == this )
g_delayedFocus = NULL;
- m_isBeingDeleted = true;
m_hasVMT = false;
// destroy children before destroying this window itself
if (m_wxwindow)
{
gtk_widget_destroy( m_wxwindow );
- m_wxwindow = (GtkWidget*) NULL;
+ m_wxwindow = NULL;
}
if (m_widget)
{
gtk_widget_destroy( m_widget );
- m_widget = (GtkWidget*) NULL;
+ m_widget = NULL;
}
}
{
wxSizeEvent event( wxSize(m_width,m_height), GetId() );
event.SetEventObject( this );
- GetEventHandler()->ProcessEvent( event );
+ HandleWindowEvent( event );
}
m_resizing = false;
gdk_window_set_cursor( window, cursor.GetCursor() );
}
- else
+ else if ( m_widget )
{
-
GdkWindow *window = m_widget->window;
- if ((window) && !(GTK_WIDGET_NO_WINDOW(m_widget)))
+ if ( window && !GTK_WIDGET_NO_WINDOW(m_widget) )
gdk_window_set_cursor( window, cursor.GetCursor() );
-
}
}
- if (wxUpdateUIEvent::CanUpdate(this))
+ if (wxUpdateUIEvent::CanUpdate(this) && IsShownOnScreen())
UpdateWindowUI(wxUPDATE_UI_FROMIDLE);
}
int dh = 0;
#ifndef __WXUNIVERSAL__
- if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
+ if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER) || HasFlag(wxBORDER_THEME))
{
/* when using GTK 1.2 we set the shadow border size to 2 */
dw += 2 * 2;
int dh = 0;
#ifndef __WXUNIVERSAL__
- if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
+ if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER) || HasFlag(wxBORDER_THEME))
{
/* when using GTK 1.2 we set the shadow border size to 2 */
dw += 2 * 2;
if (!m_widget->window) return;
- GdkWindow *source = (GdkWindow *) NULL;
+ GdkWindow *source = NULL;
if (m_wxwindow)
source = GTK_PIZZA(m_wxwindow)->bin_window;
else
if (!m_widget->window) return;
- GdkWindow *source = (GdkWindow *) NULL;
+ GdkWindow *source = NULL;
if (m_wxwindow)
source = GTK_PIZZA(m_wxwindow)->bin_window;
else
wxShowEvent eventShow(GetId(), show);
eventShow.SetEventObject(this);
- GetEventHandler()->ProcessEvent(eventShow);
+ HandleWindowEvent(eventShow);
return true;
}
-static void wxWindowNotifyEnable(wxWindowGTK* win, bool enable)
+void wxWindowGTK::DoEnable( bool enable )
{
- win->OnParentEnable(enable);
-
- // Recurse, so that children have the opportunity to Do The Right Thing
- // and reset colours that have been messed up by a parent's (really ancestor's)
- // Enable call
- for ( wxWindowList::compatibility_iterator node = win->GetChildren().GetFirst();
- node;
- node = node->GetNext() )
- {
- wxWindow *child = node->GetData();
- if (!child->IsKindOf(CLASSINFO(wxDialog)) && !child->IsKindOf(CLASSINFO(wxFrame)))
- wxWindowNotifyEnable(child, enable);
- }
-}
-
-bool wxWindowGTK::Enable( bool enable )
-{
- wxCHECK_MSG( (m_widget != NULL), false, wxT("invalid window") );
-
- if (!wxWindowBase::Enable(enable))
- {
- // nothing to do
- return false;
- }
+ wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
gtk_widget_set_sensitive( m_widget, enable );
if ( m_wxwindow )
gtk_widget_set_sensitive( m_wxwindow, enable );
-
- wxWindowNotifyEnable(this, enable);
-
- return true;
}
int wxWindowGTK::GetCharHeight() const
return gdk_string_width( gfont, "g" );
}
-void wxWindowGTK::GetTextExtent( const wxString& string,
- int *x,
- int *y,
- int *descent,
- int *externalLeading,
- const wxFont *theFont ) const
+void wxWindowGTK::DoGetTextExtent(const wxString& string,
+ int *x,
+ int *y,
+ int *descent,
+ int *externalLeading,
+ const wxFont *theFont) const
{
wxFont fontToUse = theFont ? *theFont : GetFont();
// it should be focused and will do it later, during the idle
// time, as soon as we can
wxLogTrace(TRACE_FOCUS,
- _T("Delaying setting focus to %s(%s)"),
+ wxT("Delaying setting focus to %s(%s)"),
GetClassInfo()->GetClassName(), GetLabel().c_str());
g_delayedFocus = this;
else
{
wxLogTrace(TRACE_FOCUS,
- _T("Setting focus to %s(%s)"),
+ wxT("Setting focus to %s(%s)"),
GetClassInfo()->GetClassName(), GetLabel().c_str());
gtk_widget_grab_focus (m_widget);
else
{
wxLogTrace(TRACE_FOCUS,
- _T("Can't set focus to %s(%s)"),
+ wxT("Can't set focus to %s(%s)"),
GetClassInfo()->GetClassName(), GetLabel().c_str());
}
}
{
wxCHECK_MSG( (m_widget != NULL), false, wxT("invalid window") );
- if (cursor == m_cursor)
+ if ( cursor.IsSameAs(m_cursor) )
return false;
if (g_isIdle)
wxapp_install_idle_handler();
- if (cursor == wxNullCursor)
- return wxWindowBase::SetCursor( *wxSTANDARD_CURSOR );
- else
- return wxWindowBase::SetCursor( cursor );
+ return wxWindowBase::SetCursor( cursor.IsOk() ? cursor
+ : *wxSTANDARD_CURSOR );
}
void wxWindowGTK::WarpPointer( int x, int y )
// We provide this function ourselves as it is
// missing in GDK (top of this file).
- GdkWindow *window = (GdkWindow*) NULL;
+ GdkWindow *window = NULL;
if (m_wxwindow)
window = GTK_PIZZA(m_wxwindow)->bin_window;
else
}
else
{
- gtk_widget_draw( m_widget, (GdkRectangle*) NULL );
+ gtk_widget_draw( m_widget, NULL );
}
}
}
}
}
}
- else
-
- // if (!m_clearRegion.IsEmpty()) // Always send an erase event under GTK 1.2
+ else // Always send an erase event under GTK 1.2
{
wxWindowDC dc( (wxWindow*)this );
- if (m_clearRegion.IsEmpty())
- dc.SetClippingRegion( m_updateRegion );
- else
- dc.SetClippingRegion( m_clearRegion );
+ dc.SetDeviceClippingRegion( m_clearRegion.IsEmpty() ? m_updateRegion
+ : m_clearRegion );
wxEraseEvent erase_event( GetId(), &dc );
erase_event.SetEventObject( this );
- if (!GetEventHandler()->ProcessEvent(erase_event) && GetBackgroundStyle() != wxBG_STYLE_CUSTOM)
+ if (!HandleWindowEvent(erase_event) && GetBackgroundStyle() != wxBG_STYLE_CUSTOM)
{
if (!g_eraseGC)
{
wxNcPaintEvent nc_paint_event( GetId() );
nc_paint_event.SetEventObject( this );
- GetEventHandler()->ProcessEvent( nc_paint_event );
+ HandleWindowEvent( nc_paint_event );
wxPaintEvent paint_event( GetId() );
paint_event.SetEventObject( this );
- GetEventHandler()->ProcessEvent( paint_event );
+ HandleWindowEvent( paint_event );
m_clipPaintRegion = false;
void wxWindowGTK::ApplyToolTip( GtkTooltips *tips, const wxChar *tip )
{
wxString tmp( tip );
- gtk_tooltips_set_tip( tips, GetConnectWidget(), wxGTK_CONV(tmp), (gchar*) NULL );
+ gtk_tooltips_set_tip( tips, GetConnectWidget(), wxGTK_CONV(tmp), NULL );
}
#endif // wxUSE_TOOLTIPS
if (style == wxBG_STYLE_CUSTOM)
{
- GdkWindow *window = (GdkWindow*) NULL;
+ GdkWindow *window = NULL;
if (m_wxwindow)
window = GTK_PIZZA(m_wxwindow)->bin_window;
else
{
wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
- GdkWindow *window = (GdkWindow*) NULL;
+ GdkWindow *window = NULL;
if (m_wxwindow)
window = GTK_PIZZA(m_wxwindow)->bin_window;
else
window = GetConnectWidget()->window;
- wxCHECK_RET( window, _T("CaptureMouse() failed") );
+ wxCHECK_RET( window, wxT("CaptureMouse() failed") );
const wxCursor* cursor = &m_cursor;
if (!cursor->Ok())
GDK_BUTTON_RELEASE_MASK |
GDK_POINTER_MOTION_HINT_MASK |
GDK_POINTER_MOTION_MASK),
- (GdkWindow *) NULL,
+ NULL,
cursor->GetCursor(),
(guint32)GDK_CURRENT_TIME );
g_captureWindow = this;
wxCHECK_RET( g_captureWindow, wxT("can't release mouse - not captured") );
- g_captureWindow = (wxWindowGTK*) NULL;
+ g_captureWindow = NULL;
- GdkWindow *window = (GdkWindow*) NULL;
+ GdkWindow *window = NULL;
if (m_wxwindow)
window = GTK_PIZZA(m_wxwindow)->bin_window;
else
if (g_eraseGC)
gdk_gc_unref( g_eraseGC );
}
+
+GdkWindow* wxWindowGTK::GTKGetDrawingWindow() const
+{
+ GdkWindow* window = NULL;
+ if (m_wxwindow)
+ window = GTK_PIZZA(m_wxwindow)->bin_window;
+ return window;
+}
projects / wxWidgets.git / blobdiff