Debian Codegraph @

phoenix/gtk/window.cpp

raw
1 namespace phoenix {
2
3 static gint Window_close(GtkWidget* widget, GdkEvent* event, Window* window) {
4 if(window->onClose) window->onClose();
5 else window->setVisible(false);
6 if(window->state.modal && !window->visible()) window->setModal(false);
7 return true;
8 }
9
10 static gboolean Window_expose(GtkWidget* widget, GdkEvent* event, Window* window) {
11 if(window->state.backgroundColorOverride == false) return false;
12 cairo_t* context = gdk_cairo_create(widget->window);
13
14 Color color = window->backgroundColor();
15 double red = (double)color.red / 255.0;
16 double green = (double)color.green / 255.0;
17 double blue = (double)color.blue / 255.0;
18 double alpha = (double)color.alpha / 255.0;
19
20 if(gdk_screen_is_composited(gdk_screen_get_default())
21 && gdk_screen_get_rgba_colormap(gdk_screen_get_default())
22 ) {
23 cairo_set_source_rgba(context, red, green, blue, alpha);
24 } else {
25 cairo_set_source_rgb(context, red, green, blue);
26 }
27
28 cairo_set_operator(context, CAIRO_OPERATOR_SOURCE);
29 cairo_paint(context);
30 cairo_destroy(context);
31
32 return false;
33 }
34
35 static gboolean Window_configure(GtkWidget* widget, GdkEvent* event, Window* window) {
36 if(gtk_widget_get_realized(window->p.widget) == false) return false;
37 if(window->visible() == false) return false;
38 GdkWindow *gdkWindow = gtk_widget_get_window(widget);
39
40 GdkRectangle border, client;
41 gdk_window_get_frame_extents(gdkWindow, &border);
42 gdk_window_get_geometry(gdkWindow, nullptr, nullptr, &client.width, &client.height, nullptr);
43 gdk_window_get_origin(gdkWindow, &client.x, &client.y);
44
45 if(window->state.fullScreen == false) {
46 //update geometry settings
47 settings->geometry.frameX = client.x - border.x;
48 settings->geometry.frameY = client.y - border.y;
49 settings->geometry.frameWidth = border.width - client.width;
50 settings->geometry.frameHeight = border.height - client.height;
51 if(window->state.backgroundColorOverride == false) {
52 GdkColor color = widget->style->bg[GTK_STATE_NORMAL];
53 settings->window.backgroundColor
54 = ((uint8_t)(color.red >> 8) << 16)
55 + ((uint8_t)(color.green >> 8) << 8)
56 + ((uint8_t)(color.blue >> 8) << 0);
57 }
58 settings->save();
59 }
60
61 Geometry geometry = {
62 client.x,
63 client.y + window->p.menuHeight(),
64 client.width,
65 client.height - window->p.menuHeight() - window->p.statusHeight()
66 };
67
68 //move
69 if(geometry.x != window->state.geometry.x || geometry.y != window->state.geometry.y) {
70 if(window->state.fullScreen == false) {
71 window->state.geometry.x = geometry.x;
72 window->state.geometry.y = geometry.y;
73 }
74 if(window->p.locked == false && window->onMove) window->onMove();
75 }
76
77 //size
78 if(geometry.width != window->state.geometry.width || geometry.height != window->state.geometry.height) {
79 window->p.onSizePending = true;
80 }
81
82 return false;
83 }
84
85 static void Window_drop(GtkWidget* widget, GdkDragContext* context, gint x, gint y,
86 GtkSelectionData* data, guint type, guint timestamp, Window* window) {
87 if(window->state.droppable == false) return;
88 lstring paths = DropPaths(data);
89 if(paths.empty()) return;
90 if(window->onDrop) window->onDrop(paths);
91 }
92
93 static gboolean Window_keyPress(GtkWidget* widget, GdkEventKey* event, Window* window) {
94 Keyboard::Keycode key = Keysym(event->keyval);
95 if(key != Keyboard::Keycode::None && window->onKeyPress) window->onKeyPress(key);
96 return false;
97 }
98
99 static gboolean Window_keyRelease(GtkWidget* widget, GdkEventKey* event, Window* window) {
100 Keyboard::Keycode key = Keysym(event->keyval);
101 if(key != Keyboard::Keycode::None && window->onKeyRelease) window->onKeyRelease(key);
102 return false;
103 }
104
105 static void Window_sizeAllocate(GtkWidget* widget, GtkAllocation* allocation, Window* window) {
106 //size-allocate sent from gtk_fixed_move(); detect if layout unchanged and return
107 if(allocation->width == window->p.lastAllocation.width
108 && allocation->height == window->p.lastAllocation.height) return;
109
110 window->state.geometry.width = allocation->width;
111 window->state.geometry.height = allocation->height;
112
113 for(auto& layout : window->state.layout) {
114 Geometry geometry = window->geometry();
115 geometry.x = geometry.y = 0;
116 layout.setGeometry(geometry);
117 }
118
119 if(window->p.onSizePending && window->p.locked == false && window->onSize) {
120 window->p.onSizePending = false;
121 window->onSize();
122 }
123
124 window->p.lastAllocation = *allocation;
125 }
126
127 static void Window_sizeRequest(GtkWidget* widget, GtkRequisition* requisition, Window* window) {
128 requisition->width = window->state.geometry.width;
129 requisition->height = window->state.geometry.height;
130 }
131
132 Window& pWindow::none() {
133 static Window* window = nullptr;
134 if(window == nullptr) window = new Window;
135 return *window;
136 }
137
138 void pWindow::append(Layout& layout) {
139 Geometry geometry = this->geometry();
140 geometry.x = geometry.y = 0;
141 layout.setGeometry(geometry);
142 }
143
144 void pWindow::append(Menu& menu) {
145 if(window.state.menuFont) menu.p.setFont(window.state.menuFont);
146 else menu.p.setFont(Font::sans(8));
147 gtk_menu_shell_append(GTK_MENU_SHELL(this->menu), menu.p.widget);
148 gtk_widget_show(menu.p.widget);
149 }
150
151 void pWindow::append(Widget& widget) {
152 if(widget.font().empty() && !window.state.widgetFont.empty()) {
153 widget.setFont(window.state.widgetFont);
154 }
155
156 if(GetParentWidget(&widget)) {
157 widget.p.gtkParent = GetParentWidget(&widget)->p.container(widget);
158 } else {
159 widget.p.gtkParent = formContainer;
160 }
161
162 gtk_fixed_put(GTK_FIXED(widget.p.gtkParent), widget.p.gtkWidget, 0, 0);
163 if(widget.state.font) widget.p.setFont(widget.state.font);
164 else if(window.state.widgetFont) widget.p.setFont(window.state.widgetFont);
165 else widget.p.setFont(Font::sans(8));
166 widget.setVisible(widget.visible());
167 }
168
169 Geometry pWindow::frameMargin() {
170 if(window.state.fullScreen) return {
171 0,
172 menuHeight(),
173 0,
174 menuHeight() + statusHeight()
175 };
176
177 return {
178 settings->geometry.frameX,
179 settings->geometry.frameY + menuHeight(),
180 settings->geometry.frameWidth,
181 settings->geometry.frameHeight + menuHeight() + statusHeight()
182 };
183 }
184
185 bool pWindow::focused() {
186 return gtk_window_is_active(GTK_WINDOW(widget));
187 }
188
189 Geometry pWindow::geometry() {
190 if(window.state.fullScreen) {
191 int x, y, width, height;
192 gtk_window_get_position(GTK_WINDOW(widget), &x, &y);
193 gtk_window_get_size(GTK_WINDOW(widget), &width, &height);
194 return {x, y + menuHeight(), width, height - menuHeight() - statusHeight()};
195 }
196 return window.state.geometry;
197 }
198
199 void pWindow::remove(Layout& layout) {
200 }
201
202 void pWindow::remove(Menu& menu) {
203 menu.p.orphan();
204 }
205
206 void pWindow::remove(Widget& widget) {
207 widget.p.orphan();
208 }
209
210 void pWindow::setBackgroundColor(Color color) {
211 GdkColor gdkColor = CreateColor(color.red, color.green, color.blue);
212 gtk_widget_modify_bg(widget, GTK_STATE_NORMAL, &gdkColor);
213 }
214
215 void pWindow::setDroppable(bool droppable) {
216 gtk_drag_dest_set(widget, GTK_DEST_DEFAULT_ALL, nullptr, 0, GDK_ACTION_COPY);
217 if(droppable) gtk_drag_dest_add_uri_targets(widget);
218 }
219
220 void pWindow::setFocused() {
221 gtk_window_present(GTK_WINDOW(widget));
222 }
223
224 void pWindow::setFullScreen(bool fullScreen) {
225 if(fullScreen == false) {
226 gtk_window_unfullscreen(GTK_WINDOW(widget));
227 } else {
228 gtk_window_fullscreen(GTK_WINDOW(widget));
229 /*unsigned monitor = gdk_screen_get_monitor_at_window(gdk_screen_get_default(), gtk_widget_get_window(widget));
230 GdkRectangle rectangle = {0};
231 gdk_screen_get_monitor_geometry(gdk_screen_get_default(), monitor, &rectangle);
232 gtk_window_set_decorated(GTK_WINDOW(widget), false);
233 gtk_window_move(GTK_WINDOW(widget), rectangle.x, rectangle.y);
234 gtk_window_resize(GTK_WINDOW(widget), rectangle.width, rectangle.height);
235 gtk_widget_set_size_request(formContainer, rectangle.width, rectangle.height);*/
236 }
237 }
238
239 void pWindow::setGeometry(Geometry geometry) {
240 Geometry margin = frameMargin();
241 gtk_window_move(GTK_WINDOW(widget), geometry.x - margin.x, geometry.y - margin.y);
242
243 GdkGeometry geom;
244 geom.min_width = window.state.resizable ? 1 : window.state.geometry.width;
245 geom.min_height = window.state.resizable ? 1 : window.state.geometry.height;
246 gtk_window_set_geometry_hints(GTK_WINDOW(widget), GTK_WIDGET(widget), &geom, GDK_HINT_MIN_SIZE);
247
248 //gtk_window_set_policy(GTK_WINDOW(widget), true, true, false);
249 gtk_widget_set_size_request(formContainer, geometry.width, geometry.height);
250 gtk_window_resize(GTK_WINDOW(widget), geometry.width, geometry.height + menuHeight() + statusHeight());
251
252 for(auto& layout : window.state.layout) {
253 Geometry layoutGeometry = geometry;
254 layoutGeometry.x = layoutGeometry.y = 0;
255 layout.setGeometry(layoutGeometry);
256 }
257 }
258
259 void pWindow::setMenuFont(string font) {
260 for(auto& item : window.state.menu) item.p.setFont(font);
261 }
262
263 void pWindow::setMenuVisible(bool visible) {
264 gtk_widget_set_visible(menu, visible);
265 }
266
267 void pWindow::setModal(bool modal) {
268 if(modal == true) {
269 gtk_window_set_modal(GTK_WINDOW(widget), true);
270 while(window.state.modal) {
271 Application::processEvents();
272 usleep(20 * 1000);
273 }
274 gtk_window_set_modal(GTK_WINDOW(widget), false);
275 }
276 }
277
278 void pWindow::setResizable(bool resizable) {
279 gtk_window_set_resizable(GTK_WINDOW(widget), resizable);
280 gtk_statusbar_set_has_resize_grip(GTK_STATUSBAR(status), resizable);
281 }
282
283 void pWindow::setStatusFont(string font) {
284 pFont::setFont(status, font);
285 }
286
287 void pWindow::setStatusText(string text) {
288 gtk_statusbar_pop(GTK_STATUSBAR(status), 1);
289 gtk_statusbar_push(GTK_STATUSBAR(status), 1, text);
290 }
291
292 void pWindow::setStatusVisible(bool visible) {
293 gtk_widget_set_visible(status, visible);
294 }
295
296 void pWindow::setTitle(string text) {
297 gtk_window_set_title(GTK_WINDOW(widget), text);
298 }
299
300 void pWindow::setVisible(bool visible) {
301 gtk_widget_set_visible(widget, visible);
302 if(visible) {
303 if(gtk_widget_get_visible(menu)) {
304 GtkAllocation allocation;
305 gtk_widget_get_allocation(menu, &allocation);
306 settings->geometry.menuHeight = allocation.height;
307 }
308
309 if(gtk_widget_get_visible(status)) {
310 GtkAllocation allocation;
311 gtk_widget_get_allocation(status, &allocation);
312 settings->geometry.statusHeight = allocation.height;
313 }
314 }
315 }
316
317 void pWindow::setWidgetFont(string font) {
318 }
319
320 void pWindow::constructor() {
321 lastAllocation.width = 0;
322 lastAllocation.height = 0;
323 onSizePending = false;
324
325 widget = gtk_window_new(GTK_WINDOW_TOPLEVEL);
326
327 //if program was given a name, try and set the window taskbar icon from one of the pixmaps folders
328 if(applicationState.name.empty() == false) {
329 string filename = {"/usr/share/pixmaps/", applicationState.name, ".png"};
330 if(!file::exists(filename)) filename = {"/usr/local/share/pixmaps/", applicationState.name, ".png"};
331 if(file::exists(filename)) {
332 //maximum image size supported by GTK+ is 256x256; so we must scale larger images ourselves
333 nall::image icon(filename);
334 icon.scale(min(256u, icon.width), min(256u, icon.height), Interpolation::Hermite);
335 GdkPixbuf* pixbuf = CreatePixbuf(icon);
336 gtk_window_set_icon(GTK_WINDOW(widget), pixbuf);
337 g_object_unref(G_OBJECT(pixbuf));
338 }
339 }
340
341 GdkColormap* colormap = gdk_screen_get_rgba_colormap(gdk_screen_get_default());
342 if(!colormap) colormap = gdk_screen_get_rgb_colormap(gdk_screen_get_default());
343 if(colormap) gtk_widget_set_colormap(widget, colormap);
344
345 gtk_window_set_resizable(GTK_WINDOW(widget), true);
346 #if GTK_MAJOR_VERSION >= 3
347 gtk_window_set_has_resize_grip(GTK_WINDOW(widget), false);
348 #endif
349
350 gtk_widget_set_app_paintable(widget, true);
351 gtk_widget_add_events(widget, GDK_CONFIGURE);
352
353 menuContainer = gtk_vbox_new(false, 0);
354 gtk_container_add(GTK_CONTAINER(widget), menuContainer);
355 gtk_widget_show(menuContainer);
356
357 menu = gtk_menu_bar_new();
358 gtk_box_pack_start(GTK_BOX(menuContainer), menu, false, false, 0);
359
360 formContainer = gtk_fixed_new();
361 gtk_box_pack_start(GTK_BOX(menuContainer), formContainer, true, true, 0);
362 gtk_widget_show(formContainer);
363
364 statusContainer = gtk_event_box_new();
365 status = gtk_statusbar_new();
366 gtk_statusbar_set_has_resize_grip(GTK_STATUSBAR(status), true);
367 gtk_container_add(GTK_CONTAINER(statusContainer), status);
368 gtk_box_pack_start(GTK_BOX(menuContainer), statusContainer, false, false, 0);
369 gtk_widget_show(statusContainer);
370
371 setTitle("");
372 setResizable(window.state.resizable);
373 setGeometry(window.state.geometry);
374 setMenuFont(Font::sans(8));
375 setStatusFont(Font::sans(8));
376
377 g_signal_connect(G_OBJECT(widget), "delete-event", G_CALLBACK(Window_close), (gpointer)&window);
378 g_signal_connect(G_OBJECT(widget), "expose-event", G_CALLBACK(Window_expose), (gpointer)&window);
379 g_signal_connect(G_OBJECT(widget), "configure-event", G_CALLBACK(Window_configure), (gpointer)&window);
380 g_signal_connect(G_OBJECT(widget), "drag-data-received", G_CALLBACK(Window_drop), (gpointer)&window);
381 g_signal_connect(G_OBJECT(widget), "key-press-event", G_CALLBACK(Window_keyPress), (gpointer)&window);
382 g_signal_connect(G_OBJECT(widget), "key-release-event", G_CALLBACK(Window_keyPress), (gpointer)&window);
383
384 g_signal_connect(G_OBJECT(formContainer), "size-allocate", G_CALLBACK(Window_sizeAllocate), (gpointer)&window);
385 g_signal_connect(G_OBJECT(formContainer), "size-request", G_CALLBACK(Window_sizeRequest), (gpointer)&window);
386
387 window.state.backgroundColor = Color(
388 (uint8_t)(settings->window.backgroundColor >> 16),
389 (uint8_t)(settings->window.backgroundColor >> 8),
390 (uint8_t)(settings->window.backgroundColor >> 0)
391 );
392 }
393
394 unsigned pWindow::menuHeight() {
395 return window.state.menuVisible ? settings->geometry.menuHeight : 0;
396 }
397
398 unsigned pWindow::statusHeight() {
399 return window.state.statusVisible ? settings->geometry.statusHeight : 0;
400 }
401
402 }