jcs.org
A tiling window manager
frames: Store vscreen in rp_frame, get rid of frames_vscreen()
Initializing screens -> vscreens -> frames had a weird process
because certain calls needed to be done after prior initialization
was done. This wasn't being done in response to xrandr changes and
the frame lists in a new screen's vscreens were not being
initialized properly.
Avoid that by storing a pointer to the vscreen in rp_frame to avoid
having to look it up dynamically with frames_vscreen(), which was
failing to find the vscreen during this initialization because the
prior lists hadn't been finished getting setup.
Since frames can't move between screens or vscreens, it shouldn't be
an issue storing a pointer in rp_frame.
Should fix #19
+29
-69
+2
-3
actions.c
+2
-3
actions.c
···
4487
4487
cmdret *
4488
4488
cmd_swap(int interactive, struct cmdarg **args)
4489
4489
{
4490
-
rp_vscreen *v;
4491
4490
rp_frame *dest_frame;
4492
4491
rp_frame *src_frame;
4493
4492
···
4495
4494
src_frame = args[1] ? ARG(1, frame) : current_frame(rp_current_vscreen);
4496
4495
4497
4496
if (!rp_have_xrandr) {
4498
-
v = frames_vscreen(src_frame);
4499
-
if (vscreen_find_frame_by_frame(v, dest_frame) == NULL)
4497
+
if (vscreen_find_frame_by_frame(src_frame->vscreen,
4498
+
dest_frame) == NULL)
4500
4499
return cmdret_new(RET_FAILURE,
4501
4500
"swap: frames on different screens");
4502
4501
}
+2
data.h
+2
data.h
+5
-8
frame.c
+5
-8
frame.c
···
31
31
int
32
32
frame_left_screen_edge(rp_frame *frame)
33
33
{
34
-
rp_vscreen *v = frames_vscreen(frame);
35
-
return (frame_left(frame) <= screen_left(v->screen) +
34
+
return (frame_left(frame) <= screen_left(frame->vscreen->screen) +
36
35
defaults.padding_left);
37
36
}
38
37
···
45
44
int
46
45
frame_top_screen_edge(rp_frame *frame)
47
46
{
48
-
rp_vscreen *v = frames_vscreen(frame);
49
-
return (frame_top(frame) <= (screen_top(v->screen) +
47
+
return (frame_top(frame) <= (screen_top(frame->vscreen->screen) +
50
48
defaults.padding_top));
51
49
}
52
50
···
59
57
int
60
58
frame_right_screen_edge(rp_frame *frame)
61
59
{
62
-
rp_vscreen *v = frames_vscreen(frame);
63
-
return (frame_right(frame) >= screen_right(v->screen) -
60
+
return (frame_right(frame) >= screen_right(frame->vscreen->screen) -
64
61
defaults.padding_right);
65
62
}
66
63
···
73
70
int
74
71
frame_bottom_screen_edge(rp_frame *frame)
75
72
{
76
-
rp_vscreen *v = frames_vscreen(frame);
77
-
return (frame_bottom(frame) >= screen_bottom(v->screen) -
73
+
return (frame_bottom(frame) >= screen_bottom(frame->vscreen->screen) -
78
74
defaults.padding_bottom);
79
75
}
80
76
···
162
158
163
159
f = xmalloc(sizeof(rp_frame));
164
160
init_frame(f);
161
+
f->vscreen = v;
165
162
f->number = numset_request(v->frames_numset);
166
163
167
164
return f;
-1
screen.c
-1
screen.c
-1
sdorfehs.c
-1
sdorfehs.c
+18
-54
split.c
+18
-54
split.c
···
45
45
cleanup_frame(rp_frame *frame)
46
46
{
47
47
rp_window *win;
48
-
rp_vscreen *vscreen;
49
-
vscreen = frames_vscreen(frame);
48
+
rp_vscreen *vscreen = frame->vscreen;
50
49
51
50
win = find_window_other(vscreen);
52
51
if (win == NULL) {
···
77
76
* screen, since with Xrandr, windows can move from one screen
78
77
* to another.
79
78
*/
80
-
win->vscr = frames_vscreen(frame);
79
+
win->vscr = frame->vscreen;
81
80
} else {
82
81
frame->win_number = EMPTY;
83
82
}
···
85
84
return find_window_number(last_win);
86
85
}
87
86
88
-
rp_vscreen *
89
-
frames_vscreen(rp_frame *frame)
90
-
{
91
-
rp_frame *cur_frame;
92
-
rp_screen *cur_screen;
93
-
rp_vscreen *cur_vscreen;
94
-
95
-
list_for_each_entry(cur_screen, &rp_screens, node) {
96
-
list_for_each_entry(cur_vscreen, &cur_screen->vscreens, node) {
97
-
list_for_each_entry(cur_frame, &cur_vscreen->frames,
98
-
node) {
99
-
if (frame == cur_frame)
100
-
return cur_vscreen;
101
-
}
102
-
}
103
-
}
104
-
105
-
/*
106
-
* This SHOULD be impossible to get to. FIXME: It'll crash higher up if
107
-
* we return NULL.
108
-
*/
109
-
return NULL;
110
-
}
111
-
112
87
void
113
88
maximize_all_windows_in_frame(rp_frame *frame)
114
89
{
···
125
100
void
126
101
maximize_frame(rp_frame *frame)
127
102
{
128
-
rp_vscreen *v = frames_vscreen(frame);
103
+
rp_vscreen *v = frame->vscreen;
129
104
130
105
frame->x = screen_left(v->screen);
131
106
frame->y = screen_top(v->screen);
···
151
126
}
152
127
153
128
void
154
-
init_frame_lists(void)
155
-
{
156
-
rp_screen *cur;
157
-
rp_vscreen *vcur;
158
-
159
-
list_for_each_entry(cur, &rp_screens, node)
160
-
list_for_each_entry(vcur, &cur->vscreens, node)
161
-
init_frame_list(vcur);
162
-
}
163
-
164
-
void
165
129
init_frame_list(rp_vscreen *vscreen)
166
130
{
167
131
INIT_LIST_HEAD(&vscreen->frames);
···
219
183
{
220
184
if (frame == NULL)
221
185
return NULL;
222
-
return list_next_entry(frame, &frames_vscreen(frame)->frames, node);
186
+
return list_next_entry(frame, &frame->vscreen->frames, node);
223
187
}
224
188
225
189
rp_frame *
···
227
191
{
228
192
if (frame == NULL)
229
193
return NULL;
230
-
return list_prev_entry(frame, &frames_vscreen(frame)->frames, node);
194
+
return list_prev_entry(frame, &frame->vscreen->frames, node);
231
195
}
232
196
233
197
rp_window *
···
260
224
rp_window *
261
225
find_window_for_frame(rp_frame *frame)
262
226
{
263
-
rp_vscreen *v = frames_vscreen(frame);
227
+
rp_vscreen *v = frame->vscreen;
264
228
int last_access = 0;
265
229
rp_window_elem *most_recent = NULL;
266
230
rp_window_elem *cur;
···
294
258
rp_window *win;
295
259
rp_frame *new_frame;
296
260
297
-
v = frames_vscreen(frame);
261
+
v = frame->vscreen;
298
262
299
263
/* Make our new frame. */
300
264
new_frame = frame_new(v);
···
423
387
void (*resize2)(rp_frame *, int),
424
388
int (*resize3)(rp_frame *, rp_frame *, int))
425
389
{
426
-
rp_vscreen *v = frames_vscreen(frame);
390
+
rp_vscreen *v = frame->vscreen;
427
391
rp_frame *cur;
428
392
429
393
/*
···
534
498
{
535
499
int (*resize_fn)(rp_frame *, rp_frame *, int);
536
500
struct list_head *l;
537
-
rp_vscreen *v = frames_vscreen(frame);
501
+
rp_vscreen *v = frame->vscreen;
538
502
539
503
if (num_frames(v) < 2 || diff == 0)
540
504
return;
···
577
541
{
578
542
int (*resize_fn)(rp_frame *, rp_frame *, int);
579
543
struct list_head *l;
580
-
rp_vscreen *v = frames_vscreen(frame);
544
+
rp_vscreen *v = frame->vscreen;
581
545
582
546
if (num_frames(v) < 2 || diff == 0)
583
547
return;
···
676
640
rp_vscreen *v;
677
641
rp_frame *cur;
678
642
679
-
v = frames_vscreen(frame);
643
+
v = frame->vscreen;
680
644
681
645
list_for_each_entry(cur, &v->frames, node) {
682
646
if (cur != frame && frames_overlap(cur, frame)) {
···
697
661
if (frame == NULL)
698
662
return;
699
663
700
-
v = frames_vscreen(frame);
664
+
v = frame->vscreen;
701
665
702
666
area = total_frame_area(v);
703
667
PRINT_DEBUG(("Total Area: %d\n", area));
···
801
765
set_active_frame(rp_frame *frame, int force_indicator)
802
766
{
803
767
rp_vscreen *old_v = rp_current_vscreen;
804
-
rp_vscreen *v = frames_vscreen(frame);
768
+
rp_vscreen *v = frame->vscreen;
805
769
int old = old_v->current_frame;
806
770
rp_window *win, *old_win;
807
771
rp_frame *old_frame;
···
888
852
if (frame->win_number == EMPTY)
889
853
return;
890
854
891
-
v = frames_vscreen(frame);
855
+
v = frame->vscreen;
892
856
893
857
win = find_window_number(frame->win_number);
894
858
hide_window(win);
···
981
945
find_frame_up(rp_frame *frame)
982
946
{
983
947
rp_frame *cur, *winner = NULL;
984
-
rp_vscreen *v = frames_vscreen(frame);
948
+
rp_vscreen *v = frame->vscreen;
985
949
int wingap = 0, curgap;
986
950
987
951
list_for_each_entry(cur, &v->frames, node) {
···
1002
966
find_frame_down(rp_frame *frame)
1003
967
{
1004
968
rp_frame *cur, *winner = NULL;
1005
-
rp_vscreen *v = frames_vscreen(frame);
969
+
rp_vscreen *v = frame->vscreen;
1006
970
int wingap = 0, curgap;
1007
971
1008
972
list_for_each_entry(cur, &v->frames, node) {
···
1023
987
find_frame_left(rp_frame *frame)
1024
988
{
1025
989
rp_frame *cur, *winner = NULL;
1026
-
rp_vscreen *v = frames_vscreen(frame);
990
+
rp_vscreen *v = frame->vscreen;
1027
991
int wingap = 0, curgap;
1028
992
1029
993
list_for_each_entry(cur, &v->frames, node) {
···
1044
1008
find_frame_right(rp_frame *frame)
1045
1009
{
1046
1010
rp_frame *cur, *winner = NULL;
1047
-
rp_vscreen *v = frames_vscreen(frame);
1011
+
rp_vscreen *v = frame->vscreen;
1048
1012
int wingap = 0, curgap;
1049
1013
1050
1014
list_for_each_entry(cur, &v->frames, node) {
-1
split.h
-1
split.h
···
36
36
rp_frame *find_frame_next(rp_frame *frame);
37
37
rp_frame *find_frame_prev(rp_frame *frame);
38
38
rp_window *current_window(void);
39
-
void init_frame_lists(void);
40
39
void init_frame_list(rp_vscreen *vscreen);
41
40
void set_active_frame(rp_frame *frame, int force_indicator);
42
41
void exchange_with_frame(rp_frame *cur, rp_frame *frame);
+2
-1
vscreen.c
+2
-1
vscreen.c
···
40
40
41
41
INIT_LIST_HEAD(&v->unmapped_windows);
42
42
INIT_LIST_HEAD(&v->mapped_windows);
43
+
44
+
init_frame_list(v);
43
45
}
44
46
45
47
void
···
127
129
cur = xmalloc(sizeof(rp_vscreen));
128
130
init_vscreen(cur, scr);
129
131
list_add_tail(&cur->node, &scr->vscreens);
130
-
init_frame_list(cur);
131
132
}
132
133
}
133
134
}