| 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 |
} |