From dbcade013706cca271810ce5344f5e30ee362256 Mon Sep 17 00:00:00 2001 From: Aleksey Lim Date: Sun, 31 Jan 2010 14:19:21 +0000 Subject: Fix new views using in ObjectChooser --- diff --git a/src/jarabe/journal/Makefile.am b/src/jarabe/journal/Makefile.am index d653725..2a75284 100644 --- a/src/jarabe/journal/Makefile.am +++ b/src/jarabe/journal/Makefile.am @@ -5,6 +5,7 @@ sugar_PYTHON = \ detailview.py \ entry.py \ expandedentry.py \ + fields.py \ homogenetable.py \ homogeneview.py \ journalactivity.py \ @@ -19,5 +20,4 @@ sugar_PYTHON = \ preview.py \ thumbsview.py \ view.py \ - volumestoolbar.py \ - widgets.py + volumestoolbar.py diff --git a/src/jarabe/journal/expandedentry.py b/src/jarabe/journal/expandedentry.py index cd8322b..1a69f84 100644 --- a/src/jarabe/journal/expandedentry.py +++ b/src/jarabe/journal/expandedentry.py @@ -32,7 +32,7 @@ from sugar.graphics.entry import CanvasEntry from sugar.graphics.canvastextview import CanvasTextView from sugar.util import format_size -from jarabe.journal.widgets import KeepIcon +from jarabe.journal.fields import KeepIcon from jarabe.journal.palettes import ObjectPalette, BuddyPalette from jarabe.journal import misc from jarabe.journal import model diff --git a/src/jarabe/journal/widgets.py b/src/jarabe/journal/fields.py index dc1dc32..a65a75d 100644 --- a/src/jarabe/journal/widgets.py +++ b/src/jarabe/journal/fields.py @@ -141,7 +141,7 @@ class KeepIcon(_Button): else: keep = 0 - self.metadata['keep'] = keep + self.metadata['keep'] = str(keep) model.write(self.metadata, update_mtime=False) self._set_keep(keep) @@ -168,10 +168,10 @@ class _JournalObject(gtk.EventBox): self._invoker = WidgetInvoker(self) self._invoker._position_hint = Invoker.AT_CURSOR + self.props.visible_window = False + self.modify_fg(gtk.STATE_NORMAL, style.COLOR_PANEL_GREY.get_gdk_color()) - self.modify_bg(gtk.STATE_NORMAL, - style.COLOR_WHITE.get_gdk_color()) self.connect_after('button-release-event', self.__button_release_event_cb) @@ -204,9 +204,9 @@ class _JournalObject(gtk.EventBox): self._invoker.detach() def __expose_event_cb(self, widget, event): - __, __, width, height = self.allocation + x, y, width, height = self.allocation fg = self.style.fg_gc[gtk.STATE_NORMAL] - self.window.draw_rectangle(fg, False, 0, 0, width - 1, height - 1) + self.window.draw_rectangle(fg, False, x, y, width - 1, height - 1) def __drag_begin_cb(self, widget, context): self._drag = True diff --git a/src/jarabe/journal/homogenetable.py b/src/jarabe/journal/homogenetable.py index e92b717..d6b8a14 100644 --- a/src/jarabe/journal/homogenetable.py +++ b/src/jarabe/journal/homogenetable.py @@ -24,7 +24,7 @@ import logging _SPARE_ROWS_COUNT = 2 -class VHomogeneTable(gtk.Container): +class HomogeneTable(gtk.Container): """ Grid widget with homogeneously placed children of the same class. @@ -33,8 +33,8 @@ class VHomogeneTable(gtk.Container): cells and virtual (widget is model less itself and only ask callback object about right cell's value) ones - just cells. User can scroll up/down grid to see all virtual cells and the same frame cell could represent - content of various virtual cells (widget will call cell_fill_in_cb callback - to refill frame cell content) in different time moments. + content of various virtual cells (widget will call do_fill_cell_in to + refill frame cell content) in different time moments. By default widget doesn't have any cells, to make it useful, assign proper value to either frame_size or cell_size property. Also set cell_count to @@ -44,28 +44,26 @@ class VHomogeneTable(gtk.Container): __gsignals__ = { 'set-scroll-adjustments': (gobject.SIGNAL_RUN_FIRST, None, [gtk.Adjustment, gtk.Adjustment]), - 'cursor-changed': (gobject.SIGNAL_RUN_FIRST, None, [object]), + 'cursor-changed': (gobject.SIGNAL_RUN_FIRST, None, []), 'frame-scrolled': (gobject.SIGNAL_RUN_FIRST, None, []), } - def __init__(self, cell_class, **kwargs): - assert(hasattr(cell_class, 'do_fill_in')) - - self._cell_class = cell_class + def __init__(self, **kwargs): self._row_cache = [] self._cell_cache = [] self._cell_cache_pos = 0 - self._adjustment = None - self._adjustment_value_changed_id = None + self._adjustments = [] self._bin_window = None self._cell_count = 0 - self._cell_height = 0 + self._cell_length = 0 self._frame_size = [None, None] self._cell_size = [None, None] - self._selected_index = None - self._editable = True + self._cursor_index = None self._pending_allocate = None self._frame_range = None + self._orientation = gtk.ORIENTATION_VERTICAL + self._hover_selection = False + self._cursor_visible = True gtk.Container.__init__(self, **kwargs) @@ -127,6 +125,41 @@ class VHomogeneTable(gtk.Container): by frame_size/cell_size values.""" cell_count = gobject.property(getter=get_cell_count, setter=set_cell_count) + def get_orientation(self): + return self._orientation + + def set_orientation(self, value): + if self._orientation == value: + return + + self._orientation = value + for adjustment, __ in self._adjustments: + adjustment.lower = 0 + adjustment.upper = 0 + self._resize_table() + + orientation = gobject.property(getter=get_orientation, + setter=set_orientation) + + def get_hover_selection(self): + return self._hover_selection + + def set_hover_selection(self, value): + if value == self.hover_selection: + return + if value: + self.add_events(gtk.gdk.POINTER_MOTION_HINT_MASK | \ + gtk.gdk.POINTER_MOTION_MASK) + self._hover_selection = value + + def do_motion_notify_event(self, event): + if not self.hover_selection: + return + self.cursor = self.get_cell_at_pos(*self.get_pointer()) + + hover_selection = gobject.property( + getter=get_hover_selection, setter=set_hover_selection) + def get_cell(self, cell_index): """Get cell widget by index Method returns non-None values only for visible cells.""" @@ -136,11 +169,8 @@ class VHomogeneTable(gtk.Container): else: return cell.widget - def __getitem__(self, cell_index): - return self.get_cell(cell_index) - def get_cursor(self): - return self._selected_index + return self._cursor_index def set_cursor(self, cell_index): cell_index = min(max(0, cell_index), self.cell_count - 1) @@ -152,6 +182,20 @@ class VHomogeneTable(gtk.Container): """Selected cell""" cursor = gobject.property(getter=get_cursor, setter=set_cursor) + def get_cursor_visible(self): + return self._cursor_visible + + def set_cursor_visible(self, value): + if value == self.cursor_visible: + return + cell = self._get_cell(self.cursor) + if cell is not None: + self.do_highlight_cell(cell.widget, value) + self._cursor_visible = value + + cursor_visible = gobject.property( + getter=get_cursor_visible, setter=set_cursor_visible) + def get_frame_range(self): if self._frame_range is None: return xrange(0) @@ -167,20 +211,10 @@ class VHomogeneTable(gtk.Container): for cell in self._cell_cache: yield cell.widget - def get_editable(self): - return self._editable - - def set_editable(self, value): - self._editable = value - - """Can cells be focused""" - editable = gobject.property(getter=get_editable, setter=set_editable) - - def get_editing(self): - if not self._editable or self._selected_index is None or \ - self.props.has_focus: + def get_focus_cell(self): + if self.cursor is None or self.props.has_focus: return False - cell = self._get_cell(self._selected_index) + cell = self._get_cell(self.cursor) if cell is None: return False else: @@ -195,60 +229,85 @@ class VHomogeneTable(gtk.Container): focus = focus.parent return False - def set_editing(self, value): - if value == self.editing: + def set_focus_cell(self, value): + if value == self.focus_cell: return if value: if not self.props.has_focus: self.grab_focus() - cell = self._get_cell(self._selected_index) + cell = self._get_cell(self.cursor) if cell is not None: cell.widget.child_focus(gtk.DIR_TAB_FORWARD) else: self.grab_focus() """Selected cell got focused""" - editing = gobject.property(getter=get_editing, setter=set_editing) + focus_cell = gobject.property(getter=get_focus_cell, setter=set_focus_cell) def get_cell_at_pos(self, x, y): - """Get cell index at pos which is relative to VHomogeneTable widget""" + """Get cell index at pos which is relative to HomogeneTable widget""" if self._empty: return None - x, y = self.get_pointer() - x = min(max(0, x), self.allocation.width) - y = min(max(0, y), self.allocation.height) + self._pos_y + x = min(max(0, x), self.allocation.width - 1) + y = min(max(0, y), self.allocation.height - 1) + + x, y = self._rotate(x, y) + y += self._pos return self._get_cell_at_pos(x, y) def scroll_to_cell(self, cell_index): - """Scroll VHomogeneTable to position where cell is viewable""" + """Scroll HomogeneTable to position where cell is viewable""" if self._empty: return - self.editing = False + self.focus_cell = False row = cell_index / self._column_count - pos = row * self._cell_height + pos = row * self._cell_length - if pos < self._pos_y: - self._pos_y = pos - elif pos + self._cell_height >= self._pos_y + self._page: - self._pos_y = pos + self._cell_height - self._page + if pos < self._pos: + self._pos = pos + elif pos + self._cell_length >= self._pos + self._page: + self._pos = pos + self._cell_length - self._page else: return self._pos_changed() def refill(self, cells=None): - """Force VHomogeneTable widget to run filling method for all cells""" + """Force HomogeneTable widget to run filling method for all cells""" for cell in self._cell_cache: if cells is None or cell.index in cells: cell.index = -1 self._allocate_rows(force=False) + def do_cell_new(self): + raise Exception('do_cell_new() should be implemented in subclass') + + def do_fill_cell_in(self, cell, cell_index): + cell.do_fill_in(self, cell_index) + + def do_highlight_cell(self, cell, selected): + pass + # gtk.Widget overrides + def do_scroll_event(self, event): + if self._adjustment is not None and \ + self.orientation == gtk.ORIENTATION_HORIZONTAL: + adj = self._adjustment + if event.direction == gtk.gdk.SCROLL_UP: + value = max(0, adj.value - self._cell_length) + elif event.direction == gtk.gdk.SCROLL_DOWN: + value = min(self._max_pos, adj.value + self._cell_length) + else: + return False + adj.value = value + return True + return False + def do_realize(self): self.set_flags(gtk.REALIZED) @@ -267,10 +326,10 @@ class VHomogeneTable(gtk.Container): self._bin_window = gtk.gdk.Window( self.window, window_type=gtk.gdk.WINDOW_CHILD, - x=0, - y=-self._pos_y, - width=self.allocation.width, - height=self._max_y, + x=self._rotate(0, -self._pos)[0], + y=self._rotate(-self._pos, 0)[0], + width=self._rotate(self._thickness, self._length)[0], + height=self._rotate(self._length, self._thickness)[0], colormap=self.get_colormap(), wclass=gtk.gdk.INPUT_OUTPUT, event_mask=(self.get_events() | gtk.gdk.EXPOSURE_MASK | @@ -291,7 +350,7 @@ class VHomogeneTable(gtk.Container): #self.queue_resize() def do_size_allocate(self, allocation): - resize_tabel = self.allocation != allocation + resize_tabel = tuple(self.allocation) != tuple(allocation) self.allocation = allocation if resize_tabel: @@ -322,7 +381,8 @@ class VHomogeneTable(gtk.Container): for row in self._row_cache: for cell in row: - cell.widget.map() + if cell.widget.props.visible: + cell.widget.map() self._bin_window.show() self.window.show() @@ -336,18 +396,21 @@ class VHomogeneTable(gtk.Container): cell.widget.size_request() def do_set_scroll_adjustments(self, hadjustment, vadjustment): - if vadjustment is None or vadjustment == self._adjustment: + for adjustment, handler in self._adjustments: + adjustment.disconnect(handler) + + if vadjustment is None or hadjustment is None: + self._adjustments = [] return - if self._adjustment is not None: - self._adjustment.disconnect(self._adjustment_value_changed_id) + self._adjustments = ( + [vadjustment, vadjustment.connect('value-changed', + self.__adjustment_value_changed_cb)], + [hadjustment, hadjustment.connect('value-changed', + self.__adjustment_value_changed_cb)]) - self._adjustment = vadjustment self._setup_adjustment(dry_run=True) - self._adjustment_value_changed_id = vadjustment.connect( - 'value-changed', self.__adjustment_value_changed_cb) - # gtk.Container overrides def do_forall(self, include_internals, callback, data): @@ -366,15 +429,15 @@ class VHomogeneTable(gtk.Container): def do_set_focus_child(self, widget): if widget is not None: x, y, __, __ = widget.allocation - cursor = self._get_cell_at_pos(x, y) + cursor = self._get_cell_at_pos(*self._rotate(x, y)) if self.cursor is None or cursor not in self.frame_range: self.cursor = cursor def do_focus(self, type): - if self.editing: - cell = self._get_cell(self._selected_index) + if self.focus_cell: + cell = self._get_cell(self.cursor) if cell is None: - logging.error('cannot find _selected_index cell') + logging.error('cannot find cursor cell') elif not cell.widget.child_focus(type): self.grab_focus() return True @@ -382,7 +445,7 @@ class VHomogeneTable(gtk.Container): if self.props.has_focus: return False else: - if self._selected_index is None: + if self.cursor is None: x, y = self.get_pointer() self._set_cursor(self.get_cell_at_pos(x, y)) self.grab_focus() @@ -393,6 +456,13 @@ class VHomogeneTable(gtk.Container): return not self._row_cache @property + def _adjustment(self): + if not self._adjustments: + return None + else: + return self._rotate(*[i[0] for i in self._adjustments])[0] + + @property def _column_count(self): if self._row_cache: return len(self._row_cache[0]) @@ -413,34 +483,48 @@ class VHomogeneTable(gtk.Container): @property def _page(self): - return self._frame_row_count * self._cell_height + return self._frame_row_count * self._cell_length @property - def _pos_y(self): + def _pos(self): if self._adjustment is None or math.isnan(self._adjustment.value): return 0 else: return max(0, int(self._adjustment.value)) - @_pos_y.setter - def _pos_y(self, value): + @_pos.setter + def _pos(self, value): if self._adjustment is not None: self._adjustment.value = value @property - def _max_pos_y(self): + def _max_pos(self): if self._adjustment is None: return 0 else: - return max(0, self._max_y - self._page) + return max(0, self._length - self._page) + + @property + def _thickness(self): + return self._rotate(self.allocation.width, self.allocation.height)[0] @property - def _max_y(self): + def _frame_length(self): + return self._rotate(self.allocation.height, self.allocation.width)[0] + + @property + def _length(self): if self._adjustment is None: - return self.allocation.height + return self._frame_length else: return int(self._adjustment.upper) + def _rotate(self, x, y): + if self._orientation == gtk.ORIENTATION_VERTICAL: + return (x, y) + else: + return (y, x) + def _get_cell(self, cell_index): if cell_index is None: return None @@ -451,15 +535,28 @@ class VHomogeneTable(gtk.Container): return row[column] return None + def _get_row_pos(self, row): + allocation = row[0].widget.allocation + return self._rotate(allocation.y, allocation.x)[0] + def _set_cursor(self, cell_index): - old_cursor = self._selected_index - self._selected_index = cell_index - if old_cursor != self._selected_index: - self.emit('cursor-changed', old_cursor) + if self.cursor_visible: + cell = self._get_cell(self.cursor) + if cell is not None: + self.do_highlight_cell(cell.widget, False) + + self._cursor_index = cell_index + + if self.cursor_visible: + cell = self._get_cell(self.cursor) + if cell is not None: + self.do_highlight_cell(cell.widget, True) + + self.emit('cursor-changed') def _get_cell_at_pos(self, x, y): - cell_row = y / self._cell_height - cell_column = x / (self.allocation.width / self._column_count) + cell_row = y / self._cell_length + cell_column = x / (self._thickness / self._column_count) cell_index = cell_row * self._column_count + cell_column return min(cell_index, self.cell_count - 1) @@ -480,7 +577,8 @@ class VHomogeneTable(gtk.Container): self._cell_cache_pos += 1 else: cell = _Cell() - cell.widget = self._cell_class() + cell.widget = self.do_cell_new() + assert(cell.widget is not None) self._cell_cache.append(cell) self._cell_cache_pos = len(self._cell_cache) @@ -488,8 +586,8 @@ class VHomogeneTable(gtk.Container): return cell def _resize_table(self): - x, y, width, height = self.allocation - if x < 0 or y < 0: + x, y, w, h = self.allocation + if x + w == 0 or y + h == 0: return frame_row_count, column_count = self._frame_size @@ -498,11 +596,11 @@ class VHomogeneTable(gtk.Container): if frame_row_count is None: if cell_height is None: return - frame_row_count = max(1, height / cell_height) + frame_row_count = max(1, self._frame_length / cell_height) if column_count is None: if cell_width is None: return - column_count = max(1, width / cell_width) + column_count = max(1, self._thickness / cell_width) if (column_count != self._column_count or \ frame_row_count != self._frame_row_count): @@ -522,11 +620,12 @@ class VHomogeneTable(gtk.Container): cell.invalidate_pos() cell.index = -1 - self._cell_height = height / self._frame_row_count + self._cell_length = self._frame_length / self._frame_row_count self._setup_adjustment(dry_run=True) if self.flags() & gtk.REALIZED: - self._bin_window.resize(self.allocation.width, self._max_y) + self._bin_window.resize( + *self._rotate(self._thickness, self._length)) self._allocate_rows(force=True) @@ -535,36 +634,43 @@ class VHomogeneTable(gtk.Container): return self._adjustment.lower = 0 - self._adjustment.upper = self._row_count * self._cell_height + self._adjustment.upper = self._row_count * self._cell_length self._adjustment.page_size = self._page self._adjustment.changed() - if self._pos_y > self._max_pos_y: - self._pos_y = self._max_pos_y + if self._pos > self._max_pos: + self._pos = self._max_pos if not dry_run: self._adjustment.value_changed() def _allocate_cells(self, row, cell_y): cell_x = 0 - cell_row = cell_y / self._cell_height + cell_row = cell_y / self._cell_length cell_index = cell_row * self._column_count for cell_column, cell in enumerate(row): if cell.index != cell_index: if cell_index < self.cell_count: - cell.widget.do_fill_in(self, cell_index) + self.do_fill_cell_in(cell.widget, cell_index) + if self.cursor_visible: + self.do_highlight_cell(cell.widget, + cell_index == self.cursor) cell.widget.show() else: cell.widget.hide() cell.index = cell_index - cell_alloc = gtk.gdk.Rectangle(cell_x, cell_y) - cell_alloc.width = self.allocation.width / self._column_count - cell_alloc.height = self._cell_height + cell_thickness = self._thickness / self._column_count + + alloc = gtk.gdk.Rectangle() + alloc.x, alloc.y = self._rotate(cell_x, cell_y) + alloc.width, alloc.height = \ + self._rotate(cell_thickness, self._cell_length) + cell.widget.size_request() - cell.widget.size_allocate(cell_alloc) + cell.widget.size_allocate(alloc) - cell_x += cell_alloc.width + cell_x += cell_thickness cell_index += 1 def _allocate_rows(self, force): @@ -575,8 +681,8 @@ class VHomogeneTable(gtk.Container): self._pending_allocate = self._pending_allocate or force return - pos = self._pos_y - if pos < 0 or pos > self._max_pos_y: + pos = self._pos + if pos < 0 or pos > self._max_pos: return spare_rows = [] @@ -588,38 +694,39 @@ class VHomogeneTable(gtk.Container): spare_rows = [] + self._row_cache else: for row in self._row_cache: - row_y = row[0].widget.allocation.y - if row_y < 0 or row_y > page_end or \ - (row_y + self._cell_height) < pos: + row_pos = self._get_row_pos(row) + if row_pos < 0 or row_pos > page_end or \ + (row_pos + self._cell_length) < pos: spare_rows.append(row) else: - bisect.insort_right(visible_rows, _IndexedRow(row)) + bisect.insort_right(visible_rows, + _IndexedRow(row, row_pos)) if visible_rows or spare_rows: - def try_insert_spare_row(cell_y, end_y): - while cell_y < end_y: + def try_insert_spare_row(pos_begin, pos_end): + while pos_begin < pos_end: if not spare_rows: logging.error('spare_rows should not be empty') return row = spare_rows.pop() - self._allocate_cells(row, cell_y) - cell_y = cell_y + self._cell_height + self._allocate_cells(row, pos_begin) + pos_begin = pos_begin + self._cell_length frame_rows.append(row) # visible_rows could not be continuous # lets try to add spare rows to missed points - cell_y = int(pos) - int(pos) % self._cell_height + next_row_pos = int(pos) - int(pos) % self._cell_length for i in visible_rows: - cell = i.row[0].widget.allocation - try_insert_spare_row(cell_y, cell.y) - self._allocate_cells(i.row, cell.y) - cell_y = cell.y + cell.height + row_pos = self._get_row_pos(i.row) + try_insert_spare_row(next_row_pos, row_pos) + self._allocate_cells(i.row, row_pos) + next_row_pos = row_pos + self._cell_length frame_rows.append(i.row) - try_insert_spare_row(cell_y, page_end) + try_insert_spare_row(next_row_pos, page_end) - self._bin_window.move(0, int(-pos)) + self._bin_window.move(*self._rotate(0, int(-pos))) self._bin_window.process_updates(True) if frame_rows: @@ -630,11 +737,12 @@ class VHomogeneTable(gtk.Container): self._frame_range = frame_range self.emit('frame-scrolled') - if self.editing and self._selected_index not in self.frame_range: - self.editing = False + if self.focus_cell and self.cursor not in self.frame_range: + self.focus_cell = False def __adjustment_value_changed_cb(self, adjustment): self._allocate_rows(force=False) + self.cursor = self.get_cell_at_pos(*self.get_pointer()) def __key_press_event_cb(self, widget, event): if self._empty or self.cursor is None: @@ -642,18 +750,21 @@ class VHomogeneTable(gtk.Container): page = self._column_count * self._frame_row_count - if event.keyval == gtk.keysyms.Escape and self.editing: - self.editing = False - elif event.keyval == gtk.keysyms.Return and self.editable: - self.editing = not self.editing - elif event.keyval == gtk.keysyms.Left: + prev_cell, prev_row = self._rotate(gtk.keysyms.Left, gtk.keysyms.Up) + next_cell, next_row = self._rotate(gtk.keysyms.Right, gtk.keysyms.Down) + + if event.keyval == gtk.keysyms.Escape and self.focus_cell: + self.focus_cell = False + elif event.keyval == gtk.keysyms.Return: + self.focus_cell = not self.focus_cell + elif event.keyval == prev_cell: self.cursor -= 1 - elif event.keyval == gtk.keysyms.Right: + elif event.keyval == next_cell: self.cursor += 1 - elif event.keyval == gtk.keysyms.Up: + elif event.keyval == prev_row: if self.cursor >= self._column_count: self.cursor -= self._column_count - elif event.keyval == gtk.keysyms.Down: + elif event.keyval == next_row: if self.cursor / self._column_count < \ (self.cell_count - 1) / self._column_count: self.cursor += self._column_count @@ -673,12 +784,12 @@ class VHomogeneTable(gtk.Container): class _IndexedRow: - def __init__(self, row): + def __init__(self, row, row_pos): self.row = row + self.row_pos = row_pos def __lt__(self, other): - return self.row[0].widget.allocation.y < \ - other.row[0].widget.allocation.y + return self.row_pos < other.row_pos class _Cell: @@ -693,4 +804,4 @@ class _Cell: self.widget.allocation >= 0 and self.widget.allocation >= 0 -VHomogeneTable.set_set_scroll_adjustments_signal('set-scroll-adjustments') +HomogeneTable.set_set_scroll_adjustments_signal('set-scroll-adjustments') diff --git a/src/jarabe/journal/homogeneview.py b/src/jarabe/journal/homogeneview.py index 2a79d3d..c0a5f5c 100644 --- a/src/jarabe/journal/homogeneview.py +++ b/src/jarabe/journal/homogeneview.py @@ -20,35 +20,41 @@ import logging from sugar.graphics import style -from jarabe.journal.homogenetable import VHomogeneTable +from jarabe.journal.homogenetable import HomogeneTable class Cell(gtk.EventBox): def __init__(self): gtk.EventBox.__init__(self) - self.select(False) + self._fields = [] + self.fill_background(False) - def do_fill_in_cell_content(self, table, offset, metadata): - # needs to be overriden + def add_field(self, field): + self._fields.append(field) + + def fill_in(self, offset, metadata): + # stub pass def do_fill_in(self, table, cell_index): metadata = table.get_metadata(cell_index) - self.do_fill_in_cell_content(table, cell_index, metadata) - if table.hover_selection: - self.select(table.cursor == cell_index) + for i in self._fields: + i.fill_in(metadata) + self.fill_in(cell_index, metadata) - def select(self, selected): + def fill_background(self, selected): if selected: - self.modify_bg(gtk.STATE_NORMAL, - style.COLOR_SELECTION_GREY.get_gdk_color()) + color = style.COLOR_SELECTION_GREY.get_gdk_color() else: - self.modify_bg(gtk.STATE_NORMAL, - style.COLOR_WHITE.get_gdk_color()) + color = style.COLOR_WHITE.get_gdk_color() + self.modify_bg(gtk.STATE_NORMAL, color) + for i in self._fields: + if isinstance(i, gtk.TextView): + i.modify_base(gtk.STATE_NORMAL, color) -class HomogeneView(VHomogeneTable): +class HomogeneView(HomogeneTable): __gsignals__ = { 'entry-activated': (gobject.SIGNAL_RUN_FIRST, @@ -56,15 +62,13 @@ class HomogeneView(VHomogeneTable): ([str])), } - def __init__(self, cell_class, **kwargs): - assert(issubclass(cell_class, Cell)) - - VHomogeneTable.__init__(self, cell_class, **kwargs) + def __init__(self, selection, **kwargs): + HomogeneTable.__init__(self, **kwargs) + self.editable = not selection + self.cursor_visible = selection + self.hover_selection = selection self._result_set = None - self.hover_selection = False - - self.connect('cursor-changed', self.__cursor_changed_cb) def set_result_set(self, result_set): if self._result_set is result_set: @@ -82,12 +86,5 @@ class HomogeneView(VHomogeneTable): self._result_set.seek(offset) return self._result_set.read() - def __cursor_changed_cb(self, table, old_cursor): - if not self.hover_selection: - return - old_cell = table[old_cursor] - if old_cell is not None: - old_cell.select(False) - new_cell = table[table.cursor] - if new_cell is not None: - new_cell.select(True) + def do_highlight_cell(self, cell, selected): + cell.fill_background(selected) diff --git a/src/jarabe/journal/listview.py b/src/jarabe/journal/listview.py index 1072800..9d1e4c0 100644 --- a/src/jarabe/journal/listview.py +++ b/src/jarabe/journal/listview.py @@ -21,7 +21,7 @@ from sugar.graphics import style from jarabe.journal.homogeneview import HomogeneView from jarabe.journal.homogeneview import Cell -from jarabe.journal.widgets import * +from jarabe.journal.fields import * class _Cell(Cell): @@ -33,44 +33,45 @@ class _Cell(Cell): row.props.spacing = style.DEFAULT_SPACING self.add(row) - self._keep = KeepIcon() - row.pack_start(self._keep, expand=False) + keep = KeepIcon() + row.pack_start(keep, expand=False) + self.add_field(keep) - self._icon = ObjectIcon( + icon = ObjectIcon( paint_box=False, pixel_size=style.STANDARD_ICON_SIZE) - row.pack_start(self._icon, expand=False) + row.pack_start(icon, expand=False) + self.add_field(icon) - self._title = Title() + title = Title() title_alignment = gtk.Alignment( xalign=0, yalign=0.5, xscale=1, yscale=0) - title_alignment.add(self._title) + title_alignment.add(title) row.pack_start(title_alignment) + self.add_field(title) - self._details = DetailsIcon() - row.pack_end(self._details, expand=False) + details = DetailsIcon() + row.pack_end(details, expand=False) + self.add_field(details) - self._date = Timestamp() - row.pack_end(self._date, expand=False) + date = Timestamp() + row.pack_end(date, expand=False) + self.add_field(date) - self._buddies = Buddies(buddies_max=3, + buddies = Buddies(buddies_max=3, xalign=0, yalign=0.5, xscale=1, yscale=0.15) - row.pack_end(self._buddies, expand=False) + row.pack_end(buddies, expand=False) + self.add_field(buddies) self.show_all() - def do_fill_in_cell_content(self, table, offset, metadata): - self._keep.fill_in(metadata) - self._icon.fill_in(metadata) - self._title.fill_in(metadata) - self._details.fill_in(metadata) - self._date.fill_in(metadata) - self._buddies.fill_in(metadata) - class ListView(HomogeneView): def __init__(self, selection): - HomogeneView.__init__(self, _Cell, selection) + HomogeneView.__init__(self, selection) self.frame_size = (None, 1) self.cell_size = (None, style.GRID_CELL_SIZE) + + def do_cell_new(self): + return _Cell() diff --git a/src/jarabe/journal/objectchooser.py b/src/jarabe/journal/objectchooser.py index bae7b74..14c1930 100644 --- a/src/jarabe/journal/objectchooser.py +++ b/src/jarabe/journal/objectchooser.py @@ -84,8 +84,7 @@ class ObjectChooser(gtk.Window): vbox.pack_start(self._toolbar, expand=False) self._toolbar.show() - self._view = View() - self._view.props.hover_selection = True + self._view = View(selection=True) self._view.connect('entry-activated', self.__entry_activated_cb) vbox.pack_start(self._view) self._view.show() @@ -129,7 +128,7 @@ class ObjectChooser(gtk.Window): self._view.update_with_query(query) def __view_changed_cb(self, sender, view): - self._view.change_view(view) + self._view.view = view def __volume_changed_cb(self, volume_toolbar, mount_point): logging.debug('Selected volume: %r.', mount_point) diff --git a/src/jarabe/journal/thumbsview.py b/src/jarabe/journal/thumbsview.py index ccf827b..cf943ca 100644 --- a/src/jarabe/journal/thumbsview.py +++ b/src/jarabe/journal/thumbsview.py @@ -20,7 +20,7 @@ import logging from jarabe.journal.homogeneview import HomogeneView from jarabe.journal.homogeneview import Cell -from jarabe.journal.widgets import * +from jarabe.journal.fields import * from jarabe.journal import preview from jarabe.journal import entry @@ -43,11 +43,13 @@ class _Cell(Cell): toolbar = gtk.VBox() cell.pack_start(toolbar, expand=False) - self._keep = KeepIcon() - toolbar.pack_start(self._keep, expand=False) + keep = KeepIcon() + toolbar.pack_start(keep, expand=False) + self.add_field(keep) - self._details = DetailsIcon() - toolbar.pack_start(self._details, expand=False) + details = DetailsIcon() + toolbar.pack_start(details, expand=False) + self.add_field(details) # main @@ -58,31 +60,28 @@ class _Cell(Cell): self._icon = ObjectIcon(pixel_size=style.MEDIUM_ICON_SIZE) self._icon.set_size_request(preview.THUMB_WIDTH, preview.THUMB_HEIGHT) self._icon.show() + self.add_field(self._icon) self._thumb = Thumb() self._thumb.set_size_request(preview.THUMB_WIDTH, preview.THUMB_HEIGHT) self._thumb.show() + self.add_field(self._thumb) self._thumb_box = gtk.HBox() main.pack_start(self._thumb_box, expand=False) - self._title = Title(max_line_count=2) - main.pack_start(self._title, expand=False) + title = Title(max_line_count=2) + main.pack_start(title, expand=False) + self.add_field(title) - self._date = Timestamp(wrap=True, xalign=0.0) - self._date.set_size_request(preview.THUMB_WIDTH, -1) - main.pack_start(self._date, expand=False) + date = Timestamp(wrap=True, xalign=0.0) + date.set_size_request(preview.THUMB_WIDTH, -1) + main.pack_start(date, expand=False) + self.add_field(date) self.show_all() - def do_fill_in_cell_content(self, table, offset, metadata): - self._keep.fill_in(metadata) - self._details.fill_in(metadata) - self._title.fill_in(metadata) - self._date.fill_in(metadata) - self._icon.fill_in(metadata) - self._thumb.fill_in(metadata) - + def fill_in(self, offset, metadata): if self._last_thumb_offset != offset or \ self._last_thumb_uid != metadata.get('uid') or \ self._last_thumb_mtime != metadata.get('timestamp'): @@ -108,8 +107,8 @@ class _Cell(Cell): class ThumbsView(HomogeneView): - def __init__(self): - HomogeneView.__init__(self, _Cell) + def __init__(self, selection): + HomogeneView.__init__(self, selection) cell_width = style.DEFAULT_PADDING * 2 + \ style.GRID_CELL_SIZE + \ @@ -125,6 +124,9 @@ class ThumbsView(HomogeneView): self.connect('frame-scrolled', self.__frame_scrolled_cb) preview.fetched.connect(self.__preview_fetched_cb) + def do_cell_new(self): + return _Cell() + def __frame_scrolled_cb(self, table): preview.discard_queue(table.frame_range) diff --git a/src/jarabe/journal/view.py b/src/jarabe/journal/view.py index 1ce5059..84a84fd 100644 --- a/src/jarabe/journal/view.py +++ b/src/jarabe/journal/view.py @@ -54,7 +54,7 @@ class View(gtk.EventBox): ([str])), } - def __init__(self): + def __init__(self, selection=False): gtk.EventBox.__init__(self) self._query = {} @@ -66,8 +66,8 @@ class View(gtk.EventBox): self._progress_bar = None self._page_ctors = { - VIEW_LIST: lambda: self._view_new(ListView), - VIEW_THUMBS: lambda: self._view_new(ThumbsView), + VIEW_LIST: lambda: self._view_new(ListView, selection), + VIEW_THUMBS: lambda: self._view_new(ThumbsView, selection), _MESSAGE_PROGRESS: self._progress_new, _MESSAGE_EMPTY_JOURNAL: self._message_new, _MESSAGE_NO_MATCH: self._message_new, @@ -98,13 +98,6 @@ class View(gtk.EventBox): view = property(get_view, set_view) - def set_hover_selection(self, hover_selection): - for i in self._view_widgets: - i.child.props.hover_selection = hover_selection - - hover_selection = gobject.property(type=bool, default=False, - setter=set_hover_selection) - def _set_page(self, page): if self._current_page == page: return @@ -189,8 +182,8 @@ class View(gtk.EventBox): self._progress_bar.pulse() self._last_progress_bar_pulse = time.time() - def _view_new(self, view_class): - view = view_class() + def _view_new(self, view_class, selection): + view = view_class(selection) view.modify_bg(gtk.STATE_NORMAL, style.COLOR_WHITE.get_gdk_color()) view.connect('entry-activated', self.__entry_activated_cb) -- cgit v0.9.1