alexandria-book-collection-manager 0.6.9.pre1

data/lib/alexandria/ui/main_app.rb

@@ -0,0 +1,67 @@
+# Copyright (C) 2004-2006 Laurent Sansonetti
+# Copyright (C) 2007 Cathal Mc Ginley
+# Modifications Copyright (C) 2011 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
+# published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version.
+#
+# Alexandria is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public
+# License along with Alexandria; see the file COPYING.  If not,
+# write to the Free Software Foundation, Inc., 51 Franklin Street,
+# Fifth Floor, Boston, MA 02110-1301 USA.
+
+require 'alexandria/ui/dialogs/alert_dialog'
+# misc_dialogs depends on alert_dialog
+require 'alexandria/ui/dialogs/misc_dialogs'
+require 'alexandria/ui/dialogs/about_dialog'
+require 'alexandria/ui/dialogs/book_properties_dialog_base'
+require 'alexandria/ui/dialogs/book_properties_dialog'
+require 'alexandria/ui/dialogs/new_book_dialog_manual'
+require 'alexandria/ui/dialogs/new_book_dialog'
+require 'alexandria/ui/dialogs/preferences_dialog'
+require 'alexandria/ui/dialogs/export_dialog'
+require 'alexandria/ui/dialogs/import_dialog'
+require 'alexandria/ui/dialogs/acquire_dialog'
+require 'alexandria/ui/dialogs/smart_library_properties_dialog_base'
+require 'alexandria/ui/dialogs/smart_library_properties_dialog'
+require 'alexandria/ui/dialogs/new_smart_library_dialog'
+require 'alexandria/ui/dialogs/bad_isbns_dialog'
+require 'alexandria/ui/dndable'
+require 'alexandria/ui/init'
+require 'alexandria/ui/ui_manager'
+require 'alexandria/ui/listview'
+require 'alexandria/ui/iconview'
+require 'alexandria/ui/sidepane'
+
+module Alexandria
+  module UI
+    include Logging
+    include GetText
+    GetText.bindtextdomain(Alexandria::TEXTDOMAIN, charset: 'UTF-8')
+
+    class MainApp
+      include Logging
+      include GetText
+      MAX_RATING_STARS = 5
+      include Singleton
+      attr_accessor :main_app, :libraries, :actiongroup, :appbar, :prefs
+      attr_accessor :ui_manager
+      def initialize
+        log.info { 'Starting MainApp' }
+        @ui_manager = UIManager.new self
+        @actiongroup = @ui_manager.actiongroup
+        @appbar = @ui_manager.appbar
+        @prefs = @ui_manager.prefs
+        @main_app = @ui_manager.main_app
+        @ui_manager.show
+      end
+    end
+  end
+end

data/lib/alexandria/ui/multi_drag_treeview.rb

@@ -0,0 +1,150 @@
+# Copyright (C) 2004-2006 Laurent Sansonetti
+# Modifications Copyright (C) 2011 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
+# published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version.
+#
+# Alexandria is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public
+# License along with Alexandria; see the file COPYING.  If not,
+# 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
+  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
+
+    def pending_event?
+      pending_event
+    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
+
+    @context.button_press_handler =
+      signal_connect('button_press_event') do |_widget, event, _data|
+      button_press_event(event)
+    end
+  end
+
+  def drag_context
+    @context.drag_context
+  end
+
+  #######
+  private
+  #######
+
+  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 button_release_event(_event)
+    @context.events.each { |evnt| Gtk.propagate_event(self, evnt) }
+    stop_drag_check
+    false
+  end
+
+  def motion_notify_event(event)
+    if Gtk::Drag.threshold?(self, @context.x, @context.y, event.x, event.y)
+      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)
+    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
+    end
+
+    return false if event.event_type == Gdk::Event::BUTTON2_PRESS
+
+    path, _, cell_x, cell_y = get_path_at_pos(event.x, event.y)
+    return false if path.nil?
+
+    # 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
+
+    if call_parent
+      signal_handler_block(@context.button_press_handler) do
+        signal_emit('button_press_event', event)
+      end
+    end
+
+    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

data/lib/alexandria/ui/sidepane.rb

