Skip to content

Commit cc5c63c

Browse files
SiegeLordExSiegeLord
SiegeLordEx
authored and
SiegeLord
committed
Enable toggling and setting maximized/frameless modes when native_dialog is used on Linux.
1 parent 1c346ff commit cc5c63c

File tree

4 files changed

+147
-31
lines changed

4 files changed

+147
-31
lines changed

‎addons/native_dialog/gtk_xgtk.c‎

Lines changed: 107 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -64,6 +64,14 @@ typedef struct
6464
} ARGS_POSITION;
6565

6666

67+
typedef struct ARGS_SET_FLAG
68+
{
69+
ARGS_BASE base; /* must be first */
70+
ALLEGRO_DISPLAY_XGLX *display;
71+
bool onoff;
72+
} ARGS_SET_FLAG;
73+
74+
6775
/* forward declarations */
6876
static gboolean xgtk_quit_callback(GtkWidget *widget, GdkEvent *event,
6977
ALLEGRO_DISPLAY *display);
@@ -418,6 +426,102 @@ static bool xgtk_set_window_constraints(ALLEGRO_DISPLAY *display,
418426
}
419427

420428

429+
/* [gtk thread] */
430+
static gboolean do_maximize(gpointer data)
431+
{
432+
ARGS_SET_FLAG *args = _al_gtk_lock_args(data);
433+
434+
if (args->onoff) {
435+
gtk_window_maximize(GTK_WINDOW(args->display->gtk->gtkwindow));
436+
} else {
437+
gtk_window_unmaximize(GTK_WINDOW(args->display->gtk->gtkwindow));
438+
}
439+
440+
return _al_gtk_release_args(args);
441+
}
442+
443+
444+
/* [gtk thread] */
445+
static gboolean do_set_frameless(gpointer data)
446+
{
447+
ARGS_SET_FLAG *args = _al_gtk_lock_args(data);
448+
449+
if (args->onoff) {
450+
gtk_window_set_decorated(GTK_WINDOW(args->display->gtk->gtkwindow), FALSE);
451+
} else {
452+
gtk_window_set_decorated(GTK_WINDOW(args->display->gtk->gtkwindow), TRUE);
453+
}
454+
455+
return _al_gtk_release_args(args);
456+
}
457+
458+
459+
/* [user thread] */
460+
static bool xgtk_set_display_flag(ALLEGRO_DISPLAY *display, int flag, bool onoff)
461+
{
462+
switch (flag) {
463+
case ALLEGRO_FRAMELESS: {
464+
if (!!(display->flags & ALLEGRO_FRAMELESS) == onoff)
465+
return true;
466+
ARGS_SET_FLAG args;
467+
if (_al_gtk_init_args(&args, sizeof(args))) {
468+
args.display = (ALLEGRO_DISPLAY_XGLX *)display;
469+
args.onoff = onoff;
470+
_al_gtk_wait_for_args(do_set_frameless, &args);
471+
if (onoff)
472+
display->flags |= ALLEGRO_FRAMELESS;
473+
else
474+
display->flags &= ~ALLEGRO_FRAMELESS;
475+
}
476+
return true;
477+
}
478+
case ALLEGRO_MAXIMIZED: {
479+
if (!!(display->flags & ALLEGRO_MAXIMIZED) == onoff)
480+
return true;
481+
ARGS_SET_FLAG args;
482+
if (_al_gtk_init_args(&args, sizeof(args))) {
483+
args.display = (ALLEGRO_DISPLAY_XGLX *)display;
484+
args.onoff = onoff;
485+
ALLEGRO_DISPLAY_XGLX *glx = (ALLEGRO_DISPLAY_XGLX *)display;
486+
int old_resize_count = glx->resize_count;
487+
_al_gtk_wait_for_args(do_maximize, &args);
488+
_al_display_xglx_await_resize(display, old_resize_count, true);
489+
}
490+
491+
return true;
492+
}
493+
}
494+
return false;
495+
}
496+
497+
498+
/* [gtk thread] */
499+
static gboolean do_check_maximized(gpointer data)
500+
{
501+
ARGS_SET_FLAG *args = _al_gtk_lock_args(data);
502+
503+
args->onoff = gtk_window_is_maximized(GTK_WINDOW(args->display->gtk->gtkwindow));
504+
505+
return _al_gtk_release_args(args);
506+
}
507+
508+
509+
/* [user thread] */
510+
static void xgtk_check_maximized(ALLEGRO_DISPLAY *display)
511+
{
512+
ARGS_SET_FLAG args;
513+
if (_al_gtk_init_args(&args, sizeof(args))) {
514+
args.display = (ALLEGRO_DISPLAY_XGLX *)display;
515+
_al_gtk_wait_for_args(do_check_maximized, &args);
516+
if (args.onoff) {
517+
display->flags |= ALLEGRO_MAXIMIZED;
518+
}
519+
else {
520+
display->flags &= ~ALLEGRO_MAXIMIZED;
521+
}
522+
}
523+
}
524+
421525
static struct ALLEGRO_XWIN_DISPLAY_OVERRIDABLE_INTERFACE xgtk_override_vt =
422526
{
423527
xgtk_create_display_hook,
@@ -426,7 +530,9 @@ static struct ALLEGRO_XWIN_DISPLAY_OVERRIDABLE_INTERFACE xgtk_override_vt =
426530
xgtk_set_window_title,
427531
xgtk_set_fullscreen_window,
428532
xgtk_set_window_position,
429-
xgtk_set_window_constraints
533+
xgtk_set_window_constraints,
534+
xgtk_set_display_flag,
535+
xgtk_check_maximized,
430536
};
431537

