#ifdef __GNUG__
-#pragma implementation "window.h"
+ #pragma implementation "window.h"
#endif
#include "wx/defs.h"
#include "wx/utils.h"
#include "wx/dialog.h"
#include "wx/msgdlg.h"
+
#if wxUSE_DRAG_AND_DROP
-#include "wx/dnd.h"
+ #include "wx/dnd.h"
+#endif
+
+#if wxUSE_TOOLTIPS
+ #include "wx/tooltip.h"
#endif
-#include "wx/tooltip.h"
+
#include "wx/menu.h"
#include "wx/statusbr.h"
#include "wx/intl.h"
*/
-//-------------------------------------------------------------------------
-// conditional compilation
-//-------------------------------------------------------------------------
-
-#if (GTK_MINOR_VERSION == 1)
-#if (GTK_MICRO_VERSION >= 5)
-#define NEW_GTK_SCROLL_CODE
-#endif
-#endif
-
//-----------------------------------------------------------------------------
-// (debug)
+// data
//-----------------------------------------------------------------------------
-#ifdef __WXDEBUG__
+extern wxList wxPendingDelete;
+extern bool g_blockEventsOnDrag;
+extern bool g_blockEventsOnScroll;
+static bool g_capturing = FALSE;
+static wxWindow *g_focusWindow = (wxWindow*) NULL;
-static gint gtk_debug_focus_in_callback( GtkWidget *WXUNUSED(widget),
- GdkEvent *WXUNUSED(event),
- const char *name )
-{
- printf( "FOCUS NOW AT: " );
- printf( name );
- printf( "\n" );
+/* 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;
- return FALSE;
-}
+#if (GTK_MINOR_VERSION > 0)
+
+//-----------------------------------------------------------------------------
+// local code (see below)
+//-----------------------------------------------------------------------------
-void debug_focus_in( GtkWidget* widget, const char* name, const char *window )
+static void draw_frame( GtkWidget *widget, wxWindow *win )
{
- return;
+ if (!win->HasVMT()) return;
- wxString tmp = name;
- tmp += " FROM ";
- tmp += window;
+ int dw = 0;
+ int dh = 0;
+
+ if (win->m_hasScrolling)
+ {
+ GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(widget);
+ GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(widget)->klass );
- char *s = new char[tmp.Length()+1];
+/*
+ GtkWidget *hscrollbar = scroll_window->hscrollbar;
+ GtkWidget *vscrollbar = scroll_window->vscrollbar;
+
+ we use this instead: range.slider_width = 11 + 2*2pts edge
+*/
- strcpy( s, WXSTRINGCAST tmp );
+ if (scroll_window->vscrollbar_visible)
+ {
+ dw += 15; /* dw += vscrollbar->allocation.width; */
+ dw += scroll_class->scrollbar_spacing;
+ }
- gtk_signal_connect( GTK_OBJECT(widget), "focus_in_event",
- GTK_SIGNAL_FUNC(gtk_debug_focus_in_callback), (gpointer)s );
+ if (scroll_window->hscrollbar_visible)
+ {
+ dh += 15; /* dh += hscrollbar->allocation.height; */
+ dw += scroll_class->scrollbar_spacing;
+ }
+ }
+
+ int dx = 0;
+ int dy = 0;
+ if (GTK_WIDGET_NO_WINDOW (widget))
+ {
+ dx += widget->allocation.x;
+ dy += widget->allocation.y;
+ }
+
+ if (win->m_windowStyle & wxRAISED_BORDER)
+ {
+ gtk_draw_shadow( widget->style,
+ widget->window,
+ GTK_STATE_NORMAL,
+ GTK_SHADOW_OUT,
+ dx, dy,
+ win->m_width-dw, win->m_height-dh );
+ return;
+ }
+
+ if (win->m_windowStyle & wxSUNKEN_BORDER)
+ {
+ gtk_draw_shadow( widget->style,
+ widget->window,
+ GTK_STATE_NORMAL,
+ GTK_SHADOW_IN,
+ dx, dy,
+ win->m_width-dw, win->m_height-dh );
+ return;
+ }
}
-#endif
+//-----------------------------------------------------------------------------
+// "expose_event" of m_widget
+//-----------------------------------------------------------------------------
+
+static void gtk_window_own_expose_callback( GtkWidget *widget, GdkEventExpose *gdk_event, wxWindow *win )
+{
+ if (gdk_event->count > 0) return;
+ draw_frame( widget, win );
+}
//-----------------------------------------------------------------------------
-// data
+// "draw" of m_wxwindow
//-----------------------------------------------------------------------------
-extern wxList wxPendingDelete;
-extern wxList wxTopLevelWindows;
-extern bool g_blockEventsOnDrag;
-extern bool g_blockEventsOnScroll;
-static bool g_capturing = FALSE;
-static wxWindow *g_focusWindow = (wxWindow*) NULL;
+static void gtk_window_own_draw_callback( GtkWidget *widget, GdkRectangle *WXUNUSED(rect), wxWindow *win )
+{
+ draw_frame( widget, win );
+}
-// 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;
+#endif
//-----------------------------------------------------------------------------
-// "expose_event" (of m_wxwindow, not of m_widget)
+// "expose_event" of m_wxwindow
//-----------------------------------------------------------------------------
static void gtk_window_expose_callback( GtkWidget *WXUNUSED(widget), GdkEventExpose *gdk_event, wxWindow *win )
}
//-----------------------------------------------------------------------------
-// "draw" (of m_wxwindow, not of m_widget)
+// "draw" of m_wxwindow
//-----------------------------------------------------------------------------
static void gtk_window_draw_callback( GtkWidget *WXUNUSED(widget), GdkRectangle *rect, wxWindow *win )
switch (gdk_event->keyval)
{
case GDK_BackSpace: key_code = WXK_BACK; break;
+ case GDK_ISO_Left_Tab:
+ case GDK_KP_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_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;
}
// win is a control: tab can be propagated up
- if ((!ret) && (gdk_event->keyval == GDK_Tab) && ((win->m_windowStyle & wxTE_PROCESS_TAB) == 0))
+ if ( (!ret) &&
+ ((gdk_event->keyval == GDK_Tab) || (gdk_event->keyval == GDK_ISO_Left_Tab)) &&
+ ((win->m_windowStyle & wxTE_PROCESS_TAB) == 0))
{
wxNavigationKeyEvent new_event;
- new_event.SetDirection( !(gdk_event->state & GDK_SHIFT_MASK) );
- new_event.SetWindowChange( FALSE );
+ /* 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->GetEventHandler()->ProcessEvent( new_event );
}
+ 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 );
+ }
+
/*
+ Damn, I forgot why this didn't work, but it didn't work.
+
// win is a panel: up can be propagated to the panel
if ((!ret) && (win->m_wxwindow) && (win->m_parent) && (win->m_parent->AcceptsFocus()) &&
(gdk_event->keyval == GDK_Up))
if (ret)
{
gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_press_event" );
+ return TRUE;
}
- return ret;
+ return FALSE;
}
//-----------------------------------------------------------------------------
switch (gdk_event->keyval)
{
case GDK_BackSpace: key_code = WXK_BACK; break;
+ case GDK_ISO_Left_Tab:
+ case GDK_KP_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_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;
event.m_y = 0;
event.SetEventObject( win );
- bool ret = win->GetEventHandler()->ProcessEvent( event );
-
- if (ret)
+ if (win->GetEventHandler()->ProcessEvent( event ))
{
- gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_press_event" );
+ gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_release_event" );
+ return TRUE;
}
- return ret;
+ return FALSE;
}
//-----------------------------------------------------------------------------
static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxWindow *win )
{
- if (!win->IsOwnGtkWindow( gdk_event->window )) return TRUE;
-
+ if (!win->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) )
}
}
- if (!win->HasVMT()) return TRUE;
-
/*
printf( "OnButtonPress from " );
if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
}
}
- wxPoint pt(win->GetClientAreaOrigin());
- event.m_x -= pt.x;
- event.m_y -= pt.y;
-
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;
+ }
- return TRUE;
+ return FALSE;
}
//-----------------------------------------------------------------------------
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 (g_blockEventsOnScroll) return TRUE;
+ if (!win->HasVMT()) return FALSE;
+ if (g_blockEventsOnDrag) return FALSE;
+ if (g_blockEventsOnScroll) return FALSE;
- if (!win->HasVMT()) return TRUE;
+ if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
/*
printf( "OnButtonRelease from " );
}
}
- wxPoint pt(win->GetClientAreaOrigin());
- event.m_x -= pt.x;
- event.m_y -= pt.y;
-
event.SetEventObject( win );
if (win->GetEventHandler()->ProcessEvent( event ))
+ {
gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "button_release_event" );
+ return TRUE;
+ }
- return TRUE;
+ return FALSE;
}
//-----------------------------------------------------------------------------
static gint gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion *gdk_event, wxWindow *win )
{
+ if (!win->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;
gdk_event->state = state;
}
- if (!win->IsOwnGtkWindow( gdk_event->window )) return TRUE;
-
- if (g_blockEventsOnDrag) return TRUE;
- if (g_blockEventsOnScroll) return TRUE;
-
- if (!win->HasVMT()) return TRUE;
-
/*
printf( "OnMotion from " );
if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
}
}
- wxPoint pt(win->GetClientAreaOrigin());
- event.m_x -= pt.x;
- event.m_y -= pt.y;
-
event.SetEventObject( win );
if (win->GetEventHandler()->ProcessEvent( event ))
+ {
gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "motion_notify_event" );
+ return TRUE;
+ }
- return TRUE;
+ return FALSE;
}
//-----------------------------------------------------------------------------
static gint gtk_window_focus_in_callback( GtkWidget *widget, GdkEvent *WXUNUSED(event), wxWindow *win )
{
- if (g_blockEventsOnDrag) return TRUE;
+ if (!win->HasVMT()) return FALSE;
+ if (g_blockEventsOnDrag) return FALSE;
g_focusWindow = win;
}
}
- if (!win->HasVMT()) return TRUE;
/*
printf( "OnSetFocus from " );
event.SetEventObject( win );
if (win->GetEventHandler()->ProcessEvent( event ))
+ {
gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus_in_event" );
-
- return TRUE;
+ return TRUE;
+ }
+
+ return FALSE;
}
//-----------------------------------------------------------------------------
static gint gtk_window_focus_out_callback( GtkWidget *widget, GdkEvent *WXUNUSED(event), wxWindow *win )
{
- if (g_blockEventsOnDrag) return TRUE;
+ if (!win->HasVMT()) return FALSE;
+ if (g_blockEventsOnDrag) return FALSE;
+
if (win->m_wxwindow)
{
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())
event.SetEventObject( win );
if (win->GetEventHandler()->ProcessEvent( event ))
+ {
gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus_out_event" );
-
- return TRUE;
+ return TRUE;
+ }
+
+ return FALSE;
}
//-----------------------------------------------------------------------------
static gint gtk_window_enter_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindow *win )
{
- if (g_blockEventsOnDrag) return TRUE;
+ if (!win->HasVMT()) return FALSE;
+ if (g_blockEventsOnDrag) return FALSE;
+
+ if (widget->window != gdk_event->window) return FALSE;
if ((widget->window) && (win->m_cursor))
gdk_window_set_cursor( widget->window, win->m_cursor->GetCursor() );
- if (widget->window != gdk_event->window) return TRUE;
-
- if (!win->HasVMT()) return TRUE;
-
/*
printf( "OnEnter from " );
if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
event.m_x = (long)x;
event.m_y = (long)y;
- wxPoint pt(win->GetClientAreaOrigin());
- event.m_x -= pt.x;
- event.m_y -= pt.y;
-
if (win->GetEventHandler()->ProcessEvent( event ))
+ {
gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "enter_notify_event" );
-
- return TRUE;
+ return TRUE;
+ }
+
+ return FALSE;
}
//-----------------------------------------------------------------------------
static gint gtk_window_leave_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindow *win )
{
- if (g_blockEventsOnDrag) return TRUE;
+ if (!win->HasVMT()) return FALSE;
+ if (g_blockEventsOnDrag) return FALSE;
+ if (widget->window != gdk_event->window) return FALSE;
+
if ((widget->window) && (win->m_cursor))
gdk_window_set_cursor( widget->window, wxSTANDARD_CURSOR->GetCursor() );
- if (widget->window != gdk_event->window) return TRUE;
-
- if (!win->HasVMT()) return TRUE;
-
/*
printf( "OnLeave from " );
if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
event.m_x = (long)x;
event.m_y = (long)y;
- wxPoint pt(win->GetClientAreaOrigin());
- event.m_x -= pt.x;
- event.m_y -= pt.y;
-
if (win->GetEventHandler()->ProcessEvent( event ))
+ {
gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "leave_notify_event" );
-
- return TRUE;
+ return TRUE;
+ }
+
+ return FALSE;
}
//-----------------------------------------------------------------------------
float diff = win->m_vAdjust->value - win->m_oldVerticalPos;
if (fabs(diff) < 0.2) return;
+ win->m_oldVerticalPos = win->m_vAdjust->value;
wxEventType command = wxEVT_NULL;
float diff = win->m_hAdjust->value - win->m_oldHorizontalPos;
if (fabs(diff) < 0.2) return;
+ win->m_oldHorizontalPos = win->m_hAdjust->value;
wxEventType command = wxEVT_NULL;
child->m_width,
child->m_height );
- if (wxIS_KIND_OF(parent,wxFrame))
- {
- parent->m_sizeSet = FALSE;
- }
-
if (parent->m_windowStyle & wxTAB_TRAVERSAL)
{
/* we now allow a window to get the focus as long as it
EVT_KEY_DOWN(wxWindow::OnKeyDown)
END_EVENT_TABLE()
-wxWindow::wxWindow()
+void wxWindow::Init()
{
+ m_isWindow = TRUE;
+
m_widget = (GtkWidget *) NULL;
m_wxwindow = (GtkWidget *) NULL;
m_parent = (wxWindow *) NULL;
#endif // wxUSE_TOOLTIPS
}
+wxWindow::wxWindow()
+{
+ Init();
+}
+
wxWindow::wxWindow( wxWindow *parent, wxWindowID id,
const wxPoint &pos, const wxSize &size,
long style, const wxString &name )
{
- m_insertCallback = wxInsertChildInWindow;
+ Init();
+
Create( parent, id, pos, size, style, name );
}
const wxPoint &pos, const wxSize &size,
long style, const wxString &name )
{
- m_isShown = FALSE;
- m_isEnabled = TRUE;
- m_needParent = TRUE;
+ wxASSERT_MSG( m_isWindow, _T("Init() must have been called before!") );
PreCreation( parent, id, pos, size, style, name );
m_widget = gtk_scrolled_window_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL );
GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
-#ifdef __WXDEBUG__
- debug_focus_in( m_widget, "wxWindow::m_widget", name );
-#endif
-
GtkScrolledWindow *s_window = GTK_SCROLLED_WINDOW(m_widget);
-#ifdef __WXDEBUG__
- debug_focus_in( s_window->hscrollbar, "wxWindow::hsrcollbar", name );
- debug_focus_in( s_window->vscrollbar, "wxWindow::vsrcollbar", name );
-#endif
-
GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
scroll_class->scrollbar_spacing = 0;
m_wxwindow = gtk_myfixed_new();
-#ifdef __WXDEBUG__
- debug_focus_in( m_wxwindow, "wxWindow::m_wxwindow", name );
-#endif
+ gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
+
+#if (GTK_MINOR_VERSION > 0)
+ GtkMyFixed *myfixed = GTK_MYFIXED(m_wxwindow);
-#ifdef NEW_GTK_SCROLL_CODE
- gtk_scrolled_window_add_with_viewport( GTK_SCROLLED_WINDOW(m_widget), m_wxwindow );
- GtkViewport *viewport = GTK_VIEWPORT(s_window->child);
+ if (m_windowStyle & wxRAISED_BORDER)
+ {
+ gtk_myfixed_set_shadow_type( myfixed, GTK_SHADOW_OUT );
+ }
+ else if (m_windowStyle & wxSUNKEN_BORDER)
+ {
+ gtk_myfixed_set_shadow_type( myfixed, GTK_SHADOW_IN );
+ }
+ else
+ {
+ gtk_myfixed_set_shadow_type( myfixed, GTK_SHADOW_NONE );
+ }
#else
- gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
GtkViewport *viewport = GTK_VIEWPORT(s_window->viewport);
-#endif
-
-#ifdef __WXDEBUG__
- debug_focus_in( GTK_WIDGET(viewport), "wxWindow::viewport", name );
-#endif
if (m_windowStyle & wxRAISED_BORDER)
{
{
gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_NONE );
}
+#endif
if (m_windowStyle & wxTAB_TRAVERSAL)
{
m_acceptsFocus = TRUE;
}
+#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
// I _really_ don't want scrollbars in the beginning
m_vAdjust->lower = 0.0;
gtk_signal_connect( GTK_OBJECT(s_window->hscrollbar), "button_release_event",
(GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this );
- // these handers het notified when screen updates are required either when
+ // these handlers get notified when screen updates are required either when
// scrolling or when the window size (and therefore scrollbar configuration)
// has changed
m_hasVMT = FALSE;
#if wxUSE_DRAG_AND_DROP
- wxDELETE(m_dropTarget);
+ if (m_dropTarget)
+ {
+ delete m_dropTarget;
+ m_dropTarget = (wxDropTarget*) NULL;
+ }
#endif
#if wxUSE_TOOLTIPS
- wxDELETE(m_toolTip);
+ if (m_toolTip)
+ {
+ delete m_toolTip;
+ m_toolTip = (wxToolTip*) NULL;
+ }
#endif // wxUSE_TOOLTIPS
- if (m_parent) m_parent->RemoveChild( this );
if (m_widget) Show( FALSE );
DestroyChildren();
+ if (m_parent) m_parent->RemoveChild( this );
+
if (m_widgetStyle) gtk_style_unref( m_widgetStyle );
if (m_scrollGC) gdk_gc_unref( m_scrollGC );
DeleteRelatedConstraints();
if (m_constraints)
{
- // This removes any dangling pointers to this window
- // in other windows' constraintsInvolvedIn lists.
+ /* 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 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.
+ /* 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
+ /* 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;
const wxPoint &pos, const wxSize &size,
long style, const wxString &name )
{
- wxASSERT_MSG( (!m_needParent) || (parent), "Need complete parent." );
+ wxASSERT_MSG( (!m_needParent) || (parent), _T("Need complete parent.") );
m_widget = (GtkWidget*) NULL;
m_wxwindow = (GtkWidget*) NULL;
m_x = (int)pos.x;
m_y = (int)pos.y;
- if (!m_needParent) // some reasonable defaults
+ if (!m_needParent) /* some reasonable defaults */
{
if (m_x == -1)
{
void wxWindow::PostCreation()
{
+ wxASSERT_MSG( (m_widget != NULL), _T("invalid window") );
+
if (m_wxwindow)
{
- gtk_signal_connect( GTK_OBJECT(m_wxwindow), "expose_event",
- GTK_SIGNAL_FUNC(gtk_window_expose_callback), (gpointer)this );
+ /* these get reported to wxWindows -> wxPaintEvent */
+ 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_FUNC(gtk_window_draw_callback), (gpointer)this );
+
+#if (GTK_MINOR_VERSION > 0)
+ /* 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 );
- gtk_signal_connect( GTK_OBJECT(m_wxwindow), "draw",
- GTK_SIGNAL_FUNC(gtk_window_draw_callback), (gpointer)this );
+ gtk_signal_connect( GTK_OBJECT(m_widget), "draw",
+ GTK_SIGNAL_FUNC(gtk_window_own_draw_callback), (gpointer)this );
+#endif
}
ConnectWidget( GetConnectWidget() );
- if (m_widget && m_parent) gtk_widget_realize( m_widget );
+ /* we force the creation of wxFrame and wxDialog in the respective code */
+ if (m_parent) gtk_widget_realize( m_widget );
if (m_wxwindow) gtk_widget_realize( m_wxwindow );
bool wxWindow::Close( bool force )
{
- wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+ wxASSERT_MSG( (m_widget != NULL), _T("invalid window") );
wxCloseEvent event(wxEVT_CLOSE_WINDOW, m_windowId);
event.SetEventObject(this);
event.SetCanVeto(!force);
- // return FALSE if window wasn't closed because the application vetoed the
- // close event
+ /* return FALSE if window wasn't closed because the application vetoed the
+ * close event */
return GetEventHandler()->ProcessEvent(event) && !event.GetVeto();
}
bool wxWindow::Destroy()
{
- wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+ wxASSERT_MSG( (m_widget != NULL), _T("invalid window") );
m_hasVMT = FALSE;
delete this;
// are we to set fonts here ?
}
-wxPoint wxWindow::GetClientAreaOrigin() const
+void wxWindow::DoSetSize( int x, int y, int width, int height, int sizeFlags )
{
- return wxPoint(0,0);
-}
+ wxASSERT_MSG( (m_widget != NULL), _T("invalid window") );
+ wxASSERT_MSG( (m_parent != NULL), _T("wxWindow::SetSize requires parent.\n") );
-void wxWindow::AdjustForParentClientOrigin( int& x, int& y, int sizeFlags )
-{
- if (((sizeFlags & wxSIZE_NO_ADJUSTMENTS) == 0) && GetParent())
- {
- wxPoint pt(GetParent()->GetClientAreaOrigin());
- x += pt.x;
- y += pt.y;
- }
-}
-
-void wxWindow::SetSize( int x, int y, int width, int height, int sizeFlags )
-{
- wxASSERT_MSG( (m_widget != NULL), "invalid window" );
- wxASSERT_MSG( (m_parent != NULL), "wxWindow::SetSize requires parent.\n" );
-
- if (m_resizing) return; // I don't like recursions
+ if (m_resizing) return; /* I don't like recursions */
m_resizing = TRUE;
- if (m_parent->m_wxwindow == NULL) // i.e. wxNotebook
+ if (m_parent->m_wxwindow == NULL) /* i.e. wxNotebook */
{
- // don't set the size for children of wxNotebook, just take the values.
+ /* don't set the size for children of wxNotebook, just take the values. */
m_x = x;
m_y = y;
m_width = width;
if ((m_maxWidth != -1) && (m_width > m_maxWidth)) m_width = m_maxWidth;
if ((m_maxHeight != -1) && (m_height > m_maxHeight)) m_height = m_maxHeight;
- wxPoint pt( m_parent->GetClientAreaOrigin() );
- gtk_myfixed_move( GTK_MYFIXED(m_parent->m_wxwindow), m_widget, m_x+pt.x, m_y+pt.y );
+ if (GTK_WIDGET_HAS_DEFAULT(m_widget))
+ {
+ /* the default button has a border around it */
+ int border = 5;
+
+ gtk_myfixed_move( GTK_MYFIXED(m_parent->m_wxwindow), m_widget, m_x-border, m_y-border );
- if ((old_width != m_width) || (old_height != m_height))
- gtk_widget_set_usize( m_widget, m_width, m_height );
+ gtk_widget_set_usize( m_widget, m_width+2*border, m_height+2*border );
+ }
+ else
+ {
+ gtk_myfixed_move( GTK_MYFIXED(m_parent->m_wxwindow), m_widget, m_x, m_y );
+
+ if ((old_width != m_width) || (old_height != m_height))
+ gtk_widget_set_usize( m_widget, m_width, m_height );
+ }
}
m_sizeSet = TRUE;
UpdateWindowUI();
}
-void wxWindow::SetSize( int width, int height )
-{
- SetSize( -1, -1, width, height, wxSIZE_USE_EXISTING );
-}
-
-void wxWindow::Move( int x, int y )
-{
- SetSize( x, y, -1, -1, wxSIZE_USE_EXISTING );
-}
-
void wxWindow::GetSize( int *width, int *height ) const
{
- wxCHECK_RET( (m_widget != NULL), "invalid window" );
+ wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
if (width) (*width) = m_width;
if (height) (*height) = m_height;
}
-void wxWindow::SetClientSize( int width, int height )
+void wxWindow::DoSetClientSize( int width, int height )
{
- wxCHECK_RET( (m_widget != NULL), "invalid window" );
+ wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
if (!m_wxwindow)
{
GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
-#ifdef NEW_GTK_SCROLL_CODE
- GtkWidget *viewport = scroll_window->child;
-#else
+#if (GTK_MINOR_VERSION == 0)
GtkWidget *viewport = scroll_window->viewport;
-#endif
-
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;
}
+#endif
+
+/*
+ GtkWidget *hscrollbar = scroll_window->hscrollbar;
+ GtkWidget *vscrollbar = scroll_window->vscrollbar;
+
+ we use this instead: range.slider_width = 11 + 2*2pts edge
+*/
if (scroll_window->vscrollbar_visible)
{
- dw += vscrollbar->allocation.width;
+ dw += 15; /* dw += vscrollbar->allocation.width; */
dw += scroll_class->scrollbar_spacing;
}
if (scroll_window->hscrollbar_visible)
{
- dh += hscrollbar->allocation.height;
+ dh += 15; /* dh += hscrollbar->allocation.height; */
dw += scroll_class->scrollbar_spacing;
}
}
- SetSize( width+dw, height+dh );
+ SetSize( width+dw, height+dh );
}
}
void wxWindow::GetClientSize( int *width, int *height ) const
{
- wxCHECK_RET( (m_widget != NULL), "invalid window" );
+ wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
if (!m_wxwindow)
{
GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
-#ifdef NEW_GTK_SCROLL_CODE
- GtkWidget *viewport = scroll_window->child;
-#else
+#if (GTK_MINOR_VERSION == 0)
GtkWidget *viewport = scroll_window->viewport;
-#endif
-
GtkStyleClass *viewport_class = viewport->style->klass;
if ((m_windowStyle & wxRAISED_BORDER) ||
dw += 2 * viewport_class->xthickness;
dh += 2 * viewport_class->ythickness;
}
+#endif
+/*
+ GtkWidget *hscrollbar = scroll_window->hscrollbar;
+ GtkWidget *vscrollbar = scroll_window->vscrollbar;
+
+ we use this instead: range.slider_width = 11 + 2*2pts edge
+*/
if (scroll_window->vscrollbar_visible)
{
-// dw += vscrollbar->allocation.width;
- dw += 15; // range.slider_width = 11 + 2*2pts edge
+ dw += 15; /* dw += vscrollbar->allocation.width; */
dw += scroll_class->scrollbar_spacing;
}
if (scroll_window->hscrollbar_visible)
{
-// dh += hscrollbar->allocation.height;
- dh += 15;
+ dh += 15; /* dh += hscrollbar->allocation.height; */
dh += scroll_class->scrollbar_spacing;
}
}
void wxWindow::GetPosition( int *x, int *y ) const
{
- wxCHECK_RET( (m_widget != NULL), "invalid window" );
+ wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
if (x) (*x) = m_x;
if (y) (*y) = m_y;
void wxWindow::ClientToScreen( int *x, int *y )
{
- wxCHECK_RET( (m_widget != NULL), "invalid window" );
+ wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
GdkWindow *source = (GdkWindow *) NULL;
if (m_wxwindow)
}
}
- wxPoint pt(GetClientAreaOrigin());
- org_x += pt.x;
- org_y += pt.y;
-
if (x) *x += org_x;
if (y) *y += org_y;
}
void wxWindow::ScreenToClient( int *x, int *y )
{
- wxCHECK_RET( (m_widget != NULL), "invalid window" );
+ wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
GdkWindow *source = (GdkWindow *) NULL;
if (m_wxwindow)
}
}
- wxPoint pt(GetClientAreaOrigin());
- org_x -= pt.x;
- org_y -= pt.y;
-
if (x) *x -= org_x;
if (y) *y -= org_y;
}
void wxWindow::Centre( int direction )
{
- wxCHECK_RET( (m_widget != NULL), "invalid window" );
+ wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
int x = m_x;
int y = m_y;
void wxWindow::Fit()
{
- wxCHECK_RET( (m_widget != NULL), "invalid window" );
+ wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
int maxX = 0;
int maxY = 0;
void wxWindow::SetSizeHints( int minW, int minH, int maxW, int maxH, int WXUNUSED(incW), int WXUNUSED(incH) )
{
- wxCHECK_RET( (m_widget != NULL), "invalid window" );
+ wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
m_minWidth = minW;
m_minHeight = minH;
bool wxWindow::Show( bool show )
{
- wxCHECK_MSG( (m_widget != NULL), FALSE, "invalid window" );
+ wxCHECK_MSG( (m_widget != NULL), FALSE, _T("invalid window") );
+
+ if (show == m_isShown) return TRUE;
if (show)
gtk_widget_show( m_widget );
void wxWindow::Enable( bool enable )
{
- wxCHECK_RET( (m_widget != NULL), "invalid window" );
+ wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
m_isEnabled = enable;
int wxWindow::GetCharHeight() const
{
- wxCHECK_MSG( (m_widget != NULL), 12, "invalid window" );
+ wxCHECK_MSG( (m_widget != NULL), 12, _T("invalid window") );
- wxCHECK_MSG( m_font.Ok(), 12, "invalid font" );
+ wxCHECK_MSG( m_font.Ok(), 12, _T("invalid font") );
GdkFont *font = m_font.GetInternalFont( 1.0 );
int wxWindow::GetCharWidth() const
{
- wxCHECK_MSG( (m_widget != NULL), 8, "invalid window" );
+ wxCHECK_MSG( (m_widget != NULL), 8, _T("invalid window") );
- wxCHECK_MSG( m_font.Ok(), 8, "invalid font" );
+ wxCHECK_MSG( m_font.Ok(), 8, _T("invalid font") );
GdkFont *font = m_font.GetInternalFont( 1.0 );
wxFont fontToUse = m_font;
if (theFont) fontToUse = *theFont;
- wxCHECK_RET( fontToUse.Ok(), "invalid font" );
+ wxCHECK_RET( fontToUse.Ok(), _T("invalid font") );
GdkFont *font = fontToUse.GetInternalFont( 1.0 );
- if (x) (*x) = gdk_string_width( font, string );
+ 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; // ??
void wxWindow::SetFocus()
{
- wxCHECK_RET( (m_widget != NULL), "invalid window" );
+ wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
GtkWidget *connect_widget = GetConnectWidget();
if (connect_widget)
void wxWindow::AddChild( wxWindow *child )
{
- wxCHECK_RET( (m_widget != NULL), "invalid window" );
- wxCHECK_RET( (child != NULL), "invalid child" );
+ wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
+ wxCHECK_RET( (child != NULL), _T("invalid child") );
m_children.Append( child );
}
wxWindow *wxWindow::ReParent( wxWindow *newParent )
{
- wxCHECK_MSG( (m_widget != NULL), (wxWindow*) NULL, "invalid window" );
+ wxCHECK_MSG( (m_widget != NULL), (wxWindow*) NULL, _T("invalid window") );
wxWindow *oldParent = GetParent();
void wxWindow::Raise()
{
- wxCHECK_RET( (m_widget != NULL), "invalid window" );
+ wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
if (m_widget) gdk_window_raise( m_widget->window );
}
void wxWindow::Lower()
{
- wxCHECK_RET( (m_widget != NULL), "invalid window" );
+ wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
if (m_widget) gdk_window_lower( m_widget->window );
}
void wxWindow::SetCursor( const wxCursor &cursor )
{
- wxCHECK_RET( (m_widget != NULL), "invalid window" );
+ wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
if (cursor.Ok())
{
void wxWindow::Refresh( bool eraseBackground, const wxRect *rect )
{
- wxCHECK_RET( (m_widget != NULL), "invalid window" );
+ wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
if (eraseBackground && m_wxwindow && m_wxwindow->window)
{
{
gdk_window_clear_area( m_wxwindow->window,
rect->x, rect->y,
- rect->width,
- rect->height );
+ rect->width, rect->height );
}
else
{
- Clear();
+ gdk_window_clear( m_wxwindow->window );
}
}
void wxWindow::Clear()
{
- wxCHECK_RET( m_widget != NULL, "invalid window" );
+ wxCHECK_RET( m_widget != NULL, _T("invalid window") );
- if (m_wxwindow && m_wxwindow->window) gdk_window_clear( m_wxwindow->window );
+ if (m_wxwindow && m_wxwindow->window)
+ {
+ gdk_window_clear( m_wxwindow->window );
+ }
}
#if wxUSE_TOOLTIPS
m_toolTip->Apply( this );
}
-void wxWindow::ApplyToolTip( GtkTooltips *tips, const char *tip )
+void wxWindow::ApplyToolTip( GtkTooltips *tips, const wxChar *tip )
{
- gtk_tooltips_set_tip( tips, GetConnectWidget(), tip, (gchar*) NULL );
+ gtk_tooltips_set_tip( tips, GetConnectWidget(), wxConv_current->cWX2MB(tip), (gchar*) NULL );
}
#endif // wxUSE_TOOLTIPS
void wxWindow::SetBackgroundColour( const wxColour &colour )
{
- wxCHECK_RET( m_widget != NULL, "invalid window" );
+ wxCHECK_RET( m_widget != NULL, _T("invalid window") );
if (m_backgroundColour == colour) return;
m_backgroundColour = colour;
if (!m_backgroundColour.Ok()) return;
- if (m_wxwindow)
+ if (m_wxwindow && m_wxwindow->window)
{
- GdkWindow *window = m_wxwindow->window;
- m_backgroundColour.CalcPixel( gdk_window_get_colormap( window ) );
- gdk_window_set_background( window, m_backgroundColour.GetColor() );
+ /* wxMSW doesn't clear the window here. I don't do that
+ either to provide compatibility. call Clear() to do
+ the job. */
+
+ m_backgroundColour.CalcPixel( gdk_window_get_colormap( m_wxwindow->window ) );
+ gdk_window_set_background( m_wxwindow->window, m_backgroundColour.GetColor() );
}
wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
+
if (sysbg.Red() == colour.Red() &&
sysbg.Green() == colour.Green() &&
sysbg.Blue() == colour.Blue())
void wxWindow::SetForegroundColour( const wxColour &colour )
{
- wxCHECK_RET( m_widget != NULL, "invalid window" );
+ wxCHECK_RET( m_widget != NULL, _T("invalid window") );
if (m_foregroundColour == colour) return;
bool wxWindow::Validate()
{
- wxCHECK_MSG( m_widget != NULL, FALSE, "invalid window" );
+ wxCHECK_MSG( m_widget != NULL, FALSE, _T("invalid window") );
wxNode *node = m_children.First();
while (node)
bool wxWindow::TransferDataToWindow()
{
- wxCHECK_MSG( m_widget != NULL, FALSE, "invalid window" );
+ wxCHECK_MSG( m_widget != NULL, FALSE, _T("invalid window") );
wxNode *node = m_children.First();
while (node)
bool wxWindow::TransferDataFromWindow()
{
- wxCHECK_MSG( m_widget != NULL, FALSE, "invalid window" );
+ wxCHECK_MSG( m_widget != NULL, FALSE, _T("invalid window") );
wxNode *node = m_children.First();
while (node)
void wxWindow::InitDialog()
{
- wxCHECK_RET( m_widget != NULL, "invalid window" );
+ wxCHECK_RET( m_widget != NULL, _T("invalid window") );
wxInitDialogEvent event(GetId());
event.SetEventObject( this );
static void SetInvokingWindow( wxMenu *menu, wxWindow *win )
{
menu->SetInvokingWindow( win );
- wxNode *node = menu->m_items.First();
+ wxNode *node = menu->GetItems().First();
while (node)
{
wxMenuItem *menuitem = (wxMenuItem*)node->Data();
bool wxWindow::PopupMenu( wxMenu *menu, int x, int y )
{
- wxCHECK_MSG( m_widget != NULL, FALSE, "invalid window" );
+ wxCHECK_MSG( m_widget != NULL, FALSE, _T("invalid window") );
- wxCHECK_MSG( menu != NULL, FALSE, "invalid popup-menu" );
+ wxCHECK_MSG( menu != NULL, FALSE, _T("invalid popup-menu") );
SetInvokingWindow( menu, this );
void wxWindow::SetDropTarget( wxDropTarget *dropTarget )
{
- wxCHECK_RET( m_widget != NULL, "invalid window" );
+ wxCHECK_RET( m_widget != NULL, _T("invalid window") );
GtkWidget *dnd_widget = GetConnectWidget();
void wxWindow::SetFont( const wxFont &font )
{
- wxCHECK_RET( m_widget != NULL, "invalid window" );
-
+ wxCHECK_RET( m_widget != NULL, _T("invalid window") );
+
+ if (m_font == font) return;
+
if (((wxFont*)&font)->Ok())
m_font = font;
else
void wxWindow::CaptureMouse()
{
- wxCHECK_RET( m_widget != NULL, "invalid window" );
+ wxCHECK_RET( m_widget != NULL, _T("invalid window") );
- wxCHECK_RET( g_capturing == FALSE, "CaptureMouse called twice" );
+ wxCHECK_RET( g_capturing == FALSE, _T("CaptureMouse called twice") );
GtkWidget *connect_widget = GetConnectWidget();
gtk_grab_add( connect_widget );
void wxWindow::ReleaseMouse()
{
- wxCHECK_RET( m_widget != NULL, "invalid window" );
+ wxCHECK_RET( m_widget != NULL, _T("invalid window") );
- wxCHECK_RET( g_capturing == TRUE, "ReleaseMouse called twice" );
+ wxCHECK_RET( g_capturing == TRUE, _T("ReleaseMouse called twice") );
GtkWidget *connect_widget = GetConnectWidget();
gtk_grab_remove( connect_widget );
void wxWindow::SetScrollbar( int orient, int pos, int thumbVisible,
int range, bool refresh )
{
- wxCHECK_RET( m_widget != NULL, "invalid window" );
+ wxCHECK_RET( m_widget != NULL, _T("invalid window") );
- wxCHECK_RET( m_wxwindow != NULL, "window needs client area for scrolling" );
+ wxCHECK_RET( m_wxwindow != NULL, _T("window needs client area for scrolling") );
m_hasScrolling = TRUE;
void wxWindow::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) )
{
- wxCHECK_RET( m_widget != NULL, "invalid window" );
+ wxCHECK_RET( m_widget != NULL, _T("invalid window") );
- wxCHECK_RET( m_wxwindow != NULL, "window needs client area for scrolling" );
+ wxCHECK_RET( m_wxwindow != NULL, _T("window needs client area for scrolling") );
if (orient == wxHORIZONTAL)
{
int wxWindow::GetScrollThumb( int orient ) const
{
- wxCHECK_MSG( m_widget != NULL, 0, "invalid window" );
+ wxCHECK_MSG( m_widget != NULL, 0, _T("invalid window") );
- wxCHECK_MSG( m_wxwindow != NULL, 0, "window needs client area for scrolling" );
+ wxCHECK_MSG( m_wxwindow != NULL, 0, _T("window needs client area for scrolling") );
if (orient == wxHORIZONTAL)
return (int)(m_hAdjust->page_size+0.5);
int wxWindow::GetScrollPos( int orient ) const
{
- wxCHECK_MSG( m_widget != NULL, 0, "invalid window" );
+ wxCHECK_MSG( m_widget != NULL, 0, _T("invalid window") );
- wxCHECK_MSG( m_wxwindow != NULL, 0, "window needs client area for scrolling" );
+ wxCHECK_MSG( m_wxwindow != NULL, 0, _T("window needs client area for scrolling") );
if (orient == wxHORIZONTAL)
return (int)(m_hAdjust->value+0.5);
int wxWindow::GetScrollRange( int orient ) const
{
- wxCHECK_MSG( m_widget != NULL, 0, "invalid window" );
+ wxCHECK_MSG( m_widget != NULL, 0, _T("invalid window") );
- wxCHECK_MSG( m_wxwindow != NULL, 0, "window needs client area for scrolling" );
+ wxCHECK_MSG( m_wxwindow != NULL, 0, _T("window needs client area for scrolling") );
if (orient == wxHORIZONTAL)
return (int)(m_hAdjust->upper+0.5);
void wxWindow::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
{
- wxCHECK_RET( m_widget != NULL, "invalid window" );
+ wxCHECK_RET( m_widget != NULL, _T("invalid window") );
- wxCHECK_RET( m_wxwindow != NULL, "window needs client area for scrolling" );
+ wxCHECK_RET( m_wxwindow != NULL, _T("window needs client area for scrolling") );
+
+ wxNode *node = m_children.First();
+ while (node)
+ {
+ wxWindow *child = (wxWindow*) node->Data();
+ child->Move( child->m_x + dx, child->m_y + dy );
+ node = node->Next();
+ }
int cw = 0;
int ch = 0;
}
else if (constr)
{
- char *windowClass = this->GetClassInfo()->GetClassName();
+ wxChar *windowClass = this->GetClassInfo()->GetClassName();
wxString winName;
- if (GetName() == "")
- winName = "unnamed";
+ if (GetName() == _T(""))
+ winName = _T("unnamed");
else
winName = GetName();
- wxLogDebug( "Constraint(s) not satisfied for window of type %s, name %s:\n",
- (const char *)windowClass,
- (const char *)winName);
- if (!constr->left.GetDone()) wxLogDebug( " unsatisfied 'left' constraint.\n" );
- if (!constr->right.GetDone()) wxLogDebug( " unsatisfied 'right' constraint.\n" );
- if (!constr->width.GetDone()) wxLogDebug( " unsatisfied 'width' constraint.\n" );
- if (!constr->height.GetDone()) wxLogDebug( " unsatisfied 'height' constraint.\n" );
- wxLogDebug( "Please check constraints: try adding AsIs() constraints.\n" );
+ wxLogDebug( _T("Constraint(s) not satisfied for window of type %s, name %s:\n"),
+ (const wxChar *)windowClass,
+ (const wxChar *)winName);
+ if (!constr->left.GetDone()) wxLogDebug( _T(" unsatisfied 'left' constraint.\n") );
+ if (!constr->right.GetDone()) wxLogDebug( _T(" unsatisfied 'right' constraint.\n") );
+ if (!constr->width.GetDone()) wxLogDebug( _T(" unsatisfied 'width' constraint.\n") );
+ if (!constr->height.GetDone()) wxLogDebug( _T(" unsatisfied 'height' constraint.\n") );
+ wxLogDebug( _T("Please check constraints: try adding AsIs() constraints.\n") );
}
if (recurse)
projects / wxWidgets.git / blobdiff