@@ -0,0 +1,194 @@
+# Modifications Copyright (C) 2011 Matijs van Zuijlen
+module Alexandria
+  module UI
+    class SidePaneManager
+      include Logging
+      include GetText
+      attr_accessor :library_listview
+      def initialize(library_listview, parent)
+        @library_listview = library_listview
+        @parent = parent
+        @libraries = Libraries.instance
+        @main_app = @parent.main_app
+        setup_sidepane
+      end
+
+      def library_already_exists(new_text)
+        x = (@libraries.all_libraries + Library.deleted_libraries).find do |library|
+          library.name == new_text.strip
+        end
+        x and x.name != @parent.selected_library.name
+      end
+
+      # if new_text is invalid utf-8, returns true
+      # if new_text contains disallowed char (/ or initial .), returns a MatchData object
+      # otherwise returns nil
+      def contains_illegal_character(new_text)
+        new_text.unpack('U*') # attempt to unpack as UTF-8 characters
+        match = /(^\.|\/)/.match(new_text)
+        # forbid / character (since Library names become dir names)
+        # also no initial . since that hides the Library (hidden file)
+        #      forbidding an initial dot also disallows "." and ".."
+        #      which are of course pre-existing directories.
+        return match
+      rescue => ex
+        log.warn { "New library name not valid UTF-8: #{ex.message}" }
+        return true
+        # /([^\w\s'"()&?!:;.\-])/.match(new_text) # anglocentric!
+      end
+
+      def on_edited_library(cell, path_string, new_text)
+        log.debug { "edited library name #{new_text}" }
+        ## new_text = new_text.reverse # for testing;
+        # a great way to generate broken UTF-8
+        if cell.text != new_text
+          if (match = contains_illegal_character(new_text))
+            if match.instance_of? MatchData
+              chars = match[1].gsub(/&/, '&')
+              ErrorDialog.new(@main_app, _("Invalid library name '%s'") % new_text,
+                              _('The name provided contains the ' \
+                                'disallowed character <b>%s</b> ') % chars)
+            else
+              ErrorDialog.new(@main_app, _('Invalid library name'),
+                              _('The name provided contains ' \
+                                'invalid characters.'))
+            end
+
+          elsif new_text.strip.empty?
+            log.debug { 'Empty text' }
+            ErrorDialog.new(@main_app, _('The library name ' \
+                                         'can not be empty'))
+          elsif library_already_exists new_text
+            log.debug { 'Already exists' }
+            ErrorDialog.new(@main_app,
+                            _('The library can not be renamed'),
+                            _('There is already a library named ' \
+                              "'%s'.  Please choose a different " \
+                              'name.') % new_text.strip)
+          else
+            log.debug { "Attempting to apply #{path_string}, #{new_text}" }
+            path = Gtk::TreePath.new(path_string)
+            iter = @library_listview.model.get_iter(path)
+            library_name = new_text.strip
+            log.info { "library name is #{library_name}" }
+            iter[1] = @parent.selected_library.name = library_name
+            @parent.setup_move_actions
+            @parent.refresh_libraries
+          end
+        end
+      end
+
+      def setup_sidepane
+        @library_listview.model = Gtk::ListStore.new(Gdk::Pixbuf,
+                                                     String,
+                                                     TrueClass,
+                                                     TrueClass)
+        @library_separator_iter = nil
+        @libraries.all_regular_libraries.each { |x| @parent.append_library(x) }
+        @libraries.all_smart_libraries.each { |x| @parent.append_library(x) }
+
+        renderer = Gtk::CellRendererPixbuf.new
+        column = Gtk::TreeViewColumn.new(_('Library'))
+        column.pack_start(renderer, false)
+        column.set_cell_data_func(renderer) do |_col, cell, _model, iter|
+          # log.debug { "sidepane: cell_data_func #{col}, #{cell}, #{iter}" }
+          cell.pixbuf = iter[0]
+        end
+        renderer = Gtk::CellRendererText.new
+        renderer.ellipsize = Pango::ELLIPSIZE_END if Pango.ellipsizable?
+        column.pack_start(renderer, true)
+        column.set_cell_data_func(renderer) do |_col, cell, _model, iter|
+          # log.debug { "sidepane: editable #{cell}, #{iter} #{iter[1]}: #{iter[2]}" }
+          cell.text, cell.editable = iter[1], iter[2]
+          # log.debug { "exit sidepane: editable #{cell}, #{iter}" }
+        end
+        renderer.signal_connect('edited', &method(:on_edited_library))
+        @library_listview.append_column(column)
+
+        @library_listview.set_row_separator_func do |_model, iter|
+          # log.debug { "library_listview row_separator #{iter}" }
+          iter[3]
+        end
+
+        @library_listview.selection.signal_connect('changed') do
+          log.debug { 'changed' }
+          @parent.refresh_libraries
+          @parent.refresh_books
+        end
+
+        @library_listview.enable_model_drag_dest(
+          BOOKS_TARGET_TABLE,
+          Gdk::DragContext::ACTION_MOVE)
+
+        @library_listview.signal_connect('drag-motion') do
+          |_widget, drag_context, x, y, time, _data|
+          log.debug { 'drag-motion' }
+
+          path, column, _, _ =
+            @library_listview.get_path_at_pos(x, y)
+
+          if path
+            # Refuse drags from/to smart libraries.
+            if @parent.selected_library.is_a?(SmartLibrary)
+              path = nil
+            else
+              iter = @library_listview.model.get_iter(path)
+              if iter[3]  # separator?
+                path = nil
+              else
+                library = @libraries.all_libraries.find do |lib|
+                  lib.name == iter[1]
+                end
+                path = nil if library.is_a?(SmartLibrary)
+              end
+            end
+          end
+
+          @library_listview.set_drag_dest_row(
+            path,
+            Gtk::TreeView::DROP_INTO_OR_AFTER)
+
+          drag_context.drag_status(
+            !path.nil? ? drag_context.suggested_action : 0,
+            time)
+        end
+
+        @library_listview.signal_connect('drag-drop') do
+          |widget, drag_context, _x, _y, time, _data|
+          log.debug { 'drag-drop' }
+
+          Gtk::Drag.get_data(widget,
+                             drag_context,
+                             drag_context.targets.first,
+                             time)
+          true
+        end
+
+        @library_listview.signal_connect('drag-data-received') do
+          |_widget, drag_context, x, y, selection_data, _info, _time|
+          log.debug { 'drag-data-received' }
+
+          success = false
+          if selection_data.type == Gdk::Selection::TYPE_STRING
+            path, _ =
+              @library_listview.get_dest_row_at_pos(x, y)
+
+            if path
+              iter = @library_listview.model.get_iter(path)
+              library = @libraries.all_libraries.find do |lib|
+                lib.name == iter[1]
+              end
+              @parent.move_selected_books_to_library(library)
+              success = true
+            end
+          end
+          begin
+            Gtk::Drag.finish(drag_context, success, false, 0) # ,time)
+          rescue => ex
+            log.error { "Gtk::Drag.finish failed: #{ex}" }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/alexandria/ui/sound.rb

