src/gtk1/popupwin.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        popupwin.cpp
   3 // Purpose:
   4 // Author:      Robert Roebling
   5 // Id:          $Id$
   6 // Copyright:   (c) 1998 Robert Roebling
   7 // Licence:     wxWindows licence
   8 /////////////////////////////////////////////////////////////////////////////
   9
  10 // For compilers that support precompilation, includes "wx.h".
  11 #include "wx/wxprec.h"
  12
  13 #if wxUSE_POPUPWIN
  14
  15 #include "wx/popupwin.h"
  16 #include "wx/frame.h"
  17 #include "wx/app.h"
  18 #include "wx/cursor.h"
  19
  20 #include <gdk/gdk.h>
  21 #include <gtk/gtk.h>
  22 #include <gdk/gdkkeysyms.h>
  23
  24 #include "wx/gtk1/win_gtk.h"
  25
  26 //-----------------------------------------------------------------------------
  27 // idle system
  28 //-----------------------------------------------------------------------------
  29
  30 extern void wxapp_install_idle_handler();
  31 extern bool g_isIdle;
  32
  33 //-----------------------------------------------------------------------------
  34 // "button_press"
  35 //-----------------------------------------------------------------------------
  36
  37 extern "C" {
  38 static gint gtk_popup_button_press (GtkWidget *widget, GdkEvent *gdk_event, wxPopupWindow* win )
  39 {
  40     GtkWidget *child = gtk_get_event_widget (gdk_event);
  41
  42   /* We don't ask for button press events on the grab widget, so
  43    *  if an event is reported directly to the grab widget, it must
  44    *  be on a window outside the application (and thus we remove
  45    *  the popup window). Otherwise, we check if the widget is a child
  46    *  of the grab widget, and only remove the popup window if it
  47    *  is not.
  48    */
  49     if (child != widget)
  50     {
  51         while (child)
  52         {
  53             if (child == widget)
  54                 return FALSE;
  55             child = child->parent;
  56         }
  57     }
  58
  59     wxFocusEvent event( wxEVT_KILL_FOCUS, win->GetId() );
  60     event.SetEventObject( win );
  61
  62     (void)win->GetEventHandler()->ProcessEvent( event );
  63
  64     return TRUE;
  65 }
  66 }
  67
  68 //-----------------------------------------------------------------------------
  69 // "focus" from m_window
  70 //-----------------------------------------------------------------------------
  71
  72 extern "C" {
  73 static gint gtk_dialog_focus_callback( GtkWidget *widget, GtkDirectionType WXUNUSED(d), wxWindow *WXUNUSED(win) )
  74 {
  75     if (g_isIdle)
  76         wxapp_install_idle_handler();
  77
  78     // This disables GTK's tab traversal
  79     gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus" );
  80     return TRUE;
  81 }
  82 }
  83
  84 //-----------------------------------------------------------------------------
  85 // "delete_event"
  86 //-----------------------------------------------------------------------------
  87
  88 extern "C" {
  89 bool gtk_dialog_delete_callback( GtkWidget *WXUNUSED(widget), GdkEvent *WXUNUSED(event), wxPopupWindow *win )
  90 {
  91     if (g_isIdle)
  92         wxapp_install_idle_handler();
  93
  94     if (win->IsEnabled())
  95         win->Close();
  96
  97     return TRUE;
  98 }
  99 }
 100
 101 //-----------------------------------------------------------------------------
 102 // "realize" from m_widget
 103 //-----------------------------------------------------------------------------
 104
 105 /* we cannot MWM hints and icons before the widget has been realized,
 106    so we do this directly after realization */
 107
 108 extern "C" {
 109 static gint
 110 gtk_dialog_realized_callback( GtkWidget * WXUNUSED(widget), wxPopupWindow *win )
 111 {
 112     if (g_isIdle)
 113         wxapp_install_idle_handler();
 114
 115     /* all this is for Motif Window Manager "hints" and is supposed to be
 116        recognized by other WM as well. not tested. */
 117     long decor = (long) GDK_DECOR_BORDER;
 118     long func = (long) GDK_FUNC_MOVE ;
 119
 120     gdk_window_set_decorations( win->m_widget->window, (GdkWMDecoration)decor);
 121     gdk_window_set_functions( win->m_widget->window, (GdkWMFunction)func);
 122
 123     gtk_window_set_policy(GTK_WINDOW(win->m_widget), 0, 0, 1);
 124
 125     return FALSE;
 126 }
 127 }
 128
 129 //-----------------------------------------------------------------------------
 130 // InsertChild for wxPopupWindow
 131 //-----------------------------------------------------------------------------
 132
 133 /* Callback for wxFrame. This very strange beast has to be used because
 134  * C++ has no virtual methods in a constructor. We have to emulate a
 135  * virtual function here as wxWidgets requires different ways to insert
 136  * a child in container classes. */
 137
 138 static void wxInsertChildInDialog( wxPopupWindow* parent, wxWindow* child )
 139 {
 140     gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow),
 141                    GTK_WIDGET(child->m_widget),
 142                    child->m_x,
 143                    child->m_y,
 144                    child->m_width,
 145                    child->m_height );
 146
 147     if (parent->HasFlag(wxTAB_TRAVERSAL))
 148     {
 149         /* we now allow a window to get the focus as long as it
 150            doesn't have any children. */
 151         GTK_WIDGET_UNSET_FLAGS( parent->m_wxwindow, GTK_CAN_FOCUS );
 152     }
 153 }
 154
 155 //-----------------------------------------------------------------------------
 156 // wxPopupWindow
 157 //-----------------------------------------------------------------------------
 158
 159 BEGIN_EVENT_TABLE(wxPopupWindow,wxPopupWindowBase)
 160 #ifdef __WXUNIVERSAL__
 161     EVT_SIZE(wxPopupWindow::OnSize)
 162 #endif
 163 END_EVENT_TABLE()
 164
 165 wxPopupWindow::~wxPopupWindow()
 166 {
 167 }
 168
 169 bool wxPopupWindow::Create( wxWindow *parent, int style )
 170 {
 171     m_needParent = FALSE;
 172
 173     if (!PreCreation( parent, wxDefaultPosition, wxDefaultSize ) ||
 174         !CreateBase( parent, -1, wxDefaultPosition, wxDefaultSize, style, wxDefaultValidator, wxT("popup") ))
 175     {
 176         wxFAIL_MSG( wxT("wxPopupWindow creation failed") );
 177         return FALSE;
 178     }
 179
 180     // Unlike windows, top level windows are created hidden by default.
 181     m_isShown = false;
 182
 183     // All dialogs should really have this style
 184     m_windowStyle |= wxTAB_TRAVERSAL;
 185
 186     m_insertCallback = (wxInsertChildFunction) wxInsertChildInDialog;
 187
 188     m_widget = gtk_window_new( GTK_WINDOW_POPUP );
 189
 190     if ((m_parent) && (GTK_IS_WINDOW(m_parent->m_widget)))
 191         gtk_window_set_transient_for( GTK_WINDOW(m_widget), GTK_WINDOW(m_parent->m_widget) );
 192
 193     GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
 194
 195     gtk_signal_connect( GTK_OBJECT(m_widget), "delete_event",
 196         GTK_SIGNAL_FUNC(gtk_dialog_delete_callback), (gpointer)this );
 197
 198     m_wxwindow = gtk_pizza_new();
 199     gtk_widget_show( m_wxwindow );
 200     GTK_WIDGET_UNSET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
 201
 202     gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
 203
 204     if (m_parent) m_parent->AddChild( this );
 205
 206     PostCreation();
 207
 208     /*  we cannot set MWM hints  before the widget has
 209         been realized, so we do this directly after realization */
 210     gtk_signal_connect( GTK_OBJECT(m_widget), "realize",
 211                         GTK_SIGNAL_FUNC(gtk_dialog_realized_callback), (gpointer) this );
 212
 213     // disable native tab traversal
 214     gtk_signal_connect( GTK_OBJECT(m_widget), "focus",
 215         GTK_SIGNAL_FUNC(gtk_dialog_focus_callback), (gpointer)this );
 216
 217     gtk_signal_connect (GTK_OBJECT(m_widget), "button_press_event",
 218         GTK_SIGNAL_FUNC(gtk_popup_button_press), (gpointer)this );
 219
 220     return TRUE;
 221 }
 222
 223 void wxPopupWindow::DoMoveWindow(int WXUNUSED(x), int WXUNUSED(y), int WXUNUSED(width), int WXUNUSED(height) )
 224 {
 225     wxFAIL_MSG( wxT("DoMoveWindow called for wxPopupWindow") );
 226 }
 227
 228 void wxPopupWindow::DoSetSize( int x, int y, int width, int height, int sizeFlags )
 229 {
 230     wxASSERT_MSG( (m_widget != NULL), wxT("invalid dialog") );
 231     wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid dialog") );
 232
 233     if (m_resizing) return; /* I don't like recursions */
 234     m_resizing = TRUE;
 235
 236     int old_x = m_x;
 237     int old_y = m_y;
 238
 239     int old_width = m_width;
 240     int old_height = m_height;
 241
 242     if ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0)
 243     {
 244         if (x != -1) m_x = x;
 245         if (y != -1) m_y = y;
 246         if (width != -1) m_width = width;
 247         if (height != -1) m_height = height;
 248     }
 249     else
 250     {
 251         m_x = x;
 252         m_y = y;
 253         m_width = width;
 254         m_height = height;
 255     }
 256
 257 /*
 258     if ((sizeFlags & wxSIZE_AUTO_WIDTH) == wxSIZE_AUTO_WIDTH)
 259     {
 260         if (width == -1) m_width = 80;
 261     }
 262
 263     if ((sizeFlags & wxSIZE_AUTO_HEIGHT) == wxSIZE_AUTO_HEIGHT)
 264     {
 265        if (height == -1) m_height = 26;
 266     }
 267 */
 268
 269     int minWidth = GetMinWidth(),
 270         minHeight = GetMinHeight(),
 271         maxWidth = GetMaxWidth(),
 272         maxHeight = GetMaxHeight();
 273
 274     if ((minWidth != -1) && (m_width < minWidth)) m_width = minWidth;
 275     if ((minHeight != -1) && (m_height < minHeight)) m_height = minHeight;
 276     if ((maxWidth != -1) && (m_width > maxWidth)) m_width = maxWidth;
 277     if ((maxHeight != -1) && (m_height > maxHeight)) m_height = maxHeight;
 278
 279     if ((m_x != -1) || (m_y != -1))
 280     {
 281         if ((m_x != old_x) || (m_y != old_y))
 282         {
 283             /* we set the position here and when showing the dialog
 284                for the first time in idle time */
 285             gtk_widget_set_uposition( m_widget, m_x, m_y );
 286         }
 287     }
 288
 289     if ((m_width != old_width) || (m_height != old_height))
 290     {
 291         gtk_widget_set_usize( m_widget, m_width, m_height );
 292
 293         /* actual resizing is deferred to GtkOnSize in idle time and
 294            when showing the dialog */
 295         m_sizeSet = FALSE;
 296
 297     }
 298
 299     m_resizing = FALSE;
 300 }
 301
 302 void wxPopupWindow::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y), int width, int height )
 303 {
 304     // due to a bug in gtk, x,y are always 0
 305     // m_x = x;
 306     // m_y = y;
 307
 308     if ((m_height == height) && (m_width == width) && (m_sizeSet)) return;
 309     if (!m_wxwindow) return;
 310
 311     m_width = width;
 312     m_height = height;
 313
 314     /* FIXME: is this a hack? */
 315     /* Since for some reason GTK will revert to using maximum size ever set
 316        for this window, we have to set geometry hints maxsize to match size
 317        given. Also set the to that minsize since resizing isn't possible
 318        anyway. */
 319
 320     /* set size hints */
 321     gint flag = GDK_HINT_MAX_SIZE | GDK_HINT_MIN_SIZE; // GDK_HINT_POS;
 322     GdkGeometry geom;
 323     geom.min_width = m_width;
 324     geom.min_height = m_height;
 325     geom.max_width = m_width;
 326     geom.max_height = m_height;
 327     gtk_window_set_geometry_hints( GTK_WINDOW(m_widget),
 328                                    (GtkWidget*) NULL,
 329                                    &geom,
 330                                    (GdkWindowHints) flag );
 331
 332
 333     m_sizeSet = TRUE;
 334
 335     wxSizeEvent event( wxSize(m_width,m_height), GetId() );
 336     event.SetEventObject( this );
 337     GetEventHandler()->ProcessEvent( event );
 338 }
 339
 340 void wxPopupWindow::OnInternalIdle()
 341 {
 342     if (!m_sizeSet && GTK_WIDGET_REALIZED(m_wxwindow))
 343         GtkOnSize( m_x, m_y, m_width, m_height );
 344
 345     wxWindow::OnInternalIdle();
 346 }
 347
 348 bool wxPopupWindow::Show( bool show )
 349 {
 350     if (show && !m_sizeSet)
 351     {
 352         /* by calling GtkOnSize here, we don't have to call
 353            either after showing the frame, which would entail
 354            much ugly flicker nor from within the size_allocate
 355            handler, because GTK 1.1.X forbids that. */
 356
 357         GtkOnSize( m_x, m_y, m_width, m_height );
 358     }
 359
 360     bool ret = wxWindow::Show( show );
 361
 362     return ret;
 363 }
 364
 365 #endif // wxUSE_POPUPWIN