#include "wx/fontutil.h"
#include "wx/sysopt.h"
-#ifdef __WXDEBUG__
- #include "wx/thread.h"
-#endif
-
#include <ctype.h>
#include "wx/gtk/private.h"
GdkEvent *g_lastMouseEvent = (GdkEvent*) NULL;
int g_lastButtonNumber = 0;
-extern bool g_mainThreadLocked;
-
//-----------------------------------------------------------------------------
// debug
//-----------------------------------------------------------------------------
-#ifdef __WXDEBUG__
-
-#if wxUSE_THREADS
-# define DEBUG_MAIN_THREAD if (wxThread::IsMain() && g_mainThreadLocked) printf("gui reentrance");
-#else
-# define DEBUG_MAIN_THREAD
-#endif
-#else
-#define DEBUG_MAIN_THREAD
-#endif // Debug
-
// the trace mask used for the focus debugging messages
#define TRACE_FOCUS _T("focus")
return (wxWindow *)NULL;
}
-static void GetScrollbarWidth(GtkWidget* widget, int& w, int& h)
-{
- GtkScrolledWindow* scroll_window = GTK_SCROLLED_WINDOW(widget);
- GtkScrolledWindowClass* scroll_class = GTK_SCROLLED_WINDOW_CLASS(GTK_OBJECT_GET_CLASS(scroll_window));
- GtkRequisition scroll_req;
-
- w = 0;
- if (scroll_window->vscrollbar_visible)
- {
- scroll_req.width = 2;
- scroll_req.height = 2;
- (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->vscrollbar) )->size_request )
- (scroll_window->vscrollbar, &scroll_req );
- w = scroll_req.width +
- scroll_class->scrollbar_spacing;
- }
-
- h = 0;
- if (scroll_window->hscrollbar_visible)
- {
- scroll_req.width = 2;
- scroll_req.height = 2;
- (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->hscrollbar) )->size_request )
- (scroll_window->hscrollbar, &scroll_req );
- h = scroll_req.height +
- scroll_class->scrollbar_spacing;
- }
-}
-
//-----------------------------------------------------------------------------
// "size_request" of m_widget
//-----------------------------------------------------------------------------
extern "C" {
static gboolean
-gtk_window_expose_callback( GtkWidget *widget,
+gtk_window_expose_callback( GtkWidget*,
GdkEventExpose *gdk_event,
wxWindow *win )
{
- DEBUG_MAIN_THREAD
-
- wxPizza *pizza = WX_PIZZA(widget);
- GdkWindow *backing_window = pizza->m_backing_window;
-
- int w = widget->allocation.width;
- int h = widget->allocation.height;
-
- // if this event is for the border-only GdkWindow
- if (backing_window && gdk_event->window == pizza->m_backing_window)
- {
- if (win->HasFlag(wxBORDER_SIMPLE))
- {
- GdkGC* gc = gdk_gc_new(gdk_event->window);
- gdk_gc_set_foreground(gc, &widget->style->black);
- gdk_draw_rectangle(gdk_event->window, gc, false, 0, 0, w - 1, h - 1);
- g_object_unref(gc);
- }
- else
- {
- GtkShadowType shadow = GTK_SHADOW_IN;
- if (win->HasFlag(wxBORDER_RAISED))
- shadow = GTK_SHADOW_OUT;
- gtk_paint_shadow(
- widget->style, gdk_event->window, GTK_STATE_NORMAL,
- shadow, NULL, widget, "viewport", 0, 0, w, h);
- }
-
- return TRUE;
- }
-
#if 0
if (win->GetName())
{
// "expose_event" from m_widget, for drawing border
//-----------------------------------------------------------------------------
-#if 0
-ndef __WXUNIVERSAL__
+#ifndef __WXUNIVERSAL__
+
+GtkWidget* GetEntryWidget();
+
extern "C" {
static gboolean
-expose_event_border(GtkWidget* widget, GdkEventExpose* event, wxWindow* win)
+expose_event_border(GtkWidget* widget, GdkEventExpose* gdk_event, wxWindow* win)
{
// if this event is not for the GdkWindow the border is drawn on
- if (win->m_wxwindow == win->m_widget && event->window == widget->window)
+ if (win->m_wxwindow == win->m_widget && gdk_event->window == widget->window)
return false;
int x = 0;
int h = win->m_wxwindow->allocation.height;
if (win->HasFlag(wxBORDER_SIMPLE))
{
- GdkGC* gc;
- gc = gdk_gc_new(event->window);
+ GdkGC* gc = gdk_gc_new(gdk_event->window);
gdk_gc_set_foreground(gc, &widget->style->black);
- gdk_draw_rectangle(event->window, gc, false, x, y, w - 1, h - 1);
+ gdk_draw_rectangle(gdk_event->window, gc, false, x, y, w - 1, h - 1);
g_object_unref(gc);
}
else
GtkShadowType shadow = GTK_SHADOW_IN;
if (win->HasFlag(wxBORDER_RAISED))
shadow = GTK_SHADOW_OUT;
+
+ // Style detail to use
+ const char* detail;
+ if (widget == win->m_wxwindow)
+ // for non-scrollable wxWindows
+ detail = "entry";
+ else
+ // for scrollable ones
+ detail = "viewport";
+
+ GtkWidget* styleWidget = GetEntryWidget();
gtk_paint_shadow(
- widget->style, event->window, GTK_STATE_NORMAL,
- shadow, &event->area, widget, "entry", x, y, w, h);
+ styleWidget->style, gdk_event->window, GTK_STATE_NORMAL,
+ shadow, NULL, styleWidget, detail, x, y, w, h);
}
// no further painting is needed for border-only GdkWindow
GdkEventKey *gdk_event,
wxWindow *win )
{
- DEBUG_MAIN_THREAD
-
if (!win->m_hasVMT)
return FALSE;
if (g_blockEventsOnDrag)
if( wxTranslateGTKKeyEventToWx(event, win, gdk_event) )
{
// Emit KEY_DOWN event
- ret = win->GetEventHandler()->ProcessEvent( event );
+ ret = win->HandleWindowEvent( event );
}
else
{
if (command != -1)
{
wxCommandEvent command_event( wxEVT_COMMAND_MENU_SELECTED, command );
- ret = ancestor->GetEventHandler()->ProcessEvent( command_event );
+ ret = ancestor->HandleWindowEvent( command_event );
break;
}
if (ancestor->IsTopLevel())
if (parent)
{
event.SetEventType( wxEVT_CHAR_HOOK );
- ret = parent->GetEventHandler()->ProcessEvent( event );
+ ret = parent->HandleWindowEvent( event );
}
if (!ret)
{
event.SetEventType(wxEVT_CHAR);
- ret = win->GetEventHandler()->ProcessEvent( event );
+ ret = win->HandleWindowEvent( event );
}
}
}
if (parent)
{
event.SetEventType( wxEVT_CHAR_HOOK );
- ret = parent->GetEventHandler()->ProcessEvent( event );
+ ret = parent->HandleWindowEvent( event );
}
if (!ret)
{
event.SetEventType(wxEVT_CHAR);
- ret = window->GetEventHandler()->ProcessEvent( event );
+ ret = window->HandleWindowEvent( event );
}
}
}
GdkEventKey *gdk_event,
wxWindowGTK *win )
{
- DEBUG_MAIN_THREAD
-
if (!win->m_hasVMT)
return FALSE;
bool wxWindowGTK::GTKProcessEvent(wxEvent& event) const
{
// nothing special at this level
- return GetEventHandler()->ProcessEvent(event);
+ return HandleWindowEvent(event);
}
int wxWindowGTK::GTKCallbackCommonPrologue(GdkEventAny *event) const
{
- DEBUG_MAIN_THREAD
-
if (!m_hasVMT)
return FALSE;
if (g_blockEventsOnDrag)
// Notify the parent keeping track of focus for the kbd navigation
// purposes that we got it.
wxChildFocusEvent eventChildFocus(win);
- (void)win->GetEventHandler()->ProcessEvent(eventChildFocus);
+ (void)win->HandleWindowEvent(eventChildFocus);
wxFocusEvent eventFocus(wxEVT_SET_FOCUS, win->GetId());
eventFocus.SetEventObject(win);
- return win->GetEventHandler()->ProcessEvent(eventFocus);
+ return win->HandleWindowEvent(eventFocus);
}
// all event handlers must have C linkage as they're called from GTK+ C code
static gboolean
window_scroll_event(GtkWidget*, GdkEventScroll* gdk_event, wxWindow* win)
{
- DEBUG_MAIN_THREAD
-
if (gdk_event->direction != GDK_SCROLL_UP &&
gdk_event->direction != GDK_SCROLL_DOWN)
{
wxMouseEvent event(wxEVT_MOUSEWHEEL);
InitMouseEvent(win, event, gdk_event);
+
+ // FIXME: Get these values from GTK or GDK
event.m_linesPerAction = 3;
event.m_wheelDelta = 120;
if (gdk_event->direction == GDK_SCROLL_UP)
GdkEventFocus *WXUNUSED(event),
wxWindow *win )
{
- DEBUG_MAIN_THREAD
-
if (win->m_imData)
gtk_im_context_focus_in(win->m_imData->context);
GdkEventFocus * WXUNUSED(gdk_event),
wxWindowGTK *win )
{
- DEBUG_MAIN_THREAD
-
if (win->m_imData)
gtk_im_context_focus_out(win->m_imData->context);
static gboolean
gtk_scrollbar_button_press_event(GtkRange*, GdkEventButton*, wxWindow* win)
{
- DEBUG_MAIN_THREAD
-
g_blockEventsOnScroll = true;
win->m_mouseButtonDown = true;
static gboolean
gtk_scrollbar_button_release_event(GtkRange* range, GdkEventButton*, wxWindow* win)
{
- DEBUG_MAIN_THREAD
-
g_blockEventsOnScroll = false;
win->m_mouseButtonDown = false;
// If thumb tracking
static void
gtk_window_realized_callback(GtkWidget* widget, wxWindow* win)
{
- DEBUG_MAIN_THREAD
-
if (win->m_imData)
{
gtk_im_context_set_client_window( win->m_imData->context,
{
wxMouseCaptureLostEvent evt( win->GetId() );
evt.SetEventObject( win );
- win->GetEventHandler()->ProcessEvent( evt );
+ win->HandleWindowEvent( evt );
}
return false;
}
GtkStyle *previous_style,
wxWindow* win )
{
- //wxLogDebug(wxT("gtk_window_style_set_callback"));
if (win && previous_style)
{
- wxString name(win->GetName());
- //wxLogDebug(wxT("gtk_window_style_set_callback %s"), name.c_str());
wxSysColourChangedEvent event;
event.SetEventObject(win);
} // extern "C"
-// Connect/disconnect style-set
-
-void wxConnectStyleSet(wxWindow* win)
-{
- if (win->m_wxwindow)
- g_signal_connect (win->m_wxwindow, "style_set",
- G_CALLBACK (gtk_window_style_set_callback), win);
-}
-
-void wxDisconnectStyleSet(wxWindow* win)
-{
- if (win->m_wxwindow)
- g_signal_handlers_disconnect_by_func (win->m_wxwindow,
- (gpointer) gtk_window_style_set_callback,
- win);
-}
-
// Helper to suspend colour change event event processing while we change a widget's style
class wxSuspendStyleEvents
{
public:
- wxSuspendStyleEvents(wxWindow* win)
- {
- m_win = win;
- if (win->IsTopLevel())
- wxDisconnectStyleSet(win);
- }
- ~wxSuspendStyleEvents()
- {
- if (m_win->IsTopLevel())
- wxConnectStyleSet(m_win);
- }
+ wxSuspendStyleEvents(wxWindow* win)
+ {
+ m_win = NULL;
+ if (win->m_wxwindow && win->IsTopLevel())
+ {
+ m_win = win;
+ g_signal_handlers_block_by_func(
+ m_win->m_wxwindow, (void*)gtk_window_style_set_callback, m_win);
+ }
+ }
+ ~wxSuspendStyleEvents()
+ {
+ if (m_win)
+ g_signal_handlers_unblock_by_func(
+ m_win->m_wxwindow, (void*)gtk_window_style_set_callback, m_win);
+ }
- wxWindow* m_win;
+ wxWindow* m_win;
};
// ----------------------------------------------------------------------------
m_noExpose = false;
m_nativeSizeEvent = false;
- m_hasScrolling = false;
m_isScrolling = false;
m_mouseButtonDown = false;
long style,
const wxString &name )
{
+ // Get default border
+ wxBorder border = GetBorder(style);
+ style &= ~wxBORDER_MASK;
+ style |= border;
+
if (!PreCreation( parent, pos, size ) ||
!CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
{
return false;
}
+
m_wxwindow = wxPizza::New(m_windowStyle);
if (!HasFlag(wxHSCROLL) && !HasFlag(wxVSCROLL))
m_widget = m_wxwindow;
else
{
m_widget = gtk_scrolled_window_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL );
- gtk_container_set_resize_mode(GTK_CONTAINER(m_widget), GTK_RESIZE_QUEUE);
GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(m_widget);
G_CALLBACK (gtk_wxwindow_commit_cb), this);
// border drawing
-#if 0
-ndef __WXUNIVERSAL__
- if (HasFlag(wxBORDER_SIMPLE | wxBORDER_RAISED | wxBORDER_SUNKEN))
+#ifndef __WXUNIVERSAL__
+ if (HasFlag(wxPizza::BORDER_STYLES))
{
g_signal_connect(m_widget, "expose_event",
G_CALLBACK(expose_event_border), this);
{
wxSizeEvent event( wxSize(m_width,m_height), GetId() );
event.SetEventObject( this );
- GetEventHandler()->ProcessEvent( event );
+ HandleWindowEvent( event );
}
}
}
gtk_widget_show( m_widget );
wxShowEvent eventShow(GetId(), true);
eventShow.SetEventObject(this);
- GetEventHandler()->ProcessEvent(eventShow);
+ HandleWindowEvent(eventShow);
m_showOnIdle = false;
return true;
}
if (m_wxwindow)
{
- int dw = 0;
- int dh = 0;
-
- if (m_hasScrolling)
- GetScrollbarWidth(m_widget, dw, dh);
+ // if window is scrollable, account for scrollbars
+ for (int i = 0; i < 2 && m_scrollBar[i]; i++)
+ {
+ GtkRequisition req;
+ GtkAdjustment* adj = gtk_range_get_adjustment(m_scrollBar[i]);
+ // if scrollbar enabled
+ if (adj->upper > adj->page_size)
+ {
+ gtk_widget_size_request(GTK_WIDGET(m_scrollBar[i]), &req);
+ if (i == ScrollDir_Horz)
+ h -= req.height;
+ else
+ w -= req.width;
+ }
+ }
int border_x, border_y;
WX_PIZZA(m_wxwindow)->get_border_widths(border_x, border_y);
- dw += 2 * border_x;
- dh += 2 * border_y;
+ w -= 2 * border_x;
+ h -= 2 * border_y;
- w -= dw;
- h -= dh;
if (w < 0)
w = 0;
if (h < 0)
return false;
}
- if (show)
+ if (show && m_showOnIdle)
{
- if (!m_showOnIdle)
- {
- gtk_widget_show( m_widget );
- wxShowEvent eventShow(GetId(), show);
- eventShow.SetEventObject(this);
- GetEventHandler()->ProcessEvent(eventShow);
- }
+ // deferred
}
else
{
- gtk_widget_hide( m_widget );
+ if (show)
+ gtk_widget_show(m_widget);
+ else
+ gtk_widget_hide(m_widget);
wxShowEvent eventShow(GetId(), show);
eventShow.SetEventObject(this);
- GetEventHandler()->ProcessEvent(eventShow);
+ HandleWindowEvent(eventShow);
}
return true;
return x;
}
-void wxWindowGTK::DoMoveInTabOrder(wxWindow *win, MoveKind move)
+void wxWindowGTK::DoMoveInTabOrder(wxWindow *win, WindowOrder move)
{
wxWindowBase::DoMoveInTabOrder(win, move);
m_dirtyTabOrder = true;
}
}
-#if 0
if (GetThemeEnabled() && (GetBackgroundStyle() == wxBG_STYLE_SYSTEM))
{
// find ancestor from which to steal background
wxEraseEvent erase_event( GetId(), &dc );
erase_event.SetEventObject( this );
- GetEventHandler()->ProcessEvent(erase_event);
+ HandleWindowEvent(erase_event);
}
-
+
wxNcPaintEvent nc_paint_event( GetId() );
nc_paint_event.SetEventObject( this );
- GetEventHandler()->ProcessEvent( nc_paint_event );
-#endif
-
- if (GetName() == "MyMiniControl")
- wxPrintf( "MyMini paint\n" );
+ HandleWindowEvent( nc_paint_event );
wxPaintEvent paint_event( GetId() );
paint_event.SetEventObject( this );
- GetEventHandler()->ProcessEvent( paint_event );
+ HandleWindowEvent( paint_event );
m_clipPaintRegion = false;
DoReleaseMouse();
wxMouseCaptureLostEvent evt(GetId());
evt.SetEventObject( this );
- GetEventHandler()->ProcessEvent( evt );
+ HandleWindowEvent( evt );
}
/* static */
GtkRange* const sb = m_scrollBar[dir];
wxCHECK_RET( sb, _T("this window is not scrollable") );
- if (range > 0)
- {
- m_hasScrolling = true;
- }
- else
+ if (range <= 0)
{
// GtkRange requires upper > lower
range =
wxEventType wxWindowGTK::GetScrollEventType(GtkRange* range)
{
- DEBUG_MAIN_THREAD
-
wxASSERT(range == m_scrollBar[0] || range == m_scrollBar[1]);
const int barIndex = range == m_scrollBar[1];
}
-// Needed for implementing e.g. combobox on wxGTK within a modal dialog.
-void wxAddGrab(wxWindow* window)
-{
- gtk_grab_add( (GtkWidget*) window->GetHandle() );
-}
-
-void wxRemoveGrab(wxWindow* window)
-{
- gtk_grab_remove( (GtkWidget*) window->GetHandle() );
-}
-
GdkWindow* wxWindowGTK::GTKGetDrawingWindow() const
{
GdkWindow* window = NULL;
projects / wxWidgets.git / blobdiff