-
Notifications
You must be signed in to change notification settings - Fork 126
/
client.c
4718 lines (4022 loc) · 158 KB
/
client.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
client.c for the Openbox window manager
Copyright (c) 2006 Mikael Magnusson
Copyright (c) 2003-2007 Dana Jansens
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
See the COPYING file for a copy of the GNU General Public License.
*/
#include "client.h"
#include "debug.h"
#include "startupnotify.h"
#include "dock.h"
#include "screen.h"
#include "moveresize.h"
#include "ping.h"
#include "place.h"
#include "frame.h"
#include "session.h"
#include "event.h"
#include "grab.h"
#include "prompt.h"
#include "focus.h"
#include "focus_cycle.h"
#include "stacking.h"
#include "openbox.h"
#include "group.h"
#include "config.h"
#include "menuframe.h"
#include "keyboard.h"
#include "mouse.h"
#include "obrender/render.h"
#include "gettext.h"
#include "obt/display.h"
#include "obt/xqueue.h"
#include "obt/prop.h"
#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif
#ifdef HAVE_SIGNAL_H
# include <signal.h> /* for kill() */
#endif
#include <glib.h>
#include <X11/Xutil.h>
/*! The event mask to grab on client windows */
#define CLIENT_EVENTMASK (PropertyChangeMask | StructureNotifyMask | \
ColormapChangeMask)
#define CLIENT_NOPROPAGATEMASK (ButtonPressMask | ButtonReleaseMask | \
ButtonMotionMask)
typedef struct
{
ObClientCallback func;
gpointer data;
} ClientCallback;
GList *client_list = NULL;
static GSList *client_destroy_notifies = NULL;
static RrImage *client_default_icon = NULL;
static void client_get_all(ObClient *self, gboolean real);
static void client_get_startup_id(ObClient *self);
static void client_get_session_ids(ObClient *self);
static void client_save_app_rule_values(ObClient *self);
static void client_get_area(ObClient *self);
static void client_get_desktop(ObClient *self);
static void client_get_state(ObClient *self);
static void client_get_shaped(ObClient *self);
static void client_get_colormap(ObClient *self);
static void client_set_desktop_recursive(ObClient *self,
guint target,
gboolean donthide,
gboolean dontraise);
static void client_change_allowed_actions(ObClient *self);
static void client_change_state(ObClient *self);
static void client_change_wm_state(ObClient *self);
static void client_apply_startup_state(ObClient *self,
gint x, gint y, gint w, gint h);
static void client_restore_session_state(ObClient *self);
static gboolean client_restore_session_stacking(ObClient *self);
static ObAppSettings *client_get_settings_state(ObClient *self);
static void client_update_transient_tree(ObClient *self,
ObGroup *oldgroup, ObGroup *newgroup,
gboolean oldgtran, gboolean newgtran,
ObClient* oldparent,
ObClient *newparent);
static void client_present(ObClient *self, gboolean here, gboolean raise,
gboolean unshade);
static GSList *client_search_all_top_parents_internal(ObClient *self,
gboolean bylayer,
ObStackingLayer layer);
static void client_call_notifies(ObClient *self, GSList *list);
static void client_ping_event(ObClient *self, gboolean dead);
static void client_prompt_kill(ObClient *self);
static gboolean client_can_steal_focus(ObClient *self,
gboolean allow_other_desktop,
gboolean request_from_user,
Time steal_time, Time launch_time);
static void client_setup_default_decor_and_functions(ObClient *self);
static void client_setup_decor_undecorated(ObClient *self);
void client_startup(gboolean reconfig)
{
client_default_icon = RrImageNewFromData(
ob_rr_icons, ob_rr_theme->def_win_icon,
ob_rr_theme->def_win_icon_w, ob_rr_theme->def_win_icon_h);
if (reconfig) return;
client_set_list();
}
void client_shutdown(gboolean reconfig)
{
RrImageUnref(client_default_icon);
client_default_icon = NULL;
if (reconfig) return;
}
static void client_call_notifies(ObClient *self, GSList *list)
{
GSList *it;
for (it = list; it; it = g_slist_next(it)) {
ClientCallback *d = it->data;
d->func(self, d->data);
}
}
void client_add_destroy_notify(ObClientCallback func, gpointer data)
{
ClientCallback *d = g_slice_new(ClientCallback);
d->func = func;
d->data = data;
client_destroy_notifies = g_slist_prepend(client_destroy_notifies, d);
}
void client_remove_destroy_notify(ObClientCallback func)
{
GSList *it;
for (it = client_destroy_notifies; it; it = g_slist_next(it)) {
ClientCallback *d = it->data;
if (d->func == func) {
g_slice_free(ClientCallback, d);
client_destroy_notifies =
g_slist_delete_link(client_destroy_notifies, it);
break;
}
}
}
void client_remove_destroy_notify_data(ObClientCallback func, gpointer data)
{
GSList *it;
for (it = client_destroy_notifies; it; it = g_slist_next(it)) {
ClientCallback *d = it->data;
if (d->func == func && d->data == data) {
g_slice_free(ClientCallback, d);
client_destroy_notifies =
g_slist_delete_link(client_destroy_notifies, it);
break;
}
}
}
void client_set_list(void)
{
Window *windows, *win_it;
GList *it;
guint size = g_list_length(client_list);
/* create an array of the window ids */
if (size > 0) {
windows = g_new(Window, size);
win_it = windows;
for (it = client_list; it; it = g_list_next(it), ++win_it)
*win_it = ((ObClient*)it->data)->window;
} else
windows = NULL;
OBT_PROP_SETA32(obt_root(ob_screen), NET_CLIENT_LIST, WINDOW,
(gulong*)windows, size);
if (windows)
g_free(windows);
stacking_set_list();
}
void client_manage(Window window, ObPrompt *prompt)
{
ObClient *self;
XSetWindowAttributes attrib_set;
gboolean try_activate = FALSE;
gboolean do_activate;
ObAppSettings *settings;
gboolean transient = FALSE;
Rect place;
Time launch_time;
guint32 user_time;
gboolean obplaced;
gulong ignore_start = FALSE;
ob_debug("Managing window: 0x%lx", window);
/* choose the events we want to receive on the CLIENT window
(ObPrompt windows can request events too) */
attrib_set.event_mask = CLIENT_EVENTMASK |
(prompt ? prompt->event_mask : 0);
attrib_set.do_not_propagate_mask = CLIENT_NOPROPAGATEMASK;
XChangeWindowAttributes(obt_display, window,
CWEventMask|CWDontPropagate, &attrib_set);
/* create the ObClient struct, and populate it from the hints on the
window */
self = g_slice_new0(ObClient);
self->obwin.type = OB_WINDOW_CLASS_CLIENT;
self->window = window;
self->prompt = prompt;
self->managed = TRUE;
/* non-zero defaults */
self->wmstate = WithdrawnState; /* make sure it gets updated first time */
self->gravity = NorthWestGravity;
self->desktop = screen_num_desktops; /* always an invalid value */
/* get all the stuff off the window */
client_get_all(self, TRUE);
ob_debug("Window type: %d", self->type);
ob_debug("Window group: 0x%x", self->group?self->group->leader:0);
ob_debug("Window name: %s class: %s role: %s title: %s",
self->name, self->class, self->role, self->title);
ob_debug("Window group name: %s group class: %s",
self->group_name, self->group_class);
/* per-app settings override stuff from client_get_all, and return the
settings for other uses too. the returned settings is a shallow copy,
that needs to be freed with g_free(). */
settings = client_get_settings_state(self);
/* the session should get the last say though */
client_restore_session_state(self);
/* the per-app settings/session may have changed the decorations for
the window, so we setup decorations for that here. this is a special
case because we want to place the window according to these decoration
changes.
we do this before setting up the frame so that it will reflect the
decorations of the window as it will be placed on screen.
*/
client_setup_decor_undecorated(self);
/* specify that if we exit, the window should not be destroyed and
should be reparented back to root automatically, unless we are managing
an internal ObPrompt window */
if (!self->prompt)
XChangeSaveSet(obt_display, window, SetModeInsert);
/* create the decoration frame for the client window */
self->frame = frame_new(self);
frame_grab_client(self->frame);
/* we've grabbed everything and set everything that we need to at mapping
time now */
grab_server(FALSE);
/* this needs to occur once we have a frame, since it sets a property on
the frame */
client_update_opacity(self);
/* don't put helper/modal windows on a different desktop if they are
related to the focused window. */
if (!screen_compare_desktops(self->desktop, screen_desktop) &&
focus_client && client_search_transient(focus_client, self) &&
(client_helper(self) || self->modal))
{
self->desktop = screen_desktop;
}
/* tell startup notification that this app started */
launch_time = sn_app_started(self->startup_id, self->class, self->name);
if (!OBT_PROP_GET32(self->window, NET_WM_USER_TIME, CARDINAL, &user_time))
user_time = event_time();
/* do this after we have a frame.. it uses the frame to help determine the
WM_STATE to apply. */
client_change_state(self);
/* add ourselves to the focus order */
focus_order_add_new(self);
/* do this to add ourselves to the stacking list in a non-intrusive way */
client_calc_layer(self);
/* focus the new window? */
if (ob_state() != OB_STATE_STARTING &&
(!self->session || self->session->focused) &&
/* this means focus=true for window is same as config_focus_new=true */
((config_focus_new || settings->focus == 1) ||
client_search_focus_tree_full(self)) &&
/* NET_WM_USER_TIME 0 when mapping means don't focus */
(user_time != 0) &&
/* this checks for focus=false for the window */
settings->focus != 0 &&
focus_valid_target(self, self->desktop,
FALSE, FALSE, TRUE, TRUE, FALSE, FALSE,
settings->focus == 1))
{
try_activate = TRUE;
}
/* remove the client's border */
XSetWindowBorderWidth(obt_display, self->window, 0);
/* adjust the frame to the client's size before showing or placing
the window */
frame_adjust_area(self->frame, FALSE, TRUE, FALSE);
frame_adjust_client_area(self->frame);
/* where the frame was placed is where the window was originally */
place = self->area;
ob_debug("Going to try activate new window? %s",
try_activate ? "yes" : "no");
if (try_activate)
do_activate = client_can_steal_focus(
self, settings->focus == 1,
(!!launch_time || settings->focus == 1),
event_time(), launch_time);
else
do_activate = FALSE;
/* figure out placement for the window if the window is new */
if (ob_state() == OB_STATE_RUNNING) {
ob_debug("Positioned: %s @ %d %d",
(!self->positioned ? "no" :
(self->positioned == PPosition ? "program specified" :
(self->positioned == USPosition ? "user specified" :
(self->positioned == (PPosition | USPosition) ?
"program + user specified" :
"BADNESS !?")))), place.x, place.y);
ob_debug("Sized: %s @ %d %d",
(!self->sized ? "no" :
(self->sized == PSize ? "program specified" :
(self->sized == USSize ? "user specified" :
(self->sized == (PSize | USSize) ?
"program + user specified" :
"BADNESS !?")))), place.width, place.height);
obplaced = place_client(self, do_activate, &place, settings);
/* watch for buggy apps that ask to be placed at (0,0) when there is
a strut there */
if (!obplaced && place.x == 0 && place.y == 0 &&
/* non-normal windows are allowed */
client_normal(self) &&
/* oldschool fullscreen windows are allowed */
!client_is_oldfullscreen(self, &place))
{
Rect *r;
r = screen_area(self->desktop, SCREEN_AREA_ALL_MONITORS, NULL);
if (r->x || r->y) {
place.x = r->x;
place.y = r->y;
ob_debug("Moving buggy app from (0,0) to (%d,%d)", r->x, r->y);
}
g_slice_free(Rect, r);
}
/* make sure the window is visible. */
client_find_onscreen(self, &place.x, &place.y,
place.width, place.height,
/* non-normal clients has less rules, and
windows that are being restored from a
session do also. we can assume you want
it back where you saved it. Clients saying
they placed themselves are subjected to
harder rules, ones that are placed by
place.c or by the user are allowed partially
off-screen and on xinerama divides (ie,
it is up to the placement routines to avoid
the xinerama divides)
children and splash screens are forced on
screen, but i don't remember why i decided to
do that.
*/
ob_state() == OB_STATE_RUNNING &&
(self->type == OB_CLIENT_TYPE_DIALOG ||
self->type == OB_CLIENT_TYPE_SPLASH ||
(!((self->positioned & USPosition) ||
settings->pos_given) &&
client_normal(self) &&
!self->session &&
/* don't move oldschool fullscreen windows to
fit inside the struts (fixes Acroread, which
makes its fullscreen window fit the screen
but it is not USSize'd or USPosition'd) */
!client_is_oldfullscreen(self, &place))));
}
/* if the window isn't user-sized, then make it fit inside
the visible screen area on its monitor. Use basically the same rules
for forcing the window on screen in the client_find_onscreen call.
do this after place_client, it chooses the monitor!
splash screens get "transient" set to TRUE by
the place_client call
*/
if (ob_state() == OB_STATE_RUNNING &&
(transient ||
(!(self->sized & USSize || self->positioned & USPosition) &&
client_normal(self) &&
!self->session &&
/* don't shrink oldschool fullscreen windows to fit inside the
struts (fixes Acroread, which makes its fullscreen window
fit the screen but it is not USSize'd or USPosition'd) */
!client_is_oldfullscreen(self, &place))))
{
Rect *a = screen_area(self->desktop, SCREEN_AREA_ONE_MONITOR, &place);
/* get the size of the frame */
place.width += self->frame->size.left + self->frame->size.right;
place.height += self->frame->size.top + self->frame->size.bottom;
/* fit the window inside the area */
place.width = MIN(place.width, a->width);
place.height = MIN(place.height, a->height);
ob_debug("setting window size to %dx%d", place.width, place.height);
/* get the size of the client back */
place.width -= self->frame->size.left + self->frame->size.right;
place.height -= self->frame->size.top + self->frame->size.bottom;
g_slice_free(Rect, a);
}
ob_debug("placing window 0x%x at %d, %d with size %d x %d. "
"some restrictions may apply",
self->window, place.x, place.y, place.width, place.height);
if (self->session)
ob_debug(" but session requested %d, %d %d x %d instead, "
"overriding",
self->session->x, self->session->y,
self->session->w, self->session->h);
/* do this after the window is placed, so the premax/prefullscreen numbers
won't be all wacko!!
this also places the window
*/
client_apply_startup_state(self, place.x, place.y,
place.width, place.height);
/* set the initial value of the desktop hint, when one wasn't requested
on map. */
OBT_PROP_SET32(self->window, NET_WM_DESKTOP, CARDINAL, self->desktop);
/* grab mouse bindings before showing the window */
mouse_grab_for_client(self, TRUE);
if (!config_focus_under_mouse)
ignore_start = event_start_ignore_all_enters();
/* this has to happen before we try focus the window, but we want it to
happen after the client's stacking has been determined or it looks bad
*/
client_show(self);
/* activate/hilight/raise the window */
if (try_activate) {
if (do_activate) {
gboolean stacked = client_restore_session_stacking(self);
client_present(self, FALSE, !stacked, TRUE);
}
else {
/* if the client isn't stealing focus, then hilite it so the user
knows it is there, but don't do this if we're restoring from a
session */
if (!client_restore_session_stacking(self))
client_hilite(self, TRUE);
}
}
else {
/* This may look rather odd. Well it's because new windows are added
to the stacking order non-intrusively. If we're not going to focus
the new window or hilite it, then we raise it to the top. This will
take affect for things that don't get focused like splash screens.
Also if you don't have focus_new enabled, then it's going to get
raised to the top. Legacy begets legacy I guess?
*/
if (!client_restore_session_stacking(self))
stacking_raise(CLIENT_AS_WINDOW(self));
}
if (!config_focus_under_mouse)
event_end_ignore_all_enters(ignore_start);
/* add to client list/map */
client_list = g_list_append(client_list, self);
window_add(&self->window, CLIENT_AS_WINDOW(self));
/* this has to happen after we're in the client_list */
if (STRUT_EXISTS(self->strut))
screen_update_areas();
/* update the list hints */
client_set_list();
/* free the ObAppSettings shallow copy */
g_slice_free(ObAppSettings, settings);
ob_debug("Managed window 0x%lx plate 0x%x (%s)",
window, self->frame->window, self->class);
}
ObClient *client_fake_manage(Window window)
{
ObClient *self;
ObAppSettings *settings;
ob_debug("Pretend-managing window: %lx", window);
/* do this minimal stuff to figure out the client's decorations */
self = g_slice_new0(ObClient);
self->window = window;
client_get_all(self, FALSE);
/* per-app settings override stuff, and return the settings for other
uses too. this returns a shallow copy that needs to be freed */
settings = client_get_settings_state(self);
/* create the decoration frame for the client window and adjust its size */
self->frame = frame_new(self);
client_apply_startup_state(self, self->area.x, self->area.y,
self->area.width, self->area.height);
ob_debug("gave extents left %d right %d top %d bottom %d",
self->frame->size.left, self->frame->size.right,
self->frame->size.top, self->frame->size.bottom);
/* free the ObAppSettings shallow copy */
g_slice_free(ObAppSettings, settings);
return self;
}
void client_unmanage_all(void)
{
while (client_list)
client_unmanage(client_list->data);
}
void client_unmanage(ObClient *self)
{
GSList *it;
gulong ignore_start;
ob_debug("Unmanaging window: 0x%x plate 0x%x (%s) (%s)",
self->window, self->frame->window,
self->class, self->title ? self->title : "");
g_assert(self != NULL);
/* we dont want events no more. do this before hiding the frame so we
don't generate more events */
XSelectInput(obt_display, self->window, NoEventMask);
/* ignore enter events from the unmap so it doesnt mess with the focus */
if (!config_focus_under_mouse)
ignore_start = event_start_ignore_all_enters();
frame_hide(self->frame);
/* flush to send the hide to the server quickly */
XFlush(obt_display);
if (!config_focus_under_mouse)
event_end_ignore_all_enters(ignore_start);
mouse_grab_for_client(self, FALSE);
self->managed = FALSE;
/* remove the window from our save set, unless we are managing an internal
ObPrompt window */
if (!self->prompt)
XChangeSaveSet(obt_display, self->window, SetModeDelete);
/* update the focus lists */
focus_order_remove(self);
if (client_focused(self)) {
/* don't leave an invalid focus_client */
focus_client = NULL;
}
/* if we're prompting to kill the client, close that */
prompt_unref(self->kill_prompt);
self->kill_prompt = NULL;
client_list = g_list_remove(client_list, self);
stacking_remove(self);
window_remove(self->window);
/* once the client is out of the list, update the struts to remove its
influence */
if (STRUT_EXISTS(self->strut))
screen_update_areas();
client_call_notifies(self, client_destroy_notifies);
/* tell our parent(s) that we're gone */
for (it = self->parents; it; it = g_slist_next(it))
((ObClient*)it->data)->transients =
g_slist_remove(((ObClient*)it->data)->transients,self);
/* tell our transients that we're gone */
for (it = self->transients; it; it = g_slist_next(it)) {
((ObClient*)it->data)->parents =
g_slist_remove(((ObClient*)it->data)->parents, self);
/* we could be keeping our children in a higher layer */
client_calc_layer(it->data);
}
/* remove from its group */
if (self->group) {
group_remove(self->group, self);
self->group = NULL;
}
/* restore the window's original geometry so it is not lost */
{
Rect a;
a = self->area;
if (self->fullscreen)
a = self->pre_fullscreen_area;
else if (self->max_horz || self->max_vert) {
if (self->max_horz) {
a.x = self->pre_max_area.x;
a.width = self->pre_max_area.width;
}
if (self->max_vert) {
a.y = self->pre_max_area.y;
a.height = self->pre_max_area.height;
}
}
self->fullscreen = self->max_horz = self->max_vert = FALSE;
/* let it be moved and resized no matter what */
self->functions = OB_CLIENT_FUNC_MOVE | OB_CLIENT_FUNC_RESIZE;
self->decorations = 0; /* unmanaged windows have no decor */
/* give the client its border back */
XSetWindowBorderWidth(obt_display, self->window, self->border_width);
client_move_resize(self, a.x, a.y, a.width, a.height);
}
/* reparent the window out of the frame, and free the frame */
frame_release_client(self->frame);
frame_free(self->frame);
self->frame = NULL;
if (ob_state() != OB_STATE_EXITING) {
/* these values should not be persisted across a window
unmapping/mapping */
OBT_PROP_ERASE(self->window, NET_WM_DESKTOP);
OBT_PROP_ERASE(self->window, NET_WM_STATE);
OBT_PROP_ERASE(self->window, WM_STATE);
} else {
/* if we're left in an unmapped state, the client wont be mapped.
this is bad, since we will no longer be managing the window on
restart */
XMapWindow(obt_display, self->window);
}
/* these should not be left on the window ever. other window managers
don't necessarily use them and it will mess them up (like compiz) */
OBT_PROP_ERASE(self->window, NET_WM_VISIBLE_NAME);
OBT_PROP_ERASE(self->window, NET_WM_VISIBLE_ICON_NAME);
/* update the list hints */
client_set_list();
ob_debug("Unmanaged window 0x%lx", self->window);
/* free all data allocated in the client struct */
RrImageUnref(self->icon_set);
g_slist_free(self->transients);
g_free(self->startup_id);
g_free(self->wm_command);
g_free(self->title);
g_free(self->icon_title);
g_free(self->original_title);
g_free(self->name);
g_free(self->class);
g_free(self->role);
g_free(self->group_name);
g_free(self->group_class);
g_free(self->client_machine);
g_free(self->sm_client_id);
g_slice_free(ObClient, self);
}
void client_fake_unmanage(ObClient *self)
{
/* this is all that got allocated to get the decorations */
frame_free(self->frame);
g_slice_free(ObClient, self);
}
static gboolean client_can_steal_focus(ObClient *self,
gboolean allow_other_desktop,
gboolean request_from_user,
Time steal_time,
Time launch_time)
{
gboolean steal;
gboolean relative_focused;
steal = TRUE;
relative_focused = (focus_client != NULL &&
(client_search_focus_tree_full(self) != NULL ||
client_search_focus_group_full(self) != NULL));
/* This is focus stealing prevention */
ob_debug("Want to focus window 0x%x at time %u "
"launched at %u (last user interaction time %u) "
"request from %s, allow other desktop: %s, "
"desktop switch time %u",
self->window, steal_time, launch_time,
event_last_user_time,
(request_from_user ? "user" : "other"),
(allow_other_desktop ? "yes" : "no"),
screen_desktop_user_time);
/*
if no launch time is provided for an application, make one up.
if the window is related to other existing windows
and one of those windows was the last used
then we will give it a launch time equal to the last user time,
which will end up giving the window focus probably.
else
the window is related to other windows, but you are not working in
them?
seems suspicious, so we will give it a launch time of
NOW - STEAL_INTERVAL,
so it will be given focus only if we didn't use something else
during the steal interval.
else
the window is all on its own, so we can't judge it. give it a launch
time equal to the last user time, so it will probably take focus.
this way running things from a terminal will give them focus, but popups
without a launch time shouldn't steal focus so easily.
*/
if (!launch_time) {
if (client_has_relative(self)) {
if (event_last_user_time && client_search_focus_group_full(self)) {
/* our relative is focused */
launch_time = event_last_user_time;
ob_debug("Unknown launch time, using %u - window in active "
"group", launch_time);
}
else if (!request_from_user) {
/* has relatives which are not being used. suspicious */
launch_time = event_time() - OB_EVENT_USER_TIME_DELAY;
ob_debug("Unknown launch time, using %u - window in inactive "
"group", launch_time);
}
else {
/* has relatives which are not being used, but the user seems
to want to go there! */
launch_time = event_last_user_time;
ob_debug("Unknown launch time, using %u - user request",
launch_time);
}
}
else {
/* the window is on its own, probably the user knows it is going
to appear */
launch_time = event_last_user_time;
ob_debug("Unknown launch time, using %u - independent window",
launch_time);
}
}
/* if it's on another desktop
and if allow_other_desktop is true, we generally let it steal focus.
but if it didn't come from the user, don't let it steal unless it was
launched before the user switched desktops.
focus, unless it was launched after we changed desktops and the request
came from the user
*/
if (!screen_compare_desktops(screen_desktop, self->desktop)) {
/* must be allowed */
if (!allow_other_desktop) {
steal = FALSE;
ob_debug("Not focusing the window because its on another desktop");
}
/* if we don't know when the desktop changed, but request is from an
application, don't let it change desktop on you */
else if (!request_from_user) {
steal = FALSE;
ob_debug("Not focusing the window because non-user request");
}
}
/* If something is focused... */
else if (focus_client) {
/* If the user is working in another window right now, then don't
steal focus */
if (!relative_focused &&
event_last_user_time &&
/* last user time must be strictly > launch_time to block focus */
(event_time_after(event_last_user_time, launch_time) &&
event_last_user_time != launch_time) &&
event_time_after(event_last_user_time,
steal_time - OB_EVENT_USER_TIME_DELAY))
{
steal = FALSE;
ob_debug("Not focusing the window because the user is "
"working in another window that is not its relative");
}
/* Don't move focus if it's not going to go to this window
anyway */
else if (client_focus_target(self) != self) {
steal = FALSE;
ob_debug("Not focusing the window because another window "
"would get the focus anyway");
}
/* For requests that don't come from the user */
else if (!request_from_user) {
/* If the new window is a transient (and its relatives aren't
focused) */
if (client_has_parent(self) && !relative_focused) {
steal = FALSE;
ob_debug("Not focusing the window because it is a "
"transient, and its relatives aren't focused");
}
/* Don't steal focus from globally active clients.
I stole this idea from KWin. It seems nice.
*/
else if (!(focus_client->can_focus || focus_client->focus_notify))
{
steal = FALSE;
ob_debug("Not focusing the window because a globally "
"active client has focus");
}
/* Don't move focus if the window is not visible on the current
desktop and none of its relatives are focused */
else if (!allow_other_desktop &&
!screen_compare_desktops(self->desktop, screen_desktop) &&
!relative_focused)
{
steal = FALSE;
ob_debug("Not focusing the window because it is on "
"another desktop and no relatives are focused ");
}
}
}
if (!steal)
ob_debug("Focus stealing prevention activated for %s at "
"time %u (last user interaction time %u)",
self->title, steal_time, event_last_user_time);
else
ob_debug("Allowing focus stealing for %s at time %u (last user "
"interaction time %u)",
self->title, steal_time, event_last_user_time);
return steal;
}
/*! Returns a new structure containing the per-app settings for this client.
The returned structure needs to be freed with g_free. */
static ObAppSettings *client_get_settings_state(ObClient *self)
{
ObAppSettings *settings;
GSList *it;
settings = config_create_app_settings();
for (it = config_per_app_settings; it; it = g_slist_next(it)) {
ObAppSettings *app = it->data;
gboolean match = TRUE;
g_assert(app->name != NULL || app->class != NULL ||
app->role != NULL || app->title != NULL ||
app->group_name != NULL || app->group_class != NULL ||
(signed)app->type >= 0);
if (app->name &&
!g_pattern_match(app->name, strlen(self->name), self->name, NULL))
match = FALSE;
else if (app->group_name &&
!g_pattern_match(app->group_name,
strlen(self->group_name), self->group_name, NULL))
match = FALSE;
else if (app->class &&
!g_pattern_match(app->class,
strlen(self->class), self->class, NULL))
match = FALSE;
else if (app->group_class &&
!g_pattern_match(app->group_class,
strlen(self->group_class), self->group_class,
NULL))
match = FALSE;
else if (app->role &&
!g_pattern_match(app->role,
strlen(self->role), self->role, NULL))
match = FALSE;
else if (app->title &&
!g_pattern_match(app->title,
strlen(self->title), self->title, NULL))
match = FALSE;
else if ((signed)app->type >= 0 && app->type != self->type) {
match = FALSE;
}
if (match) {
ob_debug("Window matching: %s", app->name);
/* copy the settings to our struct, overriding the existing
settings if they are not defaults */
config_app_settings_copy_non_defaults(app, settings);
}
}
if (settings->shade != -1)
self->shaded = !!settings->shade;
if (settings->decor != -1)
self->undecorated = !settings->decor;
if (settings->iconic != -1)
self->iconic = !!settings->iconic;
if (settings->skip_pager != -1)
self->skip_pager = !!settings->skip_pager;
if (settings->skip_taskbar != -1)
self->skip_taskbar = !!settings->skip_taskbar;
if (settings->max_vert != -1)
self->max_vert = !!settings->max_vert;
if (settings->max_horz != -1)
self->max_horz = !!settings->max_horz;
if (settings->fullscreen != -1)
self->fullscreen = !!settings->fullscreen;
if (settings->desktop) {
if (settings->desktop == DESKTOP_ALL)
self->desktop = settings->desktop;
else if (settings->desktop > 0 &&
settings->desktop <= screen_num_desktops)
self->desktop = settings->desktop - 1;
}
if (settings->layer == -1) {
self->below = TRUE;
self->above = FALSE;
}
else if (settings->layer == 0) {
self->below = FALSE;
self->above = FALSE;
}
else if (settings->layer == 1) {
self->below = FALSE;
self->above = TRUE;
}
return settings;