alexandria-book-collection-manager 0.6.9 → 0.7.0

data/lib/alexandria/ui/listview.rb

@@ -1,7 +1,7 @@
 # Copyright (C) 2004-2006 Laurent Sansonetti
 # Copyright (C) 2008 Joseph Method
 # Copyright (C) 2010 Cathal Mc Ginley
-# Copyright (C) 2011 Matijs van Zuijlen
+# Copyright (C) 2011, 2016 Matijs van Zuijlen
 #
 # Alexandria is free software; you can redistribute it and/or
 # modify it under the terms of the GNU General Public License aso
@@ -27,7 +27,7 @@ module Alexandria
       include Logging
       include GetText
       include DragAndDropable
-      BOOKS_TARGET_TABLE = [['ALEXANDRIA_BOOKS', Gtk::Drag::TARGET_SAME_APP, 0]]
+      BOOKS_TARGET_TABLE = [['ALEXANDRIA_BOOKS', :same_app, 0]].freeze
 
       MAX_RATING_STARS = 5
       module Columns
@@ -51,55 +51,21 @@ module Alexandria
         title = _('Title')
         log.debug { 'Create listview column for %s' % title }
         column = Gtk::TreeViewColumn.new(title)
-        column.widget = Gtk::Label.new(title).show
+
         renderer = Gtk::CellRendererPixbuf.new
         column.pack_start(renderer, false)
-        column.set_cell_data_func(renderer) do |_col, cell, _model, iter|
-          iter = @listview_model.convert_iter_to_child_iter(iter)
-          iter = @filtered_model.convert_iter_to_child_iter(iter)
-          cell.pixbuf = iter[Columns::COVER_LIST]
-        end
-        renderer = Gtk::CellRendererText.new
-        renderer.ellipsize = Pango::ELLIPSIZE_END if Pango.ellipsizable?
-        # Editable tree views are behaving strangely
-        # make_renderer_editable renderer
+        column.add_attribute(renderer, 'pixbuf', Columns::COVER_LIST)
 
+        renderer = Gtk::CellRendererText.new
+        renderer.ellipsize = Pango::ELLIPSIZE_END
         column.pack_start(renderer, true)
-
-        column.set_cell_data_func(renderer) do |_col, cell, _model, iter|
-          iter = @listview_model.convert_iter_to_child_iter(iter)
-          iter = @filtered_model.convert_iter_to_child_iter(iter)
-          cell.text = iter[Columns::TITLE]
-          cell.editable = false # true
-        end
+        column.add_attribute(renderer, 'text', Columns::TITLE)
 
         column.sort_column_id = Columns::TITLE
         column.resizable = true
         @listview.append_column(column)
       end
 
-      def make_renderer_editable(renderer)
-        renderer.signal_connect('editing_started') do |_cell, entry, _path_string|
-          log.debug { 'editing_started' }
-          entry.complete_titles
-        end
-
-        renderer.signal_connect('edited') do |_cell, path_string, new_string|
-          log.debug { 'edited' }
-          path = Gtk::TreePath.new(path_string)
-          path = @listview_model.convert_path_to_child_path(path)
-          path = @filtered_model.convert_path_to_child_path(path)
-          iter = @listview.model.get_iter(path)
-          book = @parent.book_from_iter(@parent.selected_library, iter)
-          book.title = new_string
-          @listview.freeze
-          @iconview.freeze
-          @parent.fill_iter_with_book(iter, book)
-          @iconview.unfreeze
-          @listview.unfreeze
-        end
-      end
-
       TEXT_COLUMNS = [
         [_('Authors'), Columns::AUTHORS],
         [_('ISBN'), Columns::ISBN],
@@ -107,12 +73,12 @@ module Alexandria
         [_('Publish Year'), Columns::PUBLISH_DATE],
         [_('Binding'), Columns::EDITION],
         [_('Loaned To'), Columns::LOANED_TO]
-      ]
+      ].freeze
       CHECK_COLUMNS = [
         [_('Read'), Columns::REDD],
         [_('Own'), Columns::OWN],
         [_('Want'), Columns::WANT]
-      ]
+      ].freeze
 
       def setup_books_listview
         log.debug { 'setup_books_listview' }
@@ -125,13 +91,13 @@ module Alexandria
           setup_check_column title, iterid
         end
         setup_rating_column
