rui 0.1.0

data/lib/rui/toolkits/qt/qt.rb

@@ -0,0 +1,350 @@
+# 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'
+
+module KDE
+  def self.ki18n(str)
+    str
+  end
+
+  def self.i18n(str)
+    str
+  end
+  
+  def self.i18nc(context, str)
+    str
+  end
+  
+  def self.active_color
+    $qApp.palette.color(Qt::Palette::Highlight)
+  end
+  
+  def self.std_shortcut(name)
+    code = Qt::KeySequence.send(name.to_s.capitalize)
+    Qt::KeySequence.new(code)
+  end
+end
+
+class Qt::UrlRequester < Qt::LineEdit
+  def url=(val)
+    self.text = val.to_string
+  end
+  
+  def url
+    Qt::Url.new(text)
+  end
+end
+
+class Qt::MainWindow
+  attr_reader :guis
+  
+  def initialize(parent)
+    super(parent)
+    
+    setToolButtonStyle(Qt::ToolButtonFollowStyle)
+    
+    # create basic GUI
+    @guis = []
+    @gui = Qt::gui(:qt_base) do |g|
+      g.menu_bar do |mb|
+        mb.merge_point
+        mb.menu(:settings, :text => KDE::i18n("&Settings"))
+        mb.menu(:help, :text => KDE::i18n("&Help")) do |m|
+          m.action :about
+          m.action :about_qt
+        end
+      end
+    end
+  end
+  
+  def setGUI(gui)
+    regular_action(:about, :text => KDE::i18n("&About")) do
+      Qt::MessageBox.about(nil,
+                           $qApp.data[:name],
+                           [$qApp.data[:description],
+                            $qApp.data[:copyright]].join("\n"))
+    end
+    regular_action(:about_qt, :text => KDE::i18n("About &Qt")) { $qApp.about_qt }
+    
+    @gui.merge!(gui)
+    @guis.each {|g| @gui.merge! g }
+    RUI::GuiBuilder.build(self, @gui)
+    
+    # restore state
+    settings = Qt::Settings.new
+    state = nil
+    geometry = nil
+    if settings.contains("mainwindow/state")
+      state = settings.value("mainwindow/state").toByteArray
+      geometry = settings.value("mainwindow/geometry").toByteArray
+      restore_geometry(geometry)
+      restore_state(state)
+    end
+  end
+
+  def saveGUI
+    settings = Qt::Settings.new
+    settings.begin_group("mainwindow")
+    settings.set_value("geometry", Qt::Variant.new(save_geometry))
+    settings.set_value("state", Qt::Variant.new(save_state))
+    settings.end_group
+    settings.sync
+  end
+  
+  def caption=(title)
+    self.window_title = $qApp.application_name.capitalize + 
+        " - " + title
+  end
+end
+
+class Qt::Dialog
+  include Layoutable
+  
+  def setGUI(gui)
+    self.window_title = gui.opts[:caption]
+    layout = Qt::VBoxLayout.new(self)
+    widget = Qt::Widget.new(self)
+    widget.owner = self
+    widget.setGUI(gui)
+    buttons = Qt::DialogButtonBox.new
+    buttons.add_button(Qt::DialogButtonBox::Ok)
+    buttons.add_button(Qt::DialogButtonBox::Cancel)
+    layout.add_widget(widget)
+    layout.add_widget(buttons)
+    
+    buttons.on(:accepted) { fire :ok_clicked; accept }
+    buttons.on(:rejected) { reject }
+  end
+end
+
+class Qt::XMLGUIClient < Qt::Object
+  def setGUI(gui)
+    parent.guis << gui
+  end
+end
+
+module ActionHandler
+  def action_collection
+    @action_collection ||= { }
+  end
+
+  def action_list_entries
+    @action_list_entries ||= Hash.new {|h, x| h[x] = [] }
+  end
+
+  def plug_action_list(name, actions)
+    action_list_entries[name].each do |entry|
+      actions.each do |action|
+        puts "adding action to #{entry.parent}: #{action.text}"
+        entry.add_action(action)
+      end
+    end
+  end
+
+  def unplug_action_list(name)
+    action_list_entries[name].each do |entry|
+      entry.clear
+    end
+  end
+  
+  def add_action(name, a)
+    action_parent.action_collection[name] = a
+  end
+  
+  def std_action(name, &blk)
+    text, icon_name = Qt::STD_ACTIONS[name]
+    if text
+      icon = Qt::Icon.from_theme(icon_name)
+      a = Qt::Action.new(icon, text, action_parent)
+      add_action(name, a)
+      a.on(:triggered, &blk)
+      a
+    end
+  end
+  
+  def regular_action(name, opts = { }, &blk)
+    a = Qt::Action.new(opts[:text], action_parent)
+    add_action(name, a)
+    a.on(:triggered, &blk)
+    if (opts[:icon])
+      a.icon = Qt::Icon.from_theme(opts[:icon])
+    end
+    a.shortcut = opts[:shortcut] if opts[:shortcut]
+    a.tool_tip = opts[:tooltip] if opts[:tooltip]
+    a
+  end
+  
+  def action_parent
+    self
+  end
+end
+
+module Qt
+  STD_ACTIONS = {
+    :undo => [KDE::i18n("&Undo"), 'edit-undo'],
+    :redo => [KDE::i18n("&Redo"), 'edit-redo']
+  }
+  
+  def self.gui(name, opts = { }, &blk)
+    self.autogui(name, opts, &blk)
+  end
+end
+
+class Qt::Application
+  attr_accessor :data
+  
+  def self.init(data)
+    app = new(ARGV)
+    app.application_name = data[:id]
+    app.organization_name = data[:id]
+    app.data = data
+
+    if block_given?
+      yield app
+      app.exec
+    end
+    app
+  end
+end
+
+class KDE::CmdLineArgs
+  def self.parsed_args
+    new(ARGV)
+  end
+  
+  def initialize(args)
+    @args = args
+  end
+  
+  def [](i)
+    @args[i]
+  end
+  
+  def count
+    @args.size
+  end
+  
+  def is_set(name)
+    false
+  end
+end
+
+class KDE::Global
+  def self.config
+    Qt::Settings::Group.new(Qt::Settings.new, "")
+  end
+end
+
+class Qt::Settings
+  class Group
+    def initialize(settings, prefix)
+      @settings = settings
+      @prefix = prefix
+    end
+    
+    def exists
+      in_group do
+        not @settings.all_keys.empty?
+      end
+    end
+    
+    def delete_group
+      @settings.remove(@prefix)
+    end
+      
+    def group(name)
+      Group.new(@settings, prefixed(name))
+    end
+    
+    def write_entry(key, value)
+      @settings.set_value(prefixed(key), 
+                          Qt::Variant.new(value))
+    end
+    
+    def read_entry(key, default_value = nil)
+      @settings.value(prefixed(key)).toString || default_value
+    end
+    
+    def sync
+      @settings.sync
+    end
+    
+    def group_list
+      in_group do
+        @settings.child_groups
+      end
+    end
+    
+    def entry_map
+      in_group do
+        @settings.child_keys.inject({}) do |res, key|
+          res[key] = @settings.value(key).toString
+          res
+        end
+      end
+    end
+    
+    def each_group
+      names = in_group do
+        @settings.child_groups
+      end
+      names.each do |name|
+        yield group(name)
+      end
+    end
+    
+    def name
+      if @prefix =~ /\/([^\/]+)$/
+        $1
+      else
+        @prefix
+      end
+    end
+    
+    private
+    
+    def prefixed(key)
+      if @prefix.empty?
+        key
+      else
+        [@prefix, key].join('/')
+      end
+    end
+    
+    def in_group
+      @settings.begin_group(@prefix)
+      result = yield
+      @settings.end_group
+      result
+    end
+  end
+end
+
+class Qt::TabWidget
+  include Layoutable
+end
+
+class Qt::Process
+  def output_channel_mode=(val)
+    case val
+    when :only_stdout
+      setProcessChannelMode(Qt::Process::SeparateChannels)
+      setReadChannel(Qt::Process::StandardOutput)
+    else
+      raise "Unsupported output mode #{val}"
+    end
+  end
+  
+  def self.split_args(str)
+    str.split(/\s+/)
+  end
+  
+  def run(path, args)
+    start(path, args)
+  end
+end