432538

‎include/allegro5/internal/aintern_xdisplay.h‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -91,6 +91,8 @@ struct ALLEGRO_XWIN_DISPLAY_OVERRIDABLE_INTERFACE
9191
void (*set_fullscreen_window)(ALLEGRO_DISPLAY *display, bool onoff);
9292
void (*set_window_position)(ALLEGRO_DISPLAY *display, int x, int y);
9393
bool (*set_window_constraints)(ALLEGRO_DISPLAY *display, int min_w, int min_h, int max_w, int max_h);
94+
bool (*set_display_flag)(ALLEGRO_DISPLAY *display, int flag, bool onoff);
95+
void (*check_maximized)(ALLEGRO_DISPLAY *display);
9496
};
9597

9698
bool _al_xwin_set_gtk_display_overridable_interface(uint32_t check_version,

‎src/x/xdisplay.c‎

Lines changed: 38 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -249,14 +249,6 @@ static bool xdpy_create_display_window(ALLEGRO_SYSTEM_XGLX *system,
249249
}
250250
}
251251

252-
if (display->flags & ALLEGRO_FRAMELESS) {
253-
_al_xwin_set_frame(display, false);
254-
}
255-
256-
if (display->flags & ALLEGRO_DRAG_AND_DROP) {
257-
_al_xwin_accept_drag_and_drop(display, true);
258-
}
259-
260252
ALLEGRO_DEBUG("X11 window created.\n");
261253

262254
/* Set the PID related to the window. */
@@ -463,11 +455,26 @@ static ALLEGRO_DISPLAY_XGLX *xdpy_create_display_locked(
463455
}
464456
}
465457

458+
if (display->flags & ALLEGRO_FRAMELESS) {
459+
/* set_display_flag works by comparing to current flag value, so we need
460+
* to start with an unset state. */
461+
display->flags &= ~ALLEGRO_FRAMELESS;
462+
/* Call the vt directly to bypass system lock.
463+
*/
464+
d->overridable_vt->set_display_flag(display, ALLEGRO_FRAMELESS, true);
465+
}
466+
467+
if (display->flags & ALLEGRO_DRAG_AND_DROP) {
468+
_al_xwin_accept_drag_and_drop(display, true);
469+
}
470+
466471
if (flags & ALLEGRO_MAXIMIZED) {
467-
/* _al_xwin_maximize works by comparing to current flag value, so we need
468-
* to start with an unmaximized state. */
472+
/* set_display_flag works by comparing to current flag value, so we need
473+
* to start with an unset state. */
469474
display->flags &= ~ALLEGRO_MAXIMIZED;
470-
_al_xwin_maximize(display, true);
475+
/* Call the vt directly to bypass system lock.
476+
*/
477+
d->overridable_vt->set_display_flag(display, ALLEGRO_MAXIMIZED, true);
471478
}
472479

473480
if (!_al_xglx_config_create_context(d)) {
@@ -890,7 +897,7 @@ static bool xdpy_acknowledge_resize(ALLEGRO_DISPLAY *d)
890897
_al_ogl_setup_gl(d);
891898
}
892899

893-
_al_xwin_check_maximized(d);
900+
glx->overridable_vt->check_maximized(d);
894901
}
895902

896903
_al_mutex_unlock(&system->lock);
@@ -1081,7 +1088,7 @@ void _al_xglx_display_configure(ALLEGRO_DISPLAY *d, int x, int y,
10811088

10821089
}
10831090

1084-
_al_xwin_check_maximized(d);
1091+
glx->overridable_vt->check_maximized(d);
10851092

