def render(self, size, focus=False): if len(size) < 2: cols, rows = (size[0], None) else: cols, rows = size if len(self._contents) < 1: # No contents - return empty canvas return urwid.SolidCanvas(' ', cols, rows) combinelist = [] position = self._contents.focus # Render tab bar and add it to combinelist. The tab bar is always # rendered as focused to highlight the focused tab. canvas = self._tabbar_render((cols,), True) combinelist.append((canvas, position, True)) if rows is not None: rows -= 1 # Account for title bar # Render and add content of currently selected tab current_widget = self._contents[position] if current_widget is None: canvas = urwid.SolidCanvas(' ', cols, rows) else: if rows is not None: canvas = current_widget.render((cols,rows), focus) else: canvas = current_widget.render((cols,), focus) combinelist.append((canvas, position, focus)) return urwid.CanvasCombine(combinelist)
def render(self, size, focus=False): if len(size) < 2: cols, rows = (size[0], None) else: cols, rows = size if len(self._contents) < 1: # No contents - return empty canvas return urwid.SolidCanvas(' ', cols, rows) if rows is not None: size_content = (cols, rows - self._tabbar.rows((cols, ))) else: size_content = (cols, ) combinelist = [] position = self._contents.focus # Always render tab titles as focused to highlight the focused tab canvas = self._tabbar.render((cols, ), focus=True) combinelist.append((canvas, position, True)) # Render and add content of currently selected tab current_widget = self._contents[position] if current_widget is None: canvas = urwid.SolidCanvas(' ', *size_content) else: canvas = current_widget.render(size_content, focus) combinelist.append((canvas, position, focus)) return urwid.CanvasCombine(combinelist)
def render(self, size, focus=False): (maxcol, ) = size if self._history is None: # No data; display nothing return ur.SolidCanvas('╌', maxcol, 1) if self._minimum == self._maximum: # Minimum and maximum are equal; display nothing return ur.SolidCanvas('╌', maxcol, 1) if isinstance(self._format, str): label = self._format.format(min=self._minimum, max=self._maximum) else: label = self._format(self._minimum, self._maximum) bar_len = maxcol - len(label) if bar_len < 4: # Bar is too short to be useful; just display ▸▸▸ return ur.SolidCanvas('▸', maxcol, 1) step = (self._maximum - self._minimum) / len(self.chars) bar_ranges = [ self._minimum + (i * step) for i in range(len(self.chars)) ] bar = ''.join(self.chars[min( len(self.chars) - 1, bisect_left(bar_ranges, value))] for value in reversed(self._history[:bar_len])) s = '{bar:{bar_align}{bar_len}s}{label}'.format( bar=bar, bar_align=self.bar_align, bar_len=bar_len, label=label) text, cs = ur.apply_target_encoding(s) return ur.TextCanvas([text], [cs], maxcol=maxcol)
def render(self, size, focus=False): (maxcol, ) = size if not self._total: return ur.SolidCanvas('╌', maxcol, 1) total_label = str(self._total) bar_len = maxcol - sum( len(s) for s in (self.left, self.right, total_label)) bar_len -= len(self._parts) - 1 # separators if bar_len < len(self._parts): # Bar is too short to be useful; just display ▸▸▸ return ur.SolidCanvas('▸', maxcol, 1) part_lens = [ round(bar_len * n / self._total) for part, n in self._parts ] if sum(part_lens) > bar_len: longest_ix = part_lens.index(max(part_lens)) part_lens[longest_ix] -= 1 elif sum(part_lens) < bar_len: shortest_ix = part_lens.index(min(part_lens)) part_lens[shortest_ix] += 1 assert sum(part_lens) == bar_len bar = self.sep.join( '{0:{fill}^{width}}'.format(part, fill=bar_char, width=part_len) if len(part) + 2 <= part_len else bar_char * part_len for (part, count), part_len, bar_char in zip( self._parts, part_lens, cycle(self.bar))) s = ''.join((self.left, bar, self.right, total_label)) text, cs = ur.apply_target_encoding(s) return ur.TextCanvas([text], [cs], maxcol=maxcol)
def render(self, size, focus=False): maxcol, maxrow = size sb_width = self._scrollbar_width ow_size = (max(0, maxcol - sb_width), maxrow) sb_width = maxcol - ow_size[0] ow = self._original_widget ow_base = self.scrolling_base_widget ow_rows_max = ow_base.rows_max(size, focus) if ow_rows_max <= maxrow: # Canvas fits without scrolling - no scrollbar needed self._original_widget_size = size return ow.render(size, focus) ow_rows_max = ow_base.rows_max(ow_size, focus) ow_canv = ow.render(ow_size, focus) self._original_widget_size = ow_size pos = ow_base.get_scrollpos(ow_size, focus) posmax = ow_rows_max - maxrow # Thumb shrinks/grows according to the ratio of # <number of visible lines> / <number of total lines> thumb_weight = min(1, maxrow / max(1, ow_rows_max)) thumb_height = max(1, round(thumb_weight * maxrow)) # Thumb may only touch top/bottom if the first/last row is visible top_weight = float(pos) / max(1, posmax) top_height = int((maxrow - thumb_height) * top_weight) if top_height == 0 and top_weight > 0: top_height = 1 # Bottom part is remaining space bottom_height = maxrow - thumb_height - top_height assert thumb_height + top_height + bottom_height == maxrow # Create scrollbar canvas # Creating SolidCanvases of correct height may result in "cviews do not # fill gaps in shard_tail!" or "cviews overflow gaps in shard_tail!" # exceptions. Stacking the same SolidCanvas is a workaround. # https://github.com/urwid/urwid/issues/226#issuecomment-437176837 top = urwid.SolidCanvas(self._trough_char, sb_width, 1) thumb = urwid.SolidCanvas(self._thumb_char, sb_width, 1) bottom = urwid.SolidCanvas(self._trough_char, sb_width, 1) sb_canv = urwid.CanvasCombine( [(top, None, False)] * top_height + [(thumb, None, False)] * thumb_height + [(bottom, None, False)] * bottom_height, ) combinelist = [(ow_canv, None, True, ow_size[0]), (sb_canv, None, False, sb_width)] if self._scrollbar_side != SCROLLBAR_LEFT: return urwid.CanvasJoin(combinelist) else: return urwid.CanvasJoin(reversed(combinelist))
def render(self, size, focus=False): maxcol, maxrow = size ow = self._original_widget ow_base = self.scrolling_base_widget ow_rows_max = ow_base.rows_max(size, focus) if ow_rows_max <= maxrow: # Canvas fits without scrolling - no scrollbar needed self._original_widget_size = size return ow.render(size, focus) sb_width = self._scrollbar_width self._original_widget_size = ow_size = (maxcol - sb_width, maxrow) ow_canv = ow.render(ow_size, focus) pos = ow_base.get_scrollpos(ow_size, focus) posmax = ow_rows_max - maxrow # Thumb shrinks/grows according to the ratio of # <number of visible lines> / <number of total lines> thumb_weight = min(1, maxrow / max(1, ow_rows_max)) thumb_height = max(1, round(thumb_weight * maxrow)) # Thumb may only touch top/bottom if the first/last row is visible top_weight = float(pos) / max(1, posmax) top_height = int((maxrow - thumb_height) * top_weight) if top_height == 0 and top_weight > 0: top_height = 1 # Bottom part is remaining space bottom_height = maxrow - thumb_height - top_height assert thumb_height + top_height + bottom_height == maxrow # Create scrollbar canvas top = urwid.SolidCanvas(self._trough_char, sb_width, top_height) thumb = urwid.SolidCanvas(self._thumb_char, sb_width, thumb_height) bottom = urwid.SolidCanvas(self._trough_char, sb_width, bottom_height) sb_canv = urwid.CanvasCombine([ (top, None, False), (thumb, None, False), (bottom, None, False), ]) combinelist = [(ow_canv, None, True, ow_size[0]), (sb_canv, None, False, sb_width)] if self._scrollbar_side != SCROLLBAR_LEFT: return urwid.CanvasJoin(combinelist) else: return urwid.CanvasJoin(reversed(combinelist))
def render_init(self, size): (maxcol, maxrow) = size bardata, top, hlines = self.get_data((maxcol, maxrow)) back_char = self.char[0] self.column_canvas_list = [] # create the empty bars, for the bar columns that do not have data yet for no_data in range(maxcol - len(bardata)): back_canvas = urwid.SolidCanvas(back_char, 1, maxrow) combine_list_item = [(back_canvas, None, False)] column_canvas = urwid.CanvasCombine(combine_list_item) self.column_canvas_list.append((column_canvas, None, False, 1)) # for each data point, create a single bar graph color_index = 0 data_value = 0 for single_bar_data in bardata: for pallet_index, value in enumerate(single_bar_data): color_index = pallet_index data_value = value if data_value != 0: break self.render_incremental(size, data_value, color_index)
def render(self, size, focus=False): maxcol = size[0] item_rows = None combinelist = [] for i, (w, (f, height)) in enumerate(self.contents): item_focus = self.focus_item == w canv = None if f == urwid.widget.GIVEN: canv = w.render((maxcol, height), focus=focus) elif f == urwid.widget.PACK or len(size) == 1: canv = w.render((maxcol, ), focus=focus) else: if item_rows is None: item_rows = self.get_item_rows(size, focus) rows = item_rows[i] if rows > 0: canv = w.render((maxcol, rows), focus=focus) if canv: combinelist.append((canv, i, item_focus)) if not combinelist: return urwid.SolidCanvas(" ", size[0], (size[1:] + (0, ))[0]) out = urwid.CanvasCombine(combinelist) if len(size) == 2 and size[1] != out.rows(): # flow/fixed widgets rendered too large/small out = urwid.CompositeCanvas(out) out.pad_trim_top_bottom(0, size[1] - out.rows()) return out
def render(self, size, focus=False): (maxcol, maxrow) = size rows = int((self.size * maxrow) + 0.5) comp = urwid.CompositeCanvas( urwid.SolidCanvas(self._fill, maxcol, rows)) pad = maxrow - rows toppad = int((float(pad) * self.location) + 0.5) bottompad = pad - toppad comp.pad_trim_top_bottom(toppad, bottompad) comp.fill_attr(self._attr) return comp
def render(self, size, focus=False): (maxcol, maxrow) = size cols = int((self.size * maxcol) + 0.5) comp = urwid.CompositeCanvas( urwid.SolidCanvas(self._fill, cols, maxrow)) pad = maxcol - cols leftpad = int((float(pad) * self.location) + 0.5) rightpad = pad - leftpad comp.pad_trim_left_right(leftpad, rightpad) comp.fill_attr(self._attr) return comp
def render(self, szie, focus=False): maxcol, maxrow = size ow = self._original_widget ow_base = self._scrolling_base_widget ow_rows_max = ow_base.rows_max(size, focus) if ow_rows_max <= maxrow: self._original_widget_size = size return ow.render(size, focus) sb_width = self._scrollbar_width self._original_widget_size = ow_size = (maxcol - sb_width, maxrow) ow_canv = ow.render(ow_size, focus) pos = ow_base.get_scrollpos(ow_size, focus) posmax = ow_rows_max - maxrow thumb_weight = min(1, maxrow / max(1, ow_rows_max)) thumb_height = max(1, round(thumb_weight * maxrow)) top_weight = float(pos) / max(1, posmax) top_height = int((maxrow - thumb_height) * top_weight) if top_height == 0 and top_weight > 0: top_height = 1 bottom_height = maxrow - thumb_height - top_height assert thumb_height + top_height + bottom_height == maxrow top = urwid.SolidCanvas(self._trough_char, sb_width, top_height) thumb = urwid.SolidCanvas(self._thumb_char, sb_width, thumb_height) bottom = urwid.SolidCanvas(self._trough_char, sb_width, bottom_height) sb_canv = urwid.CanvasCombine([ (top, None, False), (thumb, None, False), (bottom, None, False), ]) combinelist = [(ow_canv, None, True, ow_size[0]), (sb_canv, None, False, sb_widt)] if self._scrollbar_side != SCROLLBAR_LEFT: return urwid.CanvasJoin(combinelist) else: return urwid.CanvasJoin(reversed(combinelist))
def render(self, size, focus=False): return urwid.SolidCanvas(' ', size[0], self.rows(size, focus))
def render(self, size, focus=False): return urwid.SolidCanvas(" ", *size, 0)
def render(self, size, focus=False): clamp = lambda _min, _max, v: min(_max, max(_min, v)) (maxcol, ) = size if self._recent is None: # No data; display nothing return ur.SolidCanvas('╌', maxcol, 1) min_label = '{label:>{width}}'.format(label=self._format( self._minimum), width=self.label_width) max_label = '{label:<{width}}'.format(label=self._format( self._maximum), width=self.label_width) bar_range = self._maximum - self._minimum if not bar_range: # Minimum and maximum are equal; display nothing return ur.SolidCanvas('╌', maxcol, 1) while True: bar_len = maxcol - sum( len(s) for s in (min_label, self.left, self.right, max_label)) bar_len //= len(self.back) if bar_len > 4: break else: # Bar is too short to be useful; if the minimum and maximum are # trivial attempt to eliminate their labels and if this isn't # enough just display >>>> if self._minimum == 0: if min_label != '': min_label = '' continue elif self._maximum in (1, 100) and max_label != '': max_label = '' continue return ur.SolidCanvas('▸', maxcol, 1) pre_len = clamp( 0, bar_len, round(bar_len * ((min(self._recent, self._history) - self._minimum) / bar_range))) post_len = clamp( 0, bar_len, round(bar_len * ((self._maximum - max(self._recent, self._history)) / bar_range))) trend_len = bar_len - (pre_len + post_len) while trend_len < 0: # Can happen by rounding; knock 1 off the first largest value. trend_len += 1 if pre_len >= post_len: pre_len -= 1 else: post_len -= 1 s = ''.join(( self.fore * pre_len, (self.falling if self._recent < self._history else self.rising if self._recent > self._history else self.fore) * trend_len, self.back * post_len, )) if self.show_current: latest_pos = clamp( 0, bar_len - 1, round(bar_len * ((self._latest - self._minimum) / bar_range))) s = s[:latest_pos] + self.current + s[latest_pos + 1:] s = ''.join((min_label, self.left, s, self.right, max_label)) text, cs = ur.apply_target_encoding(s) return ur.TextCanvas([text], [cs], maxcol=maxcol)
def render(self, size, focus=False): """Render listbox and return canvas. """ (maxcol, maxrow) = size middle, top, bottom = self.calculate_visible((maxcol, maxrow), focus=focus) if middle is None: return urwid.SolidCanvas(" ", maxcol, maxrow) _ignore, focus_widget, focus_pos, focus_rows, cursor = middle trim_top, fill_above = top trim_bottom, fill_below = bottom if bottom[1]: self._bottom_pos = bottom[1][-1][1] else: self._bottom_pos = None if top[1]: self._top_pos = top[1][-1][1] else: self._top_pos = None self._focus_pos = focus_pos combinelist = [] rows = 0 fill_above.reverse() # fill_above is in bottom-up order for widget, w_pos, w_rows in fill_above: canvas = widget.render((maxcol, )) attr = self.get_row_attr(w_pos) if attr: canvas = urwid.CompositeCanvas(canvas) canvas.fill_attr(attr) if w_rows != canvas.rows(): raise urwid.ListBoxError, BADROWSMSG % ( ` widget `, ` w_pos `, w_rows, canvas.rows()) rows += w_rows combinelist.append((canvas, w_pos, False)) focus_canvas = focus_widget.render((maxcol, ), focus=focus) focus_attr = None if focus_pos in self.row_attrs: focus_attr = self.get_row_attr(focus_pos) if focus and self.focus_str: focus_attr += self.focus_str elif focus: focus_attr = self.focus_attr if focus_attr: focus_canvas = urwid.CompositeCanvas(focus_canvas) focus_canvas.fill_attr(focus_attr) if focus_canvas.rows() != focus_rows: raise ListBoxError, BADFOCUSROWSMSG % ( ` focus_widget `, ` focus_pos `, focus_rows, focus_canvas.rows()) c_cursor = focus_canvas.cursor if cursor != c_cursor: raise urwid.ListBoxError, BADCURSORMSG % ( ` focus_widget `, ` focus_pos `, ` cursor `, ` c_cursor `) rows += focus_rows combinelist.append((focus_canvas, focus_pos, True)) for widget, w_pos, w_rows in fill_below: canvas = widget.render((maxcol, )) attr = self.get_row_attr(w_pos) if attr: canvas = urwid.CompositeCanvas(canvas) canvas.fill_attr(attr) if w_rows != canvas.rows(): raise urwid.ListBoxError, BADROWSMSG % ( ` widget `, ` w_pos `, w_rows, canvas.rows()) rows += w_rows combinelist.append((canvas, w_pos, False)) final_canvas = urwid.CanvasCombine(combinelist) if trim_top: final_canvas.trim(trim_top) rows -= trim_top if trim_bottom: final_canvas.trim_end(trim_bottom) rows -= trim_bottom assert rows <= maxrow if rows < maxrow: bottom_pos = focus_pos if fill_below: bottom_pos = fill_below[-1][1] assert trim_bottom == 0 and self.body.get_next(bottom_pos) == ( None, None) final_canvas.pad_trim_top_bottom(0, maxrow - rows) return final_canvas