Languages/Ruby

cleanup

   Qt::Widget.new do

       self.window_title = 'Hello QtRuby v1.0'
       resize(200, 100)
   
       button = Qt::PushButton.new('Quit') do
           connect(SIGNAL :clicked) { Qt::Application.instance.quit }
       end

       label = Qt::Label.new('Hello Qt in the Ruby way!')
       
       self.layout = Qt::VBoxLayout.new do
           add_widget(label, 0, Qt::AlignCenter)
           add_widget(button, 0, Qt::AlignRight)
       end
       
       show
   end
   
   exec

                 self, SLOT( "slotColorMenu(int)" ) )

   def initialize(value)
       super()
       @value = value
   end

   attr_accessor :value

   def to_variant
       Qt::RubyVariant.new self
   end

   signals "mySignal(QVariant)"
   def doEmit
       # since KDE 4.5:
       # emit mySignal(Qt::Variant.fromValue(ruby_object))
       emit mySignal(ruby_object.to_variant)
   end

   slots "mySlot(QVariant)"
   def mySlot(variant)
       ruby_object = variant.value
   end

   def to_variant
       Qt::Variant.new object_id
   end

   def to_object
       ObjectSpace._id2ref to_int
   end

                   Qt::Font.new("Helvetica [Cronyx]", 10), 
                   self)

      classname    == QApplication
      :: method == loadLibrary$
      -> methodIds == []
      candidate list:
      Possible prototypes:
          static QWidget* QApplication::widgetAt(int, int, bool)
			...

   a = Qt::Application.new(ARGV)
   w = MainForm.new
   w.show
   a.exec

      $ ruby mainform.rb

   about = KDE::AboutData.new("knotifywidgetbase", 
		                       "KNotifyWidgetBase", "0.1")
   KDE::CmdLineArgs.init(ARGV, about)
   a = KDE::Application.new()
   w = KNotifyWidgetBase.new
   w.show
   a.exec

      require 'Qt4'
      require 'quiloader'

      a = Qt::Application.new(ARGV)
      if ARGV.length == 0
        exit
      end

      if ARGV.length == 2
        QUI::WidgetFactory.loadImages ARGV[0]
        w = QUI::WidgetFactory.create ARGV[1]
        if w.nil?
          exit
        end
        w.show()
        a.connect(a, SIGNAL('lastWindowClosed()'), a, SLOT('quit()'))
        a.exec()
      end

      require 'Qt4'
      require 'qtuitools'

      a = Qt::Application.new(ARGV)
      if ARGV.length == 0
        exit
      end

      if ARGV.length == 1
        file = Qt::File.new(ARGV[0])
        file.open(Qt::File::ReadOnly)

        loader = Qt::UiLoader.new
        window = loader.load(file, nil)
        file.close

        if (window.nil?)
          print "Error. Window is nil.\n"
          exit
        end
        window.show
        a.connect(a, SIGNAL('lastWindowClosed()'), a, SLOT('quit()'))
        a.exec
      end

   it "Should Implement QAbstractTableModel" do
       CardModel.ancestors.should include Qt::AbstractTableModel
   end

   it "Should Not Be Editable" do
       @model.data(mock_index(1,2), Qt::EditRole).should_not be_valid
       @model.headerData(nil, nil, Qt::EditRole).should_not be_valid
       
       flags = @model.flags(nil)
       flags.should have_flag Qt::ItemIsEnabled
       flags.should have_flag Qt::ItemIsSelectable
       flags.should_not have_flag Qt::ItemIsEditable
   end

   it "Should not return any vertical headers" do
       @model.headerData(1, Qt::Vertical).should_not be_valid
   end

   it "Should color a row according to the status" do
       @model.data(mock_index(1,2), Qt::ForegroundRole).value.color.should == Qt::Color.new(Qt::red)
       @model.data(mock_index(0,2), Qt::ForegroundRole).value.color.should == Qt::Color.new(Qt::green)
       @model.data(mock_index(0,0), Qt::ForegroundRole).should_not be_valid
   end

   def mock_index(row, col)
       stub(:row => row, :column => col)
   end

   def have_flag(flag)
       return simple_matcher("A flag that matches " + flag.to_s) { |given| (given & flag) != 0 }
   end

   def self.create(*args, &block)
       Class.new(self).new(*args, &block)
   end

   def count(name)
       @calls[name].size
   end

   def params(name, invocation = 0)
       @calls[name][invocation]
   end

   def method_missing(name, *args, &block)
       @calls[name.to_sym] << args
       exec_action_for(name, args)
   end

   def responds_to?(name)
       true
   end

 private
   def initialize
       @calls = {}
       def @calls.[](index)
           super || self[index] = []
       end
       @actions = {}
       super
   end

   def mocked_slots(*names, &block)
       slots *names
       names.each { |name| @actions[name] = block }
   end

   def exec_action_for(name, args)
       @actions[name].call(self, args) if @actions[name]
   end

   def slots(*args)
       self.class.slots(*args)
   end

     it "Should be able to emit a signal when called" do
       reciever = RubySignalSpy.create do
           slots "recieved(int, int)"                      # Explicitly name slots with parameters
           mocked_slot :some_other_slot do |spy, params|   # Pass a block to be executed when called
           end                                             # You must call mocked_slot with a symbol
       end

       class ClassWeAreTesting < Qt::Object
           signals "sending(int, int)"
           def broadcast
               emit sending(4, 2)
           end
       end

       sender = ClassWeAreTesting.new

       Qt::Object.connect(sender, SIGNAL("sending(int, int)"), reciever, SLOT("recieved(int, int)"))
       sender.broadcast
       reciever.count(:recieved).should == 1               # Get count of calls
       reciever.params(:recieved, 0).should == [4, 2]      # Get the parameters of nth invocation
   end

   before(:all) do
       @app = Qt::Application.new(ARGV)
       @view = SomeTableView.new
   end

   it "Should accept a mouse click on second row"        
       @row2 = @view.rowViewportPosition 1
       @view.mousePressEvent(Qt::MouseEvent.new(Qt::Event::MouseButtonPress, Qt::Point.new(0,@row2), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier))
       # Assert something here, such as that a signal has been emitted
   end

   after(:all) do
       @app.dispose!
   end

#qtruby
#kde-ruby

Languages/Ruby

Development/Languages/Ruby

QtRuby

Current api coverage overview

Available calls

Virtual methods

Properties

Use either CamelCase or lowercase with underscore naming

Operator overloading

Declare signals and slots

Emitting Ruby Classes

Alternate way to emit Ruby Classes

Constructors

Garbage Collection

C++ 'int*' and 'int&' argument types

C++ 'bool*' and 'bool&' argument types

C++ (const )(unsigned )char* argument types

C++ unsigned char* functions

Debugging

String i18n

Other capabilities and offerings

Qt Designer

Loading .ui files at runtime with Qt::UILoader

API reference

Example programs

Writing Unit Tests

Testing Out Signals and Slots

Testing UI Classes

KDE Specific Infomation

Build dependencies

Tutorials

Download

More help

More information