-        @listview.selection.mode = Gtk::SELECTION_MULTIPLE
+        @listview.selection.mode = :multiple
         @listview.selection.signal_connect('changed') do
           log.debug { 'changed' }
           @parent.on_books_selection_changed
         end
         setup_tags_column
-        setup_listview_hack
+        setup_row_activation
         setup_view_source_dnd(@listview)
       end
 
@@ -140,24 +106,19 @@ module Alexandria
         title = _('Tags')
         log.debug { 'Create listview column for tags...' }
         renderer = Gtk::CellRendererText.new
-        renderer.ellipsize = Pango::ELLIPSIZE_END if Pango.ellipsizable?
+        renderer.ellipsize = Pango::ELLIPSIZE_END
         column = Gtk::TreeViewColumn.new(title, renderer,
                                          text: Columns::TAGS)
-        column.widget = Gtk::Label.new(title).show
         column.sort_column_id = Columns::TAGS
         column.resizable = true
         @listview.append_column(column)
       end
 
-      def setup_listview_hack
+      def setup_row_activation
         @listview.signal_connect('row-activated') do
-          # Dirty hack to avoid the beginning of a drag within this
-          # handler.
           log.debug { 'row-activated' }
-          Gtk.timeout_add(100) do
-            @actiongroup['Properties'].activate
-            false
-          end
+          @actiongroup['Properties'].activate
+          false
         end
       end
 
@@ -165,16 +126,14 @@ module Alexandria
         title = _('Rating')
         log.debug { 'Create listview column for %s...' % title }
         column = Gtk::TreeViewColumn.new(title)
-        column.widget = Gtk::Label.new(title).show
-        column.sizing = Gtk::TreeViewColumn::FIXED
-        column.fixed_width = column.min_width = column.max_width =
-          (Icons::STAR_SET.width + 1) * MAX_RATING_STARS
+        column.sizing = :fixed
+        width = (Icons::STAR_SET.width + 1) * MAX_RATING_STARS
+        column.fixed_width = column.min_width = column.max_width = width
         MAX_RATING_STARS.times do |i|
           renderer = Gtk::CellRendererPixbuf.new
+          renderer.xalign = 0.0
           column.pack_start(renderer, false)
-          column.set_cell_data_func(renderer) do |_col, cell, _model, iter|
-            iter = @listview_model.convert_iter_to_child_iter(iter)
-            iter = @filtered_model.convert_iter_to_child_iter(iter)
+          column.set_cell_data_func(renderer) do |_tree_column, cell, _tree_model, iter|
             rating = (iter[Columns::RATING] - MAX_RATING_STARS).abs
             cell.pixbuf = rating >= i.succ ?
               Icons::STAR_SET : Icons::STAR_UNSET
@@ -225,30 +184,15 @@ module Alexandria
           end
         end
         column = Gtk::TreeViewColumn.new(title, renderer, text: iterid)
-        column.widget = Gtk::Label.new(title).show
         column.sort_column_id = iterid
         column.resizable = true
         log.debug { 'Create listview column for %s...' % title }
-        setup_column = proc do |iter, cell, col|
-          state = iter[col]
-          cell.set_active(state)
-          cell.activatable = true
-        end
-        log.debug { "Setting cell_data_func for #{renderer}" }
-        column.set_cell_data_func(renderer) do |_col, cell, _model, iter|
-          iter = @listview_model.convert_iter_to_child_iter(iter)
-          iter = @filtered_model.convert_iter_to_child_iter(iter)
-          case iterid
-          when 12
-            setup_column.call(iter, cell, Columns::REDD)
-          when 13
-            setup_column.call(iter, cell, Columns::OWN)
-          when 14
-            setup_column.call(iter, cell, Columns::WANT)
-            own_state = iter[Columns::OWN]
-            cell.inconsistent = own_state
-          end
+
+        column.add_attribute(renderer, 'active', iterid)
+        if iterid == Columns::WANT
+          column.add_attribute(renderer, 'inconsistent', Columns::OWN)
         end
+
         log.debug { "append_column #{column}" }
         @listview.append_column(column)
       end
@@ -256,10 +200,9 @@ module Alexandria
       def setup_text_column(title, iterid)
         log.debug { 'Create listview column for %s...' % title }
         renderer = Gtk::CellRendererText.new
