X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/32e9da8bfaafe4f462f7473a7e11e3387847e121..2d33aec94c9217b94ada107fbd125db4c51c22ab:/src/gtk1/window.cpp?ds=sidebyside diff --git a/src/gtk1/window.cpp b/src/gtk1/window.cpp index f220749ead..830bfd343c 100644 --- a/src/gtk1/window.cpp +++ b/src/gtk1/window.cpp @@ -1,39 +1,70 @@ ///////////////////////////////////////////////////////////////////////////// -// Name: window.cpp +// Name: gtk/window.cpp // Purpose: // Author: Robert Roebling -// Id: $id$ +// Id: $Id$ // Copyright: (c) 1998 Robert Roebling, Julian Smart // Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// #ifdef __GNUG__ -#pragma implementation "window.h" + #pragma implementation "window.h" +#endif + +#ifdef __VMS +#define XWarpPointer XWARPPOINTER #endif #include "wx/defs.h" #include "wx/window.h" -#include "wx/dc.h" +#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/dcclient.h" -#include "wx/dnd.h" -#include "wx/mdi.h" + +#if wxUSE_DRAG_AND_DROP + #include "wx/dnd.h" +#endif + +#if wxUSE_TOOLTIPS + #include "wx/tooltip.h" +#endif + +#if wxUSE_CARET + #include "wx/caret.h" +#endif // wxUSE_CARET + +#if wxUSE_TEXTCTRL +#include "wx/textctrl.h" +#endif + #include "wx/menu.h" -#include "wx/notebook.h" #include "wx/statusbr.h" #include "wx/intl.h" -#include "wx/gtk/win_gtk.h" -#include "gdk/gdkprivate.h" -#include "gdk/gdkkeysyms.h" +#include "wx/settings.h" +#include "wx/log.h" + +#ifdef __WXDEBUG__ + #include "wx/thread.h" +#endif #include +#include +#include +#include +#include +#include + +#include +#include + +#include "wx/gtk/win_gtk.h" + //----------------------------------------------------------------------------- // documentation on internals //----------------------------------------------------------------------------- @@ -45,33 +76,37 @@ some more information about what the wxWindow, which is the base class for all other window classes, does seems required as well. + I) + What does wxWindow do? It contains the common interface for the following - jobs of its descentants: + jobs of its descendants: 1) Define the rudimentary behaviour common to all window classes, such as - resizing, intercepting user input so as to make it possible to use these - events for special purposes in a derived class, window names etc. + resizing, intercepting user input (so as to make it possible to use these + events for special purposes in a derived class), window names etc. 2) Provide the possibility to contain and manage children, if the derived class is allowed to contain children, which holds true for those window - classes, which do not display a native GTK widget. To name them, these + classes which do not display a native GTK widget. To name them, these classes are wxPanel, wxScrolledWindow, wxDialog, wxFrame. The MDI frame- work classes are a special case and are handled a bit differently from - the rest. + the rest. The same holds true for the wxNotebook class. 3) Provide the possibility to draw into a client area of a window. This, too, only holds true for classes that do not display a native GTK widget as above. - 4) Provide the entire mechanism for scrolling widgets. This actaul inter- - face for this is usually in wxScrolledWidget, but the GTK implementation + 4) Provide the entire mechanism for scrolling widgets. This actual inter- + face for this is usually in wxScrolledWindow, but the GTK implementation is in this class. 5) A multitude of helper or extra methods for special purposes, such as Drag'n'Drop, managing validators etc. - Normally one might expect, that one wxWindows class would always contain - one GTK widget. Under GTK, there is no such allround widget that has all + 6) Display a border (sunken, raised, simple or none). + + Normally one might expect, that one wxWindows window would always correspond + to one GTK widget. Under GTK, there is no such allround widget that has all the functionality. Moreover, the GTK defines a client area as a different widget from the actual widget you are handling. Last but not least some special classes (e.g. wxFrame) handle different categories of widgets and @@ -82,2827 +117,4045 @@ this directory. All windows must have a widget, with which they interact with other under- - lying GTK widget. It is this widget, e.g. that has to be resized etc and + lying GTK widgets. It is this widget, e.g. that has to be resized etc and thw wxWindow class has a member variable called m_widget which holds a - pointer to this widget. When the window class displays a GTK native widget, - this is the only GTK widget the class manages. When the class has a client - area for drawing into and for containing children it must have at least - one more GTK widget to handle (of the type GtkMyFixed, defined in win_gtk.c), - but there can be any number of widgets, handled by a class (e.g. the frame - class handles three). The common rule for all windows is only, that the - widget that interacts with the rest of GTK must be referenced in m_widget - and all other widgets must be children of this widget on the GTK level. - The top-most widget, which also represents the client area, must be in - the m_wxwindow field and must be of the type GtkMyFixed. + pointer to this widget. When the window class represents a GTK native widget, + this is (in most cases) the only GTK widget the class manages. E.g. the + wxStatitText class handles only a GtkLabel widget a pointer to which you + can find in m_widget (defined in wxWindow) + + When the class has a client area for drawing into and for containing children + it has to handle the client area widget (of the type GtkPizza, defined in + win_gtk.c), but there could be any number of widgets, handled by a class + The common rule for all windows is only, that the widget that interacts with + the rest of GTK must be referenced in m_widget and all other widgets must be + children of this widget on the GTK level. The top-most widget, which also + represents the client area, must be in the m_wxwindow field and must be of + the type GtkPizza. As I said, the window classes that display a GTK native widget only have one widget, so in the case of e.g. the wxButton class m_widget holds a pointer to a GtkButton widget. But windows with client areas (for drawing and children) have a m_widget field that is a pointer to a GtkScrolled- - Window and a m_wxwindow field that is pointer to a GtkMyFixed and this + Window and a m_wxwindow field that is pointer to a GtkPizza and this one is (in the GTK sense) a child of the GtkScrolledWindow. If the m_wxwindow field is set, then all input to this widget is inter- cepted and sent to the wxWindows class. If not, all input to the widget that gets pointed to by m_widget gets intercepted and sent to the class. + II) + + The design of scrolling in wxWindows is markedly different from that offered + by the GTK itself and therefore we cannot simply take it as it is. In GTK, + clicking on a scrollbar belonging to scrolled window will inevitably move + the window. In wxWindows, the scrollbar will only emit an event, send this + to (normally) a wxScrolledWindow and that class will call ScrollWindow() + which actually moves the window and its subchildren. Note that GtkPizza + memorizes how much it has been scrolled but that wxWindows forgets this + so that the two coordinates systems have to be kept in synch. This is done + in various places using the pizza->xoffset and pizza->yoffset values. + + III) + + Singularily the most broken code in GTK is the code that is supposes to + inform subwindows (child windows) about new positions. Very often, duplicate + events are sent without changes in size or position, equally often no + events are sent at all (All this is due to a bug in the GtkContainer code + which got fixed in GTK 1.2.6). For that reason, wxGTK completely ignores + GTK's own system and it simply waits for size events for toplevel windows + and then iterates down the respective size events to all window. This has + the disadvantage, that windows might get size events before the GTK widget + actually has the reported size. This doesn't normally pose any problem, but + the OpenGl drawing routines rely on correct behaviour. Therefore, I have + added the m_nativeSizeEvents flag, which is true only for the OpenGL canvas, + i.e. the wxGLCanvas will emit a size event, when (and not before) the X11 + window that is used for OpenGl output really has that size (as reported by + GTK). + + IV) + + If someone at some point of time feels the immense desire to have a look at, + change or attempt to optimse the Refresh() logic, this person will need an + intimate understanding of what a "draw" and what an "expose" events are and + what there are used for, in particular when used in connection with GTK's + own windowless widgets. Beware. + + V) + + Cursors, too, have been a constant source of pleasure. The main difficulty + is that a GdkWindow inherits a cursor if the programmer sets a new cursor + for the parent. To prevent this from doing too much harm, I use idle time + to set the cursor over and over again, starting from the toplevel windows + and ending with the youngest generation (speaking of parent and child windows). + Also don't forget that cursors (like much else) are connected to GdkWindows, + not GtkWidgets and that the "window" field of a GtkWidget might very well + point to the GdkWindow of the parent widget (-> "window less widget") and + that the two obviously have very different meanings. + */ //----------------------------------------------------------------------------- // data //----------------------------------------------------------------------------- -extern wxList wxPendingDelete; -extern wxList wxTopLevelWindows; -extern bool g_blockEventsOnDrag; -static bool g_capturing = FALSE; +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 bool g_captureWindowHasMouse = FALSE; + +/* extern */ wxWindowGTK *g_focusWindow = (wxWindowGTK*) NULL; -// hack: we need something to pass to gtk_menu_popup, so we store the time of -// the last click here +// 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 +static wxWindowGTK *g_focusWindowLast = (wxWindowGTK *)NULL; + +// the frame that is currently active (i.e. its child has focus). It is +// used to generate wxActivateEvents +static wxWindowGTK *g_activeFrame = (wxWindowGTK *)NULL; +static bool g_activeFrameLostFocus = FALSE; + +// if we detect that the app has got/lost the focus, we set this variable to +// either TRUE or FALSE and an activate event will be sent during the next +// OnIdle() call and it is reset to -1: this value means that we shouldn't +// send any activate events at all +static int g_sendActivateEvent = -1; + +/* hack: we need something to pass to gtk_menu_popup, so we store the time of + the last click here */ static guint32 gs_timeLastClick = 0; +extern bool g_mainThreadLocked; + //----------------------------------------------------------------------------- -// "expose_event" (of m_wxwindow, not of m_widget) +// debug //----------------------------------------------------------------------------- -static void gtk_window_expose_callback( GtkWidget *WXUNUSED(widget), GdkEventExpose *gdk_event, wxWindow *win ) -{ - if (!win->HasVMT()) return; - if (g_blockEventsOnDrag) return; +#ifndef __WXGTK20__ +#define DISABLE_STYLE_IF_BROKEN_THEME 1 +#endif - win->m_updateRegion.Union( gdk_event->area.x, - gdk_event->area.y, - gdk_event->area.width, - gdk_event->area.height ); +#ifdef __WXDEBUG__ - if (gdk_event->count > 0) return; +#if wxUSE_THREADS +# define DEBUG_MAIN_THREAD if (wxThread::IsMain() && g_mainThreadLocked) printf("gui reentrance"); +#else +# define DEBUG_MAIN_THREAD +#endif +static gint gtk_debug_focus_in_callback( GtkWidget *WXUNUSED(widget), + GdkEvent *WXUNUSED(event), + const wxChar *WXUNUSED(name) ) +{ /* - printf( "OnExpose from " ); - if (win->GetClassInfo() && win->GetClassInfo()->GetClassName()) - printf( win->GetClassInfo()->GetClassName() ); - printf( ".\n" ); + static bool s_done = FALSE; + if ( !s_done ) + { + wxLog::AddTraceMask("focus"); + s_done = TRUE; + } + wxLogTrace(wxT("FOCUS NOW AT: %s"), name); */ - wxPaintEvent event( win->GetId() ); - event.SetEventObject( win ); - win->GetEventHandler()->ProcessEvent( event ); - - win->m_updateRegion.Clear(); + return FALSE; } -//----------------------------------------------------------------------------- -// "draw" (of m_wxwindow, not of m_widget) -//----------------------------------------------------------------------------- - -static void gtk_window_draw_callback( GtkWidget *WXUNUSED(widget), GdkRectangle *rect, wxWindow *win ) +void debug_focus_in( GtkWidget* widget, const wxChar* name, const wxChar *window ) { - if (!win->HasVMT()) return; - if (g_blockEventsOnDrag) return; + // suppress warnings about gtk_debug_focus_in_callback being unused with + // this "if ( 0 )" + if ( 0 ) + { + wxString tmp = name; + tmp += wxT(" FROM "); + tmp += window; - win->m_updateRegion.Union( rect->x, rect->y, rect->width, rect->height ); + wxChar *s = new wxChar[tmp.Length()+1]; - wxPaintEvent event( win->GetId() ); - event.SetEventObject( win ); - win->GetEventHandler()->ProcessEvent( event ); + wxStrcpy( s, tmp ); - win->m_updateRegion.Clear(); + gtk_signal_connect( GTK_OBJECT(widget), "focus_in_event", + GTK_SIGNAL_FUNC(gtk_debug_focus_in_callback), (gpointer)s ); + } } +#else +#define DEBUG_MAIN_THREAD +#endif // Debug + //----------------------------------------------------------------------------- -// "key_press_event" +// missing gdk functions //----------------------------------------------------------------------------- -static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_event, wxWindow *win ) +void +gdk_window_warp_pointer (GdkWindow *window, + gint x, + gint y) { - if (!win->HasVMT()) return FALSE; - if (g_blockEventsOnDrag) return FALSE; +#ifndef __WXGTK20__ + GdkWindowPrivate *priv; +#endif -/* - printf( "OnKeyPress from " ); - if (win->GetClassInfo() && win->GetClassInfo()->GetClassName()) - printf( win->GetClassInfo()->GetClassName() ); - printf( ".\n" ); -*/ + if (!window) + window = GDK_ROOT_PARENT(); - long key_code = 0; - switch (gdk_event->keyval) +#ifdef __WXGTK20__ + if (!GDK_WINDOW_DESTROYED(window)) { - case GDK_BackSpace: key_code = WXK_BACK; break; - case GDK_Tab: key_code = WXK_TAB; break; - case GDK_Linefeed: key_code = WXK_RETURN; break; - case GDK_Clear: key_code = WXK_CLEAR; break; - case GDK_Return: key_code = WXK_RETURN; break; - case GDK_Pause: key_code = WXK_PAUSE; break; - case GDK_Scroll_Lock: key_code = WXK_SCROLL; break; - case GDK_Escape: key_code = WXK_ESCAPE; break; - case GDK_Delete: key_code = WXK_DELETE; break; - case GDK_Home: key_code = WXK_HOME; break; - case GDK_Left: key_code = WXK_LEFT; break; - case GDK_Up: key_code = WXK_UP; break; - case GDK_Right: key_code = WXK_RIGHT; break; - case GDK_Down: key_code = WXK_DOWN; break; - case GDK_Prior: key_code = WXK_PRIOR; break; -// case GDK_Page_Up: key_code = WXK_PAGEUP; break; - case GDK_Next: key_code = WXK_NEXT; break; -// case GDK_Page_Down: key_code = WXK_PAGEDOWN; break; - case GDK_End: key_code = WXK_END; break; - case GDK_Begin: key_code = WXK_HOME; break; - case GDK_Select: key_code = WXK_SELECT; break; - case GDK_Print: key_code = WXK_PRINT; break; - case GDK_Execute: key_code = WXK_EXECUTE; break; - case GDK_Insert: key_code = WXK_INSERT; break; - case GDK_Num_Lock: key_code = WXK_NUMLOCK; break; - case GDK_KP_Tab: key_code = WXK_TAB; break; - case GDK_KP_Enter: key_code = WXK_RETURN; break; - case GDK_KP_Home: key_code = WXK_HOME; break; - case GDK_KP_Left: key_code = WXK_LEFT; break; - case GDK_KP_Up: key_code = WXK_UP; break; - case GDK_KP_Right: key_code = WXK_RIGHT; break; - case GDK_KP_Down: key_code = WXK_DOWN; break; - case GDK_KP_Prior: key_code = WXK_PRIOR; break; -// case GDK_KP_Page_Up: key_code = WXK_PAGEUP; break; - case GDK_KP_Next: key_code = WXK_NEXT; break; -// case GDK_KP_Page_Down: key_code = WXK_PAGEDOWN; break; - case GDK_KP_End: key_code = WXK_END; break; - case GDK_KP_Begin: key_code = WXK_HOME; break; - case GDK_KP_Insert: key_code = WXK_INSERT; break; - case GDK_KP_Delete: key_code = WXK_DELETE; break; - case GDK_KP_Multiply: key_code = WXK_MULTIPLY; break; - case GDK_KP_Add: key_code = WXK_ADD; break; - case GDK_KP_Separator: key_code = WXK_SEPARATOR; break; - case GDK_KP_Subtract: key_code = WXK_SUBTRACT; break; - case GDK_KP_Decimal: key_code = WXK_DECIMAL; break; - case GDK_KP_Divide: key_code = WXK_DIVIDE; break; - case GDK_KP_0: key_code = WXK_NUMPAD0; break; - case GDK_KP_1: key_code = WXK_NUMPAD1; break; - case GDK_KP_2: key_code = WXK_NUMPAD2; break; - case GDK_KP_3: key_code = WXK_NUMPAD3; break; - case GDK_KP_4: key_code = WXK_NUMPAD4; break; - case GDK_KP_5: key_code = WXK_NUMPAD5; break; - case GDK_KP_6: key_code = WXK_NUMPAD6; break; - case GDK_KP_7: key_code = WXK_NUMPAD7; break; - case GDK_KP_8: key_code = WXK_NUMPAD7; break; - case GDK_KP_9: key_code = WXK_NUMPAD9; break; - case GDK_F1: key_code = WXK_F1; break; - case GDK_F2: key_code = WXK_F2; break; - case GDK_F3: key_code = WXK_F3; break; - case GDK_F4: key_code = WXK_F4; break; - case GDK_F5: key_code = WXK_F5; break; - case GDK_F6: key_code = WXK_F6; break; - case GDK_F7: key_code = WXK_F7; break; - case GDK_F8: key_code = WXK_F8; break; - case GDK_F9: key_code = WXK_F9; break; - case GDK_F10: key_code = WXK_F10; break; - case GDK_F11: key_code = WXK_F11; break; - case GDK_F12: key_code = WXK_F12; break; - default: - { - if ((gdk_event->keyval >= 0x20) && (gdk_event->keyval <= 0xFF)) - key_code = gdk_event->keyval; - } + 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) + { + XWarpPointer (priv->xdisplay, + None, /* not source window -> move from anywhere */ + priv->xwindow, /* dest window */ + 0, 0, 0, 0, /* not source window -> move from anywhere */ + x, y ); } +#endif +} - if (!key_code) return FALSE; +//----------------------------------------------------------------------------- +// idle system +//----------------------------------------------------------------------------- - wxKeyEvent event( wxEVT_CHAR ); - 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_keyCode = key_code; - event.m_x = 0; - event.m_y = 0; - event.SetEventObject( win ); +extern void wxapp_install_idle_handler(); +extern bool g_isIdle; - bool ret = win->GetEventHandler()->ProcessEvent( event ); +//----------------------------------------------------------------------------- +// local code (see below) +//----------------------------------------------------------------------------- - if (!ret) - { - wxWindow *ancestor = win; - while (ancestor) +// returns the child of win which currently has focus or NULL if not found +// +// Note: can't be static, needed by textctrl.cpp. +wxWindow *wxFindFocusedChild(wxWindowGTK *win) +{ + wxWindow *winFocus = wxWindowGTK::FindFocus(); + if ( !winFocus ) + return (wxWindow *)NULL; + + if ( winFocus == win ) + return (wxWindow *)win; + + for ( wxWindowList::Node *node = win->GetChildren().GetFirst(); + node; + node = node->GetNext() ) { - int command = ancestor->GetAcceleratorTable()->GetCommand( event ); - if (command != -1) - { - wxCommandEvent command_event( wxEVT_COMMAND_MENU_SELECTED, command ); - ret = ancestor->GetEventHandler()->ProcessEvent( command_event ); - break; - } - ancestor = ancestor->GetParent(); + wxWindow *child = wxFindFocusedChild(node->GetData()); + if ( child ) + return child; } - } - if (ret) - { - if ((gdk_event->keyval >= 0x20) && (gdk_event->keyval <= 0xFF)) - gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_press_event" ); - } + return (wxWindow *)NULL; +} - return ret; +// Returns toplevel grandparent of given window: +static wxWindowGTK* wxGetTopLevelParent(wxWindowGTK *win) +{ + wxWindowGTK *p = win; + while (p && !p->IsTopLevel()) + p = p->GetParent(); + return p; } -//----------------------------------------------------------------------------- -// "button_press_event" -//----------------------------------------------------------------------------- -static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxWindow *win ) +static void draw_frame( GtkWidget *widget, wxWindowGTK *win ) { - if (!win->IsOwnGtkWindow( gdk_event->window )) return TRUE; + // wxUniversal widgets draw the borders and scrollbars themselves +#ifndef __WXUNIVERSAL__ + if (!win->m_hasVMT) + return; - if (g_blockEventsOnDrag) return TRUE; + int dw = 0; + int dh = 0; - if (win->m_wxwindow) - { - if (GTK_WIDGET_CAN_FOCUS(win->m_wxwindow) && !GTK_WIDGET_HAS_FOCUS (win->m_wxwindow) ) + if (win->m_hasScrolling) { - gtk_widget_grab_focus (win->m_wxwindow); + GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(widget); -/* - printf( "GrabFocus from " ); - if (win->GetClassInfo() && win->GetClassInfo()->GetClassName()) - printf( win->GetClassInfo()->GetClassName() ); - printf( ".\n" ); -*/ + 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 ); - if (!win->HasVMT()) return TRUE; + GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(widget) ); -/* - printf( "OnButtonPress from " ); - if (win->GetClassInfo() && win->GetClassInfo()->GetClassName()) - printf( win->GetClassInfo()->GetClassName() ); - printf( ".\n" ); -*/ + if (scroll_window->vscrollbar_visible) + { + dw += vscroll_req.width; + dw += scroll_class->scrollbar_spacing; + } - wxEventType event_type = wxEVT_LEFT_DOWN; + if (scroll_window->hscrollbar_visible) + { + dh += hscroll_req.height; + dh += scroll_class->scrollbar_spacing; + } + } - if (gdk_event->button == 1) - { - switch (gdk_event->type) + int dx = 0; + int dy = 0; + if (GTK_WIDGET_NO_WINDOW (widget)) { - case GDK_BUTTON_PRESS: event_type = wxEVT_LEFT_DOWN; break; - case GDK_2BUTTON_PRESS: event_type = wxEVT_LEFT_DCLICK; break; - default: break; + dx += widget->allocation.x; + dy += widget->allocation.y; } - } - else if (gdk_event->button == 2) - { - switch (gdk_event->type) + + if (win->HasFlag(wxRAISED_BORDER)) { - case GDK_BUTTON_PRESS: event_type = wxEVT_MIDDLE_DOWN; break; - case GDK_2BUTTON_PRESS: event_type = wxEVT_MIDDLE_DCLICK; break; - default: break; + gtk_draw_shadow( widget->style, + widget->window, + GTK_STATE_NORMAL, + GTK_SHADOW_OUT, + dx, dy, + widget->allocation.width-dw, widget->allocation.height-dh ); + return; } - } - else if (gdk_event->button == 3) - { - switch (gdk_event->type) + + if (win->HasFlag(wxSUNKEN_BORDER)) { - case GDK_BUTTON_PRESS: event_type = wxEVT_RIGHT_DOWN; break; - case GDK_2BUTTON_PRESS: event_type = wxEVT_RIGHT_DCLICK; break; - default: break; + gtk_draw_shadow( widget->style, + widget->window, + GTK_STATE_NORMAL, + GTK_SHADOW_IN, + dx, dy, + widget->allocation.width-dw, widget->allocation.height-dh ); + return; } - } - - wxMouseEvent event( event_type ); - 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_x = (long)gdk_event->x; - event.m_y = (long)gdk_event->y; - // Some control don't have their own X window and thus cannot get - // any events. - - if (!g_capturing) - { - wxNode *node = win->GetChildren()->First(); - while (node) + if (win->HasFlag(wxSIMPLE_BORDER)) { - wxWindow *child = (wxWindow*)node->Data(); - if ((child->m_x <= event.m_x) && - (child->m_y <= event.m_y) && - (child->m_x+child->m_width >= event.m_x) && - (child->m_y+child->m_height >= event.m_y)) - { - win = child; - event.m_x -= child->m_x; - event.m_y -= child->m_y; - break; - } - node = node->Next(); + GdkGC *gc; + gc = gdk_gc_new( widget->window ); + gdk_gc_set_foreground( gc, &widget->style->black ); + gdk_draw_rectangle( widget->window, gc, FALSE, + dx, dy, + widget->allocation.width-dw-1, widget->allocation.height-dh-1 ); + gdk_gc_unref( gc ); + return; } - } - - event.SetEventObject( win ); - - gs_timeLastClick = gdk_event->time; - - if (win->GetEventHandler()->ProcessEvent( event )) - gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "button_press_event" ); - - return TRUE; +#endif // __WXUNIVERSAL__ } //----------------------------------------------------------------------------- -// "button_release_event" +// "expose_event" of m_widget //----------------------------------------------------------------------------- -static gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxWindow *win ) +gint gtk_window_own_expose_callback( GtkWidget *widget, GdkEventExpose *gdk_event, wxWindowGTK *win ) { - if (!win->IsOwnGtkWindow( gdk_event->window )) return TRUE; - - if (g_blockEventsOnDrag) return TRUE; - - if (!win->HasVMT()) return TRUE; - -/* - printf( "OnButtonRelease from " ); - if (win->GetClassInfo() && win->GetClassInfo()->GetClassName()) - printf( win->GetClassInfo()->GetClassName() ); - printf( ".\n" ); -*/ - - wxEventType event_type = wxEVT_NULL; - - switch (gdk_event->button) - { - case 1: event_type = wxEVT_LEFT_UP; break; - case 2: event_type = wxEVT_MIDDLE_UP; break; - case 3: event_type = wxEVT_RIGHT_UP; break; - } + if (gdk_event->count > 0) return FALSE; - wxMouseEvent event( event_type ); - 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_x = (long)gdk_event->x; - event.m_y = (long)gdk_event->y; - - // Some control don't have their own X window and thus cannot get - // any events. - - if (!g_capturing) - { - wxNode *node = win->GetChildren()->First(); - while (node) - { - wxWindow *child = (wxWindow*)node->Data(); - if ((child->m_x <= event.m_x) && - (child->m_y <= event.m_y) && - (child->m_x+child->m_width >= event.m_x) && - (child->m_y+child->m_height >= event.m_y)) - { - win = child; - event.m_x -= child->m_x; - event.m_y -= child->m_y; - break; - } - node = node->Next(); - } - } + draw_frame( widget, win ); - event.SetEventObject( win ); + return TRUE; +} - if (win->GetEventHandler()->ProcessEvent( event )) - gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "button_release_event" ); +//----------------------------------------------------------------------------- +// "draw" of m_widget +//----------------------------------------------------------------------------- - return TRUE; +static void gtk_window_own_draw_callback( GtkWidget *widget, GdkRectangle *WXUNUSED(rect), wxWindowGTK *win ) +{ + draw_frame( widget, win ); } //----------------------------------------------------------------------------- -// "motion_notify_event" +// key code mapping routines //----------------------------------------------------------------------------- -static gint gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion *gdk_event, wxWindow *win ) +static long map_to_unmodified_wx_keysym( GdkEventKey *event ) { - if (!win->IsOwnGtkWindow( gdk_event->window )) return TRUE; + // VZ: it seems that GDK_KEY_RELEASE event doesn't set event->string + // but only event->keyval which is quite useless to us, so remember + // the last character from GDK_KEY_PRESS and resue it as last resort + // + // NB: should be MT-neutral as always called from main thread only + static struct + { + KeySym keysym; + long keycode; + } s_lastKeyPress = { 0, 0 }; - if (g_blockEventsOnDrag) return TRUE; + KeySym keysym = event->keyval; + long key_code; - if (!win->HasVMT()) return TRUE; + switch ( keysym ) + { + case GDK_Shift_L: + case GDK_Shift_R: key_code = WXK_SHIFT; break; + case GDK_Control_L: + case GDK_Control_R: key_code = WXK_CONTROL; break; + case GDK_Meta_L: + case GDK_Meta_R: + case GDK_Alt_L: + case GDK_Alt_R: + case GDK_Super_L: + case GDK_Super_R: key_code = WXK_ALT; break; + case GDK_Menu: key_code = WXK_MENU; break; + case GDK_Help: key_code = WXK_HELP; break; + case GDK_BackSpace: key_code = WXK_BACK; break; + case GDK_ISO_Left_Tab: + case GDK_Tab: key_code = WXK_TAB; break; + case GDK_Linefeed: key_code = WXK_RETURN; break; + case GDK_Clear: key_code = WXK_CLEAR; break; + case GDK_Return: key_code = WXK_RETURN; break; + case GDK_Pause: key_code = WXK_PAUSE; break; + case GDK_Scroll_Lock: key_code = WXK_SCROLL; break; + case GDK_Escape: key_code = WXK_ESCAPE; break; + case GDK_Delete: key_code = WXK_DELETE; break; + case GDK_Home: key_code = WXK_HOME; break; + case GDK_Left: key_code = WXK_LEFT; break; + case GDK_Up: key_code = WXK_UP; break; + case GDK_Right: key_code = WXK_RIGHT; break; + case GDK_Down: key_code = WXK_DOWN; break; + case GDK_Prior: key_code = WXK_PRIOR; break; +// case GDK_Page_Up: key_code = WXK_PAGEUP; break; + case GDK_Next: key_code = WXK_NEXT; break; +// case GDK_Page_Down: key_code = WXK_PAGEDOWN; break; + case GDK_End: key_code = WXK_END; break; + case GDK_Begin: key_code = WXK_HOME; break; + case GDK_Select: key_code = WXK_SELECT; break; + case GDK_Print: key_code = WXK_PRINT; break; + case GDK_Execute: key_code = WXK_EXECUTE; break; + case GDK_Insert: key_code = WXK_INSERT; break; + case GDK_Num_Lock: key_code = WXK_NUMLOCK; break; + + case GDK_KP_0: key_code = WXK_NUMPAD0; break; + case GDK_KP_1: key_code = WXK_NUMPAD1; break; + case GDK_KP_2: key_code = WXK_NUMPAD2; break; + case GDK_KP_3: key_code = WXK_NUMPAD3; break; + case GDK_KP_4: key_code = WXK_NUMPAD4; break; + case GDK_KP_5: key_code = WXK_NUMPAD5; break; + case GDK_KP_6: key_code = WXK_NUMPAD6; break; + case GDK_KP_7: key_code = WXK_NUMPAD7; break; + case GDK_KP_8: key_code = WXK_NUMPAD8; break; + case GDK_KP_9: key_code = WXK_NUMPAD9; break; + case GDK_KP_Space: key_code = WXK_NUMPAD_SPACE; break; + case GDK_KP_Tab: key_code = WXK_NUMPAD_TAB; break; + case GDK_KP_Enter: key_code = WXK_NUMPAD_ENTER; break; + case GDK_KP_F1: key_code = WXK_NUMPAD_F1; break; + case GDK_KP_F2: key_code = WXK_NUMPAD_F2; break; + case GDK_KP_F3: key_code = WXK_NUMPAD_F3; break; + case GDK_KP_F4: key_code = WXK_NUMPAD_F4; break; + case GDK_KP_Home: key_code = WXK_NUMPAD_HOME; break; + case GDK_KP_Left: key_code = WXK_NUMPAD_LEFT; break; + case GDK_KP_Up: key_code = WXK_NUMPAD_UP; break; + case GDK_KP_Right: key_code = WXK_NUMPAD_RIGHT; break; + case GDK_KP_Down: key_code = WXK_NUMPAD_DOWN; break; + case GDK_KP_Prior: key_code = WXK_NUMPAD_PRIOR; break; +// case GDK_KP_Page_Up: key_code = WXK_NUMPAD_PAGEUP; break; + case GDK_KP_Next: key_code = WXK_NUMPAD_NEXT; break; +// case GDK_KP_Page_Down: key_code = WXK_NUMPAD_PAGEDOWN; break; + case GDK_KP_End: key_code = WXK_NUMPAD_END; break; + case GDK_KP_Begin: key_code = WXK_NUMPAD_BEGIN; break; + case GDK_KP_Insert: key_code = WXK_NUMPAD_INSERT; break; + case GDK_KP_Delete: key_code = WXK_NUMPAD_DELETE; break; + case GDK_KP_Equal: key_code = WXK_NUMPAD_EQUAL; break; + case GDK_KP_Multiply: key_code = WXK_NUMPAD_MULTIPLY; break; + case GDK_KP_Add: key_code = WXK_NUMPAD_ADD; break; + case GDK_KP_Separator: key_code = WXK_NUMPAD_SEPARATOR; break; + case GDK_KP_Subtract: key_code = WXK_NUMPAD_SUBTRACT; break; + case GDK_KP_Decimal: key_code = WXK_NUMPAD_DECIMAL; break; + case GDK_KP_Divide: key_code = WXK_NUMPAD_DIVIDE; break; + + case GDK_F1: key_code = WXK_F1; break; + case GDK_F2: key_code = WXK_F2; break; + case GDK_F3: key_code = WXK_F3; break; + case GDK_F4: key_code = WXK_F4; break; + case GDK_F5: key_code = WXK_F5; break; + case GDK_F6: key_code = WXK_F6; break; + case GDK_F7: key_code = WXK_F7; break; + case GDK_F8: key_code = WXK_F8; break; + case GDK_F9: key_code = WXK_F9; break; + case GDK_F10: key_code = WXK_F10; break; + case GDK_F11: key_code = WXK_F11; break; + case GDK_F12: key_code = WXK_F12; break; + default: + { + // do we have the translation? + if ( event->length == 1 ) + { + keysym = (KeySym)event->string[0]; + } + else if ( (keysym & 0xFF) != keysym ) + { + // non ASCII key, what to do? + + if ( event->type == GDK_KEY_RELEASE ) + { + // reuse the one from the last keypress if any + if ( keysym == s_lastKeyPress.keysym ) + { + key_code = s_lastKeyPress.keycode; + + // skip "return 0" + break; + } + } + + // ignore this one, we don't know it + return 0; + } + //else: ASCII key, ok -/* - printf( "OnMotion from " ); - if (win->GetClassInfo() && win->GetClassInfo()->GetClassName()) - printf( win->GetClassInfo()->GetClassName() ); - printf( ".\n" ); -*/ + guint upper = gdk_keyval_to_upper( (guint)keysym ); + key_code = upper ? upper : keysym; - wxMouseEvent event( wxEVT_MOTION ); - 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); + if ( event->type == GDK_KEY_PRESS ) + { + // remember it to be reused below later + s_lastKeyPress.keysym = keysym; + s_lastKeyPress.keycode = key_code; + } + } + } - event.m_x = (long)gdk_event->x; - event.m_y = (long)gdk_event->y; + return key_code; +} - // Some control don't have their own X window and thus cannot get - // any events. +static long map_to_wx_keysym( GdkEventKey *event ) +{ + KeySym keysym = event->keyval; + guint key_code = 0; - if (!g_capturing) - { - wxNode *node = win->GetChildren()->First(); - while (node) + switch (keysym) { - wxWindow *child = (wxWindow*)node->Data(); - if ((child->m_x <= event.m_x) && - (child->m_y <= event.m_y) && - (child->m_x+child->m_width >= event.m_x) && - (child->m_y+child->m_height >= event.m_y)) - { - win = child; - event.m_x -= child->m_x; - event.m_y -= child->m_y; - break; - } - node = node->Next(); + case GDK_Menu: key_code = WXK_MENU; break; + case GDK_Help: key_code = WXK_HELP; break; + case GDK_BackSpace: key_code = WXK_BACK; break; + case GDK_ISO_Left_Tab: + case GDK_Tab: key_code = WXK_TAB; break; + case GDK_Linefeed: key_code = WXK_RETURN; break; + case GDK_Clear: key_code = WXK_CLEAR; break; + case GDK_Return: key_code = WXK_RETURN; break; + case GDK_Pause: key_code = WXK_PAUSE; break; + case GDK_Scroll_Lock: key_code = WXK_SCROLL; break; + case GDK_Escape: key_code = WXK_ESCAPE; break; + case GDK_Delete: key_code = WXK_DELETE; break; + case GDK_Home: key_code = WXK_HOME; break; + case GDK_Left: key_code = WXK_LEFT; break; + case GDK_Up: key_code = WXK_UP; break; + case GDK_Right: key_code = WXK_RIGHT; break; + case GDK_Down: key_code = WXK_DOWN; break; + case GDK_Prior: key_code = WXK_PRIOR; break; +// case GDK_Page_Up: key_code = WXK_PAGEUP; break; + case GDK_Next: key_code = WXK_NEXT; break; +// case GDK_Page_Down: key_code = WXK_PAGEDOWN; break; + case GDK_End: key_code = WXK_END; break; + case GDK_Begin: key_code = WXK_HOME; break; + case GDK_Select: key_code = WXK_SELECT; break; + case GDK_Print: key_code = WXK_PRINT; break; + case GDK_Execute: key_code = WXK_EXECUTE; break; + case GDK_Insert: key_code = WXK_INSERT; break; + case GDK_Num_Lock: key_code = WXK_NUMLOCK; break; + + case GDK_KP_0: key_code = '0'; break; + case GDK_KP_1: key_code = '1'; break; + case GDK_KP_2: key_code = '2'; break; + case GDK_KP_3: key_code = '3'; break; + case GDK_KP_4: key_code = '4'; break; + case GDK_KP_5: key_code = '5'; break; + case GDK_KP_6: key_code = '6'; break; + case GDK_KP_7: key_code = '7'; break; + case GDK_KP_8: key_code = '8'; break; + case GDK_KP_9: key_code = '9'; break; + case GDK_KP_Space: key_code = ' '; break; + case GDK_KP_Tab: key_code = WXK_TAB; break; /* or '\t' ??? */ + case GDK_KP_Enter: key_code = WXK_RETURN; break; /* or '\r' ??? */ + case GDK_KP_F1: key_code = WXK_NUMPAD_F1; break; + case GDK_KP_F2: key_code = WXK_NUMPAD_F2; break; + case GDK_KP_F3: key_code = WXK_NUMPAD_F3; break; + case GDK_KP_F4: key_code = WXK_NUMPAD_F4; break; + case GDK_KP_Home: key_code = WXK_HOME; break; + case GDK_KP_Left: key_code = WXK_LEFT; break; + case GDK_KP_Up: key_code = WXK_UP; break; + case GDK_KP_Right: key_code = WXK_RIGHT; break; + case GDK_KP_Down: key_code = WXK_DOWN; break; + case GDK_KP_Prior: key_code = WXK_PRIOR; break; +// case GDK_KP_Page_Up: key_code = WXK_PAGEUP; break; + case GDK_KP_Next: key_code = WXK_NEXT; break; +// case GDK_KP_Page_Down: key_code = WXK_PAGEDOWN; break; + case GDK_KP_End: key_code = WXK_END; break; + case GDK_KP_Begin: key_code = WXK_HOME; break; + case GDK_KP_Insert: key_code = WXK_INSERT; break; + case GDK_KP_Delete: key_code = WXK_DELETE; break; + case GDK_KP_Equal: key_code = '='; break; + case GDK_KP_Multiply: key_code = '*'; break; + case GDK_KP_Add: key_code = '+'; break; + case GDK_KP_Separator: key_code = ','; break; + case GDK_KP_Subtract: key_code = '-'; break; + case GDK_KP_Decimal: key_code = '.'; break; + case GDK_KP_Divide: key_code = '/'; break; + + case GDK_F1: key_code = WXK_F1; break; + case GDK_F2: key_code = WXK_F2; break; + case GDK_F3: key_code = WXK_F3; break; + case GDK_F4: key_code = WXK_F4; break; + case GDK_F5: key_code = WXK_F5; break; + case GDK_F6: key_code = WXK_F6; break; + case GDK_F7: key_code = WXK_F7; break; + case GDK_F8: key_code = WXK_F8; break; + case GDK_F9: key_code = WXK_F9; break; + case GDK_F10: key_code = WXK_F10; break; + case GDK_F11: key_code = WXK_F11; break; + case GDK_F12: key_code = WXK_F12; break; + default: + if (event->length == 1) + { + key_code = (unsigned char)*event->string; + } + else if ((keysym & 0xFF) == keysym) + { + key_code = (guint)keysym; + } } - } - - event.SetEventObject( win ); - - if (win->GetEventHandler()->ProcessEvent( event )) - gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "motion_notify_event" ); - return TRUE; + return key_code; } //----------------------------------------------------------------------------- -// "focus_in_event" +// "size_request" of m_widget //----------------------------------------------------------------------------- -static gint gtk_window_focus_in_callback( GtkWidget *widget, GdkEvent *WXUNUSED(event), wxWindow *win ) +static void gtk_window_size_request_callback( GtkWidget *widget, GtkRequisition *requisition, wxWindow *win ) { - if (g_blockEventsOnDrag) return TRUE; - if (win->m_wxwindow) - { - if (GTK_WIDGET_CAN_FOCUS(win->m_wxwindow)) - { - GTK_WIDGET_SET_FLAGS (win->m_wxwindow, GTK_HAS_FOCUS); -/* - printf( "SetFocus flag from " ); - if (win->GetClassInfo() && win->GetClassInfo()->GetClassName()) - printf( win->GetClassInfo()->GetClassName() ); - printf( ".\n" ); -*/ - } - } - - if (!win->HasVMT()) return TRUE; - -/* - printf( "OnSetFocus from " ); - if (win->GetClassInfo() && win->GetClassInfo()->GetClassName()) - printf( win->GetClassInfo()->GetClassName() ); - printf( " " ); - printf( WXSTRINGCAST win->GetLabel() ); - printf( ".\n" ); -*/ + int w,h; + win->GetSize( &w, &h ); + if (w < 2) w = 2; + if (h < 2) h = 2; - wxFocusEvent event( wxEVT_SET_FOCUS, win->GetId() ); - event.SetEventObject( win ); - - if (win->GetEventHandler()->ProcessEvent( event )) - gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus_in_event" ); - - return TRUE; + requisition->height = h; + requisition->width = w; } //----------------------------------------------------------------------------- -// "focus_out_event" +// "expose_event" of m_wxwindow //----------------------------------------------------------------------------- -static gint gtk_window_focus_out_callback( GtkWidget *widget, GdkEvent *WXUNUSED(event), wxWindow *win ) +static int gtk_window_expose_callback( GtkWidget *widget, + GdkEventExpose *gdk_event, + wxWindow *win ) { - if (g_blockEventsOnDrag) return TRUE; - if (win->m_wxwindow) - { - if (GTK_WIDGET_CAN_FOCUS(win->m_wxwindow)) - GTK_WIDGET_UNSET_FLAGS (win->m_wxwindow, GTK_HAS_FOCUS); - } + DEBUG_MAIN_THREAD - if (!win->HasVMT()) return TRUE; + if (g_isIdle) + wxapp_install_idle_handler(); /* - printf( "OnKillFocus from " ); - if (win->GetClassInfo() && win->GetClassInfo()->GetClassName()) - printf( win->GetClassInfo()->GetClassName() ); - printf( ".\n" ); + if (win->GetName() == wxT("panel")) + { + 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 ); + } */ - wxFocusEvent event( wxEVT_KILL_FOCUS, win->GetId() ); - event.SetEventObject( win ); + GtkPizza *pizza = GTK_PIZZA (widget); + + if (win->GetThemeEnabled()) + { + wxWindow *parent = win->GetParent(); + while (parent && !parent->IsTopLevel()) + parent = parent->GetParent(); + if (!parent) + parent = win; + + gtk_paint_flat_box (parent->m_widget->style, pizza->bin_window, GTK_STATE_NORMAL, + GTK_SHADOW_NONE, &gdk_event->area, parent->m_widget, "base", 0, 0, -1, -1); + } - if (win->GetEventHandler()->ProcessEvent( event )) - gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus_out_event" ); + win->GetUpdateRegion().Union( gdk_event->area.x, + gdk_event->area.y, + gdk_event->area.width, + gdk_event->area.height ); - return TRUE; -} + if (gdk_event->count == 0) + { + win->m_clipPaintRegion = TRUE; + + wxWindowDC dc(win); + dc.SetClippingRegion(win->GetUpdateRegion()); + wxEraseEvent eevent( win->GetId(), &dc ); + eevent.SetEventObject( win ); +#if 1 + (void)win->GetEventHandler()->ProcessEvent(eevent); +#else // 0 + if (!win->GetEventHandler()->ProcessEvent(eevent)) + { + wxClientDC dc( win ); + dc.SetBrush( wxBrush( win->GetBackgroundColour(), wxSOLID ) ); + dc.SetPen( *wxTRANSPARENT_PEN ); -//----------------------------------------------------------------------------- -// "enter_notify_event" -//----------------------------------------------------------------------------- + wxRegionIterator upd( win->GetUpdateRegion() ); + while (upd) + { + dc.DrawRectangle( upd.GetX(), upd.GetY(), upd.GetWidth(), upd.GetHeight() ); + upd ++; + } + } +#endif // 1/0 -static gint gtk_window_enter_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindow *win ) -{ - if (widget->window != gdk_event->window) return TRUE; + wxNcPaintEvent eventNc( win->GetId() ); + eventNc.SetEventObject( win ); + win->GetEventHandler()->ProcessEvent( eventNc ); - if (g_blockEventsOnDrag) return TRUE; + wxPaintEvent event( win->GetId() ); + event.SetEventObject( win ); + win->GetEventHandler()->ProcessEvent( event ); - if (!win->HasVMT()) return TRUE; + win->GetUpdateRegion().Clear(); -/* - printf( "OnEnter from " ); - if (win->GetClassInfo() && win->GetClassInfo()->GetClassName()) - printf( win->GetClassInfo()->GetClassName() ); - printf( ".\n" ); -*/ + win->m_clipPaintRegion = FALSE; + } - if ((widget->window) && (win->m_cursor)) - gdk_window_set_cursor( widget->window, win->m_cursor->GetCursor() ); + /* The following code will result in all window-less widgets + being redrawn if the wxWindows class is given a chance to + paint *anything* because it will then be allowed to paint + over the window-less widgets */ + GList *children = pizza->children; + while (children) + { + GtkPizzaChild *child = (GtkPizzaChild*) children->data; + children = children->next; - wxMouseEvent event( wxEVT_ENTER_WINDOW ); - event.SetEventObject( win ); + GdkEventExpose child_event = *gdk_event; - if (win->GetEventHandler()->ProcessEvent( event )) - gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "enter_notify_event" ); + if (GTK_WIDGET_NO_WINDOW (child->widget) && + GTK_WIDGET_DRAWABLE (child->widget) /* && + gtk_widget_intersect (child->widget, &gdk_event->area, &child_event.area)*/ ) + { + child_event.area.x = child->widget->allocation.x; + child_event.area.y = child->widget->allocation.y; + child_event.area.width = child->widget->allocation.width; + child_event.area.height = child->widget->allocation.height; + gtk_widget_event (child->widget, (GdkEvent*) &child_event); + } + } - return TRUE; + return TRUE; } //----------------------------------------------------------------------------- -// "leave_notify_event" +// "event" of m_wxwindow //----------------------------------------------------------------------------- -static gint gtk_window_leave_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindow *win ) -{ - if (widget->window != gdk_event->window) return TRUE; - - if (g_blockEventsOnDrag) return TRUE; - - if (!win->HasVMT()) return TRUE; +/* 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. + There, we look for expose events ourselves whereas all other events are + handled normally. */ -/* - printf( "OnLeave from " ); - if (win->GetClassInfo() && win->GetClassInfo()->GetClassName()) - printf( win->GetClassInfo()->GetClassName() ); - printf( ".\n" ); -*/ - - if ((widget->window) && (win->m_cursor)) - gdk_window_set_cursor( widget->window, wxSTANDARD_CURSOR->GetCursor() ); - - wxMouseEvent event( wxEVT_LEAVE_WINDOW ); - event.SetEventObject( win ); - - if (win->GetEventHandler()->ProcessEvent( event )) - gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "leave_notify_event" ); +gint gtk_window_event_event_callback( GtkWidget *widget, + GdkEventExpose *event, + wxWindow *win ) +{ + if (event->type == GDK_EXPOSE) + { + gint ret = gtk_window_expose_callback( widget, event, win ); + return ret; + } - return TRUE; + return FALSE; } //----------------------------------------------------------------------------- -// "value_changed" from m_vAdjust +// "draw" of m_wxwindow //----------------------------------------------------------------------------- -static void gtk_window_vscroll_callback( GtkWidget *WXUNUSED(widget), wxWindow *win ) +/* This callback is a complete replacement of the gtk_pizza_draw() function, + which disabled. */ + +static void gtk_window_draw_callback( GtkWidget *widget, + GdkRectangle *rect, + wxWindow *win ) { - if (g_blockEventsOnDrag) return; + DEBUG_MAIN_THREAD + + if (g_isIdle) + wxapp_install_idle_handler(); + + if ((win->HasFlag(wxNO_FULL_REPAINT_ON_RESIZE)) && + (win->GetChildren().GetCount() == 0)) + { + return; + } /* - printf( "OnVScroll from " ); - if (win->GetClassInfo() && win->GetClassInfo()->GetClassName()) - printf( win->GetClassInfo()->GetClassName() ); - printf( ".\n" ); + if (win->GetName() == wxT("panel")) + { + wxPrintf( wxT("OnDraw from ") ); + if (win->GetClassInfo() && win->GetClassInfo()->GetClassName()) + wxPrintf( win->GetClassInfo()->GetClassName() ); + wxPrintf( wxT(" %d %d %d %d\n"), (int)rect->x, + (int)rect->y, + (int)rect->width, + (int)rect->height ); + } */ - if (!win->HasVMT()) return; - - float diff = win->m_vAdjust->value - win->m_oldVerticalPos; - if (fabs(diff) < 0.2) return; + GtkPizza *pizza = GTK_PIZZA (widget); - wxEventType command = wxEVT_NULL; + if (win->GetThemeEnabled()) + { + wxWindow *parent = win->GetParent(); + while (parent && !parent->IsTopLevel()) + parent = parent->GetParent(); + if (!parent) + parent = win; + + gtk_paint_flat_box (parent->m_widget->style, pizza->bin_window, GTK_STATE_NORMAL, + GTK_SHADOW_NONE, rect, parent->m_widget, "base", 0, 0, -1, -1); + } - float line_step = win->m_vAdjust->step_increment; - float page_step = win->m_vAdjust->page_increment; - if (fabs(diff-line_step) < 0.2) command = wxEVT_SCROLL_LINEDOWN; - else if (fabs(diff+line_step) < 0.2) command = wxEVT_SCROLL_LINEUP; - else if (fabs(diff-page_step) < 0.2) command = wxEVT_SCROLL_PAGEDOWN; - else if (fabs(diff+page_step) < 0.2) command = wxEVT_SCROLL_PAGEUP; - else command = wxEVT_SCROLL_THUMBTRACK; + if (!(GTK_WIDGET_APP_PAINTABLE (widget)) && + (pizza->clear_on_draw)) + { + gdk_window_clear_area( pizza->bin_window, + rect->x, rect->y, rect->width, rect->height); + } - int value = (int)(win->m_vAdjust->value+0.5); + win->GetUpdateRegion().Union( rect->x, rect->y, rect->width, rect->height ); - wxScrollEvent event( command, win->GetId(), value, wxVERTICAL ); - event.SetEventObject( win ); - win->GetEventHandler()->ProcessEvent( event ); -} + win->m_clipPaintRegion = TRUE; -//----------------------------------------------------------------------------- -// "value_changed" from m_hAdjust -//----------------------------------------------------------------------------- + wxWindowDC dc(win); + dc.SetClippingRegion(win->GetUpdateRegion()); + wxEraseEvent eevent( win->GetId(), &dc ); + eevent.SetEventObject( win ); -static void gtk_window_hscroll_callback( GtkWidget *WXUNUSED(widget), wxWindow *win ) -{ - if (g_blockEventsOnDrag) return; +#if 1 + (void)win->GetEventHandler()->ProcessEvent(eevent); +#else + if (!win->GetEventHandler()->ProcessEvent(eevent)) + { + if (!win->GetEventHandler()->ProcessEvent(eevent)) + { + wxClientDC dc( win ); + dc.SetBrush( wxBrush( win->GetBackgroundColour(), wxSOLID ) ); + dc.SetPen( *wxTRANSPARENT_PEN ); -/* - printf( "OnHScroll from " ); - if (win->GetClassInfo() && win->GetClassInfo()->GetClassName()) - printf( win->GetClassInfo()->GetClassName() ); - printf( ".\n" ); -*/ + wxRegionIterator upd( win->GetUpdateRegion() ); + while (upd) + { + dc.DrawRectangle( upd.GetX(), upd.GetY(), upd.GetWidth(), upd.GetHeight() ); + upd ++; + } + } + } +#endif - if (!win->HasVMT()) return; + wxNcPaintEvent eventNc( win->GetId() ); + eventNc.SetEventObject( win ); + win->GetEventHandler()->ProcessEvent( eventNc ); - float diff = win->m_hAdjust->value - win->m_oldHorizontalPos; - if (fabs(diff) < 0.2) return; + wxPaintEvent event( win->GetId() ); + event.SetEventObject( win ); + win->GetEventHandler()->ProcessEvent( event ); - wxEventType command = wxEVT_NULL; + win->GetUpdateRegion().Clear(); - float line_step = win->m_hAdjust->step_increment; - float page_step = win->m_hAdjust->page_increment; + win->m_clipPaintRegion = FALSE; - if (fabs(diff-line_step) < 0.2) command = wxEVT_SCROLL_LINEDOWN; - else if (fabs(diff+line_step) < 0.2) command = wxEVT_SCROLL_LINEUP; - else if (fabs(diff-page_step) < 0.2) command = wxEVT_SCROLL_PAGEDOWN; - else if (fabs(diff+page_step) < 0.2) command = wxEVT_SCROLL_PAGEUP; - else command = wxEVT_SCROLL_THUMBTRACK; - int value = (int)(win->m_hAdjust->value+0.5); + GList *children = pizza->children; + while (children) + { + GtkPizzaChild *child = (GtkPizzaChild*) children->data; + children = children->next; - wxScrollEvent event( command, win->GetId(), value, wxHORIZONTAL ); - event.SetEventObject( win ); - win->GetEventHandler()->ProcessEvent( event ); + GdkRectangle child_area; + if (gtk_widget_intersect (child->widget, rect, &child_area)) + { + gtk_widget_draw (child->widget, &child_area /* (GdkRectangle*) NULL*/ ); + } + } } //----------------------------------------------------------------------------- -// "changed" from m_vAdjust +// "key_press_event" from any window //----------------------------------------------------------------------------- -static void gtk_window_vscroll_change_callback( GtkWidget *WXUNUSED(widget), wxWindow *win ) +// turn on to see the key event codes on the console +#undef DEBUG_KEY_EVENTS + +static gint gtk_window_key_press_callback( GtkWidget *widget, + GdkEventKey *gdk_event, + wxWindow *win ) { - if (g_blockEventsOnDrag) return; + DEBUG_MAIN_THREAD -/* - printf( "OnVScroll change from " ); - if (win->GetClassInfo() && win->GetClassInfo()->GetClassName()) - printf( win->GetClassInfo()->GetClassName() ); - printf( ".\n" ); -*/ + if (g_isIdle) + wxapp_install_idle_handler(); - if (!win->HasVMT()) return; + if (!win->m_hasVMT) return FALSE; + if (g_blockEventsOnDrag) return FALSE; - wxEventType command = wxEVT_SCROLL_THUMBTRACK; - int value = (int)(win->m_vAdjust->value+0.5); - wxScrollEvent event( command, win->GetId(), value, wxVERTICAL ); - event.SetEventObject( win ); - win->GetEventHandler()->ProcessEvent( event ); -} + int x = 0; + int y = 0; + GdkModifierType state; + if (gdk_event->window) + gdk_window_get_pointer(gdk_event->window, &x, &y, &state); + + bool ret = FALSE; + + long key_code = map_to_unmodified_wx_keysym( gdk_event ); + +#ifdef DEBUG_KEY_EVENTS + wxPrintf(_T("Key press event: %d => %ld\n"), gdk_event->keyval, key_code); +#endif // DEBUG_KEY_EVENTS + + /* sending unknown key events doesn't really make sense */ + if (key_code == 0) + return FALSE; + + wxKeyEvent event( wxEVT_KEY_DOWN ); + 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_keyCode = key_code; + event.m_scanCode = gdk_event->keyval; + event.m_x = x; + event.m_y = y; + event.SetEventObject( win ); + ret = win->GetEventHandler()->ProcessEvent( event ); + +#if wxUSE_ACCEL + if (!ret) + { + wxWindowGTK *ancestor = win; + while (ancestor) + { + int command = ancestor->GetAcceleratorTable()->GetCommand( event ); + if (command != -1) + { + wxCommandEvent command_event( wxEVT_COMMAND_MENU_SELECTED, command ); + ret = ancestor->GetEventHandler()->ProcessEvent( command_event ); + break; + } + if (ancestor->IsTopLevel()) + break; + ancestor = ancestor->GetParent(); + } + } +#endif // wxUSE_ACCEL -//----------------------------------------------------------------------------- -// "changed" from m_hAdjust -//----------------------------------------------------------------------------- + /* Only send wxEVT_CHAR event if not processed yet. Thus, ALT-x + will only be sent if it is not in an accelerator table. */ + if ( !ret ) + { + key_code = map_to_wx_keysym( gdk_event ); -static void gtk_window_hscroll_change_callback( GtkWidget *WXUNUSED(widget), wxWindow *win ) -{ - if (g_blockEventsOnDrag) return; + if ( key_code ) + { +#ifdef DEBUG_KEY_EVENTS + wxPrintf(_T("Char event: %ld\n"), key_code); +#endif // DEBUG_KEY_EVENTS + + // reuse the ame event object, just change its type and use the + // translated keycode instead of the raw one + event.SetEventType(wxEVT_CHAR); + event.m_keyCode = key_code; + + ret = win->GetEventHandler()->ProcessEvent( event ); + } + } + + /* win is a control: tab can be propagated up */ + if ( !ret && + ((gdk_event->keyval == GDK_Tab) || (gdk_event->keyval == GDK_ISO_Left_Tab)) && +// VZ: testing for wxTE_PROCESS_TAB shouldn't be done here the control may +// have this style, yet choose not to process this particular TAB in which +// case TAB must still work as a navigational character +#if 0 + !win->HasFlag(wxTE_PROCESS_TAB) && +#endif // 0 + win->GetParent() && (win->GetParent()->HasFlag( wxTAB_TRAVERSAL)) ) + { + wxNavigationKeyEvent new_event; + new_event.SetEventObject( win->GetParent() ); + /* GDK reports GDK_ISO_Left_Tab for SHIFT-TAB */ + new_event.SetDirection( (gdk_event->keyval == GDK_Tab) ); + /* 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 ); + } + + /* generate wxID_CANCEL if has been pressed (typically in dialogs) */ + if ( !ret && + (gdk_event->keyval == GDK_Escape) ) + { + wxCommandEvent new_event(wxEVT_COMMAND_BUTTON_CLICKED,wxID_CANCEL); + new_event.SetEventObject( win ); + ret = win->GetEventHandler()->ProcessEvent( new_event ); + } + + /* Doesn't work. */ +#if 0 // (GTK_MINOR_VERSION > 0) + /* Pressing F10 will activate the menu bar of the top frame. */ + if ( (!ret) && + (gdk_event->keyval == GDK_F10) ) + { + wxWindowGTK *ancestor = win; + while (ancestor) + { + if (wxIsKindOf(ancestor,wxFrame)) + { + wxFrame *frame = (wxFrame*) ancestor; + wxMenuBar *menubar = frame->GetMenuBar(); + if (menubar) + { + wxNode *node = menubar->GetMenus().First(); + if (node) + { + wxMenu *firstMenu = (wxMenu*) node->Data(); + gtk_menu_item_select( GTK_MENU_ITEM(firstMenu->m_owner) ); + ret = TRUE; + break; + } + } + } + ancestor = ancestor->GetParent(); + } + } +#endif // 0 + + if (ret) + { + gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_press_event" ); + return TRUE; + } + + return FALSE; +} + +//----------------------------------------------------------------------------- +// "key_release_event" from any window +//----------------------------------------------------------------------------- + +static gint gtk_window_key_release_callback( GtkWidget *widget, GdkEventKey *gdk_event, wxWindowGTK *win ) +{ + DEBUG_MAIN_THREAD + + if (g_isIdle) + wxapp_install_idle_handler(); + + if (!win->m_hasVMT) return FALSE; + if (g_blockEventsOnDrag) return FALSE; + + long key_code = map_to_unmodified_wx_keysym( gdk_event ); + +#ifdef DEBUG_KEY_EVENTS + wxPrintf(_T("Key release event: %d => %ld\n"), gdk_event->keyval, key_code); +#endif // DEBUG_KEY_EVENTS + + /* sending unknown key events doesn't really make sense */ + if (key_code == 0) return FALSE; + + int x = 0; + int y = 0; + GdkModifierType state; + if (gdk_event->window) + gdk_window_get_pointer(gdk_event->window, &x, &y, &state); + + wxKeyEvent event( wxEVT_KEY_UP ); + 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_keyCode = key_code; + event.m_scanCode = gdk_event->keyval; + event.m_x = x; + event.m_y = y; + event.SetEventObject( win ); + + if (win->GetEventHandler()->ProcessEvent( event )) + { + gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_release_event" ); + return TRUE; + } + + return FALSE; +} + +// ============================================================================ +// the mouse events +// ============================================================================ + +// init wxMouseEvent with the info from gdk_event +#define InitMouseEvent(win, event, gdk_event) \ + { \ + 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); \ +\ + wxPoint pt = win->GetClientAreaOrigin(); \ + event.m_x = (wxCoord)gdk_event->x - pt.x; \ + event.m_y = (wxCoord)gdk_event->y - pt.y; \ + } + +// ---------------------------------------------------------------------------- +// mouse event processing helper +// ---------------------------------------------------------------------------- + +static void AdjustEventButtonState(wxMouseEvent& event) +{ + // GDK reports the old state of the button for a button press event, but + // for compatibility with MSW and common sense we want m_leftDown be TRUE + // for a LEFT_DOWN event, not FALSE, so we will invert + // left/right/middleDown for the corresponding click events + + if ((event.GetEventType() == wxEVT_LEFT_DOWN) || + (event.GetEventType() == wxEVT_LEFT_DCLICK) || + (event.GetEventType() == wxEVT_LEFT_UP)) + { + event.m_leftDown = !event.m_leftDown; + return; + } + + if ((event.GetEventType() == wxEVT_MIDDLE_DOWN) || + (event.GetEventType() == wxEVT_MIDDLE_DCLICK) || + (event.GetEventType() == wxEVT_MIDDLE_UP)) + { + event.m_middleDown = !event.m_middleDown; + return; + } + + if ((event.GetEventType() == wxEVT_RIGHT_DOWN) || + (event.GetEventType() == wxEVT_RIGHT_DCLICK) || + (event.GetEventType() == wxEVT_RIGHT_UP)) + { + event.m_rightDown = !event.m_rightDown; + return; + } +} + +//----------------------------------------------------------------------------- +// "button_press_event" +//----------------------------------------------------------------------------- + +static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxWindowGTK *win ) +{ + DEBUG_MAIN_THREAD + + if (g_isIdle) + wxapp_install_idle_handler(); + +/* + wxPrintf( wxT("1) OnButtonPress from ") ); + if (win->GetClassInfo() && win->GetClassInfo()->GetClassName()) + wxPrintf( win->GetClassInfo()->GetClassName() ); + wxPrintf( wxT(".\n") ); +*/ + if (!win->m_hasVMT) return FALSE; + if (g_blockEventsOnDrag) return TRUE; + if (g_blockEventsOnScroll) return TRUE; + + if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE; + + if (win->m_wxwindow) + { + if (GTK_WIDGET_CAN_FOCUS(win->m_wxwindow) && !GTK_WIDGET_HAS_FOCUS (win->m_wxwindow) ) + { + gtk_widget_grab_focus (win->m_wxwindow); + +/* + wxPrintf( wxT("GrabFocus from ") ); + if (win->GetClassInfo() && win->GetClassInfo()->GetClassName()) + wxPrintf( win->GetClassInfo()->GetClassName() ); + wxPrintf( wxT(".\n") ); +*/ + + } + } + + wxEventType event_type = wxEVT_NULL; + + if (gdk_event->button == 1) + { + switch (gdk_event->type) + { + case GDK_BUTTON_PRESS: event_type = wxEVT_LEFT_DOWN; break; + case GDK_2BUTTON_PRESS: event_type = wxEVT_LEFT_DCLICK; break; + default: break; + } + } + else if (gdk_event->button == 2) + { + switch (gdk_event->type) + { + case GDK_BUTTON_PRESS: event_type = wxEVT_MIDDLE_DOWN; break; + case GDK_2BUTTON_PRESS: event_type = wxEVT_MIDDLE_DCLICK; break; + default: break; + } + } + else if (gdk_event->button == 3) + { + switch (gdk_event->type) + { + case GDK_BUTTON_PRESS: event_type = wxEVT_RIGHT_DOWN; break; + case GDK_2BUTTON_PRESS: event_type = wxEVT_RIGHT_DCLICK; break; + default: break; + } + } + + if ( event_type == wxEVT_NULL ) + { + // unknown mouse button or click type + return FALSE; + } + + wxMouseEvent event( event_type ); + InitMouseEvent( win, event, gdk_event ); + + AdjustEventButtonState(event); + + // wxListBox actually get mouse events from the item + + if (win->m_isListBox) + { + event.m_x += widget->allocation.x; + event.m_y += widget->allocation.y; + } + + // Some control don't have their own X window and thus cannot get + // any events. + + if (!g_captureWindow) + { + wxCoord x = event.m_x; + wxCoord y = event.m_y; + if (win->m_wxwindow) + { + GtkPizza *pizza = GTK_PIZZA(win->m_wxwindow); + x += pizza->xoffset; + y += pizza->yoffset; + } + + wxNode *node = win->GetChildren().First(); + while (node) + { + wxWindowGTK *child = (wxWindowGTK*)node->Data(); + + node = node->Next(); + if (!child->IsShown()) + continue; + + if (child->m_isStaticBox) + { + // wxStaticBox is transparent in the box itself + int xx1 = child->m_x; + int yy1 = child->m_y; + int xx2 = child->m_x + child->m_width; + int yy2 = child->m_x + child->m_height; + + // left + if (((x >= xx1) && (x <= xx1+10) && (y >= yy1) && (y <= yy2)) || + // right + ((x >= xx2-10) && (x <= xx2) && (y >= yy1) && (y <= yy2)) || + // top + ((x >= xx1) && (x <= xx2) && (y >= yy1) && (y <= yy1+10)) || + // bottom + ((x >= xx1) && (x <= xx2) && (y >= yy2-1) && (y <= yy2))) + { + win = child; + event.m_x -= child->m_x; + event.m_y -= child->m_y; + break; + } + + } + else + { + if ((child->m_wxwindow == (GtkWidget*) NULL) && + (child->m_x <= x) && + (child->m_y <= y) && + (child->m_x+child->m_width >= x) && + (child->m_y+child->m_height >= y)) + { + win = child; + event.m_x -= child->m_x; + event.m_y -= child->m_y; + break; + } + } + } + } + + event.SetEventObject( win ); + + gs_timeLastClick = gdk_event->time; + +/* + wxPrintf( wxT("2) OnButtonPress from ") ); + if (win->GetClassInfo() && win->GetClassInfo()->GetClassName()) + wxPrintf( win->GetClassInfo()->GetClassName() ); + wxPrintf( wxT(".\n") ); +*/ + + if (win->GetEventHandler()->ProcessEvent( event )) + { + gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "button_press_event" ); + return TRUE; + } + + return FALSE; +} + +//----------------------------------------------------------------------------- +// "button_release_event" +//----------------------------------------------------------------------------- + +static gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxWindowGTK *win ) +{ + DEBUG_MAIN_THREAD + + if (g_isIdle) + wxapp_install_idle_handler(); + + if (!win->m_hasVMT) return FALSE; + if (g_blockEventsOnDrag) return FALSE; + if (g_blockEventsOnScroll) return FALSE; + + if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE; + +/* + printf( "OnButtonRelease from " ); + if (win->GetClassInfo() && win->GetClassInfo()->GetClassName()) + printf( win->GetClassInfo()->GetClassName() ); + printf( ".\n" ); +*/ + + wxEventType event_type = wxEVT_NULL; + + switch (gdk_event->button) + { + case 1: event_type = wxEVT_LEFT_UP; break; + case 2: event_type = wxEVT_MIDDLE_UP; break; + case 3: event_type = wxEVT_RIGHT_UP; break; + default: return FALSE; + } + + wxMouseEvent event( event_type ); + InitMouseEvent( win, event, gdk_event ); + + AdjustEventButtonState(event); + + // wxListBox actually get mouse events from the item + + if (win->m_isListBox) + { + event.m_x += widget->allocation.x; + event.m_y += widget->allocation.y; + } + + // Some control don't have their own X window and thus cannot get + // any events. + + if (!g_captureWindow) + { + wxCoord x = event.m_x; + wxCoord y = event.m_y; + if (win->m_wxwindow) + { + GtkPizza *pizza = GTK_PIZZA(win->m_wxwindow); + x += pizza->xoffset; + y += pizza->yoffset; + } + + wxNode *node = win->GetChildren().First(); + while (node) + { + wxWindowGTK *child = (wxWindowGTK*)node->Data(); + + node = node->Next(); + if (!child->IsShown()) + continue; + + if (child->m_isStaticBox) + { + // wxStaticBox is transparent in the box itself + int xx1 = child->m_x; + int yy1 = child->m_y; + int xx2 = child->m_x + child->m_width; + int yy2 = child->m_x + child->m_height; + + // left + if (((x >= xx1) && (x <= xx1+10) && (y >= yy1) && (y <= yy2)) || + // right + ((x >= xx2-10) && (x <= xx2) && (y >= yy1) && (y <= yy2)) || + // top + ((x >= xx1) && (x <= xx2) && (y >= yy1) && (y <= yy1+10)) || + // bottom + ((x >= xx1) && (x <= xx2) && (y >= yy2-1) && (y <= yy2))) + { + win = child; + event.m_x -= child->m_x; + event.m_y -= child->m_y; + break; + } + + } + else + { + if ((child->m_wxwindow == (GtkWidget*) NULL) && + (child->m_x <= x) && + (child->m_y <= y) && + (child->m_x+child->m_width >= x) && + (child->m_y+child->m_height >= y)) + { + win = child; + event.m_x -= child->m_x; + event.m_y -= child->m_y; + break; + } + } + } + } + + event.SetEventObject( win ); + + if (win->GetEventHandler()->ProcessEvent( event )) + { + gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "button_release_event" ); + return TRUE; + } + + return FALSE; +} + +//----------------------------------------------------------------------------- +// "motion_notify_event" +//----------------------------------------------------------------------------- + +static gint gtk_window_motion_notify_callback( GtkWidget *widget, + GdkEventMotion *gdk_event, + wxWindowGTK *win ) +{ + DEBUG_MAIN_THREAD + + if (g_isIdle) + wxapp_install_idle_handler(); + + if (!win->m_hasVMT) return FALSE; + if (g_blockEventsOnDrag) return FALSE; + if (g_blockEventsOnScroll) return FALSE; + + if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE; + + if (gdk_event->is_hint) + { + int x = 0; + int y = 0; + GdkModifierType state; + gdk_window_get_pointer(gdk_event->window, &x, &y, &state); + gdk_event->x = x; + gdk_event->y = y; + } + +/* + printf( "OnMotion from " ); + if (win->GetClassInfo() && win->GetClassInfo()->GetClassName()) + printf( win->GetClassInfo()->GetClassName() ); + printf( ".\n" ); +*/ + + wxMouseEvent event( wxEVT_MOTION ); + InitMouseEvent(win, event, gdk_event); + + if ( g_captureWindow ) + { + // synthetize a mouse enter or leave event if needed + GdkWindow *winUnderMouse = gdk_window_at_pointer(NULL, NULL); + bool hasMouse = winUnderMouse == gdk_event->window; + if ( hasMouse != g_captureWindowHasMouse ) + { + // the mouse changed window + g_captureWindowHasMouse = hasMouse; + + wxMouseEvent event(g_captureWindowHasMouse ? wxEVT_ENTER_WINDOW + : wxEVT_LEAVE_WINDOW); + InitMouseEvent(win, event, gdk_event); + event.SetEventObject(win); + win->GetEventHandler()->ProcessEvent(event); + } + } + else // no capture + { + // Some control don't have their own X window and thus cannot get + // any events. + + wxCoord x = event.m_x; + wxCoord y = event.m_y; + if (win->m_wxwindow) + { + GtkPizza *pizza = GTK_PIZZA(win->m_wxwindow); + x += pizza->xoffset; + y += pizza->yoffset; + } + + wxNode *node = win->GetChildren().First(); + while (node) + { + wxWindowGTK *child = (wxWindowGTK*)node->Data(); + + node = node->Next(); + if (!child->IsShown()) + continue; + + if (child->m_isStaticBox) + { + // wxStaticBox is transparent in the box itself + int xx1 = child->m_x; + int yy1 = child->m_y; + int xx2 = child->m_x + child->m_width; + int yy2 = child->m_x + child->m_height; + + // left + if (((x >= xx1) && (x <= xx1+10) && (y >= yy1) && (y <= yy2)) || + // right + ((x >= xx2-10) && (x <= xx2) && (y >= yy1) && (y <= yy2)) || + // top + ((x >= xx1) && (x <= xx2) && (y >= yy1) && (y <= yy1+10)) || + // bottom + ((x >= xx1) && (x <= xx2) && (y >= yy2-1) && (y <= yy2))) + { + win = child; + event.m_x -= child->m_x; + event.m_y -= child->m_y; + break; + } + + } + else + { + if ((child->m_wxwindow == (GtkWidget*) NULL) && + (child->m_x <= x) && + (child->m_y <= y) && + (child->m_x+child->m_width >= x) && + (child->m_y+child->m_height >= y)) + { + win = child; + event.m_x -= child->m_x; + event.m_y -= child->m_y; + break; + } + } + } + } + + event.SetEventObject( win ); + + if (win->GetEventHandler()->ProcessEvent( event )) + { + gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "motion_notify_event" ); + return TRUE; + } + + return FALSE; +} + +//----------------------------------------------------------------------------- +// "focus_in_event" +//----------------------------------------------------------------------------- + +static gint gtk_window_focus_in_callback( GtkWidget *widget, + GdkEvent *WXUNUSED(event), + wxWindow *win ) +{ + DEBUG_MAIN_THREAD + + if (g_isIdle) + wxapp_install_idle_handler(); + + if (!win->m_hasVMT) return FALSE; + if (g_blockEventsOnDrag) return FALSE; + + switch ( g_sendActivateEvent ) + { + case -1: + // we've got focus from outside, synthetize wxActivateEvent + g_sendActivateEvent = 1; + break; + + case 0: + // another our window just lost focus, it was already ours before + // - don't send any wxActivateEvent + g_sendActivateEvent = -1; + break; + } + + g_focusWindowLast = + g_focusWindow = win; + +#if 0 + wxPrintf( "OnSetFocus from " ); + if (win->GetClassInfo() && win->GetClassInfo()->GetClassName()) + wxPrintf( win->GetClassInfo()->GetClassName() ); + wxPrintf( ".\n" ); +#endif + + // notify the parent keeping track of focus for the kbd navigation + // purposes that we got it + wxChildFocusEvent eventFocus(win); + (void)win->GetEventHandler()->ProcessEvent(eventFocus); + +#ifdef HAVE_XIM + if (win->m_ic) + gdk_im_begin(win->m_ic, win->m_wxwindow->window); +#endif + +#if wxUSE_CARET + // caret needs to be informed about focus change + wxCaret *caret = win->GetCaret(); + if ( caret ) + { + caret->OnSetFocus(); + } +#endif // wxUSE_CARET + + wxWindowGTK *active = wxGetTopLevelParent(win); + if ( active != g_activeFrame ) + { + if ( g_activeFrame ) + { + wxLogTrace(wxT("activate"), wxT("Deactivating frame %p (from focus_in)"), g_activeFrame); + wxActivateEvent event(wxEVT_ACTIVATE, FALSE, g_activeFrame->GetId()); + event.SetEventObject(g_activeFrame); + g_activeFrame->GetEventHandler()->ProcessEvent(event); + } + + wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), active); + g_activeFrame = active; + wxActivateEvent event(wxEVT_ACTIVATE, TRUE, g_activeFrame->GetId()); + event.SetEventObject(g_activeFrame); + g_activeFrame->GetEventHandler()->ProcessEvent(event); + } + g_activeFrameLostFocus = FALSE; + + + wxFocusEvent event( wxEVT_SET_FOCUS, win->GetId() ); + event.SetEventObject( win ); + + if (win->GetEventHandler()->ProcessEvent( event )) + { + gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus_in_event" ); + return TRUE; + } + + + return FALSE; +} + +//----------------------------------------------------------------------------- +// "focus_out_event" +//----------------------------------------------------------------------------- + +static GtkWidget *gs_widgetLastFocus = NULL; + +static gint gtk_window_focus_out_callback( GtkWidget *widget, GdkEvent *WXUNUSED(event), wxWindowGTK *win ) +{ + DEBUG_MAIN_THREAD + + if (g_isIdle) + wxapp_install_idle_handler(); + + if (!win->m_hasVMT) return FALSE; + if (g_blockEventsOnDrag) return FALSE; + + // VZ: this is really weird but GTK+ seems to call us from inside + // gtk_widget_grab_focus(), i.e. it first sends "focus_out" signal to + // this widget and then "focus_in". This is totally unexpected and + // completely breaks wxUniv code so ignore this dummy event (we can't + // be losing focus if we're about to acquire it!) + if ( widget == gs_widgetLastFocus ) + { + gs_widgetLastFocus = NULL; + + return FALSE; + } + + if ( !g_activeFrameLostFocus && g_activeFrame ) + { + // VZ: commenting this out because it does happen (although not easy + // to reproduce, I only see it when using wxMiniFrame and not + // always) and makes using Mahogany quite annoying +#if 0 + wxASSERT_MSG( wxGetTopLevelParent(win) == g_activeFrame, + wxT("unfocusing window that hasn't gained focus properly") ) +#endif // 0 + + g_activeFrameLostFocus = TRUE; + } + + // if the focus goes out of our app alltogether, OnIdle() will send + // wxActivateEvent, otherwise gtk_window_focus_in_callback() will reset + // g_sendActivateEvent to -1 + g_sendActivateEvent = 0; + + wxWindowGTK *winFocus = wxFindFocusedChild(win); + if ( winFocus ) + win = winFocus; + + g_focusWindow = (wxWindowGTK *)NULL; + +#if 0 + wxPrintf( "OnKillFocus from " ); + if (win->GetClassInfo() && win->GetClassInfo()->GetClassName()) + wxPrintf( win->GetClassInfo()->GetClassName() ); + wxPrintf( ".\n" ); +#endif + +#ifdef HAVE_XIM + if (win->m_ic) + gdk_im_end(); +#endif + +#if wxUSE_CARET + // caret needs to be informed about focus change + wxCaret *caret = win->GetCaret(); + if ( caret ) + { + caret->OnKillFocus(); + } +#endif // wxUSE_CARET + + wxFocusEvent event( wxEVT_KILL_FOCUS, win->GetId() ); + event.SetEventObject( win ); + + if (win->GetEventHandler()->ProcessEvent( event )) + { + gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus_out_event" ); + return TRUE; + } + + return FALSE; +} + +//----------------------------------------------------------------------------- +// "enter_notify_event" +//----------------------------------------------------------------------------- + +static gint gtk_window_enter_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindowGTK *win ) +{ + DEBUG_MAIN_THREAD + + if (g_isIdle) + wxapp_install_idle_handler(); + + if (!win->m_hasVMT) return FALSE; + if (g_blockEventsOnDrag) return FALSE; + + if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE; + + wxMouseEvent event( wxEVT_ENTER_WINDOW ); + event.SetTimestamp( gdk_event->time ); + event.SetEventObject( win ); + + int x = 0; + int y = 0; + GdkModifierType state = (GdkModifierType)0; + + gdk_window_get_pointer( widget->window, &x, &y, &state ); + + InitMouseEvent(win, event, gdk_event); + wxPoint pt = win->GetClientAreaOrigin(); + event.m_x = x + pt.x; + event.m_y = y + pt.y; + + if (win->GetEventHandler()->ProcessEvent( event )) + { + gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "enter_notify_event" ); + return TRUE; + } + + return FALSE; +} + +//----------------------------------------------------------------------------- +// "leave_notify_event" +//----------------------------------------------------------------------------- + +static gint gtk_window_leave_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindowGTK *win ) +{ + DEBUG_MAIN_THREAD + + if (g_isIdle) + wxapp_install_idle_handler(); + + if (!win->m_hasVMT) return FALSE; + if (g_blockEventsOnDrag) return FALSE; + + if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE; + + wxMouseEvent event( wxEVT_LEAVE_WINDOW ); + event.SetTimestamp( gdk_event->time ); + event.SetEventObject( win ); + + int x = 0; + int y = 0; + GdkModifierType state = (GdkModifierType)0; + + gdk_window_get_pointer( widget->window, &x, &y, &state ); + + event.m_shiftDown = (state & GDK_SHIFT_MASK); + event.m_controlDown = (state & GDK_CONTROL_MASK); + event.m_altDown = (state & GDK_MOD1_MASK); + event.m_metaDown = (state & GDK_MOD2_MASK); + event.m_leftDown = (state & GDK_BUTTON1_MASK); + event.m_middleDown = (state & GDK_BUTTON2_MASK); + event.m_rightDown = (state & GDK_BUTTON3_MASK); + + wxPoint pt = win->GetClientAreaOrigin(); + event.m_x = x + pt.x; + event.m_y = y + pt.y; + + if (win->GetEventHandler()->ProcessEvent( event )) + { + gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "leave_notify_event" ); + return TRUE; + } + + return FALSE; +} + +//----------------------------------------------------------------------------- +// "value_changed" from m_vAdjust +//----------------------------------------------------------------------------- + +static void gtk_window_vscroll_callback( GtkAdjustment *adjust, wxWindowGTK *win ) +{ + DEBUG_MAIN_THREAD + + if (g_isIdle) + wxapp_install_idle_handler(); + + if (g_blockEventsOnDrag) return; + + if (!win->m_hasVMT) return; + + float diff = adjust->value - win->m_oldVerticalPos; + if (fabs(diff) < 0.2) return; + + win->m_oldVerticalPos = adjust->value; + + GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(win->m_widget); + GtkRange *range = GTK_RANGE( scrolledWindow->vscrollbar ); + + wxEventType command = wxEVT_SCROLLWIN_THUMBTRACK; + if (range->scroll_type == GTK_SCROLL_STEP_BACKWARD) command = wxEVT_SCROLLWIN_LINEUP; + else if (range->scroll_type == GTK_SCROLL_STEP_FORWARD) command = wxEVT_SCROLLWIN_LINEDOWN; + else if (range->scroll_type == GTK_SCROLL_PAGE_BACKWARD) command = wxEVT_SCROLLWIN_PAGEUP; + else if (range->scroll_type == GTK_SCROLL_PAGE_FORWARD) command = wxEVT_SCROLLWIN_PAGEDOWN; + + int value = (int)(adjust->value+0.5); + + wxScrollWinEvent event( command, value, wxVERTICAL ); + event.SetEventObject( win ); + win->GetEventHandler()->ProcessEvent( event ); +} + +//----------------------------------------------------------------------------- +// "value_changed" from m_hAdjust +//----------------------------------------------------------------------------- + +static void gtk_window_hscroll_callback( GtkAdjustment *adjust, wxWindowGTK *win ) +{ + DEBUG_MAIN_THREAD + + if (g_isIdle) + wxapp_install_idle_handler(); + + if (g_blockEventsOnDrag) return; + if (!win->m_hasVMT) return; + + float diff = adjust->value - win->m_oldHorizontalPos; + if (fabs(diff) < 0.2) return; + + win->m_oldHorizontalPos = adjust->value; + + GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(win->m_widget); + GtkRange *range = GTK_RANGE( scrolledWindow->hscrollbar ); + + wxEventType command = wxEVT_SCROLLWIN_THUMBTRACK; + if (range->scroll_type == GTK_SCROLL_STEP_BACKWARD) command = wxEVT_SCROLLWIN_LINEUP; + else if (range->scroll_type == GTK_SCROLL_STEP_FORWARD) command = wxEVT_SCROLLWIN_LINEDOWN; + else if (range->scroll_type == GTK_SCROLL_PAGE_BACKWARD) command = wxEVT_SCROLLWIN_PAGEUP; + else if (range->scroll_type == GTK_SCROLL_PAGE_FORWARD) command = wxEVT_SCROLLWIN_PAGEDOWN; + + int value = (int)(adjust->value+0.5); + + wxScrollWinEvent event( command, value, wxHORIZONTAL ); + event.SetEventObject( win ); + win->GetEventHandler()->ProcessEvent( event ); +} + +//----------------------------------------------------------------------------- +// "button_press_event" from scrollbar +//----------------------------------------------------------------------------- + +static gint gtk_scrollbar_button_press_callback( GtkRange *widget, + GdkEventButton *gdk_event, + wxWindowGTK *win) +{ + DEBUG_MAIN_THREAD + + if (g_isIdle) + wxapp_install_idle_handler(); + + + g_blockEventsOnScroll = TRUE; + win->m_isScrolling = (gdk_event->window == widget->slider); + + return FALSE; +} + +//----------------------------------------------------------------------------- +// "button_release_event" from scrollbar +//----------------------------------------------------------------------------- + +static gint gtk_scrollbar_button_release_callback( GtkRange *widget, + GdkEventButton *WXUNUSED(gdk_event), + wxWindowGTK *win) +{ + DEBUG_MAIN_THREAD + +// don't test here as we can release the mouse while being over +// a different window than the slider +// +// if (gdk_event->window != widget->slider) return FALSE; + + g_blockEventsOnScroll = FALSE; + + if (win->m_isScrolling) + { + wxEventType command = wxEVT_SCROLLWIN_THUMBRELEASE; + int value = -1; + int dir = -1; + + GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(win->m_widget); + if (widget == GTK_RANGE(scrolledWindow->hscrollbar)) + { + value = (int)(win->m_hAdjust->value+0.5); + dir = wxHORIZONTAL; + } + if (widget == GTK_RANGE(scrolledWindow->vscrollbar)) + { + value = (int)(win->m_vAdjust->value+0.5); + dir = wxVERTICAL; + } + + wxScrollWinEvent event( command, value, dir ); + event.SetEventObject( win ); + win->GetEventHandler()->ProcessEvent( event ); + } + + win->m_isScrolling = FALSE; + + return FALSE; +} + +// ---------------------------------------------------------------------------- +// this wxWindowBase function is implemented here (in platform-specific file) +// because it is static and so couldn't be made virtual +// ---------------------------------------------------------------------------- + +wxWindow *wxWindowBase::FindFocus() +{ + // the cast is necessary when we compile in wxUniversal mode + return (wxWindow *)g_focusWindow; +} + +//----------------------------------------------------------------------------- +// "realize" from m_widget +//----------------------------------------------------------------------------- + +/* We cannot set colours and fonts before the widget has + been realized, so we do this directly after realization. */ + +static gint +gtk_window_realized_callback( GtkWidget *WXUNUSED(m_widget), wxWindow *win ) +{ + DEBUG_MAIN_THREAD + + if (g_isIdle) + wxapp_install_idle_handler(); + + if (win->m_delayedBackgroundColour) + win->SetBackgroundColour( win->GetBackgroundColour() ); + + if (win->m_delayedForegroundColour) + win->SetForegroundColour( win->GetForegroundColour() ); + + wxWindowCreateEvent event( win ); + event.SetEventObject( win ); + win->GetEventHandler()->ProcessEvent( event ); + + return FALSE; +} + +//----------------------------------------------------------------------------- +// "size_allocate" +//----------------------------------------------------------------------------- + +static +void gtk_window_size_callback( GtkWidget *WXUNUSED(widget), + GtkAllocation *WXUNUSED(alloc), + wxWindow *win ) +{ + if (g_isIdle) + wxapp_install_idle_handler(); + + if (!win->m_hasScrolling) return; + + int client_width = 0; + int client_height = 0; + win->GetClientSize( &client_width, &client_height ); + if ((client_width == win->m_oldClientWidth) && (client_height == win->m_oldClientHeight)) + return; + + win->m_oldClientWidth = client_width; + win->m_oldClientHeight = client_height; + + if (!win->m_nativeSizeEvent) + { + wxSizeEvent event( win->GetSize(), win->GetId() ); + event.SetEventObject( win ); + win->GetEventHandler()->ProcessEvent( event ); + } +} + + +#ifdef HAVE_XIM + #define WXUNUSED_UNLESS_XIM(param) param +#else + #define WXUNUSED_UNLESS_XIM(param) WXUNUSED(param) +#endif + +/* Resize XIM window */ + +static +void gtk_wxwindow_size_callback( GtkWidget* WXUNUSED_UNLESS_XIM(widget), + GtkAllocation* WXUNUSED_UNLESS_XIM(alloc), + wxWindowGTK* WXUNUSED_UNLESS_XIM(win) ) +{ + if (g_isIdle) + wxapp_install_idle_handler(); + +#ifdef HAVE_XIM + if (!win->m_ic) + return; + + if (gdk_ic_get_style (win->m_ic) & GDK_IM_PREEDIT_POSITION) + { + gint width, height; + + gdk_window_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); + } +#endif // HAVE_XIM +} + +//----------------------------------------------------------------------------- +// "realize" from m_wxwindow +//----------------------------------------------------------------------------- + +/* Initialize XIM support */ + +static gint +gtk_wxwindow_realized_callback( GtkWidget * WXUNUSED_UNLESS_XIM(widget), + wxWindowGTK * WXUNUSED_UNLESS_XIM(win) ) +{ + if (g_isIdle) + wxapp_install_idle_handler(); + +#ifdef HAVE_XIM + if (win->m_ic) return FALSE; + if (!widget) return FALSE; + if (!gdk_im_ready()) return FALSE; + + win->m_icattr = gdk_ic_attr_new(); + if (!win->m_icattr) return FALSE; + + gint width, height; + GdkEventMask mask; + GdkColormap *colormap; + GdkICAttr *attr = win->m_icattr; + unsigned attrmask = GDK_IC_ALL_REQ; + GdkIMStyle style; + GdkIMStyle supported_style = (GdkIMStyle) + (GDK_IM_PREEDIT_NONE | + GDK_IM_PREEDIT_NOTHING | + GDK_IM_PREEDIT_POSITION | + GDK_IM_STATUS_NONE | + GDK_IM_STATUS_NOTHING); + + if (widget->style && widget->style->font->type != GDK_FONT_FONTSET) + supported_style = (GdkIMStyle)(supported_style & ~GDK_IM_PREEDIT_POSITION); + + attr->style = style = gdk_im_decide_style (supported_style); + attr->client_window = widget->window; + + if ((colormap = gtk_widget_get_colormap (widget)) != + gtk_widget_get_default_colormap ()) + { + attrmask |= GDK_IC_PREEDIT_COLORMAP; + attr->preedit_colormap = colormap; + } + + attrmask |= GDK_IC_PREEDIT_FOREGROUND; + attrmask |= GDK_IC_PREEDIT_BACKGROUND; + attr->preedit_foreground = widget->style->fg[GTK_STATE_NORMAL]; + attr->preedit_background = widget->style->base[GTK_STATE_NORMAL]; + + switch (style & GDK_IM_PREEDIT_MASK) + { + case GDK_IM_PREEDIT_POSITION: + if (widget->style && widget->style->font->type != GDK_FONT_FONTSET) + { + g_warning ("over-the-spot style requires fontset"); + break; + } -/* - printf( "OnHScroll change from " ); - if (win->GetClassInfo() && win->GetClassInfo()->GetClassName()) - printf( win->GetClassInfo()->GetClassName() ); - printf( ".\n" ); -*/ + gdk_window_get_size (widget->window, &width, &height); + + attrmask |= GDK_IC_PREEDIT_POSITION_REQ; + attr->spot_location.x = 0; + attr->spot_location.y = height; + attr->preedit_area.x = 0; + attr->preedit_area.y = 0; + attr->preedit_area.width = width; + attr->preedit_area.height = height; + attr->preedit_fontset = widget->style->font; + + break; + } - if (!win->HasVMT()) return; + win->m_ic = gdk_ic_new (attr, (GdkICAttributesType)attrmask); - wxEventType command = wxEVT_SCROLL_THUMBTRACK; - int value = (int)(win->m_hAdjust->value+0.5); + if (win->m_ic == NULL) + g_warning ("Can't create input context."); + else + { + mask = gdk_window_get_events (widget->window); + mask = (GdkEventMask)(mask | gdk_ic_get_events (win->m_ic)); + gdk_window_set_events (widget->window, mask); + + if (GTK_WIDGET_HAS_FOCUS(widget)) + gdk_im_begin (win->m_ic, widget->window); + } +#endif // HAVE_XIM - wxScrollEvent event( command, win->GetId(), value, wxHORIZONTAL ); - event.SetEventObject( win ); - win->GetEventHandler()->ProcessEvent( event ); + return FALSE; } //----------------------------------------------------------------------------- -// "button_press_event" from scrollbar +// InsertChild for wxWindowGTK. //----------------------------------------------------------------------------- -static gint gtk_scrollbar_button_press_callback( GtkRange *widget, GdkEventButton *gdk_event, wxWindow *win ) -{ - if (gdk_event->window != widget->slider) return FALSE; +/* Callback for wxWindowGTK. This very strange beast has to be used because + * C++ has no virtual methods in a constructor. We have to emulate a + * virtual function here as wxNotebook requires a different way to insert + * a child in it. I had opted for creating a wxNotebookPage window class + * which would have made this superfluous (such in the MDI window system), + * but no-one was listening to me... */ - win->m_isScrolling = TRUE; +static void wxInsertChildInWindow( wxWindowGTK* parent, wxWindowGTK* 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; - return FALSE; + 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 ); } //----------------------------------------------------------------------------- -// "button_release_event" from scrollbar +// global functions //----------------------------------------------------------------------------- -static gint gtk_scrollbar_button_release_callback( GtkRange *widget, GdkEventButton *gdk_event, wxWindow *win ) +wxWindow *wxGetActiveWindow() { - if (gdk_event->window != widget->slider) return FALSE; - - GtkScrolledWindow *s_window = GTK_SCROLLED_WINDOW(win->m_widget); - - if (widget == GTK_RANGE(s_window->vscrollbar)) - gtk_signal_emit_by_name( GTK_OBJECT(win->m_hAdjust), "value_changed" ); - else - gtk_signal_emit_by_name( GTK_OBJECT(win->m_vAdjust), "value_changed" ); - - win->m_isScrolling = FALSE; - - return FALSE; + // the cast is necessary when we compile in wxUniversal mode + return (wxWindow *)g_focusWindow; } //----------------------------------------------------------------------------- -// "drop_data_available_event" +// wxWindowGTK //----------------------------------------------------------------------------- -static void gtk_window_drop_callback( GtkWidget *widget, GdkEvent *event, wxWindow *win ) -{ - if (!win->HasVMT()) return; +// in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu() +// method +#ifdef __WXUNIVERSAL__ + IMPLEMENT_ABSTRACT_CLASS(wxWindowGTK, wxWindowBase) +#else // __WXGTK__ + IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowBase) +#endif // __WXUNIVERSAL__/__WXGTK__ + +void wxWindowGTK::Init() +{ + // common init + InitBase(); + + // GTK specific + m_widget = (GtkWidget *) NULL; + m_wxwindow = (GtkWidget *) NULL; + m_focusWidget = (GtkWidget *) NULL; + + // position/size + m_x = 0; + m_y = 0; + m_width = 0; + m_height = 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; - if (win->GetDropTarget()) - { - int x = 0; - int y = 0; - gdk_window_get_pointer( widget->window, &x, &y, (GdkModifierType *) NULL ); - win->GetDropTarget()->Drop( event, x, y ); - } + m_hAdjust = (GtkAdjustment*) NULL; + m_vAdjust = (GtkAdjustment*) NULL; + m_oldHorizontalPos = 0.0; + m_oldVerticalPos = 0.0; -/* - g_free (event->dropdataavailable.data); - g_free (event->dropdataavailable.data_type); -*/ -} + m_resizing = FALSE; + m_widgetStyle = (GtkStyle*) NULL; -//----------------------------------------------------------------------------- -// wxWindow -//----------------------------------------------------------------------------- - -IMPLEMENT_DYNAMIC_CLASS(wxWindow,wxEvtHandler) - -BEGIN_EVENT_TABLE(wxWindow, wxEvtHandler) - EVT_SIZE(wxWindow::OnSize) - EVT_SYS_COLOUR_CHANGED(wxWindow::OnSysColourChanged) - EVT_INIT_DIALOG(wxWindow::OnInitDialog) - EVT_IDLE(wxWindow::OnIdle) -END_EVENT_TABLE() - -wxWindow::wxWindow() -{ - m_widget = (GtkWidget *) NULL; - m_wxwindow = (GtkWidget *) NULL; - m_parent = (wxWindow *) NULL; - m_children.DeleteContents( FALSE ); - m_x = 0; - m_y = 0; - m_width = 0; - m_height = 0; - m_minWidth = -1; - m_minHeight = -1; - m_maxWidth = -1; - m_maxHeight = -1; - m_retCode = 0; - m_eventHandler = this; - m_windowValidator = (wxValidator *) NULL; - m_windowId = -1; - m_cursor = (wxCursor *) NULL; - m_font = *wxSWISS_FONT; - m_windowStyle = 0; - m_windowName = "noname"; - m_constraints = (wxLayoutConstraints *) NULL; - m_constraintsInvolvedIn = (wxList *) NULL; - m_windowSizer = (wxSizer *) NULL; - m_sizerParent = (wxWindow *) NULL; - m_autoLayout = FALSE; - m_sizeSet = FALSE; - m_hasVMT = FALSE; - m_needParent = TRUE; - m_hasScrolling = FALSE; - m_isScrolling = FALSE; - m_hAdjust = (GtkAdjustment *) NULL; - m_vAdjust = (GtkAdjustment *) NULL; - m_oldHorizontalPos = 0.0; - m_oldVerticalPos = 0.0; - m_isShown = FALSE; - m_isEnabled = TRUE; - m_pDropTarget = (wxDropTarget *) NULL; - m_resizing = FALSE; - m_hasOwnStyle = FALSE; - m_scrollGC = (GdkGC*) NULL; -} - -bool wxWindow::Create( wxWindow *parent, wxWindowID id, - const wxPoint &pos, const wxSize &size, - long style, const wxString &name ) -{ - m_isShown = FALSE; - m_isEnabled = TRUE; - m_needParent = TRUE; - - m_cursor = (wxCursor *) NULL; - - PreCreation( parent, id, pos, size, style, name ); - - m_widget = gtk_scrolled_window_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL ); - m_hasScrolling = TRUE; - - GtkScrolledWindow *s_window = GTK_SCROLLED_WINDOW(m_widget); - - gtk_signal_connect( GTK_OBJECT(s_window->vscrollbar), "button_press_event", - (GtkSignalFunc)gtk_scrollbar_button_press_callback, (gpointer) this ); + m_insertCallback = (wxInsertChildFunction) NULL; - gtk_signal_connect( GTK_OBJECT(s_window->hscrollbar), "button_press_event", - (GtkSignalFunc)gtk_scrollbar_button_press_callback, (gpointer) this ); + m_isStaticBox = FALSE; + m_isRadioButton = FALSE; + m_isListBox = FALSE; + m_isFrame = FALSE; + m_acceptsFocus = FALSE; - gtk_signal_connect( GTK_OBJECT(s_window->vscrollbar), "button_release_event", - (GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this ); + m_clipPaintRegion = FALSE; - gtk_signal_connect( GTK_OBJECT(s_window->hscrollbar), "button_release_event", - (GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this ); + m_cursor = *wxSTANDARD_CURSOR; - GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass ); - scroll_class->scrollbar_spacing = 0; + m_delayedForegroundColour = FALSE; + m_delayedBackgroundColour = FALSE; - gtk_scrolled_window_set_policy( s_window, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC ); +#ifdef HAVE_XIM + m_ic = (GdkIC*) NULL; + m_icattr = (GdkICAttr*) NULL; +#endif +} - m_oldHorizontalPos = 0.0; - m_oldVerticalPos = 0.0; +wxWindowGTK::wxWindowGTK() +{ + Init(); +} - m_hAdjust = gtk_range_get_adjustment( GTK_RANGE(s_window->hscrollbar) ); - m_vAdjust = gtk_range_get_adjustment( GTK_RANGE(s_window->vscrollbar) ); +wxWindowGTK::wxWindowGTK( wxWindow *parent, + wxWindowID id, + const wxPoint &pos, + const wxSize &size, + long style, + const wxString &name ) +{ + Init(); - gtk_signal_connect( GTK_OBJECT(m_hAdjust), "value_changed", - (GtkSignalFunc) gtk_window_hscroll_callback, (gpointer) this ); - gtk_signal_connect( GTK_OBJECT(m_vAdjust), "value_changed", - (GtkSignalFunc) gtk_window_vscroll_callback, (gpointer) this ); + Create( parent, id, pos, size, style, name ); +} - gtk_signal_connect( GTK_OBJECT(m_hAdjust), "changed", - (GtkSignalFunc) gtk_window_hscroll_change_callback, (gpointer) this ); - gtk_signal_connect(GTK_OBJECT(m_vAdjust), "changed", - (GtkSignalFunc) gtk_window_vscroll_change_callback, (gpointer) this ); +bool wxWindowGTK::Create( wxWindow *parent, + wxWindowID id, + const wxPoint &pos, + const wxSize &size, + long style, + const wxString &name ) +{ + if (!PreCreation( parent, pos, size ) || + !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name )) + { + wxFAIL_MSG( wxT("wxWindowGTK creation failed") ); + return FALSE; + } - GtkViewport *viewport = GTK_VIEWPORT(s_window->viewport); + m_insertCallback = wxInsertChildInWindow; - if (m_windowStyle & wxRAISED_BORDER) - { - gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_OUT ); - } - else if (m_windowStyle & wxSUNKEN_BORDER) - { - gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_IN ); - } - else - { - gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_NONE ); - } + m_widget = gtk_scrolled_window_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL ); + GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS ); - m_wxwindow = gtk_myfixed_new(); + GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(m_widget); - GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS ); + GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) ); + scroll_class->scrollbar_spacing = 0; - if (m_windowStyle & wxTAB_TRAVERSAL == wxTAB_TRAVERSAL) - GTK_WIDGET_UNSET_FLAGS( m_wxwindow, GTK_CAN_FOCUS ); - else - GTK_WIDGET_SET_FLAGS( m_wxwindow, GTK_CAN_FOCUS ); + gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC ); - gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow ); + m_hAdjust = gtk_range_get_adjustment( GTK_RANGE(scrolledWindow->hscrollbar) ); + m_vAdjust = gtk_range_get_adjustment( GTK_RANGE(scrolledWindow->vscrollbar) ); - // shut the viewport up - gtk_viewport_set_hadjustment( viewport, (GtkAdjustment*) gtk_adjustment_new( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) ); - gtk_viewport_set_vadjustment( viewport, (GtkAdjustment*) gtk_adjustment_new( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) ); + m_wxwindow = gtk_pizza_new(); - // I _really_ don't want scrollbars in the beginning - m_vAdjust->lower = 0.0; - m_vAdjust->upper = 1.0; - m_vAdjust->value = 0.0; - m_vAdjust->step_increment = 1.0; - m_vAdjust->page_increment = 1.0; - m_vAdjust->page_size = 5.0; - gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" ); - m_hAdjust->lower = 0.0; - m_hAdjust->upper = 1.0; - m_hAdjust->value = 0.0; - m_hAdjust->step_increment = 1.0; - m_hAdjust->page_increment = 1.0; - m_hAdjust->page_size = 5.0; - gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" ); + gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow ); - gtk_widget_show( m_wxwindow ); +#ifndef __WXUNIVERSAL__ +#if (GTK_MINOR_VERSION > 0) + GtkPizza *pizza = GTK_PIZZA(m_wxwindow); - PostCreation(); - - Show( TRUE ); + if (HasFlag(wxRAISED_BORDER)) + { + gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_OUT ); + } + else if (HasFlag(wxSUNKEN_BORDER)) + { + gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_IN ); + } + else if (HasFlag(wxSIMPLE_BORDER)) + { + gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_THIN ); + } + else + { + gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_NONE ); + } +#else // GTK_MINOR_VERSION == 0 + GtkViewport *viewport = GTK_VIEWPORT(scrolledWindow->viewport); - return TRUE; -} + if (HasFlag(wxRAISED_BORDER)) + { + gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_OUT ); + } + else if (HasFlag(wxSUNKEN_BORDER)) + { + gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_IN ); + } + else + { + gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_NONE ); + } +#endif // GTK_MINOR_VERSION +#endif // __WXUNIVERSAL__ -wxWindow::~wxWindow() -{ - m_hasVMT = FALSE; + GTK_WIDGET_SET_FLAGS( m_wxwindow, GTK_CAN_FOCUS ); + m_acceptsFocus = TRUE; - if (m_pDropTarget) delete m_pDropTarget; +#if (GTK_MINOR_VERSION == 0) + // shut the viewport up + gtk_viewport_set_hadjustment( viewport, (GtkAdjustment*) gtk_adjustment_new( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) ); + gtk_viewport_set_vadjustment( viewport, (GtkAdjustment*) gtk_adjustment_new( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) ); +#endif // GTK_MINOR_VERSION == 0 - if (m_parent) m_parent->RemoveChild( this ); - if (m_widget) Show( FALSE ); + // I _really_ don't want scrollbars in the beginning + m_vAdjust->lower = 0.0; + m_vAdjust->upper = 1.0; + m_vAdjust->value = 0.0; + m_vAdjust->step_increment = 1.0; + m_vAdjust->page_increment = 1.0; + m_vAdjust->page_size = 5.0; + gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" ); + m_hAdjust->lower = 0.0; + m_hAdjust->upper = 1.0; + m_hAdjust->value = 0.0; + m_hAdjust->step_increment = 1.0; + m_hAdjust->page_increment = 1.0; + m_hAdjust->page_size = 5.0; + gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" ); - DestroyChildren(); + // these handlers block mouse events to any window during scrolling such as + // motion events and prevent GTK and wxWindows from fighting over where the + // slider should be - if (m_scrollGC) gdk_gc_unref( m_scrollGC ); - - if (m_wxwindow) gtk_widget_destroy( m_wxwindow ); + gtk_signal_connect( GTK_OBJECT(scrolledWindow->vscrollbar), "button_press_event", + (GtkSignalFunc)gtk_scrollbar_button_press_callback, (gpointer) this ); - if (m_widget) gtk_widget_destroy( m_widget ); + gtk_signal_connect( GTK_OBJECT(scrolledWindow->hscrollbar), "button_press_event", + (GtkSignalFunc)gtk_scrollbar_button_press_callback, (gpointer) this ); - wxDELETE(m_cursor); + gtk_signal_connect( GTK_OBJECT(scrolledWindow->vscrollbar), "button_release_event", + (GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this ); - DeleteRelatedConstraints(); - if (m_constraints) - { - // This removes any dangling pointers to this window - // in other windows' constraintsInvolvedIn lists. - UnsetConstraints(m_constraints); - delete m_constraints; - m_constraints = (wxLayoutConstraints *) NULL; - } - if (m_windowSizer) - { - delete m_windowSizer; - m_windowSizer = (wxSizer *) NULL; - } - // If this is a child of a sizer, remove self from parent - if (m_sizerParent) m_sizerParent->RemoveChild((wxWindow *)this); - - // Just in case the window has been Closed, but - // we're then deleting immediately: don't leave - // dangling pointers. - wxPendingDelete.DeleteObject(this); - - // Just in case we've loaded a top-level window via - // wxWindow::LoadNativeDialog but we weren't a dialog - // class - wxTopLevelWindows.DeleteObject(this); - - if (m_windowValidator) delete m_windowValidator; -} - -void wxWindow::PreCreation( wxWindow *parent, wxWindowID id, - const wxPoint &pos, const wxSize &size, - long style, const wxString &name ) -{ - if (m_needParent && (parent == NULL)) - wxFatalError( "Need complete parent.", name ); - - m_widget = (GtkWidget *) NULL; - m_hasVMT = FALSE; - m_parent = parent; - m_children.DeleteContents( FALSE ); - m_x = (int)pos.x; - m_y = (int)pos.y; - m_width = size.x; - if (m_width == -1) m_width = 20; - m_height = size.y; - if (m_height == -1) m_height = 20; - m_minWidth = -1; - m_minHeight = -1; - m_maxWidth = -1; - m_maxHeight = -1; - m_retCode = 0; - m_eventHandler = this; - m_windowId = id; - m_sizeSet = FALSE; - if (m_cursor == NULL) - m_cursor = new wxCursor( wxCURSOR_ARROW ); - m_font = *wxSWISS_FONT; -// m_backgroundColour = wxWHITE; - m_foregroundColour = wxBLACK; - m_windowStyle = style; - m_windowName = name; - m_constraints = (wxLayoutConstraints *) NULL; - m_constraintsInvolvedIn = (wxList *) NULL; - m_windowSizer = (wxSizer *) NULL; - m_sizerParent = (wxWindow *) NULL; - m_autoLayout = FALSE; - m_hasScrolling = FALSE; - m_isScrolling = FALSE; - m_pDropTarget = (wxDropTarget *) NULL; - m_resizing = FALSE; - m_windowValidator = (wxValidator *) NULL; - m_hasOwnStyle = FALSE; -} - -void wxWindow::PostCreation() -{ - if (m_parent) m_parent->AddChild( this ); - - if (m_wxwindow) - { - gtk_signal_connect( GTK_OBJECT(m_wxwindow), "expose_event", - GTK_SIGNAL_FUNC(gtk_window_expose_callback), (gpointer)this ); + gtk_signal_connect( GTK_OBJECT(scrolledWindow->hscrollbar), "button_release_event", + (GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this ); - gtk_signal_connect( GTK_OBJECT(m_wxwindow), "draw", - GTK_SIGNAL_FUNC(gtk_window_draw_callback), (gpointer)this ); - } + // these handlers get notified when screen updates are required either when + // scrolling or when the window size (and therefore scrollbar configuration) + // has changed + + gtk_signal_connect( GTK_OBJECT(m_hAdjust), "value_changed", + (GtkSignalFunc) gtk_window_hscroll_callback, (gpointer) this ); + gtk_signal_connect( GTK_OBJECT(m_vAdjust), "value_changed", + (GtkSignalFunc) gtk_window_vscroll_callback, (gpointer) this ); - ConnectWidget( GetConnectWidget() ); + gtk_widget_show( m_wxwindow ); - if (m_widget && m_parent) gtk_widget_realize( m_widget ); + if (m_parent) + m_parent->DoAddChild( this ); + + m_focusWidget = m_wxwindow; - if (m_wxwindow) gtk_widget_realize( m_wxwindow ); + PostCreation(); - SetCursor( *wxSTANDARD_CURSOR ); + Show( TRUE ); - m_hasVMT = TRUE; + return TRUE; } -void wxWindow::ConnectWidget( GtkWidget *widget ) +wxWindowGTK::~wxWindowGTK() { - gtk_signal_connect( GTK_OBJECT(widget), "key_press_event", - GTK_SIGNAL_FUNC(gtk_window_key_press_callback), (gpointer)this ); + if (g_focusWindow == this) + g_focusWindow = NULL; - gtk_signal_connect( GTK_OBJECT(widget), "button_press_event", - GTK_SIGNAL_FUNC(gtk_window_button_press_callback), (gpointer)this ); + if (g_activeFrame == this) + g_activeFrame = NULL; - gtk_signal_connect( GTK_OBJECT(widget), "button_release_event", - GTK_SIGNAL_FUNC(gtk_window_button_release_callback), (gpointer)this ); + m_isBeingDeleted = TRUE; + m_hasVMT = FALSE; - gtk_signal_connect( GTK_OBJECT(widget), "motion_notify_event", - GTK_SIGNAL_FUNC(gtk_window_motion_notify_callback), (gpointer)this ); + if (m_widget) + Show( FALSE ); - gtk_signal_connect( GTK_OBJECT(widget), "focus_in_event", - GTK_SIGNAL_FUNC(gtk_window_focus_in_callback), (gpointer)this ); + DestroyChildren(); - gtk_signal_connect( GTK_OBJECT(widget), "focus_out_event", - GTK_SIGNAL_FUNC(gtk_window_focus_out_callback), (gpointer)this ); + if (m_parent) + m_parent->RemoveChild( this ); - gtk_signal_connect( GTK_OBJECT(widget), "enter_notify_event", - GTK_SIGNAL_FUNC(gtk_window_enter_callback), (gpointer)this ); +#ifdef HAVE_XIM + if (m_ic) + gdk_ic_destroy (m_ic); + if (m_icattr) + gdk_ic_attr_destroy (m_icattr); +#endif - gtk_signal_connect( GTK_OBJECT(widget), "leave_notify_event", - GTK_SIGNAL_FUNC(gtk_window_leave_callback), (gpointer)this ); -} + if (m_widgetStyle) + { +#if DISABLE_STYLE_IF_BROKEN_THEME + // don't delete if it's a pixmap theme style + if (!m_widgetStyle->engine_data) + gtk_style_unref( m_widgetStyle ); +#endif + m_widgetStyle = (GtkStyle*) NULL; + } -bool wxWindow::HasVMT() -{ - return m_hasVMT; + if (m_wxwindow) + { + gtk_widget_destroy( m_wxwindow ); + m_wxwindow = (GtkWidget*) NULL; + } + + if (m_widget) + { + gtk_widget_destroy( m_widget ); + m_widget = (GtkWidget*) NULL; + } } -bool wxWindow::Close( bool force ) +bool wxWindowGTK::PreCreation( wxWindowGTK *parent, const wxPoint &pos, const wxSize &size ) { - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); + wxCHECK_MSG( !m_needParent || parent, FALSE, wxT("Need complete parent.") ); - wxCloseEvent event(wxEVT_CLOSE_WINDOW, m_windowId); - event.SetEventObject(this); - event.SetForce(force); + /* this turns -1 into 20 so that a minimal window is + visible even although -1,-1 has been given as the + size of the window. the same trick is used in other + ports and should make debugging easier */ + m_width = WidthDefault(size.x); + m_height = HeightDefault(size.y); - return GetEventHandler()->ProcessEvent(event); -} + m_x = (int)pos.x; + m_y = (int)pos.y; -bool wxWindow::Destroy() -{ - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); + /* some reasonable defaults */ + if (!parent) + { + if (m_x == -1) + { + m_x = (gdk_screen_width () - m_width) / 2; + if (m_x < 10) m_x = 10; + } + if (m_y == -1) + { + m_y = (gdk_screen_height () - m_height) / 2; + if (m_y < 10) m_y = 10; + } + } - m_hasVMT = FALSE; - delete this; - return TRUE; + return TRUE; } -bool wxWindow::DestroyChildren() +void wxWindowGTK::PostCreation() { - if (GetChildren()) - { - wxNode *node; - while ((node = GetChildren()->First()) != (wxNode *)NULL) + wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") ); + + if (m_wxwindow) { - wxWindow *child; - if ((child = (wxWindow *)node->Data()) != (wxWindow *)NULL) - { - delete child; - if (GetChildren()->Member(child)) delete node; - } - } - } - return TRUE; -} + if (!m_noExpose) + { + // these get reported to wxWindows -> wxPaintEvent -void wxWindow::PrepareDC( wxDC &WXUNUSED(dc) ) -{ - // are we to set fonts here ? -} + gtk_pizza_set_external( GTK_PIZZA(m_wxwindow), TRUE ); -void wxWindow::ImplementSetSize() -{ - if ((m_minWidth != -1) && (m_width < m_minWidth)) m_width = m_minWidth; - if ((m_minHeight != -1) && (m_height < m_minHeight)) m_height = m_minHeight; - if ((m_maxWidth != -1) && (m_width > m_maxWidth)) m_width = m_minWidth; - if ((m_maxHeight != -1) && (m_height > m_maxHeight)) m_height = m_minHeight; - gtk_widget_set_usize( m_widget, m_width, m_height ); -} + gtk_signal_connect( GTK_OBJECT(m_wxwindow), "expose_event", + GTK_SIGNAL_FUNC(gtk_window_expose_callback), (gpointer)this ); -void wxWindow::ImplementSetPosition() -{ - if (IS_KIND_OF(this,wxFrame) || IS_KIND_OF(this,wxDialog)) - { - if ((m_x != -1) || (m_y != -1)) - gtk_widget_set_uposition( m_widget, m_x, m_y ); - return; - } + gtk_signal_connect( GTK_OBJECT(m_wxwindow), "draw", + GTK_SIGNAL_FUNC(gtk_window_draw_callback), (gpointer)this ); - if (!m_parent) - { - wxFAIL_MSG( "wxWindow::SetSize error.\n" ); - return; - } + if (HasFlag(wxNO_FULL_REPAINT_ON_RESIZE)) + { + gtk_signal_connect( GTK_OBJECT(m_wxwindow), "event", + GTK_SIGNAL_FUNC(gtk_window_event_event_callback), (gpointer)this ); + } + } - if ((m_parent) && (m_parent->m_wxwindow)) - gtk_myfixed_move( GTK_MYFIXED(m_parent->m_wxwindow), m_widget, m_x, m_y ); + // 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 ); - // Don't do anything for children of wxNotebook and wxMDIChildFrame -} + gtk_signal_connect( GTK_OBJECT(m_widget), "draw", + GTK_SIGNAL_FUNC(gtk_window_own_draw_callback), (gpointer)this ); + } -void wxWindow::SetSize( int x, int y, int width, int height, int sizeFlags ) -{ - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); + // focus handling - if (m_resizing) return; // I don't like recursions - m_resizing = TRUE; + if (m_focusWidget == NULL) + m_focusWidget = m_widget; - int newX = x; - int newY = y; - int newW = width; - int newH = height; +#if 0 + if (GetClassInfo() && GetClassInfo()->GetClassName()) + wxPrintf( GetClassInfo()->GetClassName() ); + wxPrintf( ".\n" ); +#endif - if ((sizeFlags & wxSIZE_USE_EXISTING) == wxSIZE_USE_EXISTING) - { - if (newX == -1) newX = m_x; - if (newY == -1) newY = m_y; - if (newW == -1) newW = m_width; - if (newH == -1) newH = m_height; - } + gtk_signal_connect( GTK_OBJECT(m_focusWidget), "focus_in_event", + GTK_SIGNAL_FUNC(gtk_window_focus_in_callback), (gpointer)this ); - if ((sizeFlags & wxSIZE_AUTO_WIDTH) == wxSIZE_AUTO_WIDTH) - { - if (newW == -1) newW = 80; - } + gtk_signal_connect( GTK_OBJECT(m_focusWidget), "focus_out_event", + GTK_SIGNAL_FUNC(gtk_window_focus_out_callback), (gpointer)this ); - if ((sizeFlags & wxSIZE_AUTO_HEIGHT) == wxSIZE_AUTO_HEIGHT) - { - if (newH == -1) newH = 26; - } + // connect to the various key and mouse handlers - if ((m_x != newX) || (m_y != newY) || (!m_sizeSet)) - { - m_x = newX; - m_y = newY; - ImplementSetPosition(); - } - if ((m_width != newW) || (m_height != newH) || (!m_sizeSet)) - { - m_width = newW; - m_height = newH; - ImplementSetSize(); - } - m_sizeSet = TRUE; + GtkWidget *connect_widget = GetConnectWidget(); - wxSizeEvent event( wxSize(m_width,m_height), GetId() ); - event.SetEventObject( this ); - ProcessEvent( event ); + ConnectWidget( connect_widget ); - m_resizing = FALSE; -} + /* We cannot set colours, fonts and cursors before the widget has + been realized, so we do this directly after realization */ + gtk_signal_connect( GTK_OBJECT(connect_widget), "realize", + GTK_SIGNAL_FUNC(gtk_window_realized_callback), (gpointer) this ); -void wxWindow::SetSize( int width, int height ) -{ - SetSize( -1, -1, width, height, wxSIZE_USE_EXISTING ); + if (m_wxwindow) + { + // Catch native resize events + gtk_signal_connect( GTK_OBJECT(m_wxwindow), "size_allocate", + GTK_SIGNAL_FUNC(gtk_window_size_callback), (gpointer)this ); + + // Initialize XIM support + gtk_signal_connect( GTK_OBJECT(m_wxwindow), "realize", + GTK_SIGNAL_FUNC(gtk_wxwindow_realized_callback), (gpointer) this ); + + // And resize XIM window + gtk_signal_connect( GTK_OBJECT(m_wxwindow), "size_allocate", + GTK_SIGNAL_FUNC(gtk_wxwindow_size_callback), (gpointer)this ); + } + + if (!GTK_IS_COMBO(m_widget)) + { + // This is needed if we want to add our windows into native + // GTK control, such as the toolbar. With this callback, the + // toolbar gets to know the correct size (the one set by the + // programmer). Sadly, it misbehaves for wxComboBox. FIXME + // when moving to GTK 2.0. + gtk_signal_connect( GTK_OBJECT(m_widget), "size_request", + GTK_SIGNAL_FUNC(gtk_window_size_request_callback), (gpointer) this ); + } + + m_hasVMT = TRUE; } -void wxWindow::Move( int x, int y ) +void wxWindowGTK::ConnectWidget( GtkWidget *widget ) { - SetSize( x, y, -1, -1, wxSIZE_USE_EXISTING ); + gtk_signal_connect( GTK_OBJECT(widget), "key_press_event", + GTK_SIGNAL_FUNC(gtk_window_key_press_callback), (gpointer)this ); + + gtk_signal_connect( GTK_OBJECT(widget), "key_release_event", + GTK_SIGNAL_FUNC(gtk_window_key_release_callback), (gpointer)this ); + + gtk_signal_connect( GTK_OBJECT(widget), "button_press_event", + GTK_SIGNAL_FUNC(gtk_window_button_press_callback), (gpointer)this ); + + gtk_signal_connect( GTK_OBJECT(widget), "button_release_event", + GTK_SIGNAL_FUNC(gtk_window_button_release_callback), (gpointer)this ); + + gtk_signal_connect( GTK_OBJECT(widget), "motion_notify_event", + GTK_SIGNAL_FUNC(gtk_window_motion_notify_callback), (gpointer)this ); + + gtk_signal_connect( GTK_OBJECT(widget), "enter_notify_event", + GTK_SIGNAL_FUNC(gtk_window_enter_callback), (gpointer)this ); + + gtk_signal_connect( GTK_OBJECT(widget), "leave_notify_event", + GTK_SIGNAL_FUNC(gtk_window_leave_callback), (gpointer)this ); } -void wxWindow::GetSize( int *width, int *height ) const +bool wxWindowGTK::Destroy() { - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); + wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") ); + + m_hasVMT = FALSE; - if (width) (*width) = m_width; - if (height) (*height) = m_height; + return wxWindowBase::Destroy(); } -void wxWindow::SetClientSize( int width, int height ) +void wxWindowGTK::DoMoveWindow(int x, int y, int width, int height) { - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); + gtk_pizza_set_size( GTK_PIZZA(m_parent->m_wxwindow), m_widget, x, y, width, height ); +} - if (!m_wxwindow) - { - SetSize( width, height ); - } - else - { - int dw = 0; - int dh = 0; +void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags ) +{ + wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") ); + wxASSERT_MSG( (m_parent != NULL), wxT("wxWindowGTK::SetSize requires parent.\n") ); - if (!m_hasScrolling) - { /* - do we have sunken dialogs ? + printf( "DoSetSize: name %s, x,y,w,h: %d,%d,%d,%d \n", GetName().c_str(), x,y,width,height ); +*/ - GtkStyleClass *window_class = m_wxwindow->style->klass; + if (m_resizing) return; /* I don't like recursions */ + m_resizing = TRUE; - dw += 2 * window_class->xthickness; - dh += 2 * window_class->ythickness; -*/ + int currentX, currentY; + GetPosition(¤tX, ¤tY); + if (x == -1) + x = currentX; + if (y == -1) + y = currentY; + AdjustForParentClientOrigin(x, y, sizeFlags); + + 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_height = height; } else { - GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget); - GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass ); + GtkPizza *pizza = GTK_PIZZA(m_parent->m_wxwindow); - GtkWidget *viewport = scroll_window->viewport; - GtkStyleClass *viewport_class = viewport->style->klass; + if ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0) + { + if (x != -1) m_x = x + pizza->xoffset; + if (y != -1) m_y = y + pizza->yoffset; + if (width != -1) m_width = width; + if (height != -1) m_height = height; + } + else + { + m_x = x + pizza->xoffset; + m_y = y + pizza->yoffset; + m_width = width; + m_height = height; + } - GtkWidget *hscrollbar = scroll_window->hscrollbar; - GtkWidget *vscrollbar = scroll_window->vscrollbar; + if ((sizeFlags & wxSIZE_AUTO_WIDTH) == wxSIZE_AUTO_WIDTH) + { + if (width == -1) m_width = 80; + } - if ((m_windowStyle & wxRAISED_BORDER) || - (m_windowStyle & wxSUNKEN_BORDER)) - { - dw += 2 * viewport_class->xthickness; - dh += 2 * viewport_class->ythickness; - } + if ((sizeFlags & wxSIZE_AUTO_HEIGHT) == wxSIZE_AUTO_HEIGHT) + { + if (height == -1) m_height = 26; + } - if (GTK_WIDGET_VISIBLE(vscrollbar)) - { - dw += vscrollbar->allocation.width; - dw += scroll_class->scrollbar_spacing; - } + if ((m_minWidth != -1) && (m_width < m_minWidth)) m_width = m_minWidth; + if ((m_minHeight != -1) && (m_height < m_minHeight)) m_height = m_minHeight; + if ((m_maxWidth != -1) && (m_width > m_maxWidth)) m_width = m_maxWidth; + if ((m_maxHeight != -1) && (m_height > m_maxHeight)) m_height = m_maxHeight; - if (GTK_WIDGET_VISIBLE(hscrollbar)) - { - dh += hscrollbar->allocation.height; - dw += scroll_class->scrollbar_spacing; - } + int border = 0; + int bottom_border = 0; + + if (GTK_WIDGET_CAN_DEFAULT(m_widget)) + { + /* the default button has a border around it */ + border = 6; + bottom_border = 5; + } + + DoMoveWindow( m_x-border, + m_y-border, + m_width+2*border, + m_height+border+bottom_border ); } - SetSize( width+dw, height+dh ); - } + if (m_hasScrolling) + { + /* Sometimes the client area changes size without the + whole windows's size changing, but if the whole + windows's size doesn't change, no wxSizeEvent will + normally be sent. Here we add an extra test if + the client test has been changed and this will + be used then. */ + GetClientSize( &m_oldClientWidth, &m_oldClientHeight ); + } + +/* + wxPrintf( "OnSize sent from " ); + if (GetClassInfo() && GetClassInfo()->GetClassName()) + wxPrintf( GetClassInfo()->GetClassName() ); + wxPrintf( " %d %d %d %d\n", (int)m_x, (int)m_y, (int)m_width, (int)m_height ); +*/ + + if (!m_nativeSizeEvent) + { + wxSizeEvent event( wxSize(m_width,m_height), GetId() ); + event.SetEventObject( this ); + GetEventHandler()->ProcessEvent( event ); + } + + m_resizing = FALSE; } -void wxWindow::GetClientSize( int *width, int *height ) const +void wxWindowGTK::OnInternalIdle() { - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); + if ( g_sendActivateEvent != -1 ) + { + bool activate = g_sendActivateEvent != 0; - if (!m_wxwindow) - { - if (width) (*width) = m_width; - if (height) (*height) = m_height; - } - else - { - int dw = 0; - int dh = 0; + // do it only once + g_sendActivateEvent = -1; + + wxTheApp->SetActive(activate, (wxWindow *)g_focusWindowLast); + } - if (!m_hasScrolling) + if ( g_activeFrameLostFocus ) { -/* - do we have sunken dialogs ? + if ( g_activeFrame ) + { + wxLogTrace(wxT("activate"), wxT("Deactivating frame %p (from idle)"), g_activeFrame); + wxActivateEvent event(wxEVT_ACTIVATE, FALSE, g_activeFrame->GetId()); + event.SetEventObject(g_activeFrame); + g_activeFrame->GetEventHandler()->ProcessEvent(event); + g_activeFrame = NULL; + } + g_activeFrameLostFocus = FALSE; + } - GtkStyleClass *window_class = m_wxwindow->style->klass; + wxCursor cursor = m_cursor; + if (g_globalCursor.Ok()) cursor = g_globalCursor; - dw += 2 * window_class->xthickness; - dh += 2 * window_class->ythickness; -*/ - } - else + if (cursor.Ok()) { - GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget); - GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass ); + /* I now set the cursor anew in every OnInternalIdle call + as setting the cursor in a parent window also effects the + windows above so that checking for the current cursor is + not possible. */ + + if (m_wxwindow) + { + GdkWindow *window = GTK_PIZZA(m_wxwindow)->bin_window; + if (window) + gdk_window_set_cursor( window, cursor.GetCursor() ); - GtkWidget *viewport = scroll_window->viewport; - GtkStyleClass *viewport_class = viewport->style->klass; + if (!g_globalCursor.Ok()) + cursor = *wxSTANDARD_CURSOR; - GtkWidget *hscrollbar = scroll_window->hscrollbar; - GtkWidget *vscrollbar = scroll_window->vscrollbar; + window = m_widget->window; + if ((window) && !(GTK_WIDGET_NO_WINDOW(m_widget))) + gdk_window_set_cursor( window, cursor.GetCursor() ); - if ((m_windowStyle & wxRAISED_BORDER) || - (m_windowStyle & wxSUNKEN_BORDER)) - { - dw += 2 * viewport_class->xthickness; - dh += 2 * viewport_class->ythickness; - } + } + else + { - if (GTK_WIDGET_VISIBLE(vscrollbar)) - { -// dw += vscrollbar->allocation.width; - dw += 15; // range.slider_width = 11 + 2*2pts edge - dw += scroll_class->scrollbar_spacing; - } + GdkWindow *window = m_widget->window; + if ((window) && !(GTK_WIDGET_NO_WINDOW(m_widget))) + gdk_window_set_cursor( window, cursor.GetCursor() ); - if (GTK_WIDGET_VISIBLE(hscrollbar)) - { -// dh += hscrollbar->allocation.height; - dh += 15; - dh += scroll_class->scrollbar_spacing; - } + } } - if (width) (*width) = m_width - dw; - if (height) (*height) = m_height - dh; - } + UpdateWindowUI(); } -void wxWindow::GetPosition( int *x, int *y ) const +void wxWindowGTK::DoGetSize( int *width, int *height ) const { - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); + wxCHECK_RET( (m_widget != NULL), wxT("invalid window") ); - if (x) (*x) = m_x; - if (y) (*y) = m_y; + if (width) (*width) = m_width; + if (height) (*height) = m_height; } -void wxWindow::ClientToScreen( int *x, int *y ) +void wxWindowGTK::DoSetClientSize( int width, int height ) { - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); - - GdkWindow *source = (GdkWindow *) NULL; - if (m_wxwindow) - source = m_wxwindow->window; - else - source = m_widget->window; + wxCHECK_RET( (m_widget != NULL), wxT("invalid window") ); - int org_x = 0; - int org_y = 0; - gdk_window_get_origin( source, &org_x, &org_y ); - - if (!m_wxwindow) - { - if (GTK_WIDGET_NO_WINDOW (m_widget)) + if (!m_wxwindow) { - org_x += m_widget->allocation.x; - org_y += m_widget->allocation.y; + SetSize( width, height ); } - } + else + { + int dw = 0; + int dh = 0; - if (x) *x += org_x; - if (y) *y += org_y; -} +#ifndef __WXUNIVERSAL__ + if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER)) + { + /* when using GTK 1.2 we set the shadow border size to 2 */ + dw += 2 * 2; + dh += 2 * 2; + } + if (HasFlag(wxSIMPLE_BORDER)) + { + /* when using GTK 1.2 we set the simple border size to 1 */ + dw += 1 * 2; + dh += 1 * 2; + } +#endif // __WXUNIVERSAL__ -void wxWindow::ScreenToClient( int *x, int *y ) -{ - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); + 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 ); - GdkWindow *source = (GdkWindow *) NULL; - if (m_wxwindow) - source = m_wxwindow->window; - else - source = m_widget->window; + GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) ); - int org_x = 0; - int org_y = 0; - gdk_window_get_origin( source, &org_x, &org_y ); + 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 (!m_wxwindow) - { - if (GTK_WIDGET_NO_WINDOW (m_widget)) - { - org_x += m_widget->allocation.x; - org_y += m_widget->allocation.y; + SetSize( width+dw, height+dh ); } - } - - if (x) *x -= org_x; - if (y) *y -= org_y; } -void wxWindow::Centre( int direction ) +void wxWindowGTK::DoGetClientSize( int *width, int *height ) const { - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); + wxCHECK_RET( (m_widget != NULL), wxT("invalid window") ); - if (IS_KIND_OF(this,wxDialog) || IS_KIND_OF(this,wxFrame)) - { - if (direction & wxHORIZONTAL == wxHORIZONTAL) m_x = (gdk_screen_width () - m_width) / 2; - if (direction & wxVERTICAL == wxVERTICAL) m_y = (gdk_screen_height () - m_height) / 2; - ImplementSetPosition(); - } - else - { - if (m_parent) + if (!m_wxwindow) { - int p_w = 0; - int p_h = 0; - m_parent->GetSize( &p_w, &p_h ); - if (direction & wxHORIZONTAL == wxHORIZONTAL) m_x = (p_w - m_width) / 2; - if (direction & wxVERTICAL == wxVERTICAL) m_y = (p_h - m_height) / 2; - ImplementSetPosition(); + if (width) (*width) = m_width; + if (height) (*height) = m_height; } - } -} + else + { + int dw = 0; + int dh = 0; -void wxWindow::Fit() -{ - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); +#ifndef __WXUNIVERSAL__ + if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER)) + { + /* when using GTK 1.2 we set the shadow border size to 2 */ + dw += 2 * 2; + dh += 2 * 2; + } + if (HasFlag(wxSIMPLE_BORDER)) + { + /* when using GTK 1.2 we set the simple border size to 1 */ + dw += 1 * 2; + dh += 1 * 2; + } +#endif // __WXUNIVERSAL__ - int maxX = 0; - int maxY = 0; - wxNode *node = GetChildren()->First(); - while ( node ) - { - wxWindow *win = (wxWindow *)node->Data(); - int wx, wy, ww, wh; - win->GetPosition(&wx, &wy); - win->GetSize(&ww, &wh); - if ( wx + ww > maxX ) - maxX = wx + ww; - if ( wy + wh > maxY ) - maxY = wy + wh; - - node = node->Next(); - } - SetClientSize(maxX + 5, maxY + 10); -} + if (m_hasScrolling) + { + GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget); -void wxWindow::SetSizeHints( int minW, int minH, int maxW, int maxH, int WXUNUSED(incW), int WXUNUSED(incH) ) -{ - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); + 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 ); - m_minWidth = minW; - m_minHeight = minH; - m_maxWidth = maxW; - m_maxHeight = maxH; -} + 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 ); -void wxWindow::OnSize( wxSizeEvent &WXUNUSED(event) ) -{ - //if (GetAutoLayout()) Layout(); -} + GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) ); -bool wxWindow::Show( bool show ) -{ - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); + 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; + } - if (show) - gtk_widget_show( m_widget ); - else - gtk_widget_hide( m_widget ); - m_isShown = show; - return TRUE; +/* + printf( "GetClientSize, name %s ", GetName().c_str() ); + if (width) printf( " width = %d", (*width) ); + if (height) printf( " height = %d", (*height) ); + printf( "\n" ); +*/ } -void wxWindow::Enable( bool enable ) +void wxWindowGTK::DoGetPosition( int *x, int *y ) const { - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); + wxCHECK_RET( (m_widget != NULL), wxT("invalid window") ); - m_isEnabled = enable; - gtk_widget_set_sensitive( m_widget, enable ); - if (m_wxwindow) gtk_widget_set_sensitive( m_wxwindow, enable ); + int dx = 0; + int dy = 0; + if (m_parent && m_parent->m_wxwindow) + { + GtkPizza *pizza = GTK_PIZZA(m_parent->m_wxwindow); + dx = pizza->xoffset; + dy = pizza->yoffset; + } + + if (x) (*x) = m_x - dx; + if (y) (*y) = m_y - dy; } -int wxWindow::GetCharHeight() const +void wxWindowGTK::DoClientToScreen( int *x, int *y ) const { - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); + wxCHECK_RET( (m_widget != NULL), wxT("invalid window") ); - if (!m_font.Ok()) - { - wxFAIL_MSG( "invalid font" ); - return -1; - } + if (!m_widget->window) return; - GdkFont *font = m_font.GetInternalFont( 1.0 ); - return font->ascent + font->descent; -} + GdkWindow *source = (GdkWindow *) NULL; + if (m_wxwindow) + source = GTK_PIZZA(m_wxwindow)->bin_window; + else + source = m_widget->window; -int wxWindow::GetCharWidth() const -{ - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); + int org_x = 0; + int org_y = 0; + gdk_window_get_origin( source, &org_x, &org_y ); - if (!m_font.Ok()) - { - wxFAIL_MSG( "invalid font" ); - return -1; - } + if (!m_wxwindow) + { + if (GTK_WIDGET_NO_WINDOW (m_widget)) + { + org_x += m_widget->allocation.x; + org_y += m_widget->allocation.y; + } + } - GdkFont *font = m_font.GetInternalFont( 1.0 ); - return gdk_string_width( font, "H" ); + if (x) *x += org_x; + if (y) *y += org_y; } -void wxWindow::GetTextExtent( const wxString& string, int *x, int *y, - int *descent, int *externalLeading, const wxFont *theFont, bool WXUNUSED(use16) ) const +void wxWindowGTK::DoScreenToClient( int *x, int *y ) const { - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); + wxCHECK_RET( (m_widget != NULL), wxT("invalid window") ); - wxFont fontToUse = m_font; - if (theFont) fontToUse = *theFont; + if (!m_widget->window) return; - if (!fontToUse.Ok()) - { - wxFAIL_MSG( "invalid font" ); - return; - } - wxASSERT_MSG( (m_font.Ok()), "invalid font" ); + GdkWindow *source = (GdkWindow *) NULL; + if (m_wxwindow) + source = GTK_PIZZA(m_wxwindow)->bin_window; + else + source = m_widget->window; - GdkFont *font = fontToUse.GetInternalFont( 1.0 ); - if (x) (*x) = gdk_string_width( font, string ); - if (y) (*y) = font->ascent + font->descent; - if (descent) (*descent) = font->descent; - if (externalLeading) (*externalLeading) = 0; // ?? -} + int org_x = 0; + int org_y = 0; + gdk_window_get_origin( source, &org_x, &org_y ); -void wxWindow::MakeModal( bool modal ) -{ - return; - // Disable all other windows - if (this->IsKindOf(CLASSINFO(wxDialog)) || this->IsKindOf(CLASSINFO(wxFrame))) - { - wxNode *node = wxTopLevelWindows.First(); - while (node) + if (!m_wxwindow) { - wxWindow *win = (wxWindow *)node->Data(); - if (win != this) - win->Enable(!modal); - - node = node->Next(); + if (GTK_WIDGET_NO_WINDOW (m_widget)) + { + org_x += m_widget->allocation.x; + org_y += m_widget->allocation.y; + } } - } + + if (x) *x -= org_x; + if (y) *y -= org_y; } -void wxWindow::SetFocus() +bool wxWindowGTK::Show( bool show ) { - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); + wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") ); - GtkWidget *connect_widget = GetConnectWidget(); - if (connect_widget) - { - if (GTK_WIDGET_CAN_FOCUS(connect_widget) && !GTK_WIDGET_HAS_FOCUS (connect_widget) ) + if (!wxWindowBase::Show(show)) { - gtk_widget_grab_focus (connect_widget); + // nothing to do + return FALSE; } - } -} -bool wxWindow::OnClose() -{ - return TRUE; + if (show) + gtk_widget_show( m_widget ); + else + gtk_widget_hide( m_widget ); + + return TRUE; } -void wxWindow::AddChild( wxWindow *child ) +static void wxWindowNotifyEnable(wxWindowGTK* win, bool enable) { - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); - wxASSERT_MSG( (m_wxwindow != NULL), "window need client area" ); - wxASSERT_MSG( (child != NULL), "invalid child" ); - wxASSERT_MSG( (child->m_widget != NULL), "invalid child" ); - - // Addchild is (often) called before the program - // has left the parents constructor so that no - // virtual tables work yet. The approach below - // practically imitates virtual tables, i.e. it - // implements a different AddChild() behaviour - // for wxFrame, wxDialog, wxWindow and - // wxMDIParentFrame. - - // wxFrame and wxDialog as children aren't placed into the parents - - if (( IS_KIND_OF(child,wxFrame) || IS_KIND_OF(child,wxDialog) ) && - (!IS_KIND_OF(child,wxMDIChildFrame))) - { - m_children.Append( child ); - - if ((child->m_x != -1) && (child->m_y != -1)) - gtk_widget_set_uposition( child->m_widget, child->m_x, child->m_y ); - - return; - } + win->OnParentEnable(enable); - // In the case of an wxMDIChildFrame descendant, we use the - // client windows's AddChild() - - if (IS_KIND_OF(this,wxMDIParentFrame)) - { - if (IS_KIND_OF(child,wxMDIChildFrame)) + // 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::Node *node = win->GetChildren().GetFirst(); + node; + node = node->GetNext() ) { - wxMDIClientWindow *client = ((wxMDIParentFrame*)this)->GetClientWindow(); - if (client) - { - client->AddChild( child ); - return; - } + wxWindow *child = node->GetData(); + if (!child->IsKindOf(CLASSINFO(wxDialog)) && !child->IsKindOf(CLASSINFO(wxFrame))) + wxWindowNotifyEnable(child, enable); } - } - - // wxNotebook is very special, so it has a private AddChild() - - if (IS_KIND_OF(this,wxNotebook)) - { - wxNotebook *tab = (wxNotebook*)this; - tab->AddChild( child ); - return; - } +} - // wxFrame has a private AddChild +bool wxWindowGTK::Enable( bool enable ) +{ + wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") ); - if (IS_KIND_OF(this,wxFrame) && !IS_KIND_OF(this,wxMDIChildFrame)) - { - wxFrame *frame = (wxFrame*)this; - frame->AddChild( child ); - return; - } + if (!wxWindowBase::Enable(enable)) + { + // nothing to do + return FALSE; + } - // All the rest + gtk_widget_set_sensitive( m_widget, enable ); + if ( m_wxwindow ) + gtk_widget_set_sensitive( m_wxwindow, enable ); - m_children.Append( child ); - if (m_wxwindow) gtk_myfixed_put( GTK_MYFIXED(m_wxwindow), child->m_widget, - child->m_x, child->m_y ); + wxWindowNotifyEnable(this, enable); - gtk_widget_set_usize( child->m_widget, child->m_width, child->m_height ); + return TRUE; } -wxList *wxWindow::GetChildren() +int wxWindowGTK::GetCharHeight() const { - return (&m_children); -} + wxCHECK_MSG( (m_widget != NULL), 12, wxT("invalid window") ); -void wxWindow::RemoveChild( wxWindow *child ) -{ - if (GetChildren()) - GetChildren()->DeleteObject( child ); - child->m_parent = (wxWindow *) NULL; -} + wxCHECK_MSG( m_font.Ok(), 12, wxT("invalid font") ); -void wxWindow::SetReturnCode( int retCode ) -{ - m_retCode = retCode; -} + GdkFont *font = m_font.GetInternalFont( 1.0 ); -int wxWindow::GetReturnCode() -{ - return m_retCode; + return font->ascent + font->descent; } -void wxWindow::Raise() +int wxWindowGTK::GetCharWidth() const { - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); + wxCHECK_MSG( (m_widget != NULL), 8, wxT("invalid window") ); - if (m_widget) gdk_window_raise( m_widget->window ); -} + wxCHECK_MSG( m_font.Ok(), 8, wxT("invalid font") ); -void wxWindow::Lower() -{ - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); + GdkFont *font = m_font.GetInternalFont( 1.0 ); - if (m_widget) gdk_window_lower( m_widget->window ); + return gdk_string_width( font, "H" ); } -wxEvtHandler *wxWindow::GetEventHandler() +void wxWindowGTK::GetTextExtent( const wxString& string, + int *x, + int *y, + int *descent, + int *externalLeading, + const wxFont *theFont ) const { - return m_eventHandler; -} + wxFont fontToUse = m_font; + if (theFont) fontToUse = *theFont; -void wxWindow::SetEventHandler( wxEvtHandler *handler ) -{ - m_eventHandler = handler; -} + wxCHECK_RET( fontToUse.Ok(), wxT("invalid font") ); -void wxWindow::PushEventHandler(wxEvtHandler *handler) -{ - handler->SetNextHandler(GetEventHandler()); - SetEventHandler(handler); + GdkFont *font = fontToUse.GetInternalFont( 1.0 ); + if (x) (*x) = gdk_string_width( font, string.mbc_str() ); + if (y) (*y) = font->ascent + font->descent; + if (descent) (*descent) = font->descent; + if (externalLeading) (*externalLeading) = 0; // ?? } -wxEvtHandler *wxWindow::PopEventHandler(bool deleteHandler) +void wxWindowGTK::SetFocus() { - if (GetEventHandler()) - { - wxEvtHandler *handlerA = GetEventHandler(); - wxEvtHandler *handlerB = handlerA->GetNextHandler(); - handlerA->SetNextHandler((wxEvtHandler *) NULL); - SetEventHandler(handlerB); - if (deleteHandler) + wxCHECK_RET( (m_widget != NULL), wxT("invalid window") ); + + if (m_wxwindow) { - delete handlerA; - return (wxEvtHandler*) NULL; + if (!GTK_WIDGET_HAS_FOCUS (m_wxwindow)) + { + // see comment in gtk_window_focus_out_callback() + gs_widgetLastFocus = m_wxwindow; + gtk_widget_grab_focus (m_wxwindow); + } + } + else if (m_widget) + { + if (GTK_WIDGET_CAN_FOCUS(m_widget) && !GTK_WIDGET_HAS_FOCUS (m_widget) ) + { + gtk_widget_grab_focus (m_widget); + } + else if (GTK_IS_CONTAINER(m_widget)) + { + gtk_container_focus( GTK_CONTAINER(m_widget), GTK_DIR_TAB_FORWARD ); + } + else + { + // ? + } } - else - return handlerA; - } - else - return (wxEvtHandler *) NULL; } -wxValidator *wxWindow::GetValidator() +bool wxWindowGTK::AcceptsFocus() const { - return m_windowValidator; + return m_acceptsFocus && wxWindowBase::AcceptsFocus(); } -void wxWindow::SetValidator( const wxValidator& validator ) +bool wxWindowGTK::Reparent( wxWindowBase *newParentBase ) { - if (m_windowValidator) delete m_windowValidator; - m_windowValidator = validator.Clone(); - if (m_windowValidator) m_windowValidator->SetWindow(this); -} + wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") ); -bool wxWindow::IsBeingDeleted() -{ - return FALSE; -} + wxWindowGTK *oldParent = m_parent, + *newParent = (wxWindowGTK *)newParentBase; -void wxWindow::SetId( wxWindowID id ) -{ - m_windowId = id; -} + wxASSERT( GTK_IS_WIDGET(m_widget) ); -wxWindowID wxWindow::GetId() -{ - return m_windowId; -} + if ( !wxWindowBase::Reparent(newParent) ) + return FALSE; -void wxWindow::SetCursor( const wxCursor &cursor ) -{ - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); + wxASSERT( GTK_IS_WIDGET(m_widget) ); - if (m_cursor == NULL) - { - wxFAIL_MSG( "wxWindow::SetCursor m_cursor == NULL" ); - m_cursor = new wxCursor( wxCURSOR_ARROW ); - } + /* prevent GTK from deleting the widget arbitrarily */ + gtk_widget_ref( m_widget ); - if (cursor.Ok()) - { - if (*((wxCursor*)&cursor) == m_cursor) return; - *m_cursor = cursor; - } - else - { - *m_cursor = *wxSTANDARD_CURSOR; - } + if (oldParent) + { + gtk_container_remove( GTK_CONTAINER(m_widget->parent), m_widget ); + } + + wxASSERT( GTK_IS_WIDGET(m_widget) ); + + if (newParent) + { + /* insert GTK representation */ + (*(newParent->m_insertCallback))(newParent, this); + } - if ((m_widget) && (m_widget->window)) - gdk_window_set_cursor( m_widget->window, m_cursor->GetCursor() ); + /* reverse: prevent GTK from deleting the widget arbitrarily */ + gtk_widget_unref( m_widget ); - if ((m_wxwindow) && (m_wxwindow->window)) - gdk_window_set_cursor( m_wxwindow->window, m_cursor->GetCursor() ); + return TRUE; } -void wxWindow::Refresh( bool eraseBackground, const wxRect *rect ) +void wxWindowGTK::DoAddChild(wxWindowGTK *child) { - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); + wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") ); - if (eraseBackground && m_wxwindow && m_wxwindow->window) - { - if (rect) - gdk_window_clear_area( m_wxwindow->window, - rect->x, - rect->y, - rect->width, - rect->height ); - else - Clear(); - } - if (!rect) - { - if (m_wxwindow) - { - int w = 0; - int h = 0; - GetClientSize( &w, &h ); + wxASSERT_MSG( (child != NULL), wxT("invalid child window") ); - GdkRectangle gdk_rect; - gdk_rect.x = 0; - gdk_rect.y = 0; - gdk_rect.width = w; - gdk_rect.height = h; - gtk_widget_draw( m_wxwindow, &gdk_rect ); - } - } - else - { - GdkRectangle gdk_rect; - gdk_rect.x = rect->x; - gdk_rect.y = rect->y; - gdk_rect.width = rect->width; - gdk_rect.height = rect->height; + wxASSERT_MSG( (m_insertCallback != NULL), wxT("invalid child insertion function") ); - if (m_wxwindow) - gtk_widget_draw( m_wxwindow, &gdk_rect ); - else - gtk_widget_draw( m_widget, &gdk_rect ); - } -} + /* add to list */ + AddChild( child ); -wxRegion wxWindow::GetUpdateRegion() const -{ - return m_updateRegion; + /* insert GTK representation */ + (*m_insertCallback)(this, child); } -bool wxWindow::IsExposed( int x, int y) const +void wxWindowGTK::Raise() { - return (m_updateRegion.Contains( x, y ) != wxOutRegion ); -} + wxCHECK_RET( (m_widget != NULL), wxT("invalid window") ); -bool wxWindow::IsExposed( int x, int y, int w, int h ) const -{ - return (m_updateRegion.Contains( x, y, w, h ) != wxOutRegion ); -} + if (!m_widget->window) return; -bool wxWindow::IsExposed( const wxPoint& pt ) const -{ - return (m_updateRegion.Contains( pt.x, pt.y ) != wxOutRegion ); + gdk_window_raise( m_widget->window ); } -bool wxWindow::IsExposed( const wxRect& rect ) const +void wxWindowGTK::Lower() { - return (m_updateRegion.Contains( rect.x, rect.y, rect.width, rect.height ) != wxOutRegion ); -} + wxCHECK_RET( (m_widget != NULL), wxT("invalid window") ); -void wxWindow::Clear() -{ - wxCHECK_RET( m_widget != NULL, "invalid window" ); + if (!m_widget->window) return; - if (m_wxwindow && m_wxwindow->window) gdk_window_clear( m_wxwindow->window ); + gdk_window_lower( m_widget->window ); } -wxColour wxWindow::GetBackgroundColour() const +bool wxWindowGTK::SetCursor( const wxCursor &cursor ) { - return m_backgroundColour; -} + wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") ); -void wxWindow::SetBackgroundColourHelper( GdkWindow *window ) -{ - if (!m_backgroundColour.Ok()) return; - - m_backgroundColour.CalcPixel( gdk_window_get_colormap( window ) ); - gdk_window_set_background( window, m_backgroundColour.GetColor() ); - gdk_window_clear( window ); -} + if (cursor == m_cursor) + return FALSE; -void wxWindow::SetBackgroundColour( const wxColour &colour ) -{ - wxCHECK_RET( m_widget != NULL, "invalid window" ); + if (g_isIdle) + wxapp_install_idle_handler(); - m_backgroundColour = colour; - - GtkWidget *widget = m_wxwindow == NULL ? m_widget : m_wxwindow; - SetBackgroundColourHelper( widget->window ); + if (cursor == wxNullCursor) + return wxWindowBase::SetCursor( *wxSTANDARD_CURSOR ); + else + return wxWindowBase::SetCursor( cursor ); } -wxColour wxWindow::GetForegroundColour() const +void wxWindowGTK::WarpPointer( int x, int y ) { - return m_foregroundColour; -} + wxCHECK_RET( (m_widget != NULL), wxT("invalid window") ); -void wxWindow::SetForegroundColour( const wxColour &colour ) -{ - m_foregroundColour = colour; -} + /* we provide this function ourselves as it is + missing in GDK (top of this file) */ -bool wxWindow::Validate() -{ - wxCHECK_MSG( m_widget != NULL, FALSE, "invalid window" ); + GdkWindow *window = (GdkWindow*) NULL; + if (m_wxwindow) + window = GTK_PIZZA(m_wxwindow)->bin_window; + else + window = GetConnectWidget()->window; - wxNode *node = GetChildren()->First(); - while (node) - { - wxWindow *child = (wxWindow *)node->Data(); - if (child->GetValidator() && /* child->GetValidator()->Ok() && */ !child->GetValidator()->Validate(this)) - { return FALSE; } - node = node->Next(); - } - return TRUE; + if (window) + gdk_window_warp_pointer( window, x, y ); } -bool wxWindow::TransferDataToWindow() +void wxWindowGTK::Refresh( bool eraseBackground, const wxRect *rect ) { - wxCHECK_MSG( m_widget != NULL, FALSE, "invalid window" ); + if (!m_widget) return; + if (!m_widget->window) return; - wxNode *node = GetChildren()->First(); - while (node) - { - wxWindow *child = (wxWindow *)node->Data(); - if (child->GetValidator() && /* child->GetValidator()->Ok() && */ - !child->GetValidator()->TransferToWindow() ) + // temporarily hide the caret to avoid nasty interactions between caret + // drawing and the window contents redraw +#if 0 // def wxUSE_CARET -- doesn't seem to help :-( + wxCaretSuspend cs((wxWindow *)this); +#endif // wxUSE_CARET + + if (eraseBackground && m_wxwindow && m_wxwindow->window) { - wxMessageBox( _("Application Error"), _("Could not transfer data to window"), wxOK|wxICON_EXCLAMATION ); - return FALSE; + if (rect) + { + gdk_window_clear_area( GTK_PIZZA(m_wxwindow)->bin_window, + rect->x, rect->y, + rect->width, rect->height ); + } + else + { + gdk_window_clear( GTK_PIZZA(m_wxwindow)->bin_window ); + } } - node = node->Next(); - } - return TRUE; -} -bool wxWindow::TransferDataFromWindow() -{ - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); + /* there is no GTK equivalent of "draw only, don't clear" so we + invent our own in the GtkPizza widget */ - wxNode *node = GetChildren()->First(); - while (node) - { - wxWindow *child = (wxWindow *)node->Data(); - if ( child->GetValidator() && /* child->GetValidator()->Ok() && */ !child->GetValidator()->TransferFromWindow() ) - { return FALSE; } - node = node->Next(); - } - return TRUE; -} + if (!rect) + { + if (m_wxwindow) + { -void wxWindow::SetAcceleratorTable( const wxAcceleratorTable& accel ) -{ - m_acceleratorTable = accel; -} +/* + GtkPizza *pizza = GTK_PIZZA(m_wxwindow); + gboolean old_clear = pizza->clear_on_draw; + gtk_pizza_set_clear( pizza, FALSE ); + gtk_widget_draw( m_wxwindow, (GdkRectangle*) NULL ); + gtk_pizza_set_clear( pizza, old_clear ); +*/ + GdkEventExpose gdk_event; + gdk_event.type = GDK_EXPOSE; + gdk_event.window = GTK_PIZZA(m_wxwindow)->bin_window; + gdk_event.count = 0; + gdk_event.area.x = 0; + gdk_event.area.y = 0; + gdk_event.area.width = m_wxwindow->allocation.width; + gdk_event.area.height = m_wxwindow->allocation.height; + gtk_window_expose_callback( m_wxwindow, &gdk_event, (wxWindow *)this ); + } + else + { + gtk_widget_draw( m_widget, (GdkRectangle*) NULL ); + } + } + else + { -void wxWindow::OnInitDialog( wxInitDialogEvent &WXUNUSED(event) ) -{ - TransferDataToWindow(); + if (m_wxwindow) + { +/* + GtkPizza *pizza = GTK_PIZZA(m_wxwindow); + gboolean old_clear = pizza->clear_on_draw; + gtk_pizza_set_clear( pizza, FALSE ); + + GdkRectangle gdk_rect; + gdk_rect.x = rect->x; + gdk_rect.y = rect->y; + gdk_rect.width = rect->width; + gdk_rect.height = rect->height; + gtk_widget_draw( m_wxwindow, &gdk_rect ); + gtk_window_draw_callback( m_wxwindow, &gdk_rect, this ); + + gtk_pizza_set_clear( pizza, old_clear ); +*/ + GdkEventExpose gdk_event; + gdk_event.type = GDK_EXPOSE; + gdk_event.window = GTK_PIZZA(m_wxwindow)->bin_window; + gdk_event.count = 0; + gdk_event.area.x = rect->x; + gdk_event.area.y = rect->y; + gdk_event.area.width = rect->width; + gdk_event.area.height = rect->height; + gtk_window_expose_callback( m_wxwindow, &gdk_event, (wxWindow *)this ); + } + else + { + GdkRectangle gdk_rect; + gdk_rect.x = rect->x; + gdk_rect.y = rect->y; + gdk_rect.width = rect->width; + gdk_rect.height = rect->height; + gtk_widget_draw( m_widget, &gdk_rect ); + } + } } -void wxWindow::InitDialog() +void wxWindowGTK::Clear() { - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); + wxCHECK_RET( m_widget != NULL, wxT("invalid window") ); - wxInitDialogEvent event(GetId()); - event.SetEventObject( this ); - GetEventHandler()->ProcessEvent(event); -} + if (!m_widget->window) return; -static void SetInvokingWindow( wxMenu *menu, wxWindow *win ) -{ - menu->SetInvokingWindow( win ); - wxNode *node = menu->m_items.First(); - while (node) - { - wxMenuItem *menuitem = (wxMenuItem*)node->Data(); - if (menuitem->IsSubMenu()) - SetInvokingWindow( menuitem->GetSubMenu(), win ); - node = node->Next(); - } + if (m_wxwindow && m_wxwindow->window) + { +// gdk_window_clear( m_wxwindow->window ); + } } -bool wxWindow::PopupMenu( wxMenu *menu, int WXUNUSED(x), int WXUNUSED(y) ) +#if wxUSE_TOOLTIPS +void wxWindowGTK::DoSetToolTip( wxToolTip *tip ) { - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); + wxWindowBase::DoSetToolTip(tip); - SetInvokingWindow( menu, this ); - gtk_menu_popup( - GTK_MENU(menu->m_menu), - (GtkWidget *)NULL, // parent menu shell - (GtkWidget *)NULL, // parent menu item - (GtkMenuPositionFunc)NULL, - NULL, // client data - 0, // button used to activate it - 0//gs_timeLastClick // the time of activation - ); - return TRUE; + if (m_tooltip) + m_tooltip->Apply( (wxWindow *)this ); } -void wxWindow::SetDropTarget( wxDropTarget *dropTarget ) +void wxWindowGTK::ApplyToolTip( GtkTooltips *tips, const wxChar *tip ) { - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); + gtk_tooltips_set_tip( tips, GetConnectWidget(), wxConvCurrent->cWX2MB(tip), (gchar*) NULL ); +} +#endif // wxUSE_TOOLTIPS - GtkWidget *dnd_widget = GetConnectWidget(); +bool wxWindowGTK::SetBackgroundColour( const wxColour &colour ) +{ + wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") ); - DisconnectDnDWidget( dnd_widget ); + if (!wxWindowBase::SetBackgroundColour(colour)) + { + // don't leave if the GTK widget has just + // been realized + if (!m_delayedBackgroundColour) return FALSE; + } - if (m_pDropTarget) delete m_pDropTarget; - m_pDropTarget = dropTarget; + GdkWindow *window = (GdkWindow*) NULL; + if (m_wxwindow) + window = GTK_PIZZA(m_wxwindow)->bin_window; + else + window = GetConnectWidget()->window; - ConnectDnDWidget( dnd_widget ); -} + if (!window) + { + // indicate that a new style has been set + // but it couldn't get applied as the + // widget hasn't been realized yet. + m_delayedBackgroundColour = TRUE; + } -wxDropTarget *wxWindow::GetDropTarget() const -{ - return m_pDropTarget; -} + if ((m_wxwindow) && + (m_wxwindow->window) && + (m_backgroundColour != wxSystemSettings::GetSystemColour(wxSYS_COLOUR_BTNFACE))) + { + /* wxMSW doesn't clear the window here. I don't do that either to + provide compatibility. call Clear() to do the job. */ -void wxWindow::ConnectDnDWidget( GtkWidget *widget ) -{ - if (!m_pDropTarget) return; + m_backgroundColour.CalcPixel( gdk_window_get_colormap( window ) ); + gdk_window_set_background( window, m_backgroundColour.GetColor() ); + } - m_pDropTarget->RegisterWidget( widget ); + ApplyWidgetStyle(); - gtk_signal_connect( GTK_OBJECT(widget), "drop_data_available_event", - GTK_SIGNAL_FUNC(gtk_window_drop_callback), (gpointer)this ); + return TRUE; } -void wxWindow::DisconnectDnDWidget( GtkWidget *widget ) +bool wxWindowGTK::SetForegroundColour( const wxColour &colour ) { - if (!m_pDropTarget) return; + wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") ); - gtk_signal_disconnect_by_func( GTK_OBJECT(widget), - GTK_SIGNAL_FUNC(gtk_window_drop_callback), (gpointer)this ); + if (!wxWindowBase::SetForegroundColour(colour)) + { + // don't leave if the GTK widget has just + // been realized + if (!m_delayedForegroundColour) return FALSE; + } - m_pDropTarget->UnregisterWidget( widget ); -} + GdkWindow *window = (GdkWindow*) NULL; + if (m_wxwindow) + window = GTK_PIZZA(m_wxwindow)->bin_window; + else + window = GetConnectWidget()->window; -GtkWidget* wxWindow::GetConnectWidget() -{ - GtkWidget *connect_widget = m_widget; - if (m_wxwindow) connect_widget = m_wxwindow; + if (!window) + { + // indicate that a new style has been set + // but it couldn't get applied as the + // widget hasn't been realized yet. + m_delayedForegroundColour = TRUE; + } - return connect_widget; -} + ApplyWidgetStyle(); -bool wxWindow::IsOwnGtkWindow( GdkWindow *window ) -{ - if (m_wxwindow) return (window == m_wxwindow->window); - return (window == m_widget->window); + return TRUE; } -void wxWindow::SetFont( const wxFont &font ) +GtkStyle *wxWindowGTK::GetWidgetStyle() { - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); - - if (((wxFont*)&font)->Ok()) - m_font = font; - else - m_font = *wxSWISS_FONT; + if (m_widgetStyle) + { + GtkStyle *remake = gtk_style_copy( m_widgetStyle ); +#ifdef __WXGTK20__ + /* FIXME: is this necessary? */ + _G_TYPE_IGC(remake, GtkObjectClass) = _G_TYPE_IGC(m_widgetStyle, GtkObjectClass); +#else + remake->klass = m_widgetStyle->klass; +#endif - GtkStyle *style = (GtkStyle*) NULL; - if (!m_hasOwnStyle) - { - m_hasOwnStyle = TRUE; - style = gtk_style_copy( gtk_widget_get_style( m_widget ) ); - } - else - { - style = gtk_widget_get_style( m_widget ); - } + gtk_style_unref( m_widgetStyle ); + m_widgetStyle = remake; + } + else + { + GtkStyle *def = gtk_rc_get_style( m_widget ); - gdk_font_unref( style->font ); - style->font = gdk_font_ref( m_font.GetInternalFont( 1.0 ) ); + if (!def) + def = gtk_widget_get_default_style(); - gtk_widget_set_style( m_widget, style ); -} + m_widgetStyle = gtk_style_copy( def ); +#ifdef __WXGTK20__ + /* FIXME: is this necessary? */ + _G_TYPE_IGC(m_widgetStyle, GtkObjectClass) = _G_TYPE_IGC(def, GtkObjectClass); +#else + m_widgetStyle->klass = def->klass; +#endif + } -wxFont *wxWindow::GetFont() -{ - return &m_font; + return m_widgetStyle; } -void wxWindow::SetWindowStyleFlag( long flag ) +void wxWindowGTK::SetWidgetStyle() { - m_windowStyle = flag; -} +#if DISABLE_STYLE_IF_BROKEN_THEM + if (m_widget->style->engine_data) + { + static bool s_warningPrinted = FALSE; + if (!s_warningPrinted) + { + printf( "wxWindows warning: Widget styles disabled due to buggy GTK theme.\n" ); + s_warningPrinted = TRUE; + } + m_widgetStyle = m_widget->style; + return; + } +#endif -long wxWindow::GetWindowStyleFlag() const -{ - return m_windowStyle; -} + GtkStyle *style = GetWidgetStyle(); -void wxWindow::CaptureMouse() -{ - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); + if (m_font != wxSystemSettings::GetSystemFont( wxSYS_DEFAULT_GUI_FONT )) + { + gdk_font_unref( style->font ); + style->font = gdk_font_ref( m_font.GetInternalFont( 1.0 ) ); + } - wxASSERT_MSG( (g_capturing == FALSE), "CaptureMouse called twice" ); + if (m_foregroundColour.Ok()) + { + m_foregroundColour.CalcPixel( gtk_widget_get_colormap( m_widget ) ); + if (m_foregroundColour != wxSystemSettings::GetSystemColour(wxSYS_COLOUR_BTNTEXT)) + { + style->fg[GTK_STATE_NORMAL] = *m_foregroundColour.GetColor(); + style->fg[GTK_STATE_PRELIGHT] = *m_foregroundColour.GetColor(); + style->fg[GTK_STATE_ACTIVE] = *m_foregroundColour.GetColor(); + } + else + { + // Try to restore the gtk default style. This is still a little + // oversimplified for what is probably really needed here for controls + // other than buttons, but is better than not being able to (re)set a + // control's foreground colour to *wxBLACK -- RL + GtkStyle *def = gtk_rc_get_style( m_widget ); + + if (!def) + def = gtk_widget_get_default_style(); + + style->fg[GTK_STATE_NORMAL] = def->fg[GTK_STATE_NORMAL]; + style->fg[GTK_STATE_PRELIGHT] = def->fg[GTK_STATE_PRELIGHT]; + style->fg[GTK_STATE_ACTIVE] = def->fg[GTK_STATE_ACTIVE]; + } + } - GtkWidget *connect_widget = GetConnectWidget(); - gtk_grab_add( connect_widget ); - gdk_pointer_grab ( connect_widget->window, FALSE, - (GdkEventMask) - (GDK_BUTTON_PRESS_MASK | - GDK_BUTTON_RELEASE_MASK | - GDK_POINTER_MOTION_MASK), - (GdkWindow *) NULL, (GdkCursor *) NULL, GDK_CURRENT_TIME ); - g_capturing = TRUE; + if (m_backgroundColour.Ok()) + { + m_backgroundColour.CalcPixel( gtk_widget_get_colormap( m_widget ) ); + if (m_backgroundColour != wxSystemSettings::GetSystemColour(wxSYS_COLOUR_BTNFACE)) + { + style->bg[GTK_STATE_NORMAL] = *m_backgroundColour.GetColor(); + style->base[GTK_STATE_NORMAL] = *m_backgroundColour.GetColor(); + style->bg[GTK_STATE_PRELIGHT] = *m_backgroundColour.GetColor(); + style->base[GTK_STATE_PRELIGHT] = *m_backgroundColour.GetColor(); + style->bg[GTK_STATE_ACTIVE] = *m_backgroundColour.GetColor(); + style->base[GTK_STATE_ACTIVE] = *m_backgroundColour.GetColor(); + style->bg[GTK_STATE_INSENSITIVE] = *m_backgroundColour.GetColor(); + style->base[GTK_STATE_INSENSITIVE] = *m_backgroundColour.GetColor(); + } + else + { + // Try to restore the gtk default style. This is still a little + // oversimplified for what is probably really needed here for controls + // other than buttons, but is better than not being able to (re)set a + // control's background colour to default grey and means resetting a + // button to wxSYS_COLOUR_BTNFACE will restore its usual highlighting + // behavior -- RL + GtkStyle *def = gtk_rc_get_style( m_widget ); + + if (!def) + def = gtk_widget_get_default_style(); + + style->bg[GTK_STATE_NORMAL] = def->bg[GTK_STATE_NORMAL]; + style->base[GTK_STATE_NORMAL] = def->base[GTK_STATE_NORMAL]; + style->bg[GTK_STATE_PRELIGHT] = def->bg[GTK_STATE_PRELIGHT]; + style->base[GTK_STATE_PRELIGHT] = def->base[GTK_STATE_PRELIGHT]; + style->bg[GTK_STATE_ACTIVE] = def->bg[GTK_STATE_ACTIVE]; + style->base[GTK_STATE_ACTIVE] = def->base[GTK_STATE_ACTIVE]; + style->bg[GTK_STATE_INSENSITIVE] = def->bg[GTK_STATE_INSENSITIVE]; + style->base[GTK_STATE_INSENSITIVE] = def->base[GTK_STATE_INSENSITIVE]; + } + } } -void wxWindow::ReleaseMouse() +void wxWindowGTK::ApplyWidgetStyle() { - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); +} - wxASSERT_MSG( (g_capturing == TRUE), "ReleaseMouse called twice" ); +//----------------------------------------------------------------------------- +// Pop-up menu stuff +//----------------------------------------------------------------------------- - GtkWidget *connect_widget = GetConnectWidget(); - gtk_grab_remove( connect_widget ); - gdk_pointer_ungrab ( GDK_CURRENT_TIME ); - g_capturing = FALSE; -} +#if wxUSE_MENUS_NATIVE -void wxWindow::SetTitle( const wxString &WXUNUSED(title) ) +static void gtk_pop_hide_callback( GtkWidget *WXUNUSED(widget), bool* is_waiting ) { + *is_waiting = FALSE; } -wxString wxWindow::GetTitle() const +static void SetInvokingWindow( wxMenu *menu, wxWindowGTK *win ) { - return (wxString&)m_windowName; -} + menu->SetInvokingWindow( win ); + wxMenuItemList::Node *node = menu->GetMenuItems().GetFirst(); + while (node) + { + wxMenuItem *menuitem = node->GetData(); + if (menuitem->IsSubMenu()) + { + SetInvokingWindow( menuitem->GetSubMenu(), win ); + } -wxString wxWindow::GetLabel() const -{ - return GetTitle(); + node = node->GetNext(); + } } -void wxWindow::SetName( const wxString &name ) -{ - m_windowName = name; -} +// used to pass the coordinates from wxWindowGTK::DoPopupMenu() to +// wxPopupMenuPositionCallback() +// +// should be safe even in the MT case as the user can hardly popup 2 menus +// simultaneously, can he? +static gint gs_pop_x = 0; +static gint gs_pop_y = 0; -wxString wxWindow::GetName() const +static void wxPopupMenuPositionCallback( GtkMenu *menu, + gint *x, gint *y, + gpointer WXUNUSED(user_data) ) { - return (wxString&)m_windowName; -} + // ensure that the menu appears entirely on screen + GtkRequisition req; + gtk_widget_get_child_requisition(GTK_WIDGET(menu), &req); -bool wxWindow::IsShown() const -{ - return m_isShown; -} + wxSize sizeScreen = wxGetDisplaySize(); -bool wxWindow::IsRetained() -{ - return FALSE; -} + gint xmax = sizeScreen.x - req.width, + ymax = sizeScreen.y - req.height; -wxWindow *wxWindow::FindWindow( long id ) -{ - if (id == m_windowId) return this; - wxNode *node = m_children.First(); - while (node) - { - wxWindow *child = (wxWindow*)node->Data(); - wxWindow *res = child->FindWindow( id ); - if (res) return res; - node = node->Next(); - } - return (wxWindow *) NULL; + *x = gs_pop_x < xmax ? gs_pop_x : xmax; + *y = gs_pop_y < ymax ? gs_pop_y : ymax; } -wxWindow *wxWindow::FindWindow( const wxString& name ) +bool wxWindowGTK::DoPopupMenu( wxMenu *menu, int x, int y ) { - if (name == m_windowName) return this; - wxNode *node = m_children.First(); - while (node) - { - wxWindow *child = (wxWindow*)node->Data(); - wxWindow *res = child->FindWindow( name ); - if (res) return res; - node = node->Next(); - } - return (wxWindow *) NULL; -} + wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") ); -void wxWindow::SetScrollbar( int orient, int pos, int thumbVisible, - int range, bool refresh ) -{ - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); + wxCHECK_MSG( menu != NULL, FALSE, wxT("invalid popup-menu") ); - wxASSERT_MSG( (m_wxwindow != NULL), "window needs client area" ); + SetInvokingWindow( menu, this ); - if (!m_wxwindow) return; + menu->UpdateUI(); - if (orient == wxHORIZONTAL) - { - float fpos = (float)pos; - float frange = (float)range; - float fthumb = (float)thumbVisible; + gs_pop_x = x; + gs_pop_y = y; + ClientToScreen( &gs_pop_x, &gs_pop_y ); - if ((fabs(frange-m_hAdjust->upper) < 0.2) && - (fabs(fthumb-m_hAdjust->page_size) < 0.2)) - { - SetScrollPos( orient, pos, refresh ); - return; - } + bool is_waiting = TRUE; - m_oldHorizontalPos = fpos; + gtk_signal_connect( GTK_OBJECT(menu->m_menu), "hide", + GTK_SIGNAL_FUNC(gtk_pop_hide_callback), (gpointer)&is_waiting ); - m_hAdjust->lower = 0.0; - m_hAdjust->upper = frange; - m_hAdjust->value = fpos; - m_hAdjust->step_increment = 1.0; - m_hAdjust->page_increment = (float)(wxMax(fthumb,0)); - m_hAdjust->page_size = fthumb; - } - else - { - float fpos = (float)pos; - float frange = (float)range; - float fthumb = (float)thumbVisible; + gtk_menu_popup( + GTK_MENU(menu->m_menu), + (GtkWidget *) NULL, // parent menu shell + (GtkWidget *) NULL, // parent menu item + wxPopupMenuPositionCallback, // function to position it + NULL, // client data + 0, // button used to activate it + gs_timeLastClick // the time of activation + ); - if ((fabs(frange-m_vAdjust->upper) < 0.2) && - (fabs(fthumb-m_vAdjust->page_size) < 0.2)) + while (is_waiting) { - SetScrollPos( orient, pos, refresh ); - return; + while (gtk_events_pending()) + gtk_main_iteration(); } - m_oldVerticalPos = fpos; - - m_vAdjust->lower = 0.0; - m_vAdjust->upper = frange; - m_vAdjust->value = fpos; - m_vAdjust->step_increment = 1.0; - m_vAdjust->page_increment = (float)(wxMax(fthumb,0)); - m_vAdjust->page_size = fthumb; - } + return TRUE; +} - if (m_wxwindow->window) - { - if (orient == wxHORIZONTAL) - gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" ); - else - gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" ); +#endif // wxUSE_MENUS_NATIVE - gtk_widget_set_usize( m_widget, m_width, m_height ); - } -} +#if wxUSE_DRAG_AND_DROP -void wxWindow::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) ) +void wxWindowGTK::SetDropTarget( wxDropTarget *dropTarget ) { - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); + wxCHECK_RET( m_widget != NULL, wxT("invalid window") ); - wxASSERT_MSG( (m_wxwindow != NULL), "window needs client area" ); + GtkWidget *dnd_widget = GetConnectWidget(); - if (!m_wxwindow) return; + if (m_dropTarget) m_dropTarget->UnregisterWidget( dnd_widget ); - if (orient == wxHORIZONTAL) - { - float fpos = (float)pos; - m_oldHorizontalPos = fpos; - - if (fabs(fpos-m_hAdjust->value) < 0.2) return; - m_hAdjust->value = fpos; - } - else - { - float fpos = (float)pos; - m_oldVerticalPos = fpos; - if (fabs(fpos-m_vAdjust->value) < 0.2) return; - m_vAdjust->value = fpos; - } + if (m_dropTarget) delete m_dropTarget; + m_dropTarget = dropTarget; - if (!m_isScrolling) - { - if (m_wxwindow->window) - { - if (orient == wxHORIZONTAL) - gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "value_changed" ); - else - gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "value_changed" ); - } - } + if (m_dropTarget) m_dropTarget->RegisterWidget( dnd_widget ); } -int wxWindow::GetScrollThumb( int orient ) const -{ - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); - - wxASSERT_MSG( (m_wxwindow != NULL), "window needs client area" ); - - if (!m_wxwindow) return 0; - - if (orient == wxHORIZONTAL) - return (int)(m_hAdjust->page_size+0.5); - else - return (int)(m_vAdjust->page_size+0.5); -} +#endif // wxUSE_DRAG_AND_DROP -int wxWindow::GetScrollPos( int orient ) const +GtkWidget* wxWindowGTK::GetConnectWidget() { - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); + GtkWidget *connect_widget = m_widget; + if (m_wxwindow) connect_widget = m_wxwindow; - wxASSERT_MSG( (m_wxwindow != NULL), "window needs client area" ); - - if (!m_wxwindow) return 0; - - if (orient == wxHORIZONTAL) - return (int)(m_hAdjust->value+0.5); - else - return (int)(m_vAdjust->value+0.5); + return connect_widget; } -int wxWindow::GetScrollRange( int orient ) const +bool wxWindowGTK::IsOwnGtkWindow( GdkWindow *window ) { - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); - - wxASSERT_MSG( (m_wxwindow != NULL), "window needs client area" ); - - if (!m_wxwindow) return 0; + if (m_wxwindow) + return (window == GTK_PIZZA(m_wxwindow)->bin_window); - if (orient == wxHORIZONTAL) - return (int)(m_hAdjust->upper+0.5); - else - return (int)(m_vAdjust->upper+0.5); + return (window == m_widget->window); } -void wxWindow::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) ) +bool wxWindowGTK::SetFont( const wxFont &font ) { - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); - - wxASSERT_MSG( (m_wxwindow != NULL), "window needs client area" ); + wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") ); - if (!m_wxwindow) return; - - int cw = 0; - int ch = 0; - GetClientSize( &cw, &ch ); + if (!wxWindowBase::SetFont(font)) + { + return FALSE; + } - int w = cw - abs(dx); - int h = ch - abs(dy); - if ((h < 0) || (w < 0)) + wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE ); + if ( sysbg == m_backgroundColour ) { - Refresh(); - return; + m_backgroundColour = wxNullColour; + ApplyWidgetStyle(); + m_backgroundColour = sysbg; } - int s_x = 0; - int s_y = 0; - if (dx < 0) s_x = -dx; - if (dy < 0) s_y = -dy; - int d_x = 0; - int d_y = 0; - if (dx > 0) d_x = dx; - if (dy > 0) d_y = dy; - - if (!m_scrollGC) + else { - m_scrollGC = gdk_gc_new( m_wxwindow->window ); - gdk_gc_set_exposures( m_scrollGC, TRUE ); + ApplyWidgetStyle(); } - - gdk_window_copy_area( m_wxwindow->window, m_scrollGC, d_x, d_y, - m_wxwindow->window, s_x, s_y, w, h ); - wxRect rect; - if (dx < 0) rect.x = cw+dx; else rect.x = 0; - if (dy < 0) rect.y = ch+dy; else rect.y = 0; - if (dy != 0) rect.width = cw; else rect.width = abs(dx); - if (dx != 0) rect.height = ch; else rect.height = abs(dy); - - Refresh( TRUE, &rect ); + return TRUE; } -//------------------------------------------------------------------------------------- -// Layout -//------------------------------------------------------------------------------------- - -wxLayoutConstraints *wxWindow::GetConstraints() const +void wxWindowGTK::CaptureMouse() { - return m_constraints; -} + wxCHECK_RET( m_widget != NULL, wxT("invalid window") ); -void wxWindow::SetConstraints( wxLayoutConstraints *constraints ) -{ - if (m_constraints) - { - UnsetConstraints(m_constraints); - delete m_constraints; - } - m_constraints = constraints; - if (m_constraints) - { - // Make sure other windows know they're part of a 'meaningful relationship' - if (m_constraints->left.GetOtherWindow() && (m_constraints->left.GetOtherWindow() != this)) - m_constraints->left.GetOtherWindow()->AddConstraintReference((wxWindow *)this); - if (m_constraints->top.GetOtherWindow() && (m_constraints->top.GetOtherWindow() != this)) - m_constraints->top.GetOtherWindow()->AddConstraintReference((wxWindow *)this); - if (m_constraints->right.GetOtherWindow() && (m_constraints->right.GetOtherWindow() != this)) - m_constraints->right.GetOtherWindow()->AddConstraintReference((wxWindow *)this); - if (m_constraints->bottom.GetOtherWindow() && (m_constraints->bottom.GetOtherWindow() != this)) - m_constraints->bottom.GetOtherWindow()->AddConstraintReference((wxWindow *)this); - if (m_constraints->width.GetOtherWindow() && (m_constraints->width.GetOtherWindow() != this)) - m_constraints->width.GetOtherWindow()->AddConstraintReference((wxWindow *)this); - if (m_constraints->height.GetOtherWindow() && (m_constraints->height.GetOtherWindow() != this)) - m_constraints->height.GetOtherWindow()->AddConstraintReference((wxWindow *)this); - if (m_constraints->centreX.GetOtherWindow() && (m_constraints->centreX.GetOtherWindow() != this)) - m_constraints->centreX.GetOtherWindow()->AddConstraintReference((wxWindow *)this); - if (m_constraints->centreY.GetOtherWindow() && (m_constraints->centreY.GetOtherWindow() != this)) - m_constraints->centreY.GetOtherWindow()->AddConstraintReference((wxWindow *)this); - } -; -} -; + GdkWindow *window = (GdkWindow*) NULL; + if (m_wxwindow) + window = GTK_PIZZA(m_wxwindow)->bin_window; + else + window = GetConnectWidget()->window; -void wxWindow::SetAutoLayout( bool autoLayout ) -{ - m_autoLayout = autoLayout; -} + wxCHECK_RET( window, _T("CaptureMouse() failed") ); -bool wxWindow::GetAutoLayout() const -{ - return m_autoLayout; -} + wxCursor* cursor = & m_cursor; + if (!cursor->Ok()) + cursor = wxSTANDARD_CURSOR; -wxSizer *wxWindow::GetSizer() const -{ - return m_windowSizer; + gdk_pointer_grab( window, FALSE, + (GdkEventMask) + (GDK_BUTTON_PRESS_MASK | + GDK_BUTTON_RELEASE_MASK | + GDK_POINTER_MOTION_HINT_MASK | + GDK_POINTER_MOTION_MASK), + (GdkWindow *) NULL, + cursor->GetCursor(), + (guint32)GDK_CURRENT_TIME ); + g_captureWindow = this; + g_captureWindowHasMouse = TRUE; } -void wxWindow::SetSizerParent( wxWindow *win ) +void wxWindowGTK::ReleaseMouse() { - m_sizerParent = win; -} + wxCHECK_RET( m_widget != NULL, wxT("invalid window") ); -wxWindow *wxWindow::GetSizerParent() const -{ - return m_sizerParent; -} + wxCHECK_RET( g_captureWindow, wxT("can't release mouse - not captured") ); -// This removes any dangling pointers to this window -// in other windows' constraintsInvolvedIn lists. -void wxWindow::UnsetConstraints(wxLayoutConstraints *c) -{ - if (c) - { - if (c->left.GetOtherWindow() && (c->top.GetOtherWindow() != this)) - c->left.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this); - if (c->top.GetOtherWindow() && (c->top.GetOtherWindow() != this)) - c->top.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this); - if (c->right.GetOtherWindow() && (c->right.GetOtherWindow() != this)) - c->right.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this); - if (c->bottom.GetOtherWindow() && (c->bottom.GetOtherWindow() != this)) - c->bottom.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this); - if (c->width.GetOtherWindow() && (c->width.GetOtherWindow() != this)) - c->width.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this); - if (c->height.GetOtherWindow() && (c->height.GetOtherWindow() != this)) - c->height.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this); - if (c->centreX.GetOtherWindow() && (c->centreX.GetOtherWindow() != this)) - c->centreX.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this); - if (c->centreY.GetOtherWindow() && (c->centreY.GetOtherWindow() != this)) - c->centreY.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this); - } -} + GdkWindow *window = (GdkWindow*) NULL; + if (m_wxwindow) + window = GTK_PIZZA(m_wxwindow)->bin_window; + else + window = GetConnectWidget()->window; -// Back-pointer to other windows we're involved with, so if we delete -// this window, we must delete any constraints we're involved with. -void wxWindow::AddConstraintReference(wxWindow *otherWin) -{ - if (!m_constraintsInvolvedIn) - m_constraintsInvolvedIn = new wxList; - if (!m_constraintsInvolvedIn->Member(otherWin)) - m_constraintsInvolvedIn->Append(otherWin); -} + if (!window) + return; -// REMOVE back-pointer to other windows we're involved with. -void wxWindow::RemoveConstraintReference(wxWindow *otherWin) -{ - if (m_constraintsInvolvedIn) - m_constraintsInvolvedIn->DeleteObject(otherWin); + gdk_pointer_ungrab ( (guint32)GDK_CURRENT_TIME ); + g_captureWindow = (wxWindowGTK*) NULL; } -// Reset any constraints that mention this window -void wxWindow::DeleteRelatedConstraints() +/* static */ +wxWindow *wxWindowBase::GetCapture() { - if (m_constraintsInvolvedIn) - { - wxNode *node = m_constraintsInvolvedIn->First(); - while (node) - { - wxWindow *win = (wxWindow *)node->Data(); - wxNode *next = node->Next(); - wxLayoutConstraints *constr = win->GetConstraints(); - - // Reset any constraints involving this window - if (constr) - { - constr->left.ResetIfWin((wxWindow *)this); - constr->top.ResetIfWin((wxWindow *)this); - constr->right.ResetIfWin((wxWindow *)this); - constr->bottom.ResetIfWin((wxWindow *)this); - constr->width.ResetIfWin((wxWindow *)this); - constr->height.ResetIfWin((wxWindow *)this); - constr->centreX.ResetIfWin((wxWindow *)this); - constr->centreY.ResetIfWin((wxWindow *)this); - } - delete node; - node = next; - } - delete m_constraintsInvolvedIn; - m_constraintsInvolvedIn = (wxList *) NULL; - } + return (wxWindow *)g_captureWindow; } -void wxWindow::SetSizer(wxSizer *sizer) +bool wxWindowGTK::IsRetained() const { - m_windowSizer = sizer; - if (sizer) - sizer->SetSizerParent((wxWindow *)this); + return FALSE; } -/* - * New version - */ - -bool wxWindow::Layout() +void wxWindowGTK::SetScrollbar( int orient, int pos, int thumbVisible, + int range, bool refresh ) { - if (GetConstraints()) - { - int w, h; - GetClientSize(&w, &h); - GetConstraints()->width.SetValue(w); - GetConstraints()->height.SetValue(h); - } - - // If top level (one sizer), evaluate the sizer's constraints. - if (GetSizer()) - { - int noChanges; - GetSizer()->ResetConstraints(); // Mark all constraints as unevaluated - GetSizer()->LayoutPhase1(&noChanges); - GetSizer()->LayoutPhase2(&noChanges); - GetSizer()->SetConstraintSizes(); // Recursively set the real window sizes - return TRUE; - } - else - { - // Otherwise, evaluate child constraints - ResetConstraints(); // Mark all constraints as unevaluated - DoPhase(1); // Just one phase need if no sizers involved - DoPhase(2); - SetConstraintSizes(); // Recursively set the real window sizes - } - return TRUE; -} + wxCHECK_RET( m_widget != NULL, wxT("invalid window") ); + wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") ); -// Do a phase of evaluating constraints: -// the default behaviour. wxSizers may do a similar -// thing, but also impose their own 'constraints' -// and order the evaluation differently. -bool wxWindow::LayoutPhase1(int *noChanges) -{ - wxLayoutConstraints *constr = GetConstraints(); - if (constr) - { - return constr->SatisfyConstraints((wxWindow *)this, noChanges); - } - else - return TRUE; -} + m_hasScrolling = TRUE; -bool wxWindow::LayoutPhase2(int *noChanges) -{ - *noChanges = 0; + if (orient == wxHORIZONTAL) + { + float fpos = (float)pos; + float frange = (float)range; + float fthumb = (float)thumbVisible; + if (fpos > frange-fthumb) fpos = frange-fthumb; + if (fpos < 0.0) fpos = 0.0; + + if ((fabs(frange-m_hAdjust->upper) < 0.2) && + (fabs(fthumb-m_hAdjust->page_size) < 0.2)) + { + SetScrollPos( orient, pos, refresh ); + return; + } - // Layout children - DoPhase(1); - DoPhase(2); - return TRUE; -} + m_oldHorizontalPos = fpos; -// Do a phase of evaluating child constraints -bool wxWindow::DoPhase(int phase) -{ - int noIterations = 0; - int maxIterations = 500; - int noChanges = 1; - int noFailures = 0; - wxList succeeded; - while ((noChanges > 0) && (noIterations < maxIterations)) - { - noChanges = 0; - noFailures = 0; - wxNode *node = GetChildren()->First(); - while (node) + m_hAdjust->lower = 0.0; + m_hAdjust->upper = frange; + m_hAdjust->value = fpos; + m_hAdjust->step_increment = 1.0; + m_hAdjust->page_increment = (float)(wxMax(fthumb,0)); + m_hAdjust->page_size = fthumb; + } + else { - wxWindow *child = (wxWindow *)node->Data(); - if (!child->IsKindOf(CLASSINFO(wxFrame)) && !child->IsKindOf(CLASSINFO(wxDialog))) - { - wxLayoutConstraints *constr = child->GetConstraints(); - if (constr) + float fpos = (float)pos; + float frange = (float)range; + float fthumb = (float)thumbVisible; + if (fpos > frange-fthumb) fpos = frange-fthumb; + if (fpos < 0.0) fpos = 0.0; + + if ((fabs(frange-m_vAdjust->upper) < 0.2) && + (fabs(fthumb-m_vAdjust->page_size) < 0.2)) { - if (succeeded.Member(child)) - { - } - else - { - int tempNoChanges = 0; - bool success = ( (phase == 1) ? child->LayoutPhase1(&tempNoChanges) : child->LayoutPhase2(&tempNoChanges) ) ; - noChanges += tempNoChanges; - if (success) - { - succeeded.Append(child); - } - } + SetScrollPos( orient, pos, refresh ); + return; } - } - node = node->Next(); + + m_oldVerticalPos = fpos; + + m_vAdjust->lower = 0.0; + m_vAdjust->upper = frange; + m_vAdjust->value = fpos; + m_vAdjust->step_increment = 1.0; + m_vAdjust->page_increment = (float)(wxMax(fthumb,0)); + m_vAdjust->page_size = fthumb; } - noIterations ++; - } - return TRUE; -} -void wxWindow::ResetConstraints() -{ - wxLayoutConstraints *constr = GetConstraints(); - if (constr) - { - constr->left.SetDone(FALSE); - constr->top.SetDone(FALSE); - constr->right.SetDone(FALSE); - constr->bottom.SetDone(FALSE); - constr->width.SetDone(FALSE); - constr->height.SetDone(FALSE); - constr->centreX.SetDone(FALSE); - constr->centreY.SetDone(FALSE); - } - wxNode *node = GetChildren()->First(); - while (node) - { - wxWindow *win = (wxWindow *)node->Data(); - if (!win->IsKindOf(CLASSINFO(wxFrame)) && !win->IsKindOf(CLASSINFO(wxDialog))) - win->ResetConstraints(); - node = node->Next(); - } + if (orient == wxHORIZONTAL) + gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" ); + else + gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" ); } -// Need to distinguish between setting the 'fake' size for -// windows and sizers, and setting the real values. -void wxWindow::SetConstraintSizes(bool recurse) +void wxWindowGTK::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) ) { - wxLayoutConstraints *constr = GetConstraints(); - if (constr && constr->left.GetDone() && constr->right.GetDone() && - constr->width.GetDone() && constr->height.GetDone()) - { - int x = constr->left.GetValue(); - int y = constr->top.GetValue(); - int w = constr->width.GetValue(); - int h = constr->height.GetValue(); + wxCHECK_RET( m_widget != NULL, wxT("invalid window") ); - // If we don't want to resize this window, just move it... - if ((constr->width.GetRelationship() != wxAsIs) || - (constr->height.GetRelationship() != wxAsIs)) + wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") ); + + if (orient == wxHORIZONTAL) { - // Calls Layout() recursively. AAAGH. How can we stop that. - // Simply take Layout() out of non-top level OnSizes. - SizerSetSize(x, y, w, h); + float fpos = (float)pos; + if (fpos > m_hAdjust->upper - m_hAdjust->page_size) fpos = m_hAdjust->upper - m_hAdjust->page_size; + if (fpos < 0.0) fpos = 0.0; + m_oldHorizontalPos = fpos; + + if (fabs(fpos-m_hAdjust->value) < 0.2) return; + m_hAdjust->value = fpos; } else { - SizerMove(x, y); + float fpos = (float)pos; + if (fpos > m_vAdjust->upper - m_vAdjust->page_size) fpos = m_vAdjust->upper - m_vAdjust->page_size; + if (fpos < 0.0) fpos = 0.0; + m_oldVerticalPos = fpos; + + if (fabs(fpos-m_vAdjust->value) < 0.2) return; + m_vAdjust->value = fpos; } - } - else if (constr) - { - char *windowClass = this->GetClassInfo()->GetClassName(); - - wxString winName; - if (GetName() == "") - winName = _("unnamed"); - else - winName = GetName(); - wxDebugMsg(_("Constraint(s) not satisfied for window of type %s, name %s:\n"), (const char *)windowClass, (const char *)winName); - if (!constr->left.GetDone()) - wxDebugMsg(_(" unsatisfied 'left' constraint.\n")); - if (!constr->right.GetDone()) - wxDebugMsg(_(" unsatisfied 'right' constraint.\n")); - if (!constr->width.GetDone()) - wxDebugMsg(_(" unsatisfied 'width' constraint.\n")); - if (!constr->height.GetDone()) - wxDebugMsg(_(" unsatisfied 'height' constraint.\n")); - wxDebugMsg(_("Please check constraints: try adding AsIs() constraints.\n")); - } - if (recurse) - { - wxNode *node = GetChildren()->First(); - while (node) + if (m_wxwindow->window) { - wxWindow *win = (wxWindow *)node->Data(); - if (!win->IsKindOf(CLASSINFO(wxFrame)) && !win->IsKindOf(CLASSINFO(wxDialog))) - win->SetConstraintSizes(); - node = node->Next(); + if (orient == wxHORIZONTAL) + { + gtk_signal_disconnect_by_func( GTK_OBJECT(m_hAdjust), + (GtkSignalFunc) gtk_window_hscroll_callback, (gpointer) this ); + + gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "value_changed" ); + + gtk_signal_connect( GTK_OBJECT(m_hAdjust), "value_changed", + (GtkSignalFunc) gtk_window_hscroll_callback, (gpointer) this ); + } + else + { + gtk_signal_disconnect_by_func( GTK_OBJECT(m_vAdjust), + (GtkSignalFunc) gtk_window_vscroll_callback, (gpointer) this ); + + gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "value_changed" ); + + gtk_signal_connect( GTK_OBJECT(m_vAdjust), "value_changed", + (GtkSignalFunc) gtk_window_vscroll_callback, (gpointer) this ); + } } - } } -// This assumes that all sizers are 'on' the same -// window, i.e. the parent of this window. -void wxWindow::TransformSizerToActual(int *x, int *y) const +int wxWindowGTK::GetScrollThumb( int orient ) const { - if (!m_sizerParent || m_sizerParent->IsKindOf(CLASSINFO(wxDialog)) || - m_sizerParent->IsKindOf(CLASSINFO(wxFrame)) ) - return; + wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") ); - int xp, yp; - m_sizerParent->GetPosition(&xp, &yp); - m_sizerParent->TransformSizerToActual(&xp, &yp); - *x += xp; - *y += yp; -} + wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") ); -void wxWindow::SizerSetSize(int x, int y, int w, int h) -{ - int xx = x; - int yy = y; - TransformSizerToActual(&xx, &yy); - SetSize(xx, yy, w, h); + if (orient == wxHORIZONTAL) + return (int)(m_hAdjust->page_size+0.5); + else + return (int)(m_vAdjust->page_size+0.5); } -void wxWindow::SizerMove(int x, int y) +int wxWindowGTK::GetScrollPos( int orient ) const { - int xx = x; - int yy = y; - TransformSizerToActual(&xx, &yy); - Move(xx, yy); + wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") ); + + wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") ); + + if (orient == wxHORIZONTAL) + return (int)(m_hAdjust->value+0.5); + else + return (int)(m_vAdjust->value+0.5); } -// Only set the size/position of the constraint (if any) -void wxWindow::SetSizeConstraint(int x, int y, int w, int h) +int wxWindowGTK::GetScrollRange( int orient ) const { - wxLayoutConstraints *constr = GetConstraints(); - if (constr) - { - if (x != -1) - { - constr->left.SetValue(x); - constr->left.SetDone(TRUE); - } - if (y != -1) - { - constr->top.SetValue(y); - constr->top.SetDone(TRUE); - } - if (w != -1) - { - constr->width.SetValue(w); - constr->width.SetDone(TRUE); - } - if (h != -1) - { - constr->height.SetValue(h); - constr->height.SetDone(TRUE); - } - } + wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") ); + + wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") ); + + if (orient == wxHORIZONTAL) + return (int)(m_hAdjust->upper+0.5); + else + return (int)(m_vAdjust->upper+0.5); } -void wxWindow::MoveConstraint(int x, int y) +void wxWindowGTK::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) ) { - wxLayoutConstraints *constr = GetConstraints(); - if (constr) - { - if (x != -1) + wxCHECK_RET( m_widget != NULL, wxT("invalid window") ); + + wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") ); + + if ((dx == 0) && (dy == 0)) return; + + m_clipPaintRegion = TRUE; + gtk_pizza_scroll( GTK_PIZZA(m_wxwindow), -dx, -dy ); + m_clipPaintRegion = FALSE; + +/* + if (m_children.GetCount() > 0) { - constr->left.SetValue(x); - constr->left.SetDone(TRUE); + gtk_pizza_scroll( GTK_PIZZA(m_wxwindow), -dx, -dy ); } - if (y != -1) + else { - constr->top.SetValue(y); - constr->top.SetDone(TRUE); + GtkPizza *pizza = GTK_PIZZA(m_wxwindow); + + pizza->xoffset -= dx; + pizza->yoffset -= dy; + + GdkGC *m_scrollGC = gdk_gc_new( pizza->bin_window ); + gdk_gc_set_exposures( m_scrollGC, TRUE ); + + int cw = 0; + int ch = 0; + GetClientSize( &cw, &ch ); + int w = cw - abs(dx); + int h = ch - abs(dy); + + if ((h < 0) || (w < 0)) + { + Refresh(); + } + else + { + int s_x = 0; + int s_y = 0; + if (dx < 0) s_x = -dx; + if (dy < 0) s_y = -dy; + int d_x = 0; + int d_y = 0; + if (dx > 0) d_x = dx; + if (dy > 0) d_y = dy; + + gdk_window_copy_area( pizza->bin_window, m_scrollGC, d_x, d_y, + pizza->bin_window, s_x, s_y, w, h ); + + wxRect rect; + if (dx < 0) rect.x = cw+dx; else rect.x = 0; + if (dy < 0) rect.y = ch+dy; else rect.y = 0; + if (dy != 0) rect.width = cw; else rect.width = abs(dx); + if (dx != 0) rect.height = ch; else rect.height = abs(dy); + + Refresh( TRUE, &rect ); + } + + gdk_gc_unref( m_scrollGC ); } - } +*/ } -void wxWindow::GetSizeConstraint(int *w, int *h) const +// Find the wxWindow at the current mouse position, also returning the mouse +// position. +wxWindow* wxFindWindowAtPointer(wxPoint& pt) { - wxLayoutConstraints *constr = GetConstraints(); - if (constr) - { - *w = constr->width.GetValue(); - *h = constr->height.GetValue(); - } - else - GetSize(w, h); + pt = wxGetMousePosition(); + wxWindow* found = wxFindWindowAtPoint(pt); + return found; } -void wxWindow::GetClientSizeConstraint(int *w, int *h) const +// Get the current mouse position. +wxPoint wxGetMousePosition() { - wxLayoutConstraints *constr = GetConstraints(); - if (constr) - { - *w = constr->width.GetValue(); - *h = constr->height.GetValue(); - } - else - GetClientSize(w, h); -} + /* This crashes when used within wxHelpContext, + so we have to use the X-specific implementation below. + gint x, y; + GdkModifierType *mask; + (void) gdk_window_get_pointer(NULL, &x, &y, mask); -void wxWindow::GetPositionConstraint(int *x, int *y) const -{ - wxLayoutConstraints *constr = GetConstraints(); - if (constr) - { - *x = constr->left.GetValue(); - *y = constr->top.GetValue(); - } - else - GetPosition(x, y); -} + return wxPoint(x, y); + */ -bool wxWindow::AcceptsFocus() const -{ - return IsEnabled() && IsShown(); -} + int x, y; + GdkWindow* windowAtPtr = gdk_window_at_pointer(& x, & y); + if (!windowAtPtr) + return wxPoint(-999, -999); + + Display *display = GDK_WINDOW_XDISPLAY(windowAtPtr); + Window rootWindow = RootWindowOfScreen (DefaultScreenOfDisplay(display)); + Window rootReturn, childReturn; + int rootX, rootY, winX, winY; + unsigned int maskReturn; + + XQueryPointer (display, + rootWindow, + &rootReturn, + &childReturn, + &rootX, &rootY, &winX, &winY, &maskReturn); + return wxPoint(rootX, rootY); -void wxWindow::OnIdle(wxIdleEvent& WXUNUSED(event) ) -{ - UpdateWindowUI(); } +