plomlompom.com Git - plomrogue/blob - client/window_management.py

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