10861093
_al_event_source_unlock(es);
10871094
}
@@ -1329,9 +1336,7 @@ static void xdpy_apply_window_constraints(ALLEGRO_DISPLAY *display,
13291336

13301337
static void xdpy_set_fullscreen_window_default(ALLEGRO_DISPLAY *display, bool onoff)
13311338
{
1332-
ALLEGRO_SYSTEM_XGLX *system = (void *)al_get_system_driver();
13331339
if (onoff == !(display->flags & ALLEGRO_FULLSCREEN_WINDOW)) {
1334-
_al_mutex_lock(&system->lock);
13351340
_al_xwin_reset_size_hints(display);
13361341
_al_xwin_set_fullscreen_window(display, 2);
13371342
/* XXX Technically, the user may fiddle with the _NET_WM_STATE_FULLSCREEN
@@ -1342,19 +1347,11 @@ static void xdpy_set_fullscreen_window_default(ALLEGRO_DISPLAY *display, bool on
13421347
_al_xwin_set_size_hints(display, INT_MAX, INT_MAX);
13431348

13441349
set_compositor_bypass_flag(display);
1345-
_al_mutex_unlock(&system->lock);
13461350
}
13471351
}
13481352

13491353

1350-
static void xdpy_set_fullscreen_window(ALLEGRO_DISPLAY *display, bool onoff)
1351-
{
1352-
ALLEGRO_DISPLAY_XGLX *glx = (ALLEGRO_DISPLAY_XGLX *)display;
1353-
glx->overridable_vt->set_fullscreen_window(display, onoff);
1354-
}
1355-
1356-
1357-
static bool xdpy_set_display_flag(ALLEGRO_DISPLAY *display, int flag,
1354+
static bool xdpy_set_display_flag_default(ALLEGRO_DISPLAY *display, int flag,
13581355
bool flag_onoff)
13591356
{
13601357
switch (flag) {
@@ -1363,7 +1360,9 @@ static bool xdpy_set_display_flag(ALLEGRO_DISPLAY *display, int flag,
13631360
_al_xwin_set_frame(display, !flag_onoff);
13641361
return true;
13651362
case ALLEGRO_FULLSCREEN_WINDOW:
1366-
xdpy_set_fullscreen_window(display, flag_onoff);
1363+
/* Bypass system lock. */
1364+
ALLEGRO_DISPLAY_XGLX *glx = (ALLEGRO_DISPLAY_XGLX *)display;
1365+
glx->overridable_vt->set_fullscreen_window(display, flag_onoff);
13671366
return true;
13681367
case ALLEGRO_MAXIMIZED:
13691368
_al_xwin_maximize(display, flag_onoff);
@@ -1373,6 +1372,17 @@ static bool xdpy_set_display_flag(ALLEGRO_DISPLAY *display, int flag,
13731372
}
13741373

13751374

1375+
static bool xdpy_set_display_flag(ALLEGRO_DISPLAY *display, int flag, bool onoff)
1376+
{
1377+
ALLEGRO_DISPLAY_XGLX *glx = (ALLEGRO_DISPLAY_XGLX *)display;
1378+
ALLEGRO_SYSTEM_XGLX *system = (ALLEGRO_SYSTEM_XGLX *)al_get_system_driver();
1379+
_al_mutex_lock(&system->lock);
1380+
bool ret = glx->overridable_vt->set_display_flag(display, flag, onoff);
1381+
_al_mutex_unlock(&system->lock);
1382+
return ret;
1383+
}
1384+
1385+
13761386
static bool xdpy_wait_for_vsync(ALLEGRO_DISPLAY *display)
13771387
{
13781388
(void) display;
@@ -1433,7 +1443,9 @@ static const ALLEGRO_XWIN_DISPLAY_OVERRIDABLE_INTERFACE default_overridable_vt =
14331443
xdpy_set_window_title_default,
14341444
xdpy_set_fullscreen_window_default,
14351445
xdpy_set_window_position_default,
1436-
xdpy_set_window_constraints_default
1446+
xdpy_set_window_constraints_default,
1447+
xdpy_set_display_flag_default,
1448+
_al_xwin_check_maximized,
14371449
};
14381450

14391451

‎src/x/xwindow.c‎

Lines changed: 0 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -213,8 +213,6 @@ void _al_xwin_set_frame(ALLEGRO_DISPLAY *display, bool frame_on)
213213
Display *x11 = system->x11display;
214214
Atom hints;
215215

216-
_al_mutex_lock(&system->lock);
217-
218216
#if 1
219217
/* This code is taken from the GDK sources. So it works perfectly in Gnome,
220218
* no idea if it will work anywhere else. X11 documentation itself only
@@ -239,8 +237,6 @@ void _al_xwin_set_frame(ALLEGRO_DISPLAY *display, bool frame_on)
239237
display->flags |= ALLEGRO_FRAMELESS;
240238
}
241239
#endif
242-
243-
_al_mutex_unlock(&system->lock);
244240
}
245241

246242

0 commit comments

Comments
 (0)