// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
-// Licence: wxWindows licence
+// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#include "wx/dcclient.h"
#include "wx/dnd.h"
#include "wx/mdi.h"
+#include "wx/notebook.h"
+#include "wx/statusbr.h"
+//#include "wx/treectrl.h"
#include "gdk/gdkkeysyms.h"
#include <math.h>
#include "wx/gtk/win_gtk.h"
if (g_blockEventsOnDrag) return;
/*
- printf( "OnExpose from " );
+ if (IS_KIND_OF(win,wxTreeCtrl))
+ {
+ printf( "OnExpose from " );
if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
printf( win->GetClassInfo()->GetClassName() );
printf( ".\n" );
printf( "y: %d \n", gdk_event->area.y );
printf( "w: %d \n", gdk_event->area.width );
printf( "h: %d \n", gdk_event->area.height );
+}
*/
win->m_updateRegion.Union( gdk_event->area.x,
gdk_event->area.y,
- gdk_event->area.width,
- gdk_event->area.height );
-
+ gdk_event->area.width,
+ gdk_event->area.height );
+
if (gdk_event->count > 0) return;
wxPaintEvent event( win->GetId() );
*/
win->m_updateRegion.Union( rect->x, rect->y, rect->width, rect->height );
-
+
wxPaintEvent event( win->GetId() );
event.SetEventObject( win );
win->ProcessEvent( event );
//-----------------------------------------------------------------------------
// size
-// I don't any longer intercept GTK's internal resize events (except frames)
+// I don't any longer intercept GTK's internal resize events, except
+// for frames and from within MDI and tabbed windows (client area
+// size determined internally by GTK, not wxWin).
/*
void gtk_window_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation* alloc, wxWindow *win )
long key_code = 0;
switch (gdk_event->keyval)
{
- case GDK_BackSpace: key_code = WXK_BACK; break;
- case GDK_Tab: key_code = WXK_TAB; break;
- case GDK_Linefeed: key_code = WXK_RETURN; break;
- case GDK_Clear: key_code = WXK_CLEAR; break;
- case GDK_Return: key_code = WXK_RETURN; break;
- case GDK_Pause: key_code = WXK_PAUSE; break;
- case GDK_Scroll_Lock: key_code = WXK_SCROLL; break;
- case GDK_Escape: key_code = WXK_ESCAPE; break;
- case GDK_Delete: key_code = WXK_DELETE; break;
- case GDK_Home: key_code = WXK_HOME; break;
- case GDK_Left: key_code = WXK_LEFT; break;
- case GDK_Up: key_code = WXK_UP; break;
- case GDK_Right: key_code = WXK_RIGHT; break;
- case GDK_Down: key_code = WXK_DOWN; break;
- case GDK_Prior: key_code = WXK_PRIOR; break;
-// case GDK_Page_Up: key_code = WXK_PAGEUP; break;
- case GDK_Next: key_code = WXK_NEXT; break;
-// case GDK_Page_Down: key_code = WXK_PAGEDOWN; break;
- case GDK_End: key_code = WXK_END; break;
- case GDK_Begin: key_code = WXK_HOME; break;
- case GDK_Select: key_code = WXK_SELECT; break;
- case GDK_Print: key_code = WXK_PRINT; break;
- case GDK_Execute: key_code = WXK_EXECUTE; break;
- case GDK_Insert: key_code = WXK_INSERT; break;
- case GDK_Num_Lock: key_code = WXK_NUMLOCK; break;
- case GDK_KP_Tab: key_code = WXK_TAB; break;
- case GDK_KP_Enter: key_code = WXK_RETURN; break;
- case GDK_KP_Home: key_code = WXK_HOME; break;
- case GDK_KP_Left: key_code = WXK_LEFT; break;
- case GDK_KP_Up: key_code = WXK_UP; break;
- case GDK_KP_Right: key_code = WXK_RIGHT; break;
- case GDK_KP_Down: key_code = WXK_DOWN; break;
- case GDK_KP_Prior: key_code = WXK_PRIOR; break;
-// case GDK_KP_Page_Up: key_code = WXK_PAGEUP; break;
- case GDK_KP_Next: key_code = WXK_NEXT; break;
-// case GDK_KP_Page_Down: key_code = WXK_PAGEDOWN; break;
- case GDK_KP_End: key_code = WXK_END; break;
- case GDK_KP_Begin: key_code = WXK_HOME; break;
- case GDK_KP_Insert: key_code = WXK_INSERT; break;
- case GDK_KP_Delete: key_code = WXK_DELETE; break;
- case GDK_KP_Multiply: key_code = WXK_MULTIPLY; break;
- case GDK_KP_Add: key_code = WXK_ADD; break;
- case GDK_KP_Separator: key_code = WXK_SEPARATOR; break;
- case GDK_KP_Subtract: key_code = WXK_SUBTRACT; break;
- case GDK_KP_Decimal: key_code = WXK_DECIMAL; break;
- case GDK_KP_Divide: key_code = WXK_DIVIDE; break;
- case GDK_KP_0: key_code = WXK_NUMPAD0; break;
- case GDK_KP_1: key_code = WXK_NUMPAD1; break;
- case GDK_KP_2: key_code = WXK_NUMPAD2; break;
- case GDK_KP_3: key_code = WXK_NUMPAD3; break;
- case GDK_KP_4: key_code = WXK_NUMPAD4; break;
- case GDK_KP_5: key_code = WXK_NUMPAD5; break;
- case GDK_KP_6: key_code = WXK_NUMPAD6; break;
- case GDK_KP_7: key_code = WXK_NUMPAD7; break;
- case GDK_KP_8: key_code = WXK_NUMPAD7; break;
- case GDK_KP_9: key_code = WXK_NUMPAD9; break;
- case GDK_F1: key_code = WXK_F1; break;
- case GDK_F2: key_code = WXK_F2; break;
- case GDK_F3: key_code = WXK_F3; break;
- case GDK_F4: key_code = WXK_F4; break;
- case GDK_F5: key_code = WXK_F5; break;
- case GDK_F6: key_code = WXK_F6; break;
- case GDK_F7: key_code = WXK_F7; break;
- case GDK_F8: key_code = WXK_F8; break;
- case GDK_F9: key_code = WXK_F9; break;
- case GDK_F10: key_code = WXK_F10; break;
- case GDK_F11: key_code = WXK_F11; break;
- case GDK_F12: key_code = WXK_F12; break;
+ case GDK_BackSpace: key_code = WXK_BACK; break;
+ case GDK_Tab: key_code = WXK_TAB; break;
+ case GDK_Linefeed: key_code = WXK_RETURN; break;
+ case GDK_Clear: key_code = WXK_CLEAR; break;
+ case GDK_Return: key_code = WXK_RETURN; break;
+ case GDK_Pause: key_code = WXK_PAUSE; break;
+ case GDK_Scroll_Lock: key_code = WXK_SCROLL; break;
+ case GDK_Escape: key_code = WXK_ESCAPE; break;
+ case GDK_Delete: key_code = WXK_DELETE; break;
+ case GDK_Home: key_code = WXK_HOME; break;
+ case GDK_Left: key_code = WXK_LEFT; break;
+ case GDK_Up: key_code = WXK_UP; break;
+ case GDK_Right: key_code = WXK_RIGHT; break;
+ case GDK_Down: key_code = WXK_DOWN; break;
+ case GDK_Prior: key_code = WXK_PRIOR; break;
+// case GDK_Page_Up: key_code = WXK_PAGEUP; break;
+ case GDK_Next: key_code = WXK_NEXT; break;
+// case GDK_Page_Down: key_code = WXK_PAGEDOWN; break;
+ case GDK_End: key_code = WXK_END; break;
+ case GDK_Begin: key_code = WXK_HOME; break;
+ case GDK_Select: key_code = WXK_SELECT; break;
+ case GDK_Print: key_code = WXK_PRINT; break;
+ case GDK_Execute: key_code = WXK_EXECUTE; break;
+ case GDK_Insert: key_code = WXK_INSERT; break;
+ case GDK_Num_Lock: key_code = WXK_NUMLOCK; break;
+ case GDK_KP_Tab: key_code = WXK_TAB; break;
+ case GDK_KP_Enter: key_code = WXK_RETURN; break;
+ case GDK_KP_Home: key_code = WXK_HOME; break;
+ case GDK_KP_Left: key_code = WXK_LEFT; break;
+ case GDK_KP_Up: key_code = WXK_UP; break;
+ case GDK_KP_Right: key_code = WXK_RIGHT; break;
+ case GDK_KP_Down: key_code = WXK_DOWN; break;
+ case GDK_KP_Prior: key_code = WXK_PRIOR; break;
+// case GDK_KP_Page_Up: key_code = WXK_PAGEUP; break;
+ case GDK_KP_Next: key_code = WXK_NEXT; break;
+// case GDK_KP_Page_Down: key_code = WXK_PAGEDOWN; break;
+ case GDK_KP_End: key_code = WXK_END; break;
+ case GDK_KP_Begin: key_code = WXK_HOME; break;
+ case GDK_KP_Insert: key_code = WXK_INSERT; break;
+ case GDK_KP_Delete: key_code = WXK_DELETE; break;
+ case GDK_KP_Multiply: key_code = WXK_MULTIPLY; break;
+ case GDK_KP_Add: key_code = WXK_ADD; break;
+ case GDK_KP_Separator: key_code = WXK_SEPARATOR; break;
+ case GDK_KP_Subtract: key_code = WXK_SUBTRACT; break;
+ case GDK_KP_Decimal: key_code = WXK_DECIMAL; break;
+ case GDK_KP_Divide: key_code = WXK_DIVIDE; break;
+ case GDK_KP_0: key_code = WXK_NUMPAD0; break;
+ case GDK_KP_1: key_code = WXK_NUMPAD1; break;
+ case GDK_KP_2: key_code = WXK_NUMPAD2; break;
+ case GDK_KP_3: key_code = WXK_NUMPAD3; break;
+ case GDK_KP_4: key_code = WXK_NUMPAD4; break;
+ case GDK_KP_5: key_code = WXK_NUMPAD5; break;
+ case GDK_KP_6: key_code = WXK_NUMPAD6; break;
+ case GDK_KP_7: key_code = WXK_NUMPAD7; break;
+ case GDK_KP_8: key_code = WXK_NUMPAD7; break;
+ case GDK_KP_9: key_code = WXK_NUMPAD9; break;
+ case GDK_F1: key_code = WXK_F1; break;
+ case GDK_F2: key_code = WXK_F2; break;
+ case GDK_F3: key_code = WXK_F3; break;
+ case GDK_F4: key_code = WXK_F4; break;
+ case GDK_F5: key_code = WXK_F5; break;
+ case GDK_F6: key_code = WXK_F6; break;
+ case GDK_F7: key_code = WXK_F7; break;
+ case GDK_F8: key_code = WXK_F8; break;
+ case GDK_F9: key_code = WXK_F9; break;
+ case GDK_F10: key_code = WXK_F10; break;
+ case GDK_F11: key_code = WXK_F11; break;
+ case GDK_F12: key_code = WXK_F12; break;
default:
{
if ((gdk_event->keyval >= 0x20) && (gdk_event->keyval <= 0xFF))
event.m_x = 0;
event.m_y = 0;
event.SetEventObject( win );
- return win->ProcessEvent( event );
+
+ bool ret = win->ProcessEvent( event );
+/*
+ if (ret) printf( "found.\n") ;
+*/
+ return ret;
};
//-----------------------------------------------------------------------------
gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxWindow *win )
{
- if (widget->window != gdk_event->window) return FALSE;
- if (g_blockEventsOnDrag) return FALSE;
+ if (widget->window != gdk_event->window) return TRUE;
+ if (g_blockEventsOnDrag) return TRUE;
if (win->m_wxwindow)
{
};
};
- if (!win->HasVMT()) return FALSE;
+ if (!win->HasVMT()) return TRUE;
/*
printf( "OnButtonPress from " );
printf( ".\n" );
*/
- WXTYPE event_type = wxEVT_LEFT_DOWN;
+ wxEventType event_type = wxEVT_LEFT_DOWN;
if (gdk_event->button == 1)
{
{
if (widget->window != gdk_event->window) return TRUE;
- if (g_blockEventsOnDrag) return FALSE;
+ if (g_blockEventsOnDrag) return TRUE;
- if (!win->HasVMT()) return FALSE;
+ if (!win->HasVMT()) return TRUE;
/*
printf( "OnButtonRelease from " );
printf( ".\n" );
*/
- WXTYPE event_type = 0;
+ wxEventType event_type = wxEVT_NULL;
switch (gdk_event->button)
{
event.m_y = (long)gdk_event->y;
event.SetEventObject( win );
- return win->ProcessEvent( event );
+ win->ProcessEvent( event );
+
+ return TRUE;
};
//-----------------------------------------------------------------------------
{
if (widget->window != gdk_event->window) return TRUE;
- if (g_blockEventsOnDrag) return FALSE;
+ if (g_blockEventsOnDrag) return TRUE;
- if (!win->HasVMT()) return FALSE;
+ if (!win->HasVMT()) return TRUE;
/*
printf( "OnMotion from " );
win->ProcessEvent( event );
- return FALSE;
+ return TRUE;
};
//-----------------------------------------------------------------------------
// focus_in
-void gtk_window_focus_in_callback( GtkWidget *WXUNUSED(widget), GdkEvent *WXUNUSED(event), wxWindow *win )
+gint gtk_window_focus_in_callback( GtkWidget *WXUNUSED(widget), GdkEvent *WXUNUSED(event), wxWindow *win )
{
- if (g_blockEventsOnDrag) return;
+ if (g_blockEventsOnDrag) return TRUE;
if (win->m_wxwindow)
{
if (GTK_WIDGET_CAN_FOCUS(win->m_wxwindow))
};
};
- if (!win->HasVMT()) return;
+ if (!win->HasVMT()) return TRUE;
/*
printf( "OnSetFocus from " );
wxFocusEvent event( wxEVT_SET_FOCUS, win->GetId() );
event.SetEventObject( win );
win->ProcessEvent( event );
+
+ return TRUE;
};
//-----------------------------------------------------------------------------
// focus out
-void gtk_window_focus_out_callback( GtkWidget *WXUNUSED(widget), GdkEvent *WXUNUSED(event), wxWindow *win )
+gint gtk_window_focus_out_callback( GtkWidget *WXUNUSED(widget), GdkEvent *WXUNUSED(event), wxWindow *win )
{
- if (g_blockEventsOnDrag) return;
+ if (g_blockEventsOnDrag) return TRUE;
if (win->m_wxwindow)
{
if (GTK_WIDGET_CAN_FOCUS(win->m_wxwindow))
GTK_WIDGET_UNSET_FLAGS (win->m_wxwindow, GTK_HAS_FOCUS);
};
- if (!win->HasVMT()) return;
+ if (!win->HasVMT()) return TRUE;
/*
printf( "OnKillFocus from " );
wxFocusEvent event( wxEVT_KILL_FOCUS, win->GetId() );
event.SetEventObject( win );
win->ProcessEvent( event );
+
+ return TRUE;
};
//-----------------------------------------------------------------------------
printf( "Sending new value: %d.\n", i );
*/
- int command = 0;
+ wxEventType command = wxEVT_NULL;
float line_step = win->m_vAdjust->step_increment;
float page_step = win->m_vAdjust->page_increment;
printf( "Sending new value: %d.\n", i );
*/
- int command = 0;
+ wxEventType command = wxEVT_NULL;
float line_step = win->m_hAdjust->step_increment;
float page_step = win->m_hAdjust->page_increment;
if (!win->HasVMT()) return;
- int command = wxEVT_SCROLL_THUMBTRACK;
+ wxEventType command = wxEVT_SCROLL_THUMBTRACK;
int value = (int)(win->m_vAdjust->value+0.5);
wxScrollEvent event( command, win->GetId(), value, wxVERTICAL );
if (!win->HasVMT()) return;
- int command = wxEVT_SCROLL_THUMBTRACK;
+ wxEventType command = wxEVT_SCROLL_THUMBTRACK;
int value = (int)(win->m_hAdjust->value+0.5);
wxScrollEvent event( command, win->GetId(), value, wxHORIZONTAL );
void gtk_window_drop_callback( GtkWidget *widget, GdkEvent *event, wxWindow *win )
{
- printf( "OnDrop.\n" );
-
+ if (!win->HasVMT()) return;
+
if (win->GetDropTarget())
{
int x = 0;
//-----------------------------------------------------------------------------
// enter
-bool gtk_window_enter_callback( GtkWidget *widget, GdkEvent *WXUNUSED(event), wxWindow *win )
+bool gtk_window_enter_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindow *win )
{
- if (g_blockEventsOnDrag) return FALSE;
+ if (widget->window != gdk_event->window) return TRUE;
+ if (g_blockEventsOnDrag) return TRUE;
+ if (!win->HasVMT()) return TRUE;
if (widget->window)
gdk_window_set_cursor( widget->window, win->m_cursor->GetCursor() );
- return TRUE;
+ wxMouseEvent event( wxEVT_ENTER_WINDOW );
+ event.SetEventObject( win );
+ return win->ProcessEvent( event );
};
//-----------------------------------------------------------------------------
// leave
-bool gtk_window_leave_callback( GtkWidget *widget, GdkEvent *WXUNUSED(event), wxWindow *WXUNUSED(win) )
+bool gtk_window_leave_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindow *win )
{
- if (g_blockEventsOnDrag) return FALSE;
+ if (widget->window != gdk_event->window) return TRUE;
+ if (!win->HasVMT()) return TRUE;
+ if (g_blockEventsOnDrag) return TRUE;
if (widget->window)
gdk_window_set_cursor( widget->window, wxSTANDARD_CURSOR->GetCursor() );
- return TRUE;
+ wxMouseEvent event( wxEVT_LEAVE_WINDOW );
+ event.SetEventObject( win );
+ return win->ProcessEvent( event );
};
//-----------------------------------------------------------------------------
IMPLEMENT_DYNAMIC_CLASS(wxWindow,wxEvtHandler)
BEGIN_EVENT_TABLE(wxWindow, wxEvtHandler)
-// EVT_CHAR(wxWindow::OnChar)
EVT_SIZE(wxWindow::OnSize)
-// EVT_ERASE_BACKGROUND(wxWindow::OnEraseBackground)
EVT_SYS_COLOUR_CHANGED(wxWindow::OnSysColourChanged)
EVT_INIT_DIALOG(wxWindow::OnInitDialog)
-// EVT_IDLE(wxWindow::OnIdle)
+ EVT_IDLE(wxWindow::OnIdle)
END_EVENT_TABLE()
wxWindow::wxWindow()
m_drawingOffsetX = 0;
m_drawingOffsetY = 0;
m_pDropTarget = NULL;
+ m_resizing = FALSE;
};
-wxWindow::wxWindow( wxWindow *parent, const wxWindowID id,
- const wxPoint &pos, const wxSize &size,
- const long style, const wxString &name )
+wxWindow::wxWindow( wxWindow *parent, wxWindowID id,
+ const wxPoint &pos, const wxSize &size,
+ long style, const wxString &name )
{
+ m_cursor = NULL;
Create( parent, id, pos, size, style, name );
};
-bool wxWindow::Create( wxWindow *parent, const wxWindowID id,
- const wxPoint &pos, const wxSize &size,
- const long style, const wxString &name )
+bool wxWindow::Create( wxWindow *parent, wxWindowID id,
+ const wxPoint &pos, const wxSize &size,
+ long style, const wxString &name )
{
m_isShown = FALSE;
m_isEnabled = TRUE;
m_vAdjust = gtk_range_get_adjustment( GTK_RANGE(s_window->vscrollbar) );
gtk_signal_connect (GTK_OBJECT (m_hAdjust), "value_changed",
- (GtkSignalFunc) gtk_window_hscroll_callback, (gpointer) this );
+ (GtkSignalFunc) gtk_window_hscroll_callback, (gpointer) this );
gtk_signal_connect (GTK_OBJECT (m_vAdjust), "value_changed",
- (GtkSignalFunc) gtk_window_vscroll_callback, (gpointer) this );
-
+ (GtkSignalFunc) gtk_window_vscroll_callback, (gpointer) this );
+
gtk_signal_connect (GTK_OBJECT (m_hAdjust), "changed",
- (GtkSignalFunc) gtk_window_hscroll_change_callback, (gpointer) this );
+ (GtkSignalFunc) gtk_window_hscroll_change_callback, (gpointer) this );
gtk_signal_connect (GTK_OBJECT (m_vAdjust), "changed",
- (GtkSignalFunc) gtk_window_vscroll_change_callback, (gpointer) this );
+ (GtkSignalFunc) gtk_window_vscroll_change_callback, (gpointer) this );
GtkViewport *viewport;
viewport = GTK_VIEWPORT(s_window->viewport);
m_wxwindow = gtk_myfixed_new();
+ if (m_wxwindow) 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
if (m_widget) gtk_widget_destroy( m_widget );
-// delete m_cursor;
+ wxDELETE(m_cursor);
DeleteRelatedConstraints();
if (m_constraints)
};
-void wxWindow::PreCreation( wxWindow *parent, const wxWindowID id,
- const wxPoint &pos, const wxSize &size,
- const long style, const wxString &name )
+void wxWindow::PreCreation( wxWindow *parent, wxWindowID id,
+ const wxPoint &pos, const wxSize &size,
+ long style, const wxString &name )
{
if (m_needParent && (parent == NULL))
wxFatalError( "Need complete parent.", name );
m_windowValidator = NULL;
m_windowId = id;
m_sizeSet = FALSE;
- m_cursor = new wxCursor( wxCURSOR_ARROW );
+ if (m_cursor == NULL)
+ m_cursor = new wxCursor( wxCURSOR_ARROW );
m_font = *wxSWISS_FONT;
m_backgroundColour = wxWHITE;
m_foregroundColour = wxBLACK;
m_drawingOffsetX = 0;
m_drawingOffsetY = 0;
m_pDropTarget = NULL;
+ m_resizing = FALSE;
}
void wxWindow::PostCreation(void)
gtk_signal_connect( GTK_OBJECT(connect_widget), "focus_out_event",
GTK_SIGNAL_FUNC(gtk_window_focus_out_callback), (gpointer)this );
- gtk_signal_connect( GTK_OBJECT(connect_widget), "drop_data_available_event",
- GTK_SIGNAL_FUNC(gtk_window_drop_callback), (gpointer)this );
-
// Only for cursor handling
gtk_signal_connect( GTK_OBJECT(m_widget), "enter_notify_event",
return m_hasVMT;
};
-bool wxWindow::Close( const bool force )
+bool wxWindow::Close( bool force )
{
wxCloseEvent event(wxEVT_CLOSE_WINDOW, m_windowId);
event.SetEventObject(this);
if ((child = (wxWindow *)node->Data()) != (wxWindow *)NULL)
{
delete child;
- if (GetChildren()->Member(child)) delete node;
+ if (GetChildren()->Member(child)) delete node;
};
};
};
void wxWindow::ImplementSetPosition(void)
{
+ if (IS_KIND_OF(this,wxFrame) || IS_KIND_OF(this,wxDialog))
+ {
+ if ((m_x != -1) || (m_y != -1))
+ gtk_widget_set_uposition( m_widget, m_x, m_y );
+ return;
+ }
+
+ if (!m_parent)
+ {
+ printf( "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 );
- else
- gtk_widget_set_uposition( m_widget, m_x, m_y );
+
+ // Don't do anything for children of wxNotebook and wxMDIChildFrame
};
-void wxWindow::SetSize( const int x, const int y, const int width, const int height, const int sizeFlags )
+void wxWindow::SetSize( int x, int y, int width, int height, int sizeFlags )
{
+ if (m_resizing) return; // I don't like recursions
+ m_resizing = TRUE;
+
int newX = x;
int newY = y;
int newW = width;
wxSizeEvent event( wxSize(m_width,m_height), GetId() );
event.SetEventObject( this );
ProcessEvent( event );
+
+ m_resizing = FALSE;
};
-void wxWindow::SetSize( const int width, const int height )
+void wxWindow::SetSize( int width, int height )
{
SetSize( -1, -1, width, height, wxSIZE_USE_EXISTING );
};
-void wxWindow::Move( const int x, const int y )
+void wxWindow::Move( int x, int y )
{
SetSize( x, y, -1, -1, wxSIZE_USE_EXISTING );
};
void wxWindow::GetSize( int *width, int *height ) const
{
- (*width) = m_width;
- (*height) = m_height;
+ if (width) (*width) = m_width;
+ if (height) (*height) = m_height;
};
-void wxWindow::SetClientSize( const int width, const int height )
+void wxWindow::SetClientSize( int width, int height )
{
if (!m_wxwindow)
{
if ((m_windowStyle & wxRAISED_BORDER) ||
(m_windowStyle & wxSUNKEN_BORDER)
- )
+ )
{
dw += 2 * viewport_class->xthickness;
dh += 2 * viewport_class->ythickness;
if ((m_windowStyle & wxRAISED_BORDER) ||
(m_windowStyle & wxSUNKEN_BORDER)
- )
+ )
{
dw += 2 * viewport_class->xthickness;
dh += 2 * viewport_class->ythickness;
if (y) *y -= org_y;
};
-void wxWindow::Centre( const int direction )
+void wxWindow::Centre( int direction )
{
- int x = 0;
- int y = 0;
- GetPosition( &x, &y );
- if (this->IsKindOf(CLASSINFO(wxDialog)) || this->IsKindOf(CLASSINFO(wxFrame)))
+ if (IS_KIND_OF(this,wxDialog) || IS_KIND_OF(this,wxFrame))
{
- if (direction & wxHORIZONTAL == wxHORIZONTAL) x = (gdk_screen_width () - m_width) / 2;
- if (direction & wxVERTICAL == wxVERTICAL) y = (gdk_screen_height () - m_height) / 2;
- gtk_widget_set_uposition( m_widget, x, y );
+ if (direction & wxHORIZONTAL == wxHORIZONTAL) m_x = (gdk_screen_width () - m_width) / 2;
+ if (direction & wxVERTICAL == wxVERTICAL) m_y = (gdk_screen_height () - m_height) / 2;
+ ImplementSetPosition();
}
else
{
int p_w = 0;
int p_h = 0;
m_parent->GetSize( &p_w, &p_h );
- if (direction & wxHORIZONTAL == wxHORIZONTAL) x = (p_w - m_width) / 2;
- if (direction & wxVERTICAL == wxVERTICAL) y = (p_h - m_height) / 2;
- gtk_widget_set_uposition( m_widget, x, y );
+ if (direction & wxHORIZONTAL == wxHORIZONTAL) m_x = (p_w - m_width) / 2;
+ if (direction & wxVERTICAL == wxVERTICAL) m_y = (p_h - m_height) / 2;
+ ImplementSetPosition();
};
}
};
void wxWindow::Fit(void)
{
- int maxX = 0;
- int maxY = 0;
- wxNode *node = GetChildren()->First();
- while ( node )
- {
- wxWindow *win = (wxWindow *)node->Data();
- int wx, wy, ww, wh;
- win->GetPosition(&wx, &wy);
- win->GetSize(&ww, &wh);
- if ( wx + ww > maxX )
- maxX = wx + ww;
- if ( wy + wh > maxY )
- maxY = wy + wh;
-
- node = node->Next();
- }
- SetClientSize(maxX + 5, maxY + 5);
+ int maxX = 0;
+ int maxY = 0;
+ wxNode *node = GetChildren()->First();
+ while ( node )
+ {
+ wxWindow *win = (wxWindow *)node->Data();
+ int wx, wy, ww, wh;
+ win->GetPosition(&wx, &wy);
+ win->GetSize(&ww, &wh);
+ if ( wx + ww > maxX )
+ maxX = wx + ww;
+ if ( wy + wh > maxY )
+ maxY = wy + wh;
+
+ node = node->Next();
+ }
+ SetClientSize(maxX + 5, maxY + 10);
};
void wxWindow::OnSize( wxSizeEvent &WXUNUSED(event) )
{
- if (GetAutoLayout()) Layout();
+ //if (GetAutoLayout()) Layout();
};
-bool wxWindow::Show( const bool show )
+bool wxWindow::Show( bool show )
{
if (show)
gtk_widget_show( m_widget );
return TRUE;
};
-void wxWindow::Enable( const bool enable )
+void wxWindow::Enable( bool enable )
{
m_isEnabled = enable;
gtk_widget_set_sensitive( m_widget, enable );
if (m_wxwindow) gtk_widget_set_sensitive( m_wxwindow, enable );
};
-void wxWindow::MakeModal( const bool modal )
+void wxWindow::MakeModal( bool modal )
{
return;
// Disable all other windows
bool wxWindow::OnClose(void)
{
- printf( "OnClose event.\n" );
return TRUE;
};
// for wxFrame, wxDialog, wxWindow and
// wxMDIParentFrame.
- if (IsKindOf(CLASSINFO(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)))
{
- if (child->IsKindOf(CLASSINFO(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
+ // 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;
- };
- };
- };
- m_children.Append( child );
- if (child->IsKindOf(CLASSINFO(wxFrame)) || child->IsKindOf(CLASSINFO(wxDialog)))
+ }
+ }
+ }
+
+ // wxNotebook is very special, so it has a private AddChild()
+
+ if (IS_KIND_OF(this,wxNotebook))
{
- if ((child->m_x != -1) && (child->m_y != -1))
- gtk_widget_set_uposition( child->m_widget, child->m_x, child->m_y );
+ wxNotebook *tab = (wxNotebook*)this;
+ tab->AddChild( child );
+ return;
}
- else
+
+ // wxFrame has a private AddChild
+
+ if (IS_KIND_OF(this,wxFrame) && !IS_KIND_OF(this,wxMDIChildFrame))
{
- if (m_wxwindow)
- gtk_myfixed_put( GTK_MYFIXED(m_wxwindow), child->m_widget, child->m_x, child->m_y );
- };
+ 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,
+ child->m_x, child->m_y );
+
gtk_widget_set_usize( child->m_widget, child->m_width, child->m_height );
};
void wxWindow::SetCursor( const wxCursor &cursor )
{
- if (*m_cursor == cursor) return;
+ wxASSERT(m_cursor != NULL);
+
+ if (m_cursor != NULL)
+ if (*m_cursor == cursor)
+ return;
(*m_cursor) = cursor;
if (m_widget->window)
gdk_window_set_cursor( m_widget->window, m_cursor->GetCursor() );
gdk_window_set_cursor( m_wxwindow->window, m_cursor->GetCursor() );
};
-void wxWindow::Refresh( const bool eraseBackground, const wxRect *rect )
+void wxWindow::Refresh( bool eraseBackground, const wxRect *rect )
{
if (eraseBackground && m_wxwindow && m_wxwindow->window)
{
if (rect)
gdk_window_clear_area( m_wxwindow->window,
rect->x,
- rect->y,
- rect->width,
- rect->height );
+ rect->y,
+ rect->width,
+ rect->height );
else
Clear();
};
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
};
};
-bool wxWindow::IsExposed( const long x, const long y )
+bool wxWindow::IsExposed( long x, long y )
{
return (m_updateRegion.Contains( x, y ) != wxOutRegion );
};
-bool wxWindow::IsExposed( const long x, const long y, const long width, const long height )
+bool wxWindow::IsExposed( long x, long y, long width, long height )
{
return (m_updateRegion.Contains( x, y, width, height ) != wxOutRegion );
};
{
wxWindow *child = (wxWindow *)node->Data();
if (child->GetValidator() && /* child->GetValidator()->Ok() && */
- !child->GetValidator()->TransferToWindow() )
+ !child->GetValidator()->TransferToWindow() )
{
wxMessageBox( "Application Error", "Could not transfer data to window", wxOK|wxICON_EXCLAMATION );
return FALSE;
void wxWindow::SetDropTarget( wxDropTarget *dropTarget )
{
- GtkWidget *connect_widget = m_widget;
- if (m_wxwindow) connect_widget = m_wxwindow;
+ GtkWidget *dnd_widget = GetDropTargetWidget();
+
if (m_pDropTarget)
{
- m_pDropTarget->UnregisterWidget( connect_widget );
+ gtk_signal_disconnect_by_func( GTK_OBJECT(dnd_widget),
+ GTK_SIGNAL_FUNC(gtk_window_drop_callback), (gpointer)this );
+
+ m_pDropTarget->UnregisterWidget( dnd_widget );
delete m_pDropTarget;
};
m_pDropTarget = dropTarget;
if (m_pDropTarget)
{
- m_pDropTarget->RegisterWidget( connect_widget );
+ m_pDropTarget->RegisterWidget( dnd_widget );
+
+ gtk_signal_connect( GTK_OBJECT(dnd_widget), "drop_data_available_event",
+ GTK_SIGNAL_FUNC(gtk_window_drop_callback), (gpointer)this );
};
};
return m_pDropTarget;
};
+GtkWidget* wxWindow::GetDropTargetWidget(void)
+{
+ GtkWidget *connect_widget = m_widget;
+ if (m_wxwindow) connect_widget = m_wxwindow;
+
+ return connect_widget;
+}
+
void wxWindow::SetFont( const wxFont &font )
{
m_font = font;
gtk_grab_add( connect_widget );
gdk_pointer_grab ( connect_widget->window, FALSE,
(GdkEventMask)
- (GDK_BUTTON_PRESS_MASK |
- GDK_BUTTON_RELEASE_MASK |
- GDK_POINTER_MOTION_MASK),
- NULL, NULL, GDK_CURRENT_TIME );
+ (GDK_BUTTON_PRESS_MASK |
+ GDK_BUTTON_RELEASE_MASK |
+ GDK_POINTER_MOTION_MASK),
+ NULL, NULL, GDK_CURRENT_TIME );
};
void wxWindow::ReleaseMouse(void)
return (wxString&)m_windowName;
};
-bool wxWindow::IsShown(void)
+bool wxWindow::IsShown(void) const
{
return m_isShown;
};
return FALSE;
};
-wxWindow *wxWindow::FindWindow( const long id )
+wxWindow *wxWindow::FindWindow( long id )
{
if (id == m_windowId) return this;
wxNode *node = m_children.First();
return NULL;
};
-void wxWindow::SetScrollbar( const int orient, const int pos, const int thumbVisible,
- const int range, const bool WXUNUSED(refresh) )
+void wxWindow::SetScrollbar( int orient, int pos, int thumbVisible,
+ int range, bool WXUNUSED(refresh) )
{
if (!m_wxwindow) return;
if ((fabs(fpos-m_hAdjust->value) < 0.2) &&
(fabs(frange-m_hAdjust->upper) < 0.2) &&
- (fabs(fthumb-m_hAdjust->page_size) < 0.2))
+ (fabs(fthumb-m_hAdjust->page_size) < 0.2))
return;
m_hAdjust->lower = 0.0;
if ((fabs(fpos-m_vAdjust->value) < 0.2) &&
(fabs(frange-m_vAdjust->upper) < 0.2) &&
- (fabs(fthumb-m_vAdjust->page_size) < 0.2))
+ (fabs(fthumb-m_vAdjust->page_size) < 0.2))
return;
m_vAdjust->lower = 0.0;
m_vAdjust->page_increment = (float)(wxMax(fthumb-2,0));
m_vAdjust->page_size = fthumb;
};
-
+
if (m_wxwindow->window)
- {
+ {
if (orient == wxHORIZONTAL)
+ {
+/*
+ m_drawingOffsetX = -16000;
+
+ gtk_myfixed_set_offset( GTK_MYFIXED(m_wxwindow), m_drawingOffsetX, m_drawingOffsetY );
+*/
gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
- else
+ }
+ else
+ {
+/*
+ m_drawingOffsetY = -16000;
+
+ gtk_myfixed_set_offset( GTK_MYFIXED(m_wxwindow), m_drawingOffsetX, m_drawingOffsetY );
+*/
gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );
+ }
-// gtk_widget_set_usize( m_widget, m_width, m_height );
+ gtk_widget_set_usize( m_widget, m_width, m_height );
};
};
-void wxWindow::SetScrollPos( const int orient, const int pos, const bool WXUNUSED(refresh) )
+void wxWindow::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) )
{
if (!m_wxwindow) return;
};
};
-int wxWindow::GetScrollThumb( const int orient ) const
+int wxWindow::GetScrollThumb( int orient ) const
{
if (!m_wxwindow) return 0;
return (int)(m_vAdjust->page_size+0.5);
};
-int wxWindow::GetScrollPos( const int orient ) const
+int wxWindow::GetScrollPos( int orient ) const
{
if (!m_wxwindow) return 0;
return (int)(m_vAdjust->value+0.5);
};
-int wxWindow::GetScrollRange( const int orient ) const
+int wxWindow::GetScrollRange( int orient ) const
{
if (!m_wxwindow) return 0;
return (int)(m_vAdjust->upper+0.5);
};
-void wxWindow::ScrollWindow( const int dx, const int dy, const wxRect* WXUNUSED(rect) )
+void wxWindow::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
{
if (!m_wxwindow) return;
- m_drawingOffsetX += dx;
- m_drawingOffsetY += dy;
+ 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...
}
;
-void wxWindow::SetAutoLayout( const bool autoLayout )
+void wxWindow::SetAutoLayout( bool autoLayout )
{
m_autoLayout = autoLayout;
};
}
// Do a phase of evaluating child constraints
-bool wxWindow::DoPhase(const int phase)
+bool wxWindow::DoPhase(int phase)
{
int noIterations = 0;
int maxIterations = 500;
// Need to distinguish between setting the 'fake' size for
// windows and sizers, and setting the real values.
-void wxWindow::SetConstraintSizes(const bool recurse)
+void wxWindow::SetConstraintSizes(bool recurse)
{
wxLayoutConstraints *constr = GetConstraints();
if (constr && constr->left.GetDone() && constr->right.GetDone() &&
char *windowClass = this->GetClassInfo()->GetClassName();
wxString winName;
- if (GetName() == "")
- winName = "unnamed";
- else
- winName = GetName();
+ if (GetName() == "")
+ winName = "unnamed";
+ else
+ winName = GetName();
wxDebugMsg("Constraint(s) not satisfied for window of type %s, name %s:\n", (const char *)windowClass, (const char *)winName);
if (!constr->left.GetDone())
wxDebugMsg(" unsatisfied 'left' constraint.\n");
void wxWindow::TransformSizerToActual(int *x, int *y) const
{
if (!m_sizerParent || m_sizerParent->IsKindOf(CLASSINFO(wxDialog)) ||
- m_sizerParent->IsKindOf(CLASSINFO(wxFrame)) )
+ m_sizerParent->IsKindOf(CLASSINFO(wxFrame)) )
return;
int xp, yp;
*y += yp;
}
-void wxWindow::SizerSetSize(const int x, const int y, const int w, const int h)
+void wxWindow::SizerSetSize(int x, int y, int w, int h)
{
- int xx = x;
- int yy = y;
+ int xx = x;
+ int yy = y;
TransformSizerToActual(&xx, &yy);
SetSize(xx, yy, w, h);
}
-void wxWindow::SizerMove(const int x, const int y)
+void wxWindow::SizerMove(int x, int y)
{
- int xx = x;
- int yy = y;
+ int xx = x;
+ int yy = y;
TransformSizerToActual(&xx, &yy);
Move(xx, yy);
}
// Only set the size/position of the constraint (if any)
-void wxWindow::SetSizeConstraint(const int x, const int y, const int w, const int h)
+void wxWindow::SetSizeConstraint(int x, int y, int w, int h)
{
wxLayoutConstraints *constr = GetConstraints();
if (constr)
}
}
-void wxWindow::MoveConstraint(const int x, const int y)
+void wxWindow::MoveConstraint(int x, int y)
{
wxLayoutConstraints *constr = GetConstraints();
if (constr)
GetPosition(x, y);
}
+bool wxWindow::AcceptsFocus() const
+{
+ return IsEnabled() && IsShown();
+}
+
+void wxWindow::OnIdle(wxIdleEvent& WXUNUSED(event) )
+{
+ UpdateWindowUI();
+}
projects / wxWidgets.git / blobdiff