home · contact · privacy
Client: Minor refactorings.
[plomrogue] / client / window_management.py
1 import curses
2 import types
3
4
5 from client.config.windows import windows_config
6
7
8 redraw_windows = False
9 sep_size = 1  # Width of inter-window borders and title bars.
10 windows = []
11 stdscr = None
12 screen_size = [0,0]
13
14
15 class Window:
16     def __init__(self, title, draw_function, size):
17         self.title = title
18         self.draw = types.MethodType(draw_function, self)
19         self.size = size
20
21
22 def set_windows():
23
24     def size_window(config):
25         size = [0, 0]
26         size[0] = config[0]
27         if (config[0] == 0):
28             size[0] = screen_size[0] - sep_size
29         elif (config[0] < 0):
30             size[0] = screen_size[0] + config[0] - sep_size
31         size[1] = config[1]
32         if (config[1] == 0):
33             size[1] = screen_size[1]
34         elif (config[1] < 0):
35             size[1] = screen_size[1] + config[1]
36         return size
37
38     def place_window(win):
39         win_i = windows.index(win)
40
41         # If win is first window, it goes into the top left corner.
42         win.start = [0 + sep_size, 0]
43         if (win_i > 0):
44
45             # If not, get win's closest predecessor starting a new stack on the
46             # screen top,fit win's top left to that win_top's top right corner.
47             win_top = None
48             for i in range(win_i - 1, -1, -1):
49                 win_top = windows[i]
50                 if (win_top.start[0] == 0 + sep_size):
51                     break
52             win.start[1] = win_top.start[1] + win_top.size[1] + sep_size
53
54             # If enough space is found below win's predecessor, fit win's top
55             # left corner to that predecessor's bottom left corner.
56             win_prev = windows[win_i - 1]
57             next_free_y = win_prev.start[0] + win_prev.size[0] + sep_size
58             if (win.size[1] <= win_prev.size[1] and
59                     win.size[0] <= screen_size[0] - next_free_y):
60                 win.start[1] = win_prev.start[1]
61                 win.start[0] = next_free_y
62
63             # If that fails, try to fit win's top left corner to the top right
64             # corner of its closest predecessor win_test 1) below win_top (see
65             # above) 2) and with enough space open to its right between its
66             # right edge and the lower edge of a win_high located directly
67             # above win_test to fit win there (without growing further to the
68             # right than win_high does or surpassing the screen's lower edge).
69             else:
70                 win_test = win_prev
71                 win_high = None
72                 while (win_test != win_top):
73                     for i in range(win_i - 2, -1, -1):
74                         win_high = windows[i]
75                         if win_test.start[0] > win_high.start[0]:
76                             break
77                     next_free_y = win_high.start[0] + win_high.size[0] \
78                         + sep_size
79                     first_free_x = win_test.start[1] + win_test.size[1] \
80                         + sep_size
81                     last_free_x = win_high.start[1] + win_high.size[1]
82                     if (win.size[0] <= screen_size[0] - next_free_y and
83                             win.size[1] <= last_free_x - first_free_x):
84                         win.start[1] = first_free_x
85                         win.start[0] = next_free_y
86                         break
87                     win_test = win_high
88
89     global screen_size, stdscr
90     curses.endwin()
91     stdscr = curses.initscr()
92     screen_size = stdscr.getmaxyx()
93     for config in windows_config:
94         size = size_window(config["config"])
95         window = Window(config["title"], config["func"], size)
96         windows.append(window)
97         place_window(window)
98     redraw_windows = True
99
100
101 def draw_screen():
102
103     def healthy_addch(y, x, char, attr=0):
104         """Workaround for <http://stackoverflow.com/questions/7063128/>."""
105         if y == screen_size[0] - 1 and x == screen_size[1] - 1:
106             char_before = stdscr.inch(y, x - 1)
107             stdscr.addch(y, x - 1, char, attr)
108             stdscr.insstr(y, x - 1, " ")
109             stdscr.addch(y, x - 1, char_before)
110         else:
111             stdscr.addch(y, x, char, attr)
112
113     def draw_window_border_lines():
114         for win in windows:
115             for k in range(2):
116                 j = win.start[int(k == 0)] - sep_size
117                 if (j >= 0 and j < screen_size[int(k == 0)]):
118                     start = win.start[k]
119                     end = win.start[k] + win.size[k]
120                     end = end if end < screen_size[k] else screen_size[k]
121                     if k:
122                         [healthy_addch(j, i, '-') for i in range(start, end)]
123                     else:
124                         [healthy_addch(i, j, '|') for i in range(start, end)]
125
126     def draw_window_border_corners():
127         for win in windows:
128             up = win.start[0] - sep_size
129             down = win.start[0] + win.size[0]
130             left = win.start[1] - sep_size
131             right = win.start[1] + win.size[1]
132             if (up >= 0 and up < screen_size[0]):
133                 if (left >= 0 and left < screen_size[1]):
134                     healthy_addch(up, left, '+')
135                 if (right >= 0 and right < screen_size[1]):
136                     healthy_addch(up, right, '+')
137             if (down >= 0 and down < screen_size[0]):
138                 if (left >= 0 and left < screen_size[1]):
139                     healthy_addch(down, left, '+')
140                 if (right >= 0 and right < screen_size[1]):
141                     healthy_addch(down, right, '+')
142
143     def draw_window_titles():
144         for win in windows:
145             title = " " + win.title + " "
146             if len(title) <= win.size[1]:
147                 y = win.start[0] - 1
148                 start_x = win.start[1] + int((win.size[1] - len(title))/2)
149                 for x in range(len(title)):
150                     healthy_addch(y, start_x + x, title[x])
151
152     def draw_window_contents():
153         def draw_winmap():
154             """Draw winmap in area delimited by offset, winmap_size.
155
156             The individuall cell of a winmap is interpreted as either a single
157             character element, or as a tuple of character and attribute,
158             depending on the size len(cell) spits out.
159             """
160             stop = [0, 0]
161             for i in range(2):
162                 stop[i] = win.size[i] + offset[i]
163                 if stop[i] >= winmap_size[i]:
164                     stop[i] = winmap_size[i]
165             for y in range(offset[0], stop[0]):
166                 for x in range(offset[1], stop[1]):
167                     cell = winmap[y * winmap_size[1] + x]
168                     attr = 0
169                     if len(cell) > 1:
170                         attr = cell[1]
171                         cell = cell[0]
172                     y_in_screen = win.start[0] + (y - offset[0])
173                     x_in_screen = win.start[1] + (x - offset[1])
174                     if (y_in_screen < screen_size[0]
175                             and x_in_screen < screen_size[1]):
176                         healthy_addch(y_in_screen, x_in_screen, cell, attr)
177         def draw_scroll_hints():
178             def draw_scroll_string(n_lines_outside):
179                 hint = ' ' + str(n_lines_outside + 1) + ' more ' + unit + ' '
180                 if len(hint) <= win.size[ni]:
181                     non_hint_space = win.size[ni] - len(hint)
182                     hint_offset = int(non_hint_space / 2)
183                     for j in range(win.size[ni] - non_hint_space):
184                         pos_2 = win.start[ni] + hint_offset + j
185                         x, y = (pos_2, pos_1) if ni else (pos_1, pos_2)
186                         healthy_addch(y, x, hint[j], curses.A_REVERSE)
187             def draw_scroll_arrows(ar1, ar2):
188                 for j in range(win.size[ni]):
189                     pos_2 = win.start[ni] + j
190                     x, y = (pos_2, pos_1) if ni else (pos_1, pos_2)
191                     healthy_addch(y, x, ar1 if ni else ar2, curses.A_REVERSE)
192             for i in range(2):
193                 ni = int(i == 0)
194                 unit = 'rows' if ni else 'columns'
195                 if (offset[i] > 0):
196                     pos_1 = win.start[i]
197                     draw_scroll_arrows('^', '<')
198                     draw_scroll_string(offset[i])
199                 if (winmap_size[i] > offset[i] + win.size[i]):
200                     pos_1 = win.start[i] + win.size[i] - 1
201                     draw_scroll_arrows('v', '>')
202                     draw_scroll_string(winmap_size[i] - offset[i]
203                         - win.size[i])
204         for win in windows:
205             offset, winmap_size, winmap = win.draw()
206             draw_winmap()
207             draw_scroll_hints()
208
209     stdscr.erase()
210     draw_window_border_lines()
211     draw_window_border_corners()
212     draw_window_titles()
213     draw_window_contents()
214     stdscr.refresh()