X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/9e691f46b2ec1b5dbbff2e51131e3c532e688a89..de5dd006449a97887afb2aad39c8f20549818d98:/src/gtk1/toplevel.cpp diff --git a/src/gtk1/toplevel.cpp b/src/gtk1/toplevel.cpp index 8f33dbd97b..fb7300af9d 100644 --- a/src/gtk1/toplevel.cpp +++ b/src/gtk1/toplevel.cpp @@ -15,20 +15,28 @@ // headers // ---------------------------------------------------------------------------- -#ifdef __GNUG__ +#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA) #pragma implementation "toplevel.h" #endif +// For compilers that support precompilation, includes "wx.h". +#include "wx/wxprec.h" + #ifdef __VMS #define XIconifyWindow XICONIFYWINDOW #endif #include "wx/defs.h" +#include "wx/toplevel.h" +#include "wx/log.h" #include "wx/dialog.h" #include "wx/control.h" #include "wx/app.h" #include "wx/dcclient.h" +#include "wx/gtk/private.h" +#include "wx/timer.h" +#include "wx/settings.h" #include #include @@ -38,41 +46,108 @@ #include "wx/gtk/win_gtk.h" +#include "wx/unix/utilsx11.h" + +// XA_CARDINAL +#include + // ---------------------------------------------------------------------------- // idle system // ---------------------------------------------------------------------------- extern void wxapp_install_idle_handler(); extern bool g_isIdle; -extern int g_openDialogs; - -// ---------------------------------------------------------------------------- -// event tables -// ---------------------------------------------------------------------------- // ---------------------------------------------------------------------------- // data // ---------------------------------------------------------------------------- -extern wxList wxPendingDelete; +extern wxList wxPendingDelete; -// ---------------------------------------------------------------------------- -// debug -// ---------------------------------------------------------------------------- +extern int g_openDialogs; +extern wxWindowGTK *g_delayedFocus; -#ifdef __WXDEBUG__ +// the frame that is currently active (i.e. its child has focus). It is +// used to generate wxActivateEvents +static wxTopLevelWindowGTK *g_activeFrame = (wxTopLevelWindowGTK*) NULL; +static wxTopLevelWindowGTK *g_lastActiveFrame = (wxTopLevelWindowGTK*) NULL; -extern void debug_focus_in( GtkWidget* widget, const wxChar* name, const wxChar *window ); +// if we detect that the app has got/lost the focus, we set this variable to +// either TRUE or FALSE and an activate event will be sent during the next +// OnIdle() call and it is reset to -1: this value means that we shouldn't +// send any activate events at all +static int g_sendActivateEvent = -1; -#endif +//----------------------------------------------------------------------------- +// "focus_in_event" +//----------------------------------------------------------------------------- -// ============================================================================ -// implementation -// ============================================================================ +static gint gtk_frame_focus_in_callback( GtkWidget *widget, + GdkEvent *WXUNUSED(event), + wxTopLevelWindowGTK *win ) +{ + if (g_isIdle) + wxapp_install_idle_handler(); + + switch ( g_sendActivateEvent ) + { + case -1: + // we've got focus from outside, synthetize wxActivateEvent + g_sendActivateEvent = 1; + break; -// ---------------------------------------------------------------------------- -// GTK callbacks -// ---------------------------------------------------------------------------- + case 0: + // another our window just lost focus, it was already ours before + // - don't send any wxActivateEvent + g_sendActivateEvent = -1; + break; + } + + g_activeFrame = win; + g_lastActiveFrame = g_activeFrame; + + // wxPrintf( wxT("active: %s\n"), win->GetTitle().c_str() ); + + wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), g_activeFrame); + wxActivateEvent event(wxEVT_ACTIVATE, TRUE, g_activeFrame->GetId()); + event.SetEventObject(g_activeFrame); + g_activeFrame->GetEventHandler()->ProcessEvent(event); + + return FALSE; +} + +//----------------------------------------------------------------------------- +// "focus_out_event" +//----------------------------------------------------------------------------- + +static gint gtk_frame_focus_out_callback( GtkWidget *widget, + GdkEventFocus *WXUNUSED(gdk_event), + wxTopLevelWindowGTK *win ) +{ + if (g_isIdle) + wxapp_install_idle_handler(); + + // if the focus goes out of our app alltogether, OnIdle() will send + // wxActivateEvent, otherwise gtk_window_focus_in_callback() will reset + // g_sendActivateEvent to -1 + g_sendActivateEvent = 0; + + // wxASSERT_MSG( (g_activeFrame == win), wxT("TLW deactivatd although it wasn't active") ); + + // wxPrintf( wxT("inactive: %s\n"), win->GetTitle().c_str() ); + + if (g_activeFrame) + { + wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), g_activeFrame); + wxActivateEvent event(wxEVT_ACTIVATE, FALSE, g_activeFrame->GetId()); + event.SetEventObject(g_activeFrame); + g_activeFrame->GetEventHandler()->ProcessEvent(event); + + g_activeFrame = NULL; + } + + return FALSE; +} //----------------------------------------------------------------------------- // "focus" from m_window @@ -114,7 +189,6 @@ static void gtk_frame_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation* win->m_width = alloc->width; win->m_height = alloc->height; - win->m_queuedFullRedraw = TRUE; win->GtkUpdateSize(); } } @@ -129,7 +203,8 @@ static gint gtk_frame_delete_callback( GtkWidget *WXUNUSED(widget), GdkEvent *WX wxapp_install_idle_handler(); if (win->IsEnabled() && - (g_openDialogs == 0 || (win->GetExtraStyle() & wxTOPLEVEL_EX_DIALOG))) + (g_openDialogs == 0 || (win->GetExtraStyle() & wxTOPLEVEL_EX_DIALOG) || + win->IsGrabbed())) win->Close(); return TRUE; @@ -149,6 +224,7 @@ gtk_frame_configure_callback( GtkWidget *WXUNUSED(widget), GdkEventConfigure *WX if (!win->m_hasVMT || !win->IsShown()) return FALSE; + int x = 0; int y = 0; gdk_window_get_root_origin( win->m_widget->window, &x, &y ); @@ -170,7 +246,8 @@ gtk_frame_configure_callback( GtkWidget *WXUNUSED(widget), GdkEventConfigure *WX // so we do this directly after realization static void -gtk_frame_realized_callback( GtkWidget * WXUNUSED(widget), wxTopLevelWindowGTK *win ) +gtk_frame_realized_callback( GtkWidget * WXUNUSED(widget), + wxTopLevelWindowGTK *win ) { if (g_isIdle) wxapp_install_idle_handler(); @@ -189,27 +266,11 @@ gtk_frame_realized_callback( GtkWidget * WXUNUSED(widget), wxTopLevelWindowGTK * gtk_window_set_policy(GTK_WINDOW(win->m_widget), 1, 1, 1); // reset the icon - wxIcon iconOld = win->GetIcon(); - if ( iconOld != wxNullIcon ) + wxIconBundle iconsOld = win->GetIcons(); + if ( iconsOld.GetIcon(-1).Ok() ) { - wxIcon icon( iconOld ); win->SetIcon( wxNullIcon ); - win->SetIcon( icon ); - } - - // we set the focus to the child that accepts the focus. this - // doesn't really have to be done in "realize" but why not? - wxWindowList::Node *node = win->GetChildren().GetFirst(); - while (node) - { - wxWindow *child = node->GetData(); - if (child->AcceptsFocus()) - { - child->SetFocus(); - break; - } - - node = node->GetNext(); + win->SetIcons( iconsOld ); } } @@ -253,13 +314,14 @@ static int gtk_window_expose_callback( GtkWidget *widget, GdkEventExpose *gdk_ev (char *)"base", 0, 0, -1, -1); - return TRUE; + return FALSE; } //----------------------------------------------------------------------------- // "draw" of m_client //----------------------------------------------------------------------------- +#ifndef __WXGTK20__ static void gtk_window_draw_callback( GtkWidget *widget, GdkRectangle *rect, wxWindow *win ) { @@ -274,6 +336,8 @@ static void gtk_window_draw_callback( GtkWidget *widget, GdkRectangle *rect, wxW 0, 0, -1, -1); } +#endif // GTK+ 1.x + // ---------------------------------------------------------------------------- // wxTopLevelWindowGTK itself // ---------------------------------------------------------------------------- @@ -284,7 +348,7 @@ static void gtk_window_draw_callback( GtkWidget *widget, GdkRectangle *rect, wxW /* Callback for wxTopLevelWindowGTK. This very strange beast has to be used because * C++ has no virtual methods in a constructor. We have to emulate a - * virtual function here as wxWindows requires different ways to insert + * virtual function here as wxWidgets requires different ways to insert * a child in container classes. */ static void wxInsertChildInTopLevelWindow( wxTopLevelWindowGTK* parent, wxWindow* child ) @@ -328,11 +392,11 @@ void wxTopLevelWindowGTK::Init() m_miniTitle = 0; m_mainWidget = (GtkWidget*) NULL; m_insertInClientArea = TRUE; - m_isFrame = TRUE; m_isIconized = FALSE; m_fsIsShowing = FALSE; m_themeEnabled = TRUE; m_gdkDecor = m_gdkFunc = 0; + m_grabbed = FALSE; } bool wxTopLevelWindowGTK::Create( wxWindow *parent, @@ -346,19 +410,13 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent, // always create a frame of some reasonable, even if arbitrary, size (at // least for MSW compatibility) wxSize size = sizeOrig; - if ( size.x == -1 || size.y == -1 ) - { - wxSize sizeDpy = wxGetDisplaySize(); - if ( size.x == -1 ) - size.x = sizeDpy.x / 3; - if ( size.y == -1 ) - size.y = sizeDpy.y / 5; - } + size.x = WidthDefault(size.x); + size.y = HeightDefault(size.y); wxTopLevelWindows.Append( this ); m_needParent = FALSE; - + if (!PreCreation( parent, pos, size ) || !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name )) { @@ -370,37 +428,66 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent, m_insertCallback = (wxInsertChildFunction) wxInsertChildInTopLevelWindow; - GtkWindowType win_type = GTK_WINDOW_TOPLEVEL; - - if (style & wxFRAME_TOOL_WINDOW) - win_type = GTK_WINDOW_POPUP; - - if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG) + // NB: m_widget may be !=NULL if it was created by derived class' Create, + // e.g. in wxTaskBarIconAreaGTK + if (m_widget == NULL) { - // there is no more GTK_WINDOW_DIALOG in 2.0 + if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG) + { #ifdef __WXGTK20__ - win_type = GTK_WINDOW_TOPLEVEL; + m_widget = gtk_window_new(GTK_WINDOW_TOPLEVEL); + // Tell WM that this is a dialog window and make it center + // on parent by default (this is what GtkDialog ctor does): + gtk_window_set_type_hint(GTK_WINDOW(m_widget), + GDK_WINDOW_TYPE_HINT_DIALOG); + gtk_window_set_position(GTK_WINDOW(m_widget), + GTK_WIN_POS_CENTER_ON_PARENT); #else - win_type = GTK_WINDOW_DIALOG; + m_widget = gtk_window_new(GTK_WINDOW_DIALOG); #endif + } + else + { + m_widget = gtk_window_new(GTK_WINDOW_TOPLEVEL); +#if GTK_CHECK_VERSION(2,1,0) + if (style & wxFRAME_TOOL_WINDOW) + { + gtk_window_set_type_hint(GTK_WINDOW(m_widget), + GDK_WINDOW_TYPE_HINT_UTILITY); + + // On some WMs, like KDE, a TOOL_WINDOW will still show + // on the taskbar, but on Gnome a TOOL_WINDOW will not. + // For consistency between WMs and with Windows, we + // should set the NO_TASKBAR flag which will apply + // the set_skip_taskbar_hint if it is available, + // ensuring no taskbar entry will appear. + style |= wxFRAME_NO_TASKBAR; + } +#endif + + } } - m_widget = gtk_window_new( win_type ); + wxWindow *topParent = wxGetTopLevelParent(m_parent); + if (topParent && (((GTK_IS_WINDOW(topParent->m_widget)) && + (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)) || + (style & wxFRAME_FLOAT_ON_PARENT))) + { + gtk_window_set_transient_for( GTK_WINDOW(m_widget), + GTK_WINDOW(topParent->m_widget) ); + } - if (m_parent && (GTK_IS_WINDOW(m_parent->m_widget)) && - (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)) +#if GTK_CHECK_VERSION(2,2,0) + if (style & wxFRAME_NO_TASKBAR) { - gtk_window_set_transient_for( GTK_WINDOW(m_widget), GTK_WINDOW(m_parent->m_widget) ); + gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget), TRUE); } +#endif if (!name.IsEmpty()) - gtk_window_set_wmclass( GTK_WINDOW(m_widget), name.mb_str(), name.mb_str() ); + gtk_window_set_wmclass( GTK_WINDOW(m_widget), wxGTK_CONV( name ), wxGTK_CONV( name ) ); -#ifdef __WXDEBUG__ - debug_focus_in( m_widget, wxT("wxTopLevelWindowGTK::m_widget"), name ); -#endif - - gtk_window_set_title( GTK_WINDOW(m_widget), title.mbc_str() ); + gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( title ) ); GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS ); gtk_signal_connect( GTK_OBJECT(m_widget), "delete_event", @@ -412,25 +499,22 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent, GTK_WIDGET_UNSET_FLAGS( m_mainWidget, GTK_CAN_FOCUS ); gtk_container_add( GTK_CONTAINER(m_widget), m_mainWidget ); - // for m_mainWidget themes - gtk_signal_connect( GTK_OBJECT(m_mainWidget), "expose_event", + if (m_miniEdge == 0) // wxMiniFrame has its own version. + { + // For m_mainWidget themes + gtk_signal_connect( GTK_OBJECT(m_mainWidget), "expose_event", GTK_SIGNAL_FUNC(gtk_window_expose_callback), (gpointer)this ); - gtk_signal_connect( GTK_OBJECT(m_mainWidget), "draw", +#ifndef __WXGTK20__ + gtk_signal_connect( GTK_OBJECT(m_mainWidget), "draw", GTK_SIGNAL_FUNC(gtk_window_draw_callback), (gpointer)this ); - -#ifdef __WXDEBUG__ - debug_focus_in( m_mainWidget, wxT("wxTopLevelWindowGTK::m_mainWidget"), name ); #endif + } // m_wxwindow only represents the client area without toolbar and menubar m_wxwindow = gtk_pizza_new(); gtk_widget_show( m_wxwindow ); gtk_container_add( GTK_CONTAINER(m_mainWidget), m_wxwindow ); -#ifdef __WXDEBUG__ - debug_focus_in( m_wxwindow, wxT("wxTopLevelWindowGTK::m_wxwindow"), name ); -#endif - // we donm't allow the frame to get the focus as otherwise // the frame will grab it at arbitrary focus changes GTK_WIDGET_UNSET_FLAGS( m_wxwindow, GTK_CAN_FOCUS ); @@ -445,7 +529,7 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent, if ((m_x != -1) || (m_y != -1)) gtk_widget_set_uposition( m_widget, m_x, m_y ); - + gtk_window_set_default_size( GTK_WINDOW(m_widget), m_width, m_height ); // we cannot set MWM hints and icons before the widget has @@ -471,6 +555,12 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent, gtk_signal_connect( GTK_OBJECT(m_widget), "focus", GTK_SIGNAL_FUNC(gtk_frame_focus_callback), (gpointer)this ); + // activation + gtk_signal_connect( GTK_OBJECT(m_widget), "focus_in_event", + GTK_SIGNAL_FUNC(gtk_frame_focus_in_callback), (gpointer)this ); + gtk_signal_connect( GTK_OBJECT(m_widget), "focus_out_event", + GTK_SIGNAL_FUNC(gtk_frame_focus_out_callback), (gpointer)this ); + // decorations if ((m_miniEdge > 0) || (style & wxSIMPLE_BORDER) || (style & wxNO_BORDER)) { @@ -485,10 +575,15 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent, // All this is for Motif Window Manager "hints" and is supposed to be // recognized by other WMs as well. if ((style & wxCAPTION) != 0) + { m_gdkDecor |= GDK_DECOR_TITLE; - if ((style & wxSYSTEM_MENU) != 0) + } + if ((style & wxCLOSE_BOX) != 0) { m_gdkFunc |= GDK_FUNC_CLOSE; + } + if ((style & wxSYSTEM_MENU) != 0) + { m_gdkDecor |= GDK_DECOR_MENU; } if ((style & wxMINIMIZE_BOX) != 0) @@ -513,62 +608,111 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent, wxTopLevelWindowGTK::~wxTopLevelWindowGTK() { - m_isBeingDeleted = TRUE; - - gtk_window_set_focus( GTK_WINDOW(m_widget), NULL ); - - wxTopLevelWindows.DeleteObject( this ); + if (m_grabbed) + { + wxASSERT_MSG( FALSE, _T("Window still grabbed")); + RemoveGrab(); + } - if (wxTheApp->GetTopWindow() == this) - wxTheApp->SetTopWindow( (wxWindow*) NULL ); + m_isBeingDeleted = TRUE; - if ((wxTopLevelWindows.Number() == 0) && - (wxTheApp->GetExitOnFrameDelete())) + // it may also be GtkScrolledWindow in the case of an MDI child + if (GTK_IS_WINDOW(m_widget)) { - wxTheApp->ExitMainLoop(); + gtk_window_set_focus( GTK_WINDOW(m_widget), NULL ); } + + if (g_activeFrame == this) + g_activeFrame = NULL; + if (g_lastActiveFrame == this) + g_lastActiveFrame = NULL; } + + bool wxTopLevelWindowGTK::ShowFullScreen(bool show, long style ) { - if (show == m_fsIsShowing) return FALSE; // return what? + if (show == m_fsIsShowing) + return FALSE; // return what? m_fsIsShowing = show; - - if (show) + + wxX11FullScreenMethod method = + wxGetFullScreenMethodX11((WXDisplay*)GDK_DISPLAY(), + (WXWindow)GDK_ROOT_WINDOW()); + +#if GTK_CHECK_VERSION(2,2,0) + // NB: gtk_window_fullscreen() uses freedesktop.org's WMspec extensions + // to switch to fullscreen, which is not always available. We must + // check if WM supports the spec and use legacy methods if it + // doesn't. + if (method == wxX11_FS_WMSPEC) { - m_fsSaveGdkFunc = m_gdkFunc; - m_fsSaveGdkDecor = m_gdkDecor; - m_fsSaveFlag = style; - GetPosition( &m_fsSaveFrame.x, &m_fsSaveFrame.y ); - GetSize( &m_fsSaveFrame.width, &m_fsSaveFrame.height ); - - gtk_widget_hide( m_widget ); - gtk_widget_unrealize( m_widget ); - - m_gdkDecor = (long) GDK_DECOR_BORDER; - m_gdkFunc = (long) GDK_FUNC_MOVE; - - int x; - int y; - wxDisplaySize( &x, &y ); - SetSize( 0, 0, x, y ); + if (show) + gtk_window_fullscreen( GTK_WINDOW( m_widget ) ); + else + gtk_window_unfullscreen( GTK_WINDOW( m_widget ) ); - gtk_widget_realize( m_widget ); - gtk_widget_show( m_widget ); + return TRUE; } else +#endif // GTK+ >= 2.2.0 { - gtk_widget_hide( m_widget ); - gtk_widget_unrealize( m_widget ); + GdkWindow *window = m_widget->window; - m_gdkFunc = m_fsSaveGdkFunc; - m_gdkDecor = m_fsSaveGdkDecor; - - SetSize( m_fsSaveFrame.x, m_fsSaveFrame.y, m_fsSaveFrame.width, m_fsSaveFrame.height ); - - gtk_widget_realize( m_widget ); - gtk_widget_show( m_widget ); + if (show) + { + m_fsSaveFlag = style; + GetPosition( &m_fsSaveFrame.x, &m_fsSaveFrame.y ); + GetSize( &m_fsSaveFrame.width, &m_fsSaveFrame.height ); + + int screen_width,screen_height; + wxDisplaySize( &screen_width, &screen_height ); + + gint client_x, client_y, root_x, root_y; + gint width, height; + + if (method != wxX11_FS_WMSPEC) + { + // don't do it always, Metacity hates it + m_fsSaveGdkFunc = m_gdkFunc; + m_fsSaveGdkDecor = m_gdkDecor; + m_gdkFunc = m_gdkDecor = 0; + gdk_window_set_decorations(window, (GdkWMDecoration)0); + gdk_window_set_functions(window, (GdkWMFunction)0); + } + + gdk_window_get_origin (m_widget->window, &root_x, &root_y); + gdk_window_get_geometry (m_widget->window, &client_x, &client_y, + &width, &height, NULL); + + gdk_window_move_resize (m_widget->window, -client_x, -client_y, + screen_width + 1, screen_height + 1); + + wxSetFullScreenStateX11((WXDisplay*)GDK_DISPLAY(), + (WXWindow)GDK_ROOT_WINDOW(), + (WXWindow)GDK_WINDOW_XWINDOW(window), + show, &m_fsSaveFrame, method); + } + else + { + if (method != wxX11_FS_WMSPEC) + { + // don't do it always, Metacity hates it + m_gdkFunc = m_fsSaveGdkFunc; + m_gdkDecor = m_fsSaveGdkDecor; + gdk_window_set_decorations(window, (GdkWMDecoration)m_gdkDecor); + gdk_window_set_functions(window, (GdkWMFunction)m_gdkFunc); + } + + wxSetFullScreenStateX11((WXDisplay*)GDK_DISPLAY(), + (WXWindow)GDK_ROOT_WINDOW(), + (WXWindow)GDK_WINDOW_XWINDOW(window), + show, &m_fsSaveFrame, method); + + SetSize(m_fsSaveFrame.x, m_fsSaveFrame.y, + m_fsSaveFrame.width, m_fsSaveFrame.height); + } } return TRUE; @@ -591,10 +735,22 @@ bool wxTopLevelWindowGTK::Show( bool show ) GtkOnSize( m_x, m_y, m_width, m_height ); } - + + if (show) + gtk_widget_set_uposition( m_widget, m_x, m_y ); + return wxWindow::Show( show ); } +void wxTopLevelWindowGTK::Raise() +{ +#ifdef __WXGTK20__ + gtk_window_present( GTK_WINDOW( m_widget ) ); +#else + wxWindow::Raise(); +#endif +} + void wxTopLevelWindowGTK::DoMoveWindow(int WXUNUSED(x), int WXUNUSED(y), int WXUNUSED(width), int WXUNUSED(height) ) { wxFAIL_MSG( wxT("DoMoveWindow called for wxTopLevelWindowGTK") ); @@ -622,16 +778,14 @@ void wxTopLevelWindowGTK::DoSetSize( int x, int y, int width, int height, int si { if (x != -1) m_x = x; if (y != -1) m_y = y; - if (width != -1) m_width = width; - if (height != -1) m_height = height; } else { m_x = x; m_y = y; - m_width = width; - m_height = height; } + if (width != -1) m_width = width; + if (height != -1) m_height = height; /* if ((sizeFlags & wxSIZE_AUTO_WIDTH) == wxSIZE_AUTO_WIDTH) @@ -650,6 +804,16 @@ void wxTopLevelWindowGTK::DoSetSize( int x, int y, int width, int height, int si maxWidth = GetMaxWidth(), maxHeight = GetMaxHeight(); +#ifdef __WXGPE__ + // GPE's window manager doesn't like size hints + // at all, esp. when the user has to use the + // virtual keyboard. + minWidth = -1; + minHeight = -1; + maxWidth = -1; + maxHeight = -1; +#endif + if ((minWidth != -1) && (m_width < minWidth)) m_width = minWidth; if ((minHeight != -1) && (m_height < minHeight)) m_height = minHeight; if ((maxWidth != -1) && (m_width > maxWidth)) m_width = maxWidth; @@ -731,6 +895,16 @@ void wxTopLevelWindowGTK::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y), maxWidth = GetMaxWidth(), maxHeight = GetMaxHeight(); +#ifdef __WXGPE__ + // GPE's window manager doesn't like size hints + // at all, esp. when the user has to use the + // virtual keyboard. + minWidth = -1; + minHeight = -1; + maxWidth = -1; + maxHeight = -1; +#endif + if ((minWidth != -1) && (m_width < minWidth)) m_width = minWidth; if ((minHeight != -1) && (m_height < minHeight)) m_height = minHeight; if ((maxWidth != -1) && (m_width > maxWidth)) m_width = maxWidth; @@ -739,14 +913,37 @@ void wxTopLevelWindowGTK::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y), if (m_mainWidget) { // set size hints - gint flag = 0; // GDK_HINT_POS; + gint flag = 0; // GDK_HINT_POS; + GdkGeometry geom; + if ((minWidth != -1) || (minHeight != -1)) flag |= GDK_HINT_MIN_SIZE; if ((maxWidth != -1) || (maxHeight != -1)) flag |= GDK_HINT_MAX_SIZE; - GdkGeometry geom; + geom.min_width = minWidth; geom.min_height = minHeight; - geom.max_width = maxWidth; - geom.max_height = maxHeight; + + // Because of the way we set GDK_HINT_MAX_SIZE above, if either of + // maxHeight or maxWidth is set, we must set them both, else the + // remaining -1 will be taken literally. + + // I'm certain this also happens elsewhere, and is the probable + // cause of other such things as: + // Gtk-WARNING **: gtk_widget_size_allocate(): + // attempt to allocate widget with width 65535 and height 600 + // but I don't have time to track them all now.. + // + // Really we need to encapulate all this height/width business and + // stop any old method from ripping at the members directly and + // scattering -1's without regard for who might resolve them later. + + geom.max_width = ( maxHeight == -1 ) ? maxWidth + : ( maxWidth == -1 ) ? wxGetDisplaySize().GetWidth() + : maxWidth ; + + geom.max_height = ( maxWidth == -1 ) ? maxHeight // ( == -1 here ) + : ( maxHeight == -1 ) ? wxGetDisplaySize().GetHeight() + : maxHeight ; + gtk_window_set_geometry_hints( GTK_WINDOW(m_widget), (GtkWidget*) NULL, &geom, @@ -762,6 +959,7 @@ void wxTopLevelWindowGTK::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y), int client_y = m_miniEdge + m_miniTitle; int client_w = m_width - 2*m_miniEdge; int client_h = m_height - 2*m_miniEdge - m_miniTitle; + gtk_pizza_set_size( GTK_PIZZA(m_mainWidget), m_wxwindow, client_x, client_y, client_w, client_h ); @@ -794,9 +992,38 @@ void wxTopLevelWindowGTK::OnInternalIdle() return; } + // set the focus if not done yet and if we can already do it + if ( GTK_WIDGET_REALIZED(m_wxwindow) ) + { + if ( g_delayedFocus && + wxGetTopLevelParent((wxWindow*)g_delayedFocus) == this ) + { + wxLogTrace(_T("focus"), + _T("Setting focus from wxTLW::OnIdle() to %s(%s)"), + g_delayedFocus->GetClassInfo()->GetClassName(), + g_delayedFocus->GetLabel().c_str()); + + g_delayedFocus->SetFocus(); + g_delayedFocus = NULL; + } + } + wxWindow::OnInternalIdle(); -} + + // Synthetize activate events. + if ( g_sendActivateEvent != -1 ) + { + bool activate = g_sendActivateEvent != 0; + + // if (!activate) wxPrintf( wxT("de") ); + // wxPrintf( wxT("activate\n") ); + + // do it only once + g_sendActivateEvent = -1; + wxTheApp->SetActive(activate, (wxWindow *)g_lastActiveFrame); + } +} // ---------------------------------------------------------------------------- // frame title/icon @@ -807,52 +1034,103 @@ void wxTopLevelWindowGTK::SetTitle( const wxString &title ) wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") ); m_title = title; - gtk_window_set_title( GTK_WINDOW(m_widget), title.mbc_str() ); + gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( title ) ); } void wxTopLevelWindowGTK::SetIcon( const wxIcon &icon ) +{ + SetIcons( wxIconBundle( icon ) ); +} + +void wxTopLevelWindowGTK::SetIcons( const wxIconBundle &icons ) { wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") ); - wxTopLevelWindowBase::SetIcon(icon); + wxTopLevelWindowBase::SetIcons( icons ); - if ( !m_icon.Ok() ) - return; +#ifdef __WXGTK20__ + GList *list = NULL; + size_t max = icons.m_icons.GetCount(); - if (!m_widget->window) + for (size_t i = 0; i < max; i++) + { + if (icons.m_icons[i].Ok()) + { + list = g_list_prepend(list, icons.m_icons[i].GetPixbuf()); + } + } + gtk_window_set_icon_list(GTK_WINDOW(m_widget), list); + g_list_free(list); + +#else // !__WXGTK20__ + GdkWindow* window = m_widget->window; + if (!window) return; - wxMask *mask = icon.GetMask(); - GdkBitmap *bm = (GdkBitmap *) NULL; - if (mask) bm = mask->GetBitmap(); + wxIcon icon = icons.GetIcon(-1); + if (icon.Ok()) + { + wxMask *mask = icon.GetMask(); + GdkBitmap *bm = (GdkBitmap *) NULL; + if (mask) bm = mask->GetBitmap(); + + gdk_window_set_icon( m_widget->window, (GdkWindow *) NULL, icon.GetPixmap(), bm ); + } - gdk_window_set_icon( m_widget->window, (GdkWindow *) NULL, icon.GetPixmap(), bm ); + wxSetIconsX11( (WXDisplay*)GDK_WINDOW_XDISPLAY( window ), + (WXWindow)GDK_WINDOW_XWINDOW( window ), icons ); +#endif // !__WXGTK20__ } // ---------------------------------------------------------------------------- // frame state: maximized/iconized/normal // ---------------------------------------------------------------------------- -void wxTopLevelWindowGTK::Maximize(bool WXUNUSED(maximize)) +void wxTopLevelWindowGTK::Maximize(bool maximize) { +#ifdef __WXGTK20__ + if (maximize) + gtk_window_maximize( GTK_WINDOW( m_widget ) ); + else + gtk_window_unmaximize( GTK_WINDOW( m_widget ) ); +#else wxFAIL_MSG( _T("not implemented") ); +#endif } bool wxTopLevelWindowGTK::IsMaximized() const { +#ifdef __WXGTK20__ + if(!m_widget->window) + return false; + + return gdk_window_get_state(m_widget->window) & GDK_WINDOW_STATE_MAXIMIZED; +#else // wxFAIL_MSG( _T("not implemented") ); // This is an approximation return FALSE; +#endif } void wxTopLevelWindowGTK::Restore() { +#ifdef __WXGTK20__ + // "Present" seems similar enough to "restore" + gtk_window_present( GTK_WINDOW( m_widget ) ); +#else wxFAIL_MSG( _T("not implemented") ); +#endif } void wxTopLevelWindowGTK::Iconize( bool iconize ) { +#ifdef __WXGTK20__ + if (iconize) + gtk_window_iconify( GTK_WINDOW( m_widget ) ); + else + gtk_window_deiconify( GTK_WINDOW( m_widget ) ); +#else if (iconize) { GdkWindow *window = m_widget->window; @@ -864,6 +1142,7 @@ void wxTopLevelWindowGTK::Iconize( bool iconize ) GDK_WINDOW_XWINDOW( window ), DefaultScreen( GDK_DISPLAY() ) ); } +#endif } bool wxTopLevelWindowGTK::IsIconized() const @@ -880,3 +1159,70 @@ void wxTopLevelWindowGTK::SetIconizeState(bool iconize) } } +void wxTopLevelWindowGTK::AddGrab() +{ + if (!m_grabbed) + { + m_grabbed = TRUE; + gtk_grab_add( m_widget ); + gtk_main(); + gtk_grab_remove( m_widget ); + } +} + +void wxTopLevelWindowGTK::RemoveGrab() +{ + if (m_grabbed) + { + gtk_main_quit(); + m_grabbed = FALSE; + } +} + + +// helper +static bool do_shape_combine_region(GdkWindow* window, const wxRegion& region) +{ + if (window) + { + if (region.IsEmpty()) + { + gdk_window_shape_combine_mask(window, NULL, 0, 0); + } + else + { +#ifdef __WXGTK20__ + gdk_window_shape_combine_region(window, region.GetRegion(), 0, 0); +#else + wxBitmap bmp = region.ConvertToBitmap(); + bmp.SetMask(new wxMask(bmp, *wxBLACK)); + GdkBitmap* mask = bmp.GetMask()->GetBitmap(); + gdk_window_shape_combine_mask(window, mask, 0, 0); +#endif + return TRUE; + } + } + return FALSE; +} + + +bool wxTopLevelWindowGTK::SetShape(const wxRegion& region) +{ + wxCHECK_MSG( HasFlag(wxFRAME_SHAPED), FALSE, + _T("Shaped windows must be created with the wxFRAME_SHAPED style.")); + + GdkWindow *window = NULL; + if (m_wxwindow) + { + window = GTK_PIZZA(m_wxwindow)->bin_window; + do_shape_combine_region(window, region); + } + window = m_widget->window; + return do_shape_combine_region(window, region); +} + +bool wxTopLevelWindowGTK::IsActive() +{ + return (this == (wxTopLevelWindowGTK*)g_activeFrame); +} +