rui 0.1.0

data/lib/rui/observer_utils.rb

@@ -0,0 +1,178 @@
+# Copyright (c) 2009-2010 Paolo Capriotti <p.capriotti@gmail.com>
+# 
+# This library is free software; you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as
+# published by the Free Software Foundation; either version 3 of the
+# License, or (at your option) any later version.
+
+require 'observer'
+require 'rui/utils'
+
+#
+# A mixin to make it easier to implement observers using the standard observer
+# library.
+#
+# Mixing <tt>Observer</tt> into a class generates a default update method,
+# which reacts to notification in the form of a hash, and calls appropriate
+# event handlers, obtained by prepending "on_" to each key, and passing it the
+# corresponding value.
+#
+# For example, an event containing the following data
+#
+#   { :pressed => { :x => 34, :y => 11 },
+#     :released => { :x => 10, :y => 76 } }
+#
+# would result in the following method calls:
+#
+#   on_pressed(:x => 34, :y => 11)
+#   on_released(:x => 10, :y => 76)
+#
+# As a special case, if an event takes more than 1 parameter, the corresponding
+# value is assumed to be an array, and its elements are passed as arguments to
+# the event.
+#
+module Observer
+  #
+  # A default implementation for the <tt>update</tt> function.
+  #
+  # Parses notification data and dispatches to the corresponding events.
+  #
+  def update(data)
+    data.each_key do |key|
+      m = begin
+        method("on_#{key}")
+      rescue NameError
+      end
+      
+      if m
+        case m.arity
+        when 0
+          m[]
+        when 1
+          m[data[key]]
+        else
+          m[*data[key]]
+        end
+      end
+    end
+  end
+end
+
+#
+# Extensions to the standard Observable module of the observer library.
+#
+# This mixin allows to define event handlers dynamically, without having to
+# create an Observer class for each handler.
+#
+# For example, assuming <tt>button</tt> is an instance of some observable class:
+#
+#   count = 0
+#   button.on(:clicked) do
+#     count += 1
+#     puts "I have been clicked #{count} times"
+#   end
+#
+# Events can be fired with the <tt>fire</tt> method, and support arbitrary
+# arguments.
+#
+module Observable
+  #
+  # Alias to observe.
+  #
+  def on(event, &blk)
+    observe(event, &blk)
+  end
+  
+  #
+  # Create a dynamic observer handling a given event.
+  #
+  # @param event [Symbol] the event to handle
+  # @param &blk [Block] event handler
+  # @return an observer object, which can be later used to remove
+  #   the event handler.
+  #
+  def observe(event, &blk)
+    obs = SimpleObserver.new(event, &blk)
+    add_observer obs
+    # return observer so that we can remove it later
+    obs
+  end
+  
+  # Create a limited observer handling a given event.
+  #
+  # A limited observer behaves similarly to a normal dynamic observer, but in
+  # addition, it keeps track  of the return valur of the handler. When the
+  # handler returns true, the observer is destroyed.
+  #
+  # @param event [Symbol] the event to handle
+  # @param &blk [Block] event handler
+  # @return an observer object, which can be later used to remove
+  #   the event handler.
+  #
+  def observe_limited(event, &blk)
+    obs = LimitedObserver.new(self, event, &blk)
+    add_observer obs
+    obs
+  end
+
+  #
+  # Fire an event.
+  #
+  # @param e [Symbol, Hash] event and arguments. This needs to be either
+  #   a Symbol, or a Hash with a single key corresponding to the event, and the
+  #   value being the event data to pass to the handler.
+  #
+  def fire(e)
+    changed
+    notify_observers any_to_event(e)
+  end
+  
+  private
+
+  def any_to_event(e)
+    if e.is_a? Symbol
+      { e => nil }
+    else
+      e
+    end
+  end
+end
+
+class Proc
+  def generic_call(args)
+    case arity
+    when 0
+      call
+    when 1
+      call(args)
+    else
+      call(*args)
+    end
+  end
+end
+
+class SimpleObserver
+  def initialize(event, &blk)
+    @event = event
+    @blk = blk
+  end
+  
+  def update(data)
+    if data.has_key?(@event)
+      @blk.generic_call(data[@event])
+    end
+  end
+end
+
+class LimitedObserver < SimpleObserver
+  def initialize(observed, event, &blk)
+    super(event, &blk)
+    @observed = observed
+  end
+  
+  def update(data)
+    remove = super(data)
+    @observed.delete_observer(self) if remove
+    remove
+  end
+end

