]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/gtk/popupwin.cpp
gdk_draw_pixmap -> gdk_draw_drawable
[wxWidgets.git] / src / gtk / popupwin.cpp
... / ...
CommitLineData
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/gtk/private.h" //for idle stuff
25#include "wx/gtk/win_gtk.h"
26
27//-----------------------------------------------------------------------------
28// "button_press"
29//-----------------------------------------------------------------------------
30
31extern "C" {
32static gint gtk_popup_button_press (GtkWidget *widget, GdkEvent *gdk_event, wxPopupWindow* win )
33{
34 GtkWidget *child = gtk_get_event_widget (gdk_event);
35
36 /* Ignore events sent out before we connected to the signal */
37 if (win->m_time >= ((GdkEventButton*)gdk_event)->time)
38 return FALSE;
39
40 /* We don't ask for button press events on the grab widget, so
41 * if an event is reported directly to the grab widget, it must
42 * be on a window outside the application (and thus we remove
43 * the popup window). Otherwise, we check if the widget is a child
44 * of the grab widget, and only remove the popup window if it
45 * is not. */
46 if (child != widget)
47 {
48 while (child)
49 {
50 if (child == widget)
51 return FALSE;
52 child = child->parent;
53 }
54 }
55
56 wxFocusEvent event( wxEVT_KILL_FOCUS, win->GetId() );
57 event.SetEventObject( win );
58
59 (void)win->GetEventHandler()->ProcessEvent( event );
60
61 return TRUE;
62}
63}
64
65//-----------------------------------------------------------------------------
66// "focus" from m_window
67//-----------------------------------------------------------------------------
68
69extern "C" {
70static gint gtk_dialog_focus_callback( GtkWidget *widget, GtkDirectionType WXUNUSED(d), wxWindow *WXUNUSED(win) )
71{
72 if (g_isIdle)
73 wxapp_install_idle_handler();
74
75 /* This disables GTK's tab traversal */
76 g_signal_stop_emission_by_name (widget, "focus");
77 return TRUE;
78}
79}
80
81//-----------------------------------------------------------------------------
82// "delete_event"
83//-----------------------------------------------------------------------------
84
85extern "C" {
86bool gtk_dialog_delete_callback( GtkWidget *WXUNUSED(widget), GdkEvent *WXUNUSED(event), wxPopupWindow *win )
87{
88 if (g_isIdle)
89 wxapp_install_idle_handler();
90
91 if (win->IsEnabled())
92 win->Close();
93
94 return TRUE;
95}
96}
97
98//-----------------------------------------------------------------------------
99// "realize" from m_widget
100//-----------------------------------------------------------------------------
101
102/* we cannot MWM hints and icons before the widget has been realized,
103 so we do this directly after realization */
104
105extern "C" {
106static gint
107gtk_dialog_realized_callback( GtkWidget * WXUNUSED(widget), wxPopupWindow *win )
108{
109 if (g_isIdle)
110 wxapp_install_idle_handler();
111
112 /* all this is for Motif Window Manager "hints" and is supposed to be
113 recognized by other WM as well. not tested. */
114 long decor = (long) GDK_DECOR_BORDER;
115 long func = (long) GDK_FUNC_MOVE ;
116
117 gdk_window_set_decorations( win->m_widget->window, (GdkWMDecoration)decor);
118 gdk_window_set_functions( win->m_widget->window, (GdkWMFunction)func);
119
120 gtk_window_set_resizable(GTK_WINDOW(win->m_widget), FALSE);
121
122 return FALSE;
123}
124}
125
126//-----------------------------------------------------------------------------
127// InsertChild for wxPopupWindow
128//-----------------------------------------------------------------------------
129
130/* Callback for wxFrame. This very strange beast has to be used because
131 * C++ has no virtual methods in a constructor. We have to emulate a
132 * virtual function here as wxWidgets requires different ways to insert
133 * a child in container classes. */
134
135static void wxInsertChildInDialog( wxPopupWindow* parent, wxWindow* child )
136{
137 gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow),
138 GTK_WIDGET(child->m_widget),
139 child->m_x,
140 child->m_y,
141 child->m_width,
142 child->m_height );
143
144 if (parent->HasFlag(wxTAB_TRAVERSAL))
145 {
146 /* we now allow a window to get the focus as long as it
147 doesn't have any children. */
148 GTK_WIDGET_UNSET_FLAGS( parent->m_wxwindow, GTK_CAN_FOCUS );
149 }
150}
151
152//-----------------------------------------------------------------------------
153// wxPopupWindow
154//-----------------------------------------------------------------------------
155
156BEGIN_EVENT_TABLE(wxPopupWindow,wxPopupWindowBase)
157#ifdef __WXUNIVERSAL__
158 EVT_SIZE(wxPopupWindow::OnSize)
159#endif
160END_EVENT_TABLE()
161
162wxPopupWindow::~wxPopupWindow()
163{
164}
165
166bool wxPopupWindow::Create( wxWindow *parent, int style )
167{
168 m_needParent = FALSE;
169
170 if (!PreCreation( parent, wxDefaultPosition, wxDefaultSize ) ||
171 !CreateBase( parent, -1, wxDefaultPosition, wxDefaultSize, style, wxDefaultValidator, wxT("popup") ))
172 {
173 wxFAIL_MSG( wxT("wxPopupWindow creation failed") );
174 return FALSE;
175 }
176
177 // Unlike windows, top level windows are created hidden by default.
178 m_isShown = false;
179
180 // All dialogs should really have this style
181 m_windowStyle |= wxTAB_TRAVERSAL;
182
183 m_insertCallback = (wxInsertChildFunction) wxInsertChildInDialog;
184
185 m_widget = gtk_window_new( GTK_WINDOW_POPUP );
186
187 if ((m_parent) && (GTK_IS_WINDOW(m_parent->m_widget)))
188 gtk_window_set_transient_for( GTK_WINDOW(m_widget), GTK_WINDOW(m_parent->m_widget) );
189
190 GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
191
192 g_signal_connect (m_widget, "delete_event",
193 G_CALLBACK (gtk_dialog_delete_callback), this);
194
195 m_wxwindow = gtk_pizza_new();
196 gtk_widget_show( m_wxwindow );
197 GTK_WIDGET_UNSET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
198
199 gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
200
201 if (m_parent) m_parent->AddChild( this );
202
203 PostCreation();
204
205 /* we cannot set MWM hints before the widget has
206 been realized, so we do this directly after realization */
207 g_signal_connect (m_widget, "realize",
208 G_CALLBACK (gtk_dialog_realized_callback), this);
209
210 // disable native tab traversal
211 g_signal_connect (m_widget, "focus",
212 G_CALLBACK (gtk_dialog_focus_callback), this);
213
214 m_time = gtk_get_current_event_time();
215
216 g_signal_connect (m_widget, "button_press_event",
217 G_CALLBACK (gtk_popup_button_press), this);
218
219 return TRUE;
220}
221
222void wxPopupWindow::DoMoveWindow(int WXUNUSED(x), int WXUNUSED(y), int WXUNUSED(width), int WXUNUSED(height) )
223{
224 wxFAIL_MSG( wxT("DoMoveWindow called for wxPopupWindow") );
225}
226
227void wxPopupWindow::DoSetSize( int x, int y, int width, int height, int sizeFlags )
228{
229 wxASSERT_MSG( (m_widget != NULL), wxT("invalid dialog") );
230 wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid dialog") );
231
232 if (m_resizing) return; /* I don't like recursions */
233 m_resizing = TRUE;
234
235 int old_x = m_x;
236 int old_y = m_y;
237
238 int old_width = m_width;
239 int old_height = m_height;
240
241 if ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0)
242 {
243 if (x != -1) m_x = x;
244 if (y != -1) m_y = y;
245 if (width != -1) m_width = width;
246 if (height != -1) m_height = height;
247 }
248 else
249 {
250 m_x = x;
251 m_y = y;
252 m_width = width;
253 m_height = height;
254 }
255
256/*
257 if ((sizeFlags & wxSIZE_AUTO_WIDTH) == wxSIZE_AUTO_WIDTH)
258 {
259 if (width == -1) m_width = 80;
260 }
261
262 if ((sizeFlags & wxSIZE_AUTO_HEIGHT) == wxSIZE_AUTO_HEIGHT)
263 {
264 if (height == -1) m_height = 26;
265 }
266*/
267
268 int minWidth = GetMinWidth(),
269 minHeight = GetMinHeight(),
270 maxWidth = GetMaxWidth(),
271 maxHeight = GetMaxHeight();
272
273 if ((minWidth != -1) && (m_width < minWidth)) m_width = minWidth;
274 if ((minHeight != -1) && (m_height < minHeight)) m_height = minHeight;
275 if ((maxWidth != -1) && (m_width > maxWidth)) m_width = maxWidth;
276 if ((maxHeight != -1) && (m_height > maxHeight)) m_height = maxHeight;
277
278 if ((m_x != -1) || (m_y != -1))
279 {
280 if ((m_x != old_x) || (m_y != old_y))
281 {
282 /* we set the position here and when showing the dialog
283 for the first time in idle time */
284 // Where does that happen in idle time? I do not see it anywhere - MR
285 gtk_window_move( GTK_WINDOW(m_widget), m_x, m_y );
286 }
287 }
288
289 if ((m_width != old_width) || (m_height != old_height))
290 {
291 gtk_widget_set_size_request( 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
302void 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
340void 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
348bool 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