-        renderer.ellipsize = Pango::ELLIPSIZE_END if Pango.ellipsizable?
+        renderer.ellipsize = Pango::ELLIPSIZE_END
         column = Gtk::TreeViewColumn.new(title, renderer,
                                          text: iterid)
-        column.widget = Gtk::Label.new(title).show
         column.sort_column_id = iterid
         column.resizable = true
         @listview.append_column(column)
@@ -298,8 +241,10 @@ module Alexandria
           @listview.columns.each do |c|
             if cols_width.key?(c.title)
               log.debug { "#{c.title} : #{cols_width[c.title]}" }
-              c.sizing = Gtk::TreeViewColumn::FIXED
-              c.fixed_width = cols_width[c.title]
+              width = cols_width[c.title]
+              next if width.zero?
+              c.sizing = :fixed
+              c.fixed_width = width
             end
           end
         end

data/lib/alexandria/ui/multi_drag_treeview.rb

@@ -1,5 +1,5 @@
 # Copyright (C) 2004-2006 Laurent Sansonetti
-# Copyright (C) 2011 Matijs van Zuijlen
+# Copyright (C) 2011, 2016 Matijs van Zuijlen
 #
 # Alexandria is free software; you can redistribute it and/or
 # modify it under the terms of the GNU General Public License as
@@ -16,133 +16,136 @@
 # write to the Free Software Foundation, Inc., 51 Franklin Street,
 # Fifth Floor, Boston, MA 02110-1301 USA.
 
-class Gdk::Event
-  def ==(obj)
-    obj.is_a?(self.class) and time == obj.time and x == obj.x and y == obj.y and button == obj.button
+module Alexandria
+  module EventOverrides
+    def ==(obj)
+      obj.is_a?(self.class) && (time == obj.time) && (x == obj.x) && (y == obj.y) && (button == obj.button)
+    end
   end
-end
 
-class Gtk::TreeView
-  # include Alexandria::Logging
-
-  class Context < Struct.new(:pressed_button,
-                             :x,
-                             :y,
-                             :cell_x,
-                             :cell_y,
-                             :button_press_handler,
-                             :motion_notify_handler,
-                             :button_release_handler,
-                             :drag_data_get_handler,
-                             :events,
-                             :source_start_button_mask,
-                             :source_targets,
-                             :source_actions,
-                             :pending_event,
-                             :drag_context)
-
-    def initialize(*ary)
-      super
-      self.events ||= []
-    end
+  module TreeViewOverrides
+    # include Alexandria::Logging
+
+    class Context < Struct.new(:pressed_button,
+                               :x,
+                               :y,
+                               :cell_x,
+                               :cell_y,
+                               :button_press_handler,
+                               :motion_notify_handler,
+                               :button_release_handler,
+                               :drag_data_get_handler,
+                               :events,
+                               :source_start_button_mask,
+                               :source_targets,
+                               :source_actions,
+                               :pending_event,
+                               :drag_context)
+
+      def initialize(*ary)
+        super
+        self.events ||= []
+      end
 
-    def pending_event?
-      pending_event
+      def pending_event?
+        pending_event
+      end
     end
-  end
-
-  alias_method :old_enable_model_drag_source, :enable_model_drag_source
-  def enable_model_drag_source(start_button_mask, targets, actions)
-    old_enable_model_drag_source(start_button_mask, targets, actions)
 
-    @context = Context.new
-    @context.source_start_button_mask = start_button_mask
-    @context.source_targets = Gtk::TargetList.new(targets)
-    @context.source_actions = actions
+    def enable_model_drag_source(start_button_mask, targets, actions)
+      super
 
-    @context.button_press_handler =
-      signal_connect('button_press_event') do |_widget, event, _data|
-        button_press_event(event)
-      end
-  end
+      @context = Context.new
+      @context.source_start_button_mask = start_button_mask
+      @context.source_targets = Gtk::TargetList.new(targets)
+      @context.source_actions = actions
 
-  def drag_context
-    @context.drag_context
-  end
+      @context.button_press_handler =
+        signal_connect('button_press_event') do |_widget, event, _data|
+          button_press_event(event)
+        end
+    end
 
-  private
+    def drag_context
+      @context.drag_context
+    end
 
-  def stop_drag_check
-    raise if @context.nil?
-    @context.events.clear
-    @context.pending_event = false
-    signal_handler_disconnect(@context.motion_notify_handler)
-    signal_handler_disconnect(@context.button_release_handler)
-  end
+    private
 
