// Name: window.cpp
// Purpose:
// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Id: $id$
+// Copyright: (c) 1998 Robert Roebling, Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
I have been asked several times about writing some documentation about
the GTK port of wxWindows, especially its internal structures. Obviously,
you cannot understand wxGTK without knowing a little about the GTK, but
- some more information about what the wxWindow, which is the base class
+ some more information about what the wxWindow, which is the base class
for all other window classes, does seems required as well.
-
+
What does wxWindow do? It contains the common interface for the following
jobs of its descentants:
-
+
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.
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 are wxPanel, wxScrolledWindow, wxDialog, wxFrame. The MDI frame-
- work classes are a special case and are handled a bit differently from
+ work classes are a special case and are handled a bit differently from
the rest.
-
+
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
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
the functionality. Moreover, the GTK defines a client area as a different
represent a client area in the sense of wxWindows capable to do the jobs
2), 3) and 4). I have written this class and it resides in win_gtk.c of
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
thw wxWindow class has a member variable called m_widget which holds a
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.
-
+
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
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.
extern wxList wxPendingDelete;
extern wxList wxTopLevelWindows;
extern bool g_blockEventsOnDrag;
- bool g_capturing = FALSE;
+static bool g_capturing = FALSE;
+
+// 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;
//-----------------------------------------------------------------------------
// "expose_event" (of m_wxwindow, not of m_widget)
//-----------------------------------------------------------------------------
static void gtk_window_expose_callback( GtkWidget *WXUNUSED(widget), GdkEventExpose *gdk_event, wxWindow *win )
-{
+{
if (!win->HasVMT()) return;
if (g_blockEventsOnDrag) return;
-
+
win->m_updateRegion.Union( gdk_event->area.x,
gdk_event->area.y,
- gdk_event->area.width,
+ gdk_event->area.width,
gdk_event->area.height );
-
+
if (gdk_event->count > 0) return;
+/*
+ printf( "OnExpose from " );
+ if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
+ printf( win->GetClassInfo()->GetClassName() );
+ printf( ".\n" );
+*/
+
wxPaintEvent event( win->GetId() );
event.SetEventObject( win );
win->GetEventHandler()->ProcessEvent( event );
-
+
win->m_updateRegion.Clear();
}
//-----------------------------------------------------------------------------
static void gtk_window_draw_callback( GtkWidget *WXUNUSED(widget), GdkRectangle *rect, wxWindow *win )
-{
+{
if (!win->HasVMT()) return;
if (g_blockEventsOnDrag) return;
-
+
win->m_updateRegion.Union( rect->x, rect->y, rect->width, rect->height );
-
+
wxPaintEvent event( win->GetId() );
event.SetEventObject( win );
win->GetEventHandler()->ProcessEvent( event );
-
+
win->m_updateRegion.Clear();
}
//-----------------------------------------------------------------------------
static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_event, wxWindow *win )
-{
+{
if (!win->HasVMT()) return FALSE;
if (g_blockEventsOnDrag) return FALSE;
case GDK_F12: key_code = WXK_F12; break;
default:
{
- if ((gdk_event->keyval >= 0x20) && (gdk_event->keyval <= 0xFF))
+ if ((gdk_event->keyval >= 0x20) && (gdk_event->keyval <= 0xFF))
key_code = gdk_event->keyval;
}
}
if (!key_code) return FALSE;
-
+
wxKeyEvent event( wxEVT_CHAR );
event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
event.m_x = 0;
event.m_y = 0;
event.SetEventObject( win );
-
+
bool ret = win->GetEventHandler()->ProcessEvent( event );
-
+
if (!ret)
{
wxWindow *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;
+ break;
}
ancestor = ancestor->GetParent();
}
}
-
+
if (ret)
{
- if ((gdk_event->keyval >= 0x20) && (gdk_event->keyval <= 0xFF))
+ if ((gdk_event->keyval >= 0x20) && (gdk_event->keyval <= 0xFF))
gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_press_event" );
}
-
+
return ret;
}
static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxWindow *win )
{
if (!win->IsOwnGtkWindow( gdk_event->window )) return TRUE;
-
+
if (g_blockEventsOnDrag) return TRUE;
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);
-
+
/*
printf( "GrabFocus from " );
if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
printf( win->GetClassInfo()->GetClassName() );
printf( ".\n" );
*/
-
+
}
}
-
+
if (!win->HasVMT()) return TRUE;
/*
*/
wxEventType event_type = wxEVT_LEFT_DOWN;
-
+
if (gdk_event->button == 1)
{
switch (gdk_event->type)
default: break;
}
}
-
+
wxMouseEvent event( event_type );
event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
event.m_controlDown = (gdk_event->state & GDK_CONTROL_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.
-
+ // any events.
+
if (!g_capturing)
{
wxNode *node = win->GetChildren()->First();
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))
+ (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;
node = node->Next();
}
}
-
+
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;
}
//-----------------------------------------------------------------------------
static gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxWindow *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;
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.
-
+ // any events.
+
if (!g_capturing)
{
wxNode *node = win->GetChildren()->First();
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))
+ (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;
node = node->Next();
}
}
-
+
event.SetEventObject( win );
-
+
if (win->GetEventHandler()->ProcessEvent( event ))
gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "button_release_event" );
-
+
return TRUE;
}
//-----------------------------------------------------------------------------
static gint gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion *gdk_event, wxWindow *win )
-{
+{
if (!win->IsOwnGtkWindow( gdk_event->window )) return TRUE;
-
+
if (g_blockEventsOnDrag) return TRUE;
if (!win->HasVMT()) return TRUE;
-
+
/*
printf( "OnMotion from " );
if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
printf( win->GetClassInfo()->GetClassName() );
printf( ".\n" );
*/
-
+
wxMouseEvent event( wxEVT_MOTION );
event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
event.m_controlDown = (gdk_event->state & GDK_CONTROL_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.
-
+ // any events.
+
if (!g_capturing)
{
wxNode *node = win->GetChildren()->First();
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))
+ (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;
node = node->Next();
}
}
-
+
event.SetEventObject( win );
-
+
if (win->GetEventHandler()->ProcessEvent( event ))
gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "motion_notify_event" );
-
+
return TRUE;
}
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() );
*/
}
}
-
+
if (!win->HasVMT()) return TRUE;
-
+
/*
printf( "OnSetFocus from " );
if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
printf( WXSTRINGCAST win->GetLabel() );
printf( ".\n" );
*/
-
+
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;
}
if (GTK_WIDGET_CAN_FOCUS(win->m_wxwindow))
GTK_WIDGET_UNSET_FLAGS (win->m_wxwindow, GTK_HAS_FOCUS);
}
-
+
if (!win->HasVMT()) return TRUE;
-
+
/*
printf( "OnKillFocus from " );
if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
printf( win->GetClassInfo()->GetClassName() );
printf( ".\n" );
*/
-
+
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" );
static gint gtk_window_enter_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;
-
- if (widget->window)
+
+/*
+ printf( "OnEnter 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, win->m_cursor->GetCursor() );
-
+
wxMouseEvent event( wxEVT_ENTER_WINDOW );
event.SetEventObject( win );
-
+
if (win->GetEventHandler()->ProcessEvent( event ))
gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "enter_notify_event" );
-
+
return TRUE;
}
-
+
//-----------------------------------------------------------------------------
// "leave_notify_event"
//-----------------------------------------------------------------------------
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;
-
- if (widget->window)
+
+/*
+ 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" );
-
+
return TRUE;
}
-
+
//-----------------------------------------------------------------------------
// "value_changed" from m_vAdjust
//-----------------------------------------------------------------------------
printf( win->GetClassInfo()->GetClassName() );
printf( ".\n" );
*/
-
+
if (!win->HasVMT()) return;
-
+
float diff = win->m_vAdjust->value - win->m_oldVerticalPos;
if (fabs(diff) < 0.2) return;
-
+
wxEventType command = wxEVT_NULL;
-
+
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;
-
+
int value = (int)(win->m_vAdjust->value+0.5);
wxScrollEvent event( command, win->GetId(), value, wxVERTICAL );
//-----------------------------------------------------------------------------
static void gtk_window_hscroll_callback( GtkWidget *WXUNUSED(widget), wxWindow *win )
-{
+{
if (g_blockEventsOnDrag) return;
-
+
/*
printf( "OnHScroll from " );
if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
printf( win->GetClassInfo()->GetClassName() );
printf( ".\n" );
*/
-
+
if (!win->HasVMT()) return;
-
+
float diff = win->m_hAdjust->value - win->m_oldHorizontalPos;
if (fabs(diff) < 0.2) return;
-
+
wxEventType command = wxEVT_NULL;
-
+
float line_step = win->m_hAdjust->step_increment;
float page_step = win->m_hAdjust->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 command = wxEVT_SCROLL_THUMBTRACK;
int value = (int)(win->m_hAdjust->value+0.5);
-
+
wxScrollEvent event( command, win->GetId(), value, wxHORIZONTAL );
event.SetEventObject( win );
win->GetEventHandler()->ProcessEvent( event );
printf( win->GetClassInfo()->GetClassName() );
printf( ".\n" );
*/
-
+
if (!win->HasVMT()) return;
-
+
wxEventType command = wxEVT_SCROLL_THUMBTRACK;
int value = (int)(win->m_vAdjust->value+0.5);
//-----------------------------------------------------------------------------
static void gtk_window_hscroll_change_callback( GtkWidget *WXUNUSED(widget), wxWindow *win )
-{
+{
if (g_blockEventsOnDrag) return;
-
+
/*
printf( "OnHScroll change from " );
if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
printf( win->GetClassInfo()->GetClassName() );
printf( ".\n" );
*/
-
+
if (!win->HasVMT()) return;
-
+
wxEventType command = wxEVT_SCROLL_THUMBTRACK;
int value = (int)(win->m_hAdjust->value+0.5);
-
+
wxScrollEvent event( command, win->GetId(), 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, wxWindow *win )
+{
+ if (gdk_event->window != widget->slider) return FALSE;
+
+ win->m_isScrolling = TRUE;
+
+ return FALSE;
+}
+
+//-----------------------------------------------------------------------------
+// "button_release_event" from scrollbar
+//-----------------------------------------------------------------------------
+
+static gint gtk_scrollbar_button_release_callback( GtkRange *widget, GdkEventButton *gdk_event, wxWindow *win )
+{
+ 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;
+}
+
//-----------------------------------------------------------------------------
// "drop_data_available_event"
//-----------------------------------------------------------------------------
static void gtk_window_drop_callback( GtkWidget *widget, GdkEvent *event, wxWindow *win )
{
if (!win->HasVMT()) return;
-
+
if (win->GetDropTarget())
{
int x = 0;
gdk_window_get_pointer( widget->window, &x, &y, (GdkModifierType *) NULL );
win->GetDropTarget()->Drop( event, x, y );
}
-
+
/*
g_free (event->dropdataavailable.data);
g_free (event->dropdataavailable.data_type);
m_eventHandler = this;
m_windowValidator = (wxValidator *) NULL;
m_windowId = -1;
- m_cursor = new wxCursor( wxCURSOR_ARROW );
+ m_cursor = (wxCursor *) NULL;
m_font = *wxSWISS_FONT;
m_windowStyle = 0;
m_windowName = "noname";
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_pDropTarget = (wxDropTarget *) NULL;
m_resizing = FALSE;
m_hasOwnStyle = FALSE;
+ m_scrollGC = (GdkGC*) NULL;
}
bool wxWindow::Create( wxWindow *parent, wxWindowID id,
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;
- s_window = GTK_SCROLLED_WINDOW(m_widget);
-
+
+ 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 );
+
+ gtk_signal_connect( GTK_OBJECT(s_window->hscrollbar), "button_press_event",
+ (GtkSignalFunc)gtk_scrollbar_button_press_callback, (gpointer) this );
+
+ gtk_signal_connect( GTK_OBJECT(s_window->vscrollbar), "button_release_event",
+ (GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this );
+
+ gtk_signal_connect( GTK_OBJECT(s_window->hscrollbar), "button_release_event",
+ (GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this );
+
GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
scroll_class->scrollbar_spacing = 0;
-
+
gtk_scrolled_window_set_policy( s_window, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
-
+
m_oldHorizontalPos = 0.0;
m_oldVerticalPos = 0.0;
-
+
m_hAdjust = gtk_range_get_adjustment( GTK_RANGE(s_window->hscrollbar) );
m_vAdjust = gtk_range_get_adjustment( GTK_RANGE(s_window->vscrollbar) );
-
- gtk_signal_connect (GTK_OBJECT (m_hAdjust), "value_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",
+ gtk_signal_connect( GTK_OBJECT(m_vAdjust), "value_changed",
(GtkSignalFunc) gtk_window_vscroll_callback, (gpointer) this );
-
- gtk_signal_connect (GTK_OBJECT (m_hAdjust), "changed",
+
+ gtk_signal_connect( GTK_OBJECT(m_hAdjust), "changed",
(GtkSignalFunc) gtk_window_hscroll_change_callback, (gpointer) this );
- gtk_signal_connect (GTK_OBJECT (m_vAdjust), "changed",
+ gtk_signal_connect(GTK_OBJECT(m_vAdjust), "changed",
(GtkSignalFunc) gtk_window_vscroll_change_callback, (gpointer) this );
-
- GtkViewport *viewport;
- viewport = GTK_VIEWPORT(s_window->viewport);
-
+
+ GtkViewport *viewport = GTK_VIEWPORT(s_window->viewport);
+
if (m_windowStyle & wxRAISED_BORDER)
{
gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_OUT );
{
gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_NONE );
}
-
+
m_wxwindow = gtk_myfixed_new();
-
- if (m_wxwindow) GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
-
+
+ GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
+
if (m_windowStyle & wxTAB_TRAVERSAL == wxTAB_TRAVERSAL)
GTK_WIDGET_UNSET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
else
// 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) );
-
- // I _really_ don't want scrollbars in the beginning
+
+ // 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_hAdjust->page_increment = 1.0;
m_hAdjust->page_size = 5.0;
gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
-
+
gtk_widget_show( m_wxwindow );
-
+
PostCreation();
Show( TRUE );
- return TRUE;
+ return TRUE;
}
-wxWindow::~wxWindow(void)
+wxWindow::~wxWindow()
{
m_hasVMT = FALSE;
-
+
if (m_pDropTarget) delete m_pDropTarget;
-
+
if (m_parent) m_parent->RemoveChild( this );
if (m_widget) Show( FALSE );
DestroyChildren();
-
- if (m_wxwindow) gtk_widget_destroy( m_wxwindow );
+
+ if (m_scrollGC) gdk_gc_unref( m_scrollGC );
+ if (m_wxwindow) gtk_widget_destroy( m_wxwindow );
+
if (m_widget) gtk_widget_destroy( m_widget );
-
+
wxDELETE(m_cursor);
DeleteRelatedConstraints();
// wxWindow::LoadNativeDialog but we weren't a dialog
// class
wxTopLevelWindows.DeleteObject(this);
-
+
if (m_windowValidator) delete m_windowValidator;
}
if (m_cursor == NULL)
m_cursor = new wxCursor( wxCURSOR_ARROW );
m_font = *wxSWISS_FONT;
- m_backgroundColour = wxWHITE;
+// m_backgroundColour = wxWHITE;
m_foregroundColour = wxBLACK;
m_windowStyle = style;
m_windowName = name;
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(void)
+void wxWindow::PostCreation()
{
if (m_parent) m_parent->AddChild( this );
-
+
if (m_wxwindow)
{
- gtk_signal_connect( GTK_OBJECT(m_wxwindow), "expose_event",
+ gtk_signal_connect( GTK_OBJECT(m_wxwindow), "expose_event",
GTK_SIGNAL_FUNC(gtk_window_expose_callback), (gpointer)this );
-
- gtk_signal_connect( GTK_OBJECT(m_wxwindow), "draw",
+
+ gtk_signal_connect( GTK_OBJECT(m_wxwindow), "draw",
GTK_SIGNAL_FUNC(gtk_window_draw_callback), (gpointer)this );
}
-
+
ConnectWidget( GetConnectWidget() );
-
+
if (m_widget && m_parent) gtk_widget_realize( m_widget );
-
- if (m_wxwindow)
- {
- gtk_widget_realize( m_wxwindow );
- gdk_gc_set_exposures( m_wxwindow->style->fg_gc[0], TRUE );
- }
-
- SetCursor( wxSTANDARD_CURSOR );
-
+
+ if (m_wxwindow) gtk_widget_realize( m_wxwindow );
+
+ SetCursor( *wxSTANDARD_CURSOR );
+
m_hasVMT = TRUE;
}
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), "focus_in_event",
+
+ gtk_signal_connect( GTK_OBJECT(widget), "focus_in_event",
GTK_SIGNAL_FUNC(gtk_window_focus_in_callback), (gpointer)this );
- gtk_signal_connect( GTK_OBJECT(widget), "focus_out_event",
+ gtk_signal_connect( GTK_OBJECT(widget), "focus_out_event",
GTK_SIGNAL_FUNC(gtk_window_focus_out_callback), (gpointer)this );
- gtk_signal_connect( GTK_OBJECT(widget), "enter_notify_event",
+ 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_connect( GTK_OBJECT(widget), "leave_notify_event",
GTK_SIGNAL_FUNC(gtk_window_leave_callback), (gpointer)this );
}
-bool wxWindow::HasVMT(void)
+bool wxWindow::HasVMT()
{
return m_hasVMT;
}
bool wxWindow::Close( bool force )
{
+ wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+
wxCloseEvent event(wxEVT_CLOSE_WINDOW, m_windowId);
event.SetEventObject(this);
event.SetForce(force);
return GetEventHandler()->ProcessEvent(event);
}
-bool wxWindow::Destroy(void)
+bool wxWindow::Destroy()
{
+ wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+
m_hasVMT = FALSE;
delete this;
return TRUE;
}
-bool wxWindow::DestroyChildren(void)
+bool wxWindow::DestroyChildren()
{
- if (GetChildren())
+ if (GetChildren())
{
wxNode *node;
- while ((node = GetChildren()->First()) != (wxNode *)NULL)
+ while ((node = GetChildren()->First()) != (wxNode *)NULL)
{
wxWindow *child;
- if ((child = (wxWindow *)node->Data()) != (wxWindow *)NULL)
+ if ((child = (wxWindow *)node->Data()) != (wxWindow *)NULL)
{
delete child;
if (GetChildren()->Member(child)) delete node;
// are we to set fonts here ?
}
-void wxWindow::ImplementSetSize(void)
-{
+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;
gtk_widget_set_usize( m_widget, m_width, m_height );
}
-void wxWindow::ImplementSetPosition(void)
+void wxWindow::ImplementSetPosition()
{
if (IS_KIND_OF(this,wxFrame) || IS_KIND_OF(this,wxDialog))
{
gtk_widget_set_uposition( m_widget, m_x, m_y );
return;
}
-
+
if (!m_parent)
{
wxFAIL_MSG( "wxWindow::SetSize error.\n" );
return;
}
-
+
if ((m_parent) && (m_parent->m_wxwindow))
gtk_myfixed_move( GTK_MYFIXED(m_parent->m_wxwindow), m_widget, m_x, m_y );
-
- // Don't do anything for children of wxNotebook and wxMDIChildFrame
+
+ // Don't do anything for children of wxNotebook and wxMDIChildFrame
}
void wxWindow::SetSize( int x, int y, int width, int height, int sizeFlags )
{
+ wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+
if (m_resizing) return; // I don't like recursions
m_resizing = TRUE;
-
+
int newX = x;
int newY = y;
int newW = width;
int newH = height;
-
+
if ((sizeFlags & wxSIZE_USE_EXISTING) == wxSIZE_USE_EXISTING)
{
if (newX == -1) newX = m_x;
if (newW == -1) newW = m_width;
if (newH == -1) newH = m_height;
}
-
+
if ((sizeFlags & wxSIZE_AUTO_WIDTH) == wxSIZE_AUTO_WIDTH)
{
if (newW == -1) newW = 80;
}
-
+
if ((sizeFlags & wxSIZE_AUTO_HEIGHT) == wxSIZE_AUTO_HEIGHT)
{
if (newH == -1) newH = 26;
}
-
+
if ((m_x != newX) || (m_y != newY) || (!m_sizeSet))
{
m_x = newX;
ImplementSetSize();
}
m_sizeSet = TRUE;
-
+
wxSizeEvent event( wxSize(m_width,m_height), GetId() );
event.SetEventObject( this );
ProcessEvent( event );
-
+
m_resizing = FALSE;
}
void wxWindow::GetSize( int *width, int *height ) const
{
+ wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+
if (width) (*width) = m_width;
if (height) (*height) = m_height;
}
void wxWindow::SetClientSize( int width, int height )
{
+ wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+
if (!m_wxwindow)
{
SetSize( width, height );
{
int dw = 0;
int dh = 0;
-
+
if (!m_hasScrolling)
{
/*
do we have sunken dialogs ?
-
+
GtkStyleClass *window_class = m_wxwindow->style->klass;
-
+
dw += 2 * window_class->xthickness;
dh += 2 * window_class->ythickness;
*/
{
GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
-
+
GtkWidget *viewport = scroll_window->viewport;
GtkStyleClass *viewport_class = viewport->style->klass;
-
+
GtkWidget *hscrollbar = scroll_window->hscrollbar;
GtkWidget *vscrollbar = scroll_window->vscrollbar;
-
+
if ((m_windowStyle & wxRAISED_BORDER) ||
(m_windowStyle & wxSUNKEN_BORDER))
{
dw += 2 * viewport_class->xthickness;
dh += 2 * viewport_class->ythickness;
}
-
+
if (GTK_WIDGET_VISIBLE(vscrollbar))
{
dw += vscrollbar->allocation.width;
dw += scroll_class->scrollbar_spacing;
}
-
+
if (GTK_WIDGET_VISIBLE(hscrollbar))
{
dh += hscrollbar->allocation.height;
dw += scroll_class->scrollbar_spacing;
}
}
-
+
SetSize( width+dw, height+dh );
}
}
void wxWindow::GetClientSize( int *width, int *height ) const
{
+ wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+
if (!m_wxwindow)
{
if (width) (*width) = m_width;
{
int dw = 0;
int dh = 0;
-
+
if (!m_hasScrolling)
{
/*
do we have sunken dialogs ?
-
+
GtkStyleClass *window_class = m_wxwindow->style->klass;
-
+
dw += 2 * window_class->xthickness;
dh += 2 * window_class->ythickness;
*/
{
GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
-
+
GtkWidget *viewport = scroll_window->viewport;
GtkStyleClass *viewport_class = viewport->style->klass;
-
+
GtkWidget *hscrollbar = scroll_window->hscrollbar;
GtkWidget *vscrollbar = scroll_window->vscrollbar;
-
+
if ((m_windowStyle & wxRAISED_BORDER) ||
(m_windowStyle & wxSUNKEN_BORDER))
{
dw += 2 * viewport_class->xthickness;
dh += 2 * viewport_class->ythickness;
}
-
+
if (GTK_WIDGET_VISIBLE(vscrollbar))
{
// dw += vscrollbar->allocation.width;
dw += 15; // range.slider_width = 11 + 2*2pts edge
dw += scroll_class->scrollbar_spacing;
}
-
+
if (GTK_WIDGET_VISIBLE(hscrollbar))
{
// dh += hscrollbar->allocation.height;
dh += scroll_class->scrollbar_spacing;
}
}
-
+
if (width) (*width) = m_width - dw;
if (height) (*height) = m_height - dh;
}
void wxWindow::GetPosition( int *x, int *y ) const
{
+ wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+
if (x) (*x) = m_x;
if (y) (*y) = m_y;
}
void wxWindow::ClientToScreen( int *x, int *y )
{
+ wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+
GdkWindow *source = (GdkWindow *) NULL;
if (m_wxwindow)
source = m_wxwindow->window;
else
source = m_widget->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))
{
org_x += m_widget->allocation.x;
org_y += m_widget->allocation.y;
}
}
-
- if (x) *x += org_x;
- if (y) *y += org_y;
+
+ if (x) *x += org_x;
+ if (y) *y += org_y;
}
void wxWindow::ScreenToClient( int *x, int *y )
{
+ wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+
GdkWindow *source = (GdkWindow *) NULL;
if (m_wxwindow)
source = m_wxwindow->window;
else
source = m_widget->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))
{
org_x += m_widget->allocation.x;
org_y += m_widget->allocation.y;
}
}
-
- if (x) *x -= org_x;
- if (y) *y -= org_y;
+
+ if (x) *x -= org_x;
+ if (y) *y -= org_y;
}
void wxWindow::Centre( int direction )
{
+ wxASSERT_MSG( (m_widget != NULL), "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;
}
}
-void wxWindow::Fit(void)
+void wxWindow::Fit()
{
+ wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+
int maxX = 0;
int maxY = 0;
wxNode *node = GetChildren()->First();
void wxWindow::SetSizeHints( int minW, int minH, int maxW, int maxH, int WXUNUSED(incW), int WXUNUSED(incH) )
{
+ wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+
m_minWidth = minW;
m_minHeight = minH;
m_maxWidth = maxW;
bool wxWindow::Show( bool show )
{
+ wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+
if (show)
gtk_widget_show( m_widget );
else
gtk_widget_hide( m_widget );
- m_isShown = show;
+ m_isShown = show;
return TRUE;
}
void wxWindow::Enable( bool enable )
{
+ wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+
m_isEnabled = enable;
gtk_widget_set_sensitive( m_widget, enable );
if (m_wxwindow) gtk_widget_set_sensitive( m_wxwindow, enable );
}
-int wxWindow::GetCharHeight(void) const
+int wxWindow::GetCharHeight() const
{
+ wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+
+ if (!m_font.Ok())
+ {
+ wxFAIL_MSG( "invalid font" );
+ return -1;
+ }
+
GdkFont *font = m_font.GetInternalFont( 1.0 );
return font->ascent + font->descent;
}
-int wxWindow::GetCharWidth(void) const
+int wxWindow::GetCharWidth() const
{
+ wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+
+ if (!m_font.Ok())
+ {
+ wxFAIL_MSG( "invalid font" );
+ return -1;
+ }
+
GdkFont *font = m_font.GetInternalFont( 1.0 );
return gdk_string_width( font, "H" );
}
void wxWindow::GetTextExtent( const wxString& string, int *x, int *y,
int *descent, int *externalLeading, const wxFont *theFont, bool WXUNUSED(use16) ) const
{
+ wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+
wxFont fontToUse = m_font;
if (theFont) fontToUse = *theFont;
-
+
+ if (!fontToUse.Ok())
+ {
+ wxFAIL_MSG( "invalid font" );
+ return;
+ }
+ wxASSERT_MSG( (m_font.Ok()), "invalid font" );
+
GdkFont *font = fontToUse.GetInternalFont( 1.0 );
if (x) (*x) = gdk_string_width( font, string );
if (y) (*y) = font->ascent + font->descent;
}
}
-void wxWindow::SetFocus(void)
+void wxWindow::SetFocus()
{
+ wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+
GtkWidget *connect_widget = GetConnectWidget();
if (connect_widget)
{
}
}
-bool wxWindow::OnClose(void)
+bool wxWindow::OnClose()
{
return TRUE;
}
void wxWindow::AddChild( wxWindow *child )
{
+ 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
+ // 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;
}
-
- // In the case of an wxMDIChildFrame descendant, we use the
+
+ // 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))
{
wxMDIClientWindow *client = ((wxMDIParentFrame*)this)->GetClientWindow();
if (client)
- {
+ {
client->AddChild( child );
return;
}
}
}
-
+
// 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
-
+
if (IS_KIND_OF(this,wxFrame) && !IS_KIND_OF(this,wxMDIChildFrame))
{
wxFrame *frame = (wxFrame*)this;
frame->AddChild( child );
return;
}
-
+
// All the rest
-
+
m_children.Append( child );
- if (m_wxwindow) gtk_myfixed_put( GTK_MYFIXED(m_wxwindow), child->m_widget,
+ if (m_wxwindow) gtk_myfixed_put( GTK_MYFIXED(m_wxwindow), child->m_widget,
child->m_x, child->m_y );
-
+
gtk_widget_set_usize( child->m_widget, child->m_width, child->m_height );
}
-wxList *wxWindow::GetChildren(void)
+wxList *wxWindow::GetChildren()
{
return (&m_children);
}
void wxWindow::RemoveChild( wxWindow *child )
{
if (GetChildren())
- GetChildren()->DeleteObject( child );
+ GetChildren()->DeleteObject( child );
child->m_parent = (wxWindow *) NULL;
}
m_retCode = retCode;
}
-int wxWindow::GetReturnCode(void)
+int wxWindow::GetReturnCode()
{
return m_retCode;
}
-void wxWindow::Raise(void)
+void wxWindow::Raise()
{
+ wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+
if (m_widget) gdk_window_raise( m_widget->window );
}
-void wxWindow::Lower(void)
+void wxWindow::Lower()
{
+ wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+
if (m_widget) gdk_window_lower( m_widget->window );
}
-wxEvtHandler *wxWindow::GetEventHandler(void)
+wxEvtHandler *wxWindow::GetEventHandler()
{
return m_eventHandler;
}
void wxWindow::PushEventHandler(wxEvtHandler *handler)
{
- handler->SetNextHandler(GetEventHandler());
- SetEventHandler(handler);
+ handler->SetNextHandler(GetEventHandler());
+ SetEventHandler(handler);
}
wxEvtHandler *wxWindow::PopEventHandler(bool deleteHandler)
{
- if ( GetEventHandler() )
- {
- wxEvtHandler *handlerA = GetEventHandler();
- wxEvtHandler *handlerB = handlerA->GetNextHandler();
- handlerA->SetNextHandler((wxEvtHandler *) NULL);
- SetEventHandler(handlerB);
- if ( deleteHandler )
- {
- delete handlerA;
- return (wxEvtHandler *) NULL;
- }
- else
- return handlerA;
- }
- else
- return (wxEvtHandler *) NULL;
-}
-
-wxValidator *wxWindow::GetValidator(void)
+ if (GetEventHandler())
+ {
+ wxEvtHandler *handlerA = GetEventHandler();
+ wxEvtHandler *handlerB = handlerA->GetNextHandler();
+ handlerA->SetNextHandler((wxEvtHandler *) NULL);
+ SetEventHandler(handlerB);
+ if (deleteHandler)
+ {
+ delete handlerA;
+ return (wxEvtHandler*) NULL;
+ }
+ else
+ return handlerA;
+ }
+ else
+ return (wxEvtHandler *) NULL;
+}
+
+wxValidator *wxWindow::GetValidator()
{
return m_windowValidator;
}
if (m_windowValidator) m_windowValidator->SetWindow(this);
}
-bool wxWindow::IsBeingDeleted(void)
+bool wxWindow::IsBeingDeleted()
{
return FALSE;
}
m_windowId = id;
}
-wxWindowID wxWindow::GetId(void)
+wxWindowID wxWindow::GetId()
{
return m_windowId;
}
void wxWindow::SetCursor( const wxCursor &cursor )
{
- wxASSERT(m_cursor != NULL);
+ wxASSERT_MSG( (m_widget != NULL), "invalid window" );
- if (m_cursor != NULL)
- if (*m_cursor == cursor)
- return;
- (*m_cursor) = cursor;
- if (m_widget->window)
+ if (m_cursor == NULL)
+ {
+ wxFAIL_MSG( "wxWindow::SetCursor m_cursor == NULL" );
+ m_cursor = new wxCursor( wxCURSOR_ARROW );
+ }
+
+ if (cursor.Ok())
+ {
+ if (*((wxCursor*)&cursor) == m_cursor) return;
+ *m_cursor = cursor;
+ }
+ else
+ {
+ *m_cursor = *wxSTANDARD_CURSOR;
+ }
+
+ if ((m_widget) && (m_widget->window))
gdk_window_set_cursor( m_widget->window, m_cursor->GetCursor() );
- if (m_wxwindow && m_wxwindow->window)
+
+ if ((m_wxwindow) && (m_wxwindow->window))
gdk_window_set_cursor( m_wxwindow->window, m_cursor->GetCursor() );
}
void wxWindow::Refresh( bool eraseBackground, const wxRect *rect )
{
+ wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+
if (eraseBackground && m_wxwindow && m_wxwindow->window)
{
if (rect)
- gdk_window_clear_area( m_wxwindow->window,
- rect->x,
- rect->y,
- rect->width,
+ gdk_window_clear_area( m_wxwindow->window,
+ rect->x,
+ rect->y,
+ rect->width,
rect->height );
else
- Clear();
+ Clear();
}
if (!rect)
{
int w = 0;
int h = 0;
GetClientSize( &w, &h );
-
+
GdkRectangle gdk_rect;
gdk_rect.x = 0;
gdk_rect.y = 0;
gdk_rect.y = rect->y;
gdk_rect.width = rect->width;
gdk_rect.height = rect->height;
-
+
if (m_wxwindow)
gtk_widget_draw( m_wxwindow, &gdk_rect );
else
return (m_updateRegion.Contains( rect.x, rect.y, rect.width, rect.height ) != wxOutRegion );
}
-void wxWindow::Clear(void)
+void wxWindow::Clear()
{
+ wxCHECK_RET( m_widget != NULL, "invalid window" );
+
if (m_wxwindow && m_wxwindow->window) gdk_window_clear( m_wxwindow->window );
}
-wxColour wxWindow::GetBackgroundColour(void) const
+wxColour wxWindow::GetBackgroundColour() const
{
return m_backgroundColour;
}
+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 );
+}
+
void wxWindow::SetBackgroundColour( const wxColour &colour )
{
+ wxCHECK_RET( m_widget != NULL, "invalid window" );
+
m_backgroundColour = colour;
- if (m_wxwindow)
- {
- m_backgroundColour.CalcPixel( m_wxwindow->style->colormap );
- gdk_window_set_background( m_wxwindow->window, m_backgroundColour.GetColor() );
- gdk_window_clear( m_wxwindow->window );
- }
- // do something ?
+
+ GtkWidget *widget = m_wxwindow == NULL ? m_widget : m_wxwindow;
+ SetBackgroundColourHelper( widget->window );
}
-wxColour wxWindow::GetForegroundColour(void) const
+wxColour wxWindow::GetForegroundColour() const
{
return m_foregroundColour;
}
m_foregroundColour = colour;
}
-bool wxWindow::Validate(void)
+bool wxWindow::Validate()
{
+ wxCHECK_MSG( m_widget != NULL, FALSE, "invalid window" );
+
wxNode *node = GetChildren()->First();
while (node)
{
wxWindow *child = (wxWindow *)node->Data();
- if (child->GetValidator() && /* child->GetValidator()->Ok() && */ !child->GetValidator()->Validate(this))
+ if (child->GetValidator() && /* child->GetValidator()->Ok() && */ !child->GetValidator()->Validate(this))
{ return FALSE; }
node = node->Next();
}
return TRUE;
}
-bool wxWindow::TransferDataToWindow(void)
+bool wxWindow::TransferDataToWindow()
{
+ wxCHECK_MSG( m_widget != NULL, FALSE, "invalid window" );
+
wxNode *node = GetChildren()->First();
while (node)
{
return TRUE;
}
-bool wxWindow::TransferDataFromWindow(void)
+bool wxWindow::TransferDataFromWindow()
{
+ wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+
wxNode *node = GetChildren()->First();
while (node)
{
TransferDataToWindow();
}
-void wxWindow::InitDialog(void)
+void wxWindow::InitDialog()
{
+ wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+
wxInitDialogEvent event(GetId());
event.SetEventObject( this );
GetEventHandler()->ProcessEvent(event);
bool wxWindow::PopupMenu( wxMenu *menu, int WXUNUSED(x), int WXUNUSED(y) )
{
+ wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+
SetInvokingWindow( menu, this );
- gtk_menu_popup( GTK_MENU(menu->m_menu), (GtkWidget *) NULL, (GtkWidget *) NULL, (GtkMenuPositionFunc) NULL, NULL, 0, 0 );
+ 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;
}
void wxWindow::SetDropTarget( wxDropTarget *dropTarget )
{
+ wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+
GtkWidget *dnd_widget = GetConnectWidget();
-
+
DisconnectDnDWidget( dnd_widget );
-
+
if (m_pDropTarget) delete m_pDropTarget;
m_pDropTarget = dropTarget;
-
+
ConnectDnDWidget( dnd_widget );
}
void wxWindow::ConnectDnDWidget( GtkWidget *widget )
{
if (!m_pDropTarget) return;
-
+
m_pDropTarget->RegisterWidget( widget );
-
+
gtk_signal_connect( GTK_OBJECT(widget), "drop_data_available_event",
GTK_SIGNAL_FUNC(gtk_window_drop_callback), (gpointer)this );
}
void wxWindow::DisconnectDnDWidget( GtkWidget *widget )
{
if (!m_pDropTarget) return;
-
+
gtk_signal_disconnect_by_func( GTK_OBJECT(widget),
GTK_SIGNAL_FUNC(gtk_window_drop_callback), (gpointer)this );
-
+
m_pDropTarget->UnregisterWidget( widget );
}
-GtkWidget* wxWindow::GetConnectWidget(void)
+GtkWidget* wxWindow::GetConnectWidget()
{
GtkWidget *connect_widget = m_widget;
if (m_wxwindow) connect_widget = m_wxwindow;
-
+
return connect_widget;
}
-
+
bool wxWindow::IsOwnGtkWindow( GdkWindow *window )
{
if (m_wxwindow) return (window == m_wxwindow->window);
void wxWindow::SetFont( const wxFont &font )
{
+ wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+
if (((wxFont*)&font)->Ok())
m_font = font;
else
{
style = gtk_widget_get_style( m_widget );
}
-
+
gdk_font_unref( style->font );
style->font = gdk_font_ref( m_font.GetInternalFont( 1.0 ) );
-
+
gtk_widget_set_style( m_widget, style );
}
-wxFont *wxWindow::GetFont(void)
+wxFont *wxWindow::GetFont()
{
return &m_font;
}
m_windowStyle = flag;
}
-long wxWindow::GetWindowStyleFlag(void) const
+long wxWindow::GetWindowStyleFlag() const
{
return m_windowStyle;
}
-void wxWindow::CaptureMouse(void)
+void wxWindow::CaptureMouse()
{
+ wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+
+ wxASSERT_MSG( (g_capturing == FALSE), "CaptureMouse called twice" );
+
GtkWidget *connect_widget = GetConnectWidget();
gtk_grab_add( connect_widget );
gdk_pointer_grab ( connect_widget->window, FALSE,
(GdkEventMask)
- (GDK_BUTTON_PRESS_MASK |
+ (GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK |
- GDK_POINTER_MOTION_MASK),
+ GDK_POINTER_MOTION_MASK),
(GdkWindow *) NULL, (GdkCursor *) NULL, GDK_CURRENT_TIME );
g_capturing = TRUE;
}
-void wxWindow::ReleaseMouse(void)
+void wxWindow::ReleaseMouse()
{
+ wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+
+ wxASSERT_MSG( (g_capturing == TRUE), "ReleaseMouse called twice" );
+
GtkWidget *connect_widget = GetConnectWidget();
gtk_grab_remove( connect_widget );
gdk_pointer_ungrab ( GDK_CURRENT_TIME );
{
}
-wxString wxWindow::GetTitle(void) const
+wxString wxWindow::GetTitle() const
{
return (wxString&)m_windowName;
}
-wxString wxWindow::GetLabel(void) const
+wxString wxWindow::GetLabel() const
{
return GetTitle();
}
m_windowName = name;
}
-wxString wxWindow::GetName(void) const
+wxString wxWindow::GetName() const
{
return (wxString&)m_windowName;
}
-bool wxWindow::IsShown(void) const
+bool wxWindow::IsShown() const
{
return m_isShown;
}
-bool wxWindow::IsRetained(void)
+bool wxWindow::IsRetained()
{
return FALSE;
}
}
void wxWindow::SetScrollbar( int orient, int pos, int thumbVisible,
- int range, bool WXUNUSED(refresh) )
+ int range, bool refresh )
{
+ wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+
+ wxASSERT_MSG( (m_wxwindow != NULL), "window needs client area" );
+
if (!m_wxwindow) return;
if (orient == wxHORIZONTAL)
{
float fpos = (float)pos;
- m_oldHorizontalPos = fpos;
float frange = (float)range;
float fthumb = (float)thumbVisible;
-
- if ((fabs(fpos-m_hAdjust->value) < 0.2) &&
- (fabs(frange-m_hAdjust->upper) < 0.2) &&
- (fabs(fthumb-m_hAdjust->page_size) < 0.2))
+
+ if ((fabs(frange-m_hAdjust->upper) < 0.2) &&
+ (fabs(fthumb-m_hAdjust->page_size) < 0.2))
+ {
+ SetScrollPos( orient, pos, refresh );
return;
-
+ }
+
+ m_oldHorizontalPos = fpos;
+
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-2,0));
+ m_hAdjust->page_increment = (float)(wxMax(fthumb,0));
m_hAdjust->page_size = fthumb;
}
else
{
float fpos = (float)pos;
- m_oldVerticalPos = fpos;
float frange = (float)range;
float fthumb = (float)thumbVisible;
-
- if ((fabs(fpos-m_vAdjust->value) < 0.2) &&
- (fabs(frange-m_vAdjust->upper) < 0.2) &&
- (fabs(fthumb-m_vAdjust->page_size) < 0.2))
+
+ if ((fabs(frange-m_vAdjust->upper) < 0.2) &&
+ (fabs(fthumb-m_vAdjust->page_size) < 0.2))
+ {
+ SetScrollPos( orient, pos, refresh );
return;
-
+ }
+
+ 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-2,0));
+ m_vAdjust->page_increment = (float)(wxMax(fthumb,0));
m_vAdjust->page_size = fthumb;
}
-
+
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" );
-
+
gtk_widget_set_usize( m_widget, m_width, m_height );
}
}
void wxWindow::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) )
{
+ wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+
+ wxASSERT_MSG( (m_wxwindow != NULL), "window needs client area" );
+
if (!m_wxwindow) return;
-
+
if (orient == wxHORIZONTAL)
{
float fpos = (float)pos;
if (fabs(fpos-m_vAdjust->value) < 0.2) return;
m_vAdjust->value = fpos;
}
-
- 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_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" );
+ }
}
}
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)
int wxWindow::GetScrollPos( 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)
int wxWindow::GetScrollRange( 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)
void wxWindow::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
{
+ wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+
+ wxASSERT_MSG( (m_wxwindow != NULL), "window needs client area" );
+
if (!m_wxwindow) return;
-
-/*
- bool refresh = FALSE;
-
- if ((m_drawingOffsetX == 0) && (m_drawingOffsetY == 0))
- {
- m_drawingOffsetX = -16000;
- m_drawingOffsetY = -16000;
- refresh = TRUE;
- }
- else
- {
- m_drawingOffsetX += dx;
- m_drawingOffsetY += dy;
- }
-
-// printf( "X: %d Y: %d \n", (int)m_drawingOffsetX, (int)m_drawingOffsetY );
-
- gtk_myfixed_set_offset( GTK_MYFIXED(m_wxwindow), m_drawingOffsetX, m_drawingOffsetY );
-
- if (refresh) Refresh();
-
- The code here is very nifty, but it doesn't work with
- overlapping windows...
-*/
int cw = 0;
int ch = 0;
GetClientSize( &cw, &ch );
-
+
int w = cw - abs(dx);
int h = ch - abs(dy);
if ((h < 0) || (w < 0))
int d_y = 0;
if (dx > 0) d_x = dx;
if (dy > 0) d_y = dy;
- gdk_window_copy_area( m_wxwindow->window, m_wxwindow->style->fg_gc[0], d_x, d_y,
+
+ if (!m_scrollGC)
+ {
+ m_scrollGC = gdk_gc_new( m_wxwindow->window );
+ gdk_gc_set_exposures( m_scrollGC, TRUE );
+ }
+
+ 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 );
}
// Layout
//-------------------------------------------------------------------------------------
-wxLayoutConstraints *wxWindow::GetConstraints(void) const
+wxLayoutConstraints *wxWindow::GetConstraints() const
{
return m_constraints;
}
m_autoLayout = autoLayout;
}
-bool wxWindow::GetAutoLayout(void) const
+bool wxWindow::GetAutoLayout() const
{
return m_autoLayout;
}
-wxSizer *wxWindow::GetSizer(void) const
+wxSizer *wxWindow::GetSizer() const
{
return m_windowSizer;
}
m_sizerParent = win;
}
-wxWindow *wxWindow::GetSizerParent(void) const
+wxWindow *wxWindow::GetSizerParent() const
{
return m_sizerParent;
}
}
// Reset any constraints that mention this window
-void wxWindow::DeleteRelatedConstraints(void)
+void wxWindow::DeleteRelatedConstraints()
{
if (m_constraintsInvolvedIn)
{
* New version
*/
-bool wxWindow::Layout(void)
+bool wxWindow::Layout()
{
if (GetConstraints())
{
GetConstraints()->width.SetValue(w);
GetConstraints()->height.SetValue(h);
}
-
+
// If top level (one sizer), evaluate the sizer's constraints.
if (GetSizer())
{
bool wxWindow::LayoutPhase2(int *noChanges)
{
*noChanges = 0;
-
+
// Layout children
DoPhase(1);
DoPhase(2);
return TRUE;
}
-void wxWindow::ResetConstraints(void)
+void wxWindow::ResetConstraints()
{
wxLayoutConstraints *constr = GetConstraints();
if (constr)
if (!m_sizerParent || m_sizerParent->IsKindOf(CLASSINFO(wxDialog)) ||
m_sizerParent->IsKindOf(CLASSINFO(wxFrame)) )
return;
-
+
int xp, yp;
m_sizerParent->GetPosition(&xp, &yp);
m_sizerParent->TransformSizerToActual(&xp, &yp);
projects / wxWidgets.git / blobdiff