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