-  def button_release_event(_event)
-    @context.events.each { |evnt| Gtk.propagate_event(self, evnt) }
-    stop_drag_check
-    false
-  end
+    def stop_drag_check
+      raise if @context.nil?
+      @context.events.clear
+      @context.pending_event = false
+      signal_handler_disconnect(@context.motion_notify_handler)
+      signal_handler_disconnect(@context.button_release_handler)
+    end
 
-  def motion_notify_event(event)
-    if Gtk::Drag.threshold?(self, @context.x, @context.y, event.x, event.y)
+    def button_release_event(_event)
+      @context.events.each { |evnt| Gtk.propagate_event(self, evnt) }
       stop_drag_check
-      paths = []
-      selection.selected_each { |_model, path, _iter| paths << path }
-      @context.drag_context = Gtk::Drag.begin(self,
-                                              @context.source_targets,
-                                              @context.source_actions,
-                                              @context.pressed_button,
-                                              event)
+      false
     end
-    true
-  end
-
-  def button_press_event(event)
-    return false if event.button == 3
-    return false if event.window != bin_window
-    return false if @context.events.include?(event)
 
-    if @context.pending_event?
-      @context.events << event
-      return true
+    def motion_notify_event(event)
+      if drag_check_threshold(@context.x, @context.y, event.x, event.y)
+        stop_drag_check
+        paths = []
+        selection.each { |_model, path, _iter| paths << path }
+        @context.drag_context = drag_begin(@context.source_targets,
+                                           @context.source_actions,
+                                           @context.pressed_button,
+                                           event)
+      end
+      true
     end
 
-    return false if event.event_type == Gdk::Event::BUTTON2_PRESS
+    def button_press_event(event)
+      return false if event.button == 3
+      return false if event.window != bin_window
+      return false if @context.events.include?(event)
 
-    path, _, cell_x, cell_y = get_path_at_pos(event.x, event.y)
-    return false if path.nil?
+      if @context.pending_event?
+        @context.events << event
+        return true
+      end
 
-    # call_parent = (event.state.control_mask? or event.state.shift_mask?) or !selected or event.button != 1
-    call_parent = !selection.path_is_selected?(path) or
-      event.button != 1
+      return false if event.event_type == :'2button_press'
 
-    if call_parent
-      signal_handler_block(@context.button_press_handler) do
-        signal_emit('button_press_event', event)
-      end
-    end
+      path, _, cell_x, cell_y = get_path_at_pos(event.x, event.y)
+      return false if path.nil?
 
-    if selection.path_is_selected?(path)
-      @context.pending_event = true
-      @context.pressed_button = event.button
-      @context.x = event.x
-      @context.y = event.y
-      @context.cell_x = cell_x
-      @context.cell_y = cell_y
-      @context.motion_notify_handler =
-        signal_connect('motion_notify_event') do |_widget, evnt, _data|
-          motion_notify_event(evnt)
-        end
-      @context.button_release_handler =
-        signal_connect('button_release_event') do |_widget, evnt, _data|
-          button_release_event(evnt)
+      # call_parent = (event.state.control_mask? or event.state.shift_mask?) or !selected or event.button != 1
+      (call_parent = !selection.path_is_selected?(path)) ||
+        (event.button != 1)
+
+      if call_parent
+        signal_handler_block(@context.button_press_handler) do
+          signal_emit('button_press_event', event)
         end
-      @context.events << event unless call_parent
-    end
+      end
 
-    true
+      if selection.path_is_selected?(path)
+        @context.pending_event = true
+        @context.pressed_button = event.button
+        @context.x = event.x
+        @context.y = event.y
+        @context.cell_x = cell_x
+        @context.cell_y = cell_y
+        @context.motion_notify_handler =
+          signal_connect('motion_notify_event') do |_widget, evnt, _data|
+            motion_notify_event(evnt)
+          end
+        @context.button_release_handler =
+          signal_connect('button_release_event') do |_widget, evnt, _data|
+            button_release_event(evnt)
+          end
+        @context.events << event unless call_parent
+      end
+
+      true
+    end
   end
 end
+
+Gdk::Event.prepend Alexandria::EventOverrides
+Gtk::TreeView.prepend Alexandria::TreeViewOverrides