Languages/Ruby: Difference between revisions

#!/usr/bin/ruby -w
require 'Qt4'
a = Qt::Application.new(ARGV)
hello = Qt::PushButton.new("Hello World!")
hello.resize(100, 30)
hello.show
a.exec

require 'Qt4'

Qt::Application.new(ARGV) do
    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('<big>Hello Qt in the Ruby way!</big>')

        self.layout = Qt::VBoxLayout.new do
            add_widget(label, 0, Qt::AlignCenter)
            add_widget(button, 0, Qt::AlignRight)
        end

        show
    end

    exec
end

create_standard_status_bar_action()
createStandardStatusBarAction()

p1 = Qt::Point.new(5,5)   => (5, 5)
p2 = Qt::Point.new(20,20) => (20, 20)
p1 + p2                   => (25, 25)

slots 'setColor(QColor)', 'slotLoad(const QString&)'..
signals 'clicked()'..

slots :slotLoad
signals :clicked

Qt::Object.connect( @colormenu, SIGNAL( "activated(int)" ),
                  self, SLOT( "slotColorMenu(int)" ) )

connect(:mysig, mytarget, :mymethod))
connect(SIGNAL('mysignal(int)'), mytarget, :mymethod))

quit_button.connect(SIGNAL :clicked) { $qApp.quit }

emit colorChanged( black )

class Qt::RubyVariant < Qt::Variant
    def initialize(value)
        super()
        @value = value
    end

    attr_accessor :value
end

class Object
    def to_variant
        Qt::RubyVariant.new self
    end
end

variant = Qt::Variant.fromValue(my_ruby_object)

class MyObject < Qt::Object
    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
end

class Object
    def to_variant
        Qt::Variant.new object_id
    end
end

class Qt::Variant
    def to_object
        ObjectSpace._id2ref to_int
    end
end

quit = Qt::PushButton.new("Quit", self, "quit")

w = MyWidget.new { setCaption("foobar") }

w = MyWidget.new(nil) { setCaption("foobar") }

w = MyWidget.new { |theWidget| theWidget.setCaption "foobar" }

item2.dispose
if item2.disposed?
puts "item2 is disposed"
end

# static Ptr findByFileContent( const QString &fileName, 
#                               int *accuracy=0 );

acc = Qt::Integer.new(0)
fc = KDE::MimeType.findByFileContent("mimetype.rb", acc)

# QFont getFont(bool * ok, const QFont&initial, 
#               QWidget* parent = 0, const char *name = 0);		

ok = Qt::Boolean.new
font = Qt::FontDialog.getFont(ok, 
                    Qt::Font.new("Helvetica [Cronyx]", 10), 
                    self)
if !ok.nil? 
# font is set to the font the user selected
else 
# the user canceled the dialog
end

a = Qt::Application.new(ARGV)
Qt.debug_level = Qt::DebugLevel::High
a.loadLibrary("foo")  # Non existent method

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

Qt::Internal::setDebug(Qt::QtDebugChannel::QTDB_VIRTUAL)

Qt::Internal::setDebug(Qt::QtDebugChannel::QTDB_GC)

$ rbuic mainform.ui -x -o mainform.rb

if $0 == __FILE__
    a = Qt::Application.new(ARGV)
    w = MainForm.new
    w.show
    a.exec
end

      $ ruby mainform.rb

$ rbuic4 -x -kde knotifywidgetbase.ui -o knotifywidgetbase.rb

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

require 'Qt4'
require 'qtuitools'

class MyApp < Qt::Application
    def initialize
        super ARGV

        # 'gui.ui' was created with qt designer ('designer' on arch linux)
        file = Qt::File.new 'gui.ui' do
            open Qt::File::ReadOnly
        end

        window = Qt::UiLoader.new.load file

        file.close

        if window.nil?
            print "Error. Window is nil.\n"
            exit
        end 
        window.show
    end
end

a = MyApp.new
a.exec

$ rbqtapi Qt::TextEdit

$ rbqtapi -rsetCaption

describe CardModel do
    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
end

class RubySignalSpy < Qt::Object
    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
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

describe SomeTableView do
    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
end

require 'Qt4'

require 'korundum4'

$ rbkdeapi KDE::Action

#qtruby
#kde-ruby

@@ Line 1: / Line 1: @@
+{{Archived}}
+{{Note|The information below applies to older versions of Qt only. There are currently no Ruby bindings for Qt 5 and KDE Frameworks 5 available.}}
 {{Warning|Some important links are non-functional, specially the official Korundum page. Until we solve this problem you can find the source code at [https://projects.kde.org/projects/kde/kdebindings/ruby kdebindings project page]}}

Languages/Ruby: Difference between revisions

Latest revision as of 14:15, 31 May 2019

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