@@ -0,0 +1,107 @@
+# -*- ruby -*-
+#--
+# Copyright (C) 2011 Cathal Mc Ginley
+#
+# This file is part of Alexandria, a GNOME book collection manager.
+#
+# Alexandria is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# Alexandria is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Alexandria; see the file COPYING. If not, write to the
+# Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+# Boston, MA 02110-1301 USA.
+#++
+
+require 'gst'
+
+module Alexandria
+  module UI
+    ## Uses Ruby/GStreamer to play Ogg/Vorbis sound effects
+    class SoundEffectsPlayer
+      def initialize
+        @sounds_dir = Alexandria::Config::SOUNDS_DIR
+        @ogg_vorbis_pipeline = Gst::Pipeline.new
+        set_up_pipeline
+        @playing = false
+        set_up_glib_loop
+      end
+
+      def play(effect)
+        file = File.join(@sounds_dir, "#{effect}.ogg")
+        unless @playing
+          @filesrc.location = file
+          start_playback
+        end
+      end
+
+      def set_up_pipeline
+        @filesrc = Gst::ElementFactory.make('filesrc')
+        demuxer = Gst::ElementFactory.make('oggdemux')
+        decoder = Gst::ElementFactory.make('vorbisdec')
+        converter = Gst::ElementFactory.make('audioconvert') # #??
+        audiosink = Gst::ElementFactory.make('autoaudiosink')
+
+        @ogg_vorbis_pipeline.add(@filesrc, demuxer, decoder,
+                                 converter, audiosink)
+        @filesrc >> demuxer
+
+        # this next must be a dynamic link, as demuxers potentially
+        # have multiple src pads (for audio/video muxed streams)
+
+        demuxer.signal_connect('pad-added') do |_parser, ogg_src_pad|
+          vorbis_sink_pad = decoder.get_pad('sink')
+          ogg_src_pad.link(vorbis_sink_pad)
+        end
+
+        decoder >> converter >> audiosink
+      end
+
+      def set_up_glib_loop
+        unless @loop
+          @loop = GLib::MainLoop.new(nil, false)
+
+          @bus = @ogg_vorbis_pipeline.bus
+          @bus.add_watch do |_bus, message|
+            case message.type
+            when Gst::Message::EOS
+              @playing = false
+              @loop.quit
+            when Gst::Message::ERROR
+              if $DEBUG
+                puts 'ERROR loop.quit'
+                p message.parse
+              end
+              @playing = false
+              @loop.quit
+            end
+            true
+          end
+        end
+      end
+
+      def start_playback
+        @playing = true
+        @ogg_vorbis_pipeline.play
+        begin
+          @loop.run
+        rescue Interrupt
+        ensure
+          @ogg_vorbis_pipeline.stop
+          @playing = false
+        end
+      end
+
+      def stop_playback
+        @ogg_vorbis_pipeline.stop
+      end
+    end
+  end
+end