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