data/lib/rui/toolkits/qtbase/gui_builder.rb

@@ -0,0 +1,344 @@
+# 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/factory'
+
+module RUI
+  #
+  # Helper module used to interpret a GUI descriptor and build a Qt GUI.
+  #
+  # Classes in this module correspond to valid descriptor tags.
+  #
+  module GuiBuilder    
+    def self.build(window, gui)
+      Gui.new.build(window, nil, gui)
+    end
+    
+    def build(window, parent, desc)
+      element = create_element(window, parent, desc)
+      desc.children.each do |child|
+        b = builder(child.tag).new
+        b.build(window, element, child)
+      end
+      element
+    end
+    
+    def setup_widget(widget, parent, layout, desc)
+      layout.add_widget(widget)
+      if desc.opts[:name]
+        parent.add_accessor(desc.opts[:name], widget)
+      end        
+    end
+    
+    def builder(name)
+      GuiBuilder.const_get(name.to_s.capitalize.camelize)
+    end
+    
+    #
+    # Root tag for a GUI descriptor.
+    #
+    # Created automatically by {RUI.autogui}.
+    #
+    class Gui
+      include GuiBuilder
+      def create_element(window, parent, desc)
+        window
+      end
+    end
+    
+    #
+    # Menu bar.
+    #
+    # This tag must be a child of a gui descriptor.
+    #
+    class MenuBar
+      include GuiBuilder
+      
+      def create_element(window, parent, desc)
+        window.menu_bar
+      end
+    end
+    
+    #
+    # A menu.
+    #
+    # This tag must be a child of a menu_bar descriptor.
+    #
+    class Menu
+      include GuiBuilder
+      
+      def create_element(window, parent, desc)
+        menu = Qt::Menu.new(desc.opts[:text].to_s, window)
+        parent.add_menu(menu)
+        menu
+      end
+    end
+    
+    #
+    # Menu or toolbar action.
+    #
+    # This tag must be a child of a menu or toolbar descriptor.
+    #
+    class Action
+      include GuiBuilder
+      
+      def create_element(window, parent, desc)
+        action = window.action_collection[desc.opts[:name]]
+        if action
+          parent.add_action(action)
+        end
+        action
+      end
+    end
+    
+    #
+    # Menu or toolbar separator.
+    #
+    # This tag must be a child of a menu or toolbar descriptor.
+    #
+    class Separator
+      include GuiBuilder
+      
+      def create_element(window, parent, desc)
+        parent.add_separator
+      end
+    end
+    
+    #
+    # A descriptor group.
+    #
+    # This can be used to affect how merging of descriptor is performed
+    # (together with merge points).
+    #
+    # @see Descriptor
+    #
+    class Group
+      include GuiBuilder
+      
+      def create_element(window, parent, desc)
+        parent
+      end
+    end
+    
+    #
+    # An action list is a placeholder for dynamically pluggable actions.
+    #
+    # Action lists can be plugged by using {ActionHandler#plug_action_list} and
+    # removed with {ActionHandler#unplug_action_list}.
+    #
+    class ActionList
+      include GuiBuilder
+      
+      def create_element(window, parent, desc)
+        parent
+      end
+    end
+    
+    #
+    # A toolbar.
+    #
+    # This tag must be a child of a gui descriptor.
+    #
+    class ToolBar
+      include GuiBuilder
+      
+      def create_element(window, parent, desc)
+        tb = Qt::ToolBar.new(desc.opts[:text].to_s, parent)
+        tb.object_name = desc.opts[:name].to_s
+        parent.add_tool_bar(Qt::TopToolBarArea, tb)
+        tb
+      end
+    end
+    
+    #
+    # A widget layout.
+    #
+    # Two orientations are supported: horizontal and vertical. The orientation
+    # is controlled by the <tt>type</tt> attribute of this descriptor.
+    #
+    # A margin can also be specified using the <tt>margin</tt> attribute.
+    #
+    class Layout
+      include GuiBuilder
+      
+      def create_element(window, parent, desc)
+        factory = if desc.opts[:type] == :horizontal
+          Qt::HBoxLayout
+        else
+          Qt::VBoxLayout
+        end
+        layout = factory.new
+        layout.margin = desc.opts[:margin] if desc.opts[:margin]
+        parent.add_layout(layout)
+        layout
+      end
+    end
+    
+    #
+    # A stretch element.
+    #
+    # Used to separate consecutive elements of a layout.
+    #
+    class Stretch
+      include GuiBuilder
+      
+      def create_element(window, parent, desc)
+        parent.add_stretch
+      end
+    end
+    
+    #
+    # A label.
+    #
+    # The label text is specified by the <tt>text</tt> attribute.
+    #
+    # A <tt>buddy</tt> attribute can also be specified as a widget id. The widget with
+    # the given id will be set as the buddy of this label as GUI construction
+    # time.
+    #
+    class Label
+      include GuiBuilder
+      
+      def create_element(window, parent, desc)
+        label = Qt::Label.new(desc.opts[:text].to_s, window)
+        setup_widget(label, window, parent, desc)
+        if desc.opts[:buddy]
+          window.buddies[label] = desc.opts[:buddy]
+        end
+        label
+      end
+    end
+    
+    #
+    # A TabWidget.
+    #
+    class TabWidget
+      include GuiBuilder
+      
+      def create_element(window, parent, desc)
+        widget = KDE::TabWidget.new(window)
+        setup_widget(widget, window, parent, desc)
+        widget.owner = window.owner
+        widget
+      end
+    end
+    
+    #
+    # A generic widget.
+    #
+    # To use this tag, the <tt>factory</tt> descriptor property must be set to
+    # the Factory to use to create the widget. The {Factory} class can be
+    # useful when the widget to create needs special initialization. Note that
+    # the given factory will be invoked passing only the parent widget as a
+    # parameter, so any extra parameters must be preset by the factory itself.
+    #
+    class Widget
+      include GuiBuilder
+      
+      def create_element(window, parent, desc)
+        widget = factory(desc).new(window)
+        setup_widget(widget, window, parent, desc)
+        widget
+      end
+      
+      def factory(desc)
+        desc.opts[:factory]
+      end
+    end
+    
+    #
+    # An individual tab in a tab_widget.
+    #
+    # This tag must be a child of tab_widget descriptor.
+    #
+    class Tab
+      include GuiBuilder
+      
+      class Helper
+        def initialize(parent, text)
+          @parent = parent
+          @text = text
+        end
+        
+        def add_widget(widget)
+          @parent.add_tab(widget, @text)
+        end
+      end
+      
+      def build(window, parent, desc)
+        desc.children.each do |child|
+          b = builder(child.tag).new
+          b.build(parent, Helper.new(parent, desc.opts[:text]), child)
+        end
+      end
+    end
+    
+    #
+    # A url requester widget.
+    #
+    class UrlRequester < Widget
+      def factory(desc)
+        KDE::UrlRequester
+      end
+    end
+
+    #
+    # A line edit widget.
+    #
+    class LineEdit < Widget
+      def factory(desc)
+        Qt::LineEdit
+      end
+    end
+    
+    #
+    # A combobox.
+    #
+    class ComboBox < Widget
+      def factory(desc)
+        KDE::ComboBox
+      end
+    end
+    
+    #
+    # A list widget.
+    #
+    class List < Widget
+      def factory(desc)
+        Qt::ListView
+      end
+    end
+    
+    #
+    # A checkbox.
+    #
+    # The <tt>checked</tt> property specifies whether the checkbox is checked.
+    #
+    class CheckBox < Widget
+      def factory(desc)
+        Factory.new do |parent|
+          check = Qt::CheckBox.new(parent)
+          check.text = desc.opts[:text].to_s
+          check.checked = desc.opts[:checked]
+          check
+        end
+      end
+    end
+    
+    #
+    # A push button.
+    #
+    class Button < Widget
+      def factory(desc)
+        Factory.new do |parent|
+          KDE::PushButton.new(KDE::Icon.from_theme(desc.opts[:icon]), 
+                              desc.opts[:text], parent)
+        end
+      end
+    end
+  end
+end