data/lib/rui/toolkits/kde/kde.rb

@@ -0,0 +1,276 @@
+# Copyright (c) 2009-2010 Paolo Capriotti <p.capriotti@gmail.com>
+# 
+# This library is free software; you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as
+# published by the Free Software Foundation; either version 3 of the
+# License, or (at your option) any later version.
+
+require 'rui/toolkits/qtbase/qt'
+require 'builder'
+begin 
+  require 'kio' 
+rescue LoadError
+end
+
+class KDE::Dialog
+  include Layoutable
+  
+  def setGUI(gui)
+    self.caption = gui.opts[:caption]
+    widget = Qt::Widget.new(self)
+    widget.owner = self
+    widget.setGUI(gui)
+    self.main_widget = widget
+  end
+end
+
+class KDE::Application
+  # 
+  # Initialize an application.
+  # 
+  def self.init(data)
+    data = { :id => data } unless data.is_a?(Hash)
+    about = KDE::AboutData.new(
+      data[:id],
+      data[:id],
+      data[:name] || KDE::LocalizedString.new,
+      data[:version] || '0.0',
+      data[:description] || KDE::LocalizedString.new,
+      KDE::AboutData::License_GPL,
+      data[:copyright] || KDE::LocalizedString.new)
+    (data[:authors] || []).each do |name, email|
+      about.addAuthor(name, KDE::LocalizedString.new, email)
+    end
+    (data[:contributors] || []).each do |name, contribution|
+      about.addCredit(name, contribution)
+    end
+    about.bug_address = Qt::ByteArray.new(data[:bug_tracker] || "")
+    
+    KDE::CmdLineArgs.init(ARGV, about)
+    opts = KDE::CmdLineOptions.new
+    (data[:options] || []).each do |args|
+      case args.size
+      when 2
+        opts.add(args[0], args[1])
+      when 3
+        opts.add(args[0], args[1], args[2])
+      end
+    end
+    KDE::CmdLineArgs.add_cmd_line_options opts
+    opts
+
+    app = KDE::Application.new
+    if block_given?
+      yield app
+      app.exec
+    end
+    app
+  end
+end
+
+class KDE::CmdLineArgs
+  def [](i)
+    arg(i)
+  end
+
+  def is_set(name)
+    isSet(Qt::ByteArray.new(name))
+  end
+end
+
+class KDE::ActionCollection  
+  def []=(name, action)
+    unless action.is_a? KDE::Action
+      orig_action = action
+      action = KDE::Action.new(action.text, action.parent)
+      action.icon = orig_action.icon
+      action.checkable = orig_action.checkable
+      action.checked = orig_action.checked
+      action.on(:triggered) { orig_action.trigger }
+      orig_action.on(:changed) { action.checked = orig_action.checked }
+    end
+    add_action(name.to_s, action)
+  end
+end
+
+class KDE::XmlGuiWindow
+  def setGUI(gui)
+    RUI::with_xml_gui(gui) do |file|
+      setupGUI(KDE::XmlGuiWindow::Default, file)
+    end
+  end
+  
+  def saveGUI
+  end
+end
+
+class KDE::XMLGUIClient
+  def setGUI(gui)
+    RUI::with_xml_gui(gui) do |file|
+      setXMLFile(file)
+    end
+  end
+end
+
+module ActionHandler
+  def std_action(action, opts = {}, &blk)
+    target, slot = get_slot(opts[:slot], &blk)
+    KDE::StandardAction.method_missing(action, target, slot, action_collection)
+  end
+  
+  def get_slot(s = nil, &blk)
+    target, slot = if block_given?
+      [Qt::SignalBlockInvocation.new(action_parent, blk, 'invoke()'), SLOT('invoke()')]
+    else
+      [action_parent, SLOT(s)]
+    end
+  end
+  
+  def regular_action(name, opts, &blk)
+    a = KDE::Action.new(KDE::Icon.from_theme(opts[:icon]), 
+                    opts[:text], action_parent)
+    action_collection.add_action(name.to_s, a)  
+    a.connect(SIGNAL('triggered(bool)'), &blk)
+    a.tool_tip = opts[:tooltip] if opts[:tooltip]
+    a.shortcut = opts[:shortcut] if opts[:shortcut]
+    a
+  end
+  
+  def action_parent
+    self
+  end
+
+  def plug_action_list(name, actions)
+    plugActionList(name.to_s, actions)
+  end
+
+  def unplug_action_list(name)
+    unplugActionList(name.to_s)
+  end
+end
+
+class KDE::Icon
+  def self.from_theme(name)
+    if name
+      new(name.to_s)
+    else
+      new
+    end
+  end
+end
+
+class KDE::ConfigGroup
+  def each_group
+    group_list.each do |g|
+      yield group(g)
+    end
+  end
+end
+
+class KDE::TabWidget
+  include Layoutable
+end
+
+class KDE::Process
+  def output_channel_mode=(value)
+    c = self.class.const_get("#{value.to_s.capitalize.camelize}Channel")
+    setOutputChannelMode(c)
+  end
+  
+  def self.split_args(str)
+    KDE::Shell.split_args(str)
+  end
+  
+  def run(path, args)
+    set_program(path, args)
+    start
+  end
+end
+
+def KDE.download_tempfile(url, parent)
+  result = ""
+  if KIO::NetAccess.download(url, result, parent)
+    result
+  end
+end
+
+module RUI
+  def self.gui(name, &blk)
+    "<!DOCTYPE kpartgui SYSTEM \"kpartgui.dtd\">\n" + 
+    XmlGuiBuilder.new.gui({ :version => 2, :name => name }, &blk)
+  end
+  
+  def self.with_xml_gui(xml, &blk)
+    tmp = TemporaryFile.new
+    tmp.open
+    
+    ::File.open(tmp.file_name, 'w') do |f|
+      f.write(xml)
+    end
+    blk[tmp.file_name]
+  ensure
+    tmp.close
+    ::File.unlink(tmp.file_name)
+  end
+  
+  class XmlGuiBuilder < Builder::XmlMarkup
+    def initialize
+      super
+      @action_opts = { }
+    end
+
+    def menu_bar(&blk)
+      MenuBar(&blk)
+    end
+    
+    def menu(name, opts = {}, &blk)
+      Menu(:name => name) do |m|
+        m.text(opts[:text]) if opts[:text]
+        blk[m] if block_given?
+      end
+    end
+    
+    def action(name, opts = {})
+      Action(opts.merge(@action_opts).merge(:name => name))
+    end
+    
+    def separator
+      self.Separator
+    end
+    
+    def tool_bar(name, opts = { }, &blk)
+      ToolBar(:name => name) do |tb|
+        tb.text(opts[:text]) if opts[:text]
+        blk[tb] if block_given?
+      end
+    end
+    
+    def action_list(name)
+      ActionList(:name => name)
+    end
+    
+    def group(name, &blk)
+      if block_given?
+        @action_opts = { :group => name }
+        blk[self]
+        @action_opts = { }
+      else
+        DefineGroup(:name => name)
+      end
+    end
+  end
+
+  def self.active_color
+    scheme = KDE::ColorScheme.new(Qt::Palette::Active, KDE::ColorScheme::Window)
+    color = scheme.foreground(KDE::ColorScheme::PositiveText).color
+  end
+
+  def self.std_shortcut(name)
+    code = KDE::StandardShortcut.send(name.to_s.capitalize)
+    StandardShortcut::shortcut(code)
+  end
+
+  def self.i18n(*args)
+    KDE.i18n(*args)
+  end
+end