qtbindings 4.6.3.4 → 4.8.3.0

data/examples/draganddrop/dropsite/dropsitewidget.rb

@@ -39,7 +39,7 @@ class DropArea < Qt::Label
 	    setAlignment(Qt::AlignCenter)
 	    setAcceptDrops(true)
 	    setAutoFillBackground(true)
-        clear()
+      clear()
 	end
 	
 	def dragEnterEvent(event)
@@ -50,28 +50,29 @@ class DropArea < Qt::Label
 #	    emit changed(event.mimeData())
 	end
 	
-    def dragMoveEvent(event)
-	    event.acceptProposedAction()
-    end
+  def dragMoveEvent(event)
+      event.acceptProposedAction()
+  end
 
 	def dropEvent(event)
 	    mimeData = event.mimeData()
-        if mimeData.hasText
+      if mimeData.hasText
             setText(mimeData.text())
             setTextFormat(Qt::PlainText)
 	    end
 
-
 	    formats = mimeData.formats()
 	    formats.each do |format|
-	        if format.startsWith("image/")
-	            pixmap = createPixmap(mimeData.data(format), format)
+	        if format.start_with?("image/")
+	            pixmap = Qt::Pixmap.new
+	            pixmap.loadFromData(mimeData.data(format), format)
 	            if !pixmap.nil?
 	                setPixmap(pixmap)
 	                break
 	            end
 	        end
-	        text = createPlainText(mimeData.data(format), format)
+	        #text = createPlainText(mimeData.data(format), format)
+	        text = mimeData.data(format).to_s
 	        if !text.empty?
 	            setText(text)
 	            break

data/examples/mainwindows/mdi/mainwindow.rb

@@ -84,7 +84,7 @@ class MainWindow < Qt::MainWindow
         if !fileName.nil?
             existing = findMdiChild(fileName)
             if !existing.nil?
-                @mdiArea.activeSubWindow = existing
+                @mdiArea.setActiveSubWindow(existing)
                 return
             end
     
@@ -352,10 +352,10 @@ class MainWindow < Qt::MainWindow
     def findMdiChild(fileName)
         canonicalFilePath = Qt::FileInfo.new(fileName).canonicalFilePath()
 
-        @mdiArea.windowList().each do |window|
-            mdiChild = window
+        @mdiArea.subWindowList().each do |window|
+            mdiChild = window.widget
             if mdiChild.currentFile() == canonicalFilePath
-                return mdiChild
+                return window
             end
         end
         return nil

data/examples/network/broadcastsender/sender.rb

@@ -63,7 +63,9 @@ class Sender < Qt::Dialog
 	def broadcastDatagram()
 	    @statusLabel.text = tr("Now broadcasting datagram %d" % @messageNo)
 	    datagram = Qt::ByteArray.new("Broadcast message %d" % @messageNo)
-	    @udpSocket.writeDatagram(datagram.data(), datagram.size(),
+	    @udpSocket.writeDatagram(datagram,
+	    # method_missing with this syntax
+	    #@udpSocket.writeDatagram(datagram.data(), datagram.size(),
 	                             Qt::HostAddress.new(Qt::HostAddress::Broadcast), 45454)
 	    @messageNo += 1
 	end

data/examples/qtscribble/scribble.rb

@@ -0,0 +1,270 @@
+#!/usr/bin/env ruby -w
+
+ #
+ # A class that lets the user draw with the mouse. The
+ # window knows how to redraw itself.
+ #
+
+require 'Qt'
+	
+	class ScribbleArea < Qt::Widget
+	
+		slots "setColor(QColor)", "slotLoad(const QString&)", "slotSave(const QString&)", "slotClearArea()"
+
+		  #
+		  # The constructor. Initializes the member variables.
+		  #
+		def initialize(parent)
+			super(parent)
+			# initialize member variables
+			@_buffer = Qt::Pixmap.new()
+			@_last = Qt::Point.new()
+			@_currentcolor = Qt::black
+			
+			# don't blank the window before repainting
+			setAttribute( Qt::WA_NoBackground )
+			
+			# create a pop-up menu
+			@_popupmenu = Qt::Menu.new()
+			@_popupmenu.addAction( "&Clear", self, SLOT( "slotClearArea()" ) )
+		end
+		
+		  #
+		  # This slot sets the curren color for the scribble area. It will be
+		  # connected with the colorChanged( Qt::Color ) signal from the
+		  # ScribbleWindow.
+		  #
+		def setColor( new_color )
+			@_currentcolor = new_color
+		end
+		
+		 #
+		 # This slot clears the drawing area by filling the off-screen buffer with
+		 # white and copying it over to the window.
+		 #
+		def slotClearArea()
+			# fill the off screen buffer with plain white
+			@_buffer.fill( white )
+			
+			# and copy it over to the window
+			bitBlt( self, 0, 0, @_buffer )
+		end
+		
+		
+		  #
+		  # This method does the actual loading. It relies on Qt::Pixmap (and the
+		  # underlying I/O machinery) to determine the filetype.
+		  #
+		def slotLoad( filename )
+			if !@_buffer.load( filename )
+				Qt::MessageBox.warning( nil, "Load error", "Could not load file" )
+			end
+				
+			repaint()  # refresh the window
+		end
+		
+		
+		  #
+		 # This method does the actual saving. We hard-code the file type as
+		 # BMP. Unix users might want to replace this with something like XPM.
+		 #
+		def slotSave( filename )
+			if !@_buffer.save( filename, "BMP" )
+				Qt::MessageBox.warning( nil, "Save error", "Could not save file" )
+			end
+		end
+		
+		
+		  #
+		  # This method is called whenever the user presses the
+		  # mouse over the window. It just records the position of the mouse
+		  # at the time of the click.
+		  #
+		def mousePressEvent(event)
+			if event.button() == RightButton
+				@_popupmenu.exec( Qt::Cursor.pos() )
+			else
+				@_last = event.pos()	# retrieve the coordinates from the event
+			end
+		end
+		
+		
+		  #
+		  # The method is called whenever the usr moves the mouse
+		  # while the mouse button is pressed. If we had called
+		  # setMouseTracking(true) before, the method would also be called
+		  # when the mouse was moved with any button pressed. We know that
+		  # we haven't, and thus don't have to check whether any buttons are
+		  # pressed.
+		  #
+		def mouseMoveEvent(event)
+			# create a Qt::Painter object for drawing onto the window
+			windowpainter = Qt::Painter.new()
+			# and another Qt::Painter object for drawing int an off-screen pixmap
+			bufferpainter = Qt::Painter.new()
+			
+			# start painting
+			windowpainter.begin( self ) # This painter paints onto the window
+			bufferpainter.begin( @_buffer )  # and this one paints in the buffer
+		
+			# set a standard pen with the currently selected color
+			windowpainter.setPen( @_currentcolor )
+			bufferpainter.setPen( @_currentcolor )
+		
+			# draw a line in both the window and the buffer
+			windowpainter.drawLine( @_last, event.pos() )
+			bufferpainter.drawLine( @_last, event.pos() )
+		
+			# done with painting
+			windowpainter.end()
+			bufferpainter.end()
+		
+			# remember the current mouse position
+			@_last = event.pos()						
+		end
+		
+		  #
+		  # This method is called whenever the widget needs
+		  # painting, for example when it has been obscured and then revealed again.
+		  #
+		def paintEvent(event)
+			bitBlt(self, 0, 0, @_buffer)
+		end
+	
+		  #
+		  # This method get called whenever the widget needs
+		  # painting, for example, when it has been obscured and then revealed again.
+		  #
+		def resizeEvent(event)
+			save = Qt::Pixmap.new( @_buffer )
+			@_buffer = save.scaled(event.size.width, event.size.height)
+			@_buffer.fill( Qt::Color.new(Qt::white) )
+			drawPixmap( @_buffer, 0, 0, save )
+		end
+	end
+
+class ScribbleWindow < Qt::Widget
+
+	slots "slotAbout()", "slotAboutQt()", "slotColorMenu(int)", "slotLoad()", "slotSave()"
+	signals "colorChanged(QColor)", "load(const QString&)", "save(const QString&)"
+	
+	COLOR_MENU_ID_BLACK = 0
+	COLOR_MENU_ID_RED = 1
+	COLOR_MENU_ID_BLUE = 2
+	COLOR_MENU_ID_GREEN = 3
+	COLOR_MENU_ID_YELLOW = 4
+	
+	def initialize()
+		super
+		# The next lines build the menu bar. We first create the menus
+		# one by one, then add them to the menu bar. #
+		@_menubar = Qt::MenuBar.new( self )  # create a menu bar
+
+		@_filemenu = @_menubar.addMenu( "&File" )  # create a file menu
+		@_filemenu.addAction( "&Load", self, SLOT( "slotLoad()" ) )
+		@_filemenu.addAction( "&Save", self, SLOT( "slotSave()" ) )
+		@_filemenu.addSeparator()
+		@_filemenu.addAction( "&Quit", $qApp, SLOT( "quit()" ) )
+		
+		@_colormenu = @_menubar.addMenu( "&Color" ) # create a color menu
+#		@_colormenu.addAction( "B&lack", COLOR_MENU_ID_BLACK)
+#		@_colormenu.addAction( "&Red", COLOR_MENU_ID_RED)
+#		@_colormenu.addAction( "&Blue", COLOR_MENU_ID_BLUE)
+#		@_colormenu.addAction( "&Green", COLOR_MENU_ID_GREEN)
+#		@_colormenu.addAction( "&Yellow", COLOR_MENU_ID_YELLOW)
+#		Qt::Object.connect( @_colormenu, SIGNAL( "activated( int )" ),
+#						 self, SLOT( "slotColorMenu( int )" ) )
+						
+		@_helpmenu = @_menubar.addMenu( "&Help" )  # create a help menu
+		@_helpmenu.addAction( "&About QtScribble", self, SLOT( "slotAbout()" ) )
+		@_helpmenu.addAction( "&About Qt", self, SLOT( "slotAboutQt()" ) )
+		
+		 # We create a Qt::ScrollView and a ScribbleArea. The ScribbleArea will
+		 # be managed by the scroll view.#
+		@_scrollview = Qt::ScrollArea.new( self )
+		@_scrollview.setGeometry( 0, @_menubar.height(),
+		 							width(), height() - @_menubar.height() )
+		@_scribblearea = ScribbleArea.new( @_scrollview )
+		@_scribblearea.setGeometry( 0, 0, 1000, 1000 )
+#		@_scrollview.addChild( @_scribblearea )
+		Qt::Object.connect( self, SIGNAL( "colorChanged(QColor)" ),
+						 @_scribblearea, SLOT( "setColor(QColor)" ) )
+		Qt::Object.connect( self, SIGNAL( "save(const QString&)" ),
+						 @_scribblearea, SLOT( "slotSave(const QString&)" ) )
+		Qt::Object.connect( self, SIGNAL( "load(const QString&)" ),
+						 @_scribblearea, SLOT( "slotLoad(const QString&)" ) )
+	end
+	
+	def resizeEvent( event )
+		 # When the whole window is resized, we have to rearrange the geometry
+		 # in the ScribbleWindow as well. Note that the ScribbleArea does not need
+		 # to be changed.
+		 @_scrollview.setGeometry( 0, @_menubar.height(),
+		 							width(), height() - @_menubar.height() )
+	end
+
+	
+	
+	def slotAbout()
+		Qt::MessageBox.information( self, "About QtScribble 5",
+										"This is the Scribble 5 application\n" +
+										"Copyright 1998 by Mathias Kalle Dalheimer\n")
+	end
+	
+	def slotAboutQt()
+		Qt::MessageBox.aboutQt( self, "About Qt" )
+	end
+	
+	def slotColorMenu( item )
+		case item
+			when COLOR_MENU_ID_BLACK
+				emit colorChanged( black )
+			when COLOR_MENU_ID_RED
+				emit colorChanged( darkRed )
+			when COLOR_MENU_ID_BLUE
+				emit colorChanged( darkBlue )
+			when COLOR_MENU_ID_GREEN
+				emit colorChanged( darkGreen )
+			when COLOR_MENU_ID_YELLOW
+				emit colorChanged( yellow )
+		end
+	end
+	
+	
+	  #
+	  # This is the slot for the menu item File/Load. It opens a
+	  # Qt::FileDialog to ask the user for a filename, then emits a save()
+	  # signal with the filename as parameter.
+	  #
+	def slotLoad()
+		 # Open a file dialog for loading. The default directory is the
+		 # current directory, the filter *.bmp.
+		 #
+		filename = Qt::FileDialog.getOpenFileName( ".", "*.bmp", self )
+		if !filename.nil?
+			emit load( filename )
+		end
+	end
+	
+	  #
+	  # This is the slot for the menu item File/Load. It opens a
+	  # Qt::FileDialog to ask the user for a filename, then emits a save()
+	  # signal with the filename as parameter.
+	  #
+	def slotSave()
+		 # Open a file dialog for saving. The default directory is the
+		 # current directory, the filter *.bmp.
+		 #
+		filename = Qt::FileDialog.getSaveFileName( ".", "*.bmp", self )
+		if !filename.nil?
+			emit save( filename )
+		end
+	end
+end
+	
+myapp = Qt::Application.new(ARGV)
+mywidget = ScribbleWindow.new()
+mywidget.setGeometry(50, 500, 400, 400)
+
+mywidget.show()
+myapp.exec()

data/examples/ruboids/LICENSE.txt

@@ -0,0 +1,58 @@
+Ruby is copyrighted free software by Yukihiro Matsumoto <matz@netlab.co.jp>.
+You can redistribute it and/or modify it under either the terms of the GPL
+(see COPYING.txt file), or the conditions below:
+
+  1. You may make and give away verbatim copies of the source form of the
+     software without restriction, provided that you duplicate all of the
+     original copyright notices and associated disclaimers.
+
+  2. You may modify your copy of the software in any way, provided that
+     you do at least ONE of the following:
+
+       a) place your modifications in the Public Domain or otherwise
+          make them Freely Available, such as by posting said
+	  modifications to Usenet or an equivalent medium, or by allowing
+	  the author to include your modifications in the software.
+
+       b) use the modified software only within your corporation or
+          organization.
+
+       c) rename any non-standard executables so the names do not conflict
+	  with standard executables, which must also be provided.
+
+       d) make other distribution arrangements with the author.
+
+  3. You may distribute the software in object code or executable
+     form, provided that you do at least ONE of the following:
+
+       a) distribute the executables and library files of the software,
+	  together with instructions (in the manual page or equivalent)
+	  on where to get the original distribution.
+
+       b) accompany the distribution with the machine-readable source of
+	  the software.
+
+       c) give non-standard executables non-standard names, with
+          instructions on where to get the original software distribution.
+
+       d) make other distribution arrangements with the author.
+
+  4. You may modify and include the part of the software into any other
+     software (possibly commercial).  But some files in the distribution
+     are not written by the author, so that they are not under this terms.
+
+     They are gc.c(partly), utils.c(partly), regex.[ch], st.[ch] and some
+     files under the ./missing directory.  See each file for the copying
+     condition.
+
+  5. The scripts and library files supplied as input to or produced as 
+     output from the software do not automatically fall under the
+     copyright of the software, but belong to whomever generated them, 
+     and may be sold commercially, and may be aggregated with this
+     software.
+
+  6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
+     IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+     PURPOSE.
+

data/examples/run_all.rb

@@ -5,6 +5,7 @@ windows = true if platform == 'mswin32' or platform == 'mingw32'
 files = Dir["**/main.rb"]
 files.each do |file|
   if windows
+    next if file.include?('qdbus') # because qdbus is Unix only
     command = "cd #{File.dirname(file).gsub('/', '\\')} && ruby -rubygems #{File.basename(file)}"
   else
     command = "cd #{File.dirname(file)} && ruby -rubygems #{File.basename(file)}"

data/examples/textedit/textedit.rb

@@ -0,0 +1,150 @@
+#!/usr/bin/ruby -w
+
+require 'Qt'
+require 'rexml/document'
+
+require '../base/rui.rb'
+
+class MyTextEditor < Qt::TextEdit
+   signals 'saved()'
+   slots 'insert_icon()', 'new()', 'open()', 'save_as()'
+   def initialize(w = nil)
+      @images = {}
+      @@next_image_id = 0
+      super(w)
+      self.setTextFormat(Qt::RichText)
+   end
+   def insert_richtext(richtext)
+      # todo, use a rand string
+      unique_string = '000___xxx123456789xxx___xxx123456789xxx___000'
+      insert(unique_string)
+      txt = self.text().gsub(unique_string, richtext)
+      self.setText(txt)
+   end
+   def next_image_id
+      @@next_image_id += 1
+   end
+   def load_image(fname, image_id)
+      pixmap = Qt::Pixmap.new(fname)
+      msfactory = Qt::MimeSourceFactory.defaultFactory
+      msfactory.setPixmap(image_id, pixmap)
+      @images[image_id] = fname
+      image_id
+   end
+   def insert_icon
+      fname = Qt::FileDialog.getOpenFileName
+      return if fname.nil?
+      image_id = "image_#{next_image_id}"
+      load_image(fname, image_id)
+      insert_richtext('<qt><img source="'+image_id+'"></qt>')
+   end
+   def createPopupMenu(pos) # virtual
+      pm = Qt::PopupMenu.new
+      pm.insertItem("Insert Image!", self, SLOT('insert_icon()'))
+      pm
+   end
+   def has_metadata
+      !@images.empty?
+   end
+   def metadata_fname(fname)
+      "#{fname}.metadata.xml"
+   end
+   def attempt_metadata_load(fname)
+      return unless File.exists?(metadata_fname(fname))
+      file = File.open(metadata_fname(fname))
+      @xmldoc = REXML::Document.new file
+      @xmldoc.root.elements.each("image") {
+         |image|
+         image_id = image.attributes["ident"]
+         img_fname = image.attributes["filename"]
+         load_image(img_fname, image_id)
+      }
+   end
+   def metadata_save_if_has(fname)
+      return if not has_metadata
+      metadata_doc = REXML::Document.new '<metadata/>'
+      @images.each {
+         |id, img_fname|
+         metadata_doc.root.add_element("image", {"filename"=>img_fname, "ident"=>id})
+      }
+      file = File.new(metadata_fname(fname), "w")
+      file.puts(metadata_doc)
+      file.close
+   end
+   def metadata_clear
+      @images = {}
+   end
+   def new(txt = "")
+      metadata_clear
+      self.setText(txt)
+   end
+   def open
+      fname = Qt::FileDialog.getOpenFileName
+      return if fname.nil?
+      unless File.exists?(fname)
+         Qt::MessageBox.critical(self, "File Does Not Exist", "Sorry, unable to find the requested file!")
+         return
+      end
+      return if fname.nil?
+      txt = File.open(fname).gets(nil)
+      metadata_clear
+      attempt_metadata_load(fname)
+      self.setText(txt)
+   end
+   def save_as
+      fname = Qt::FileDialog.getSaveFileName
+      return if fname.nil?
+      if File.exists?(fname)
+         Qt::MessageBox.critical(self, "File Already Exists", "Sorry, file already exists. Please choose a non-existing filename!")
+         return save_as
+      end
+      file = File.new(fname, "w")
+      file.puts(text())
+      file.close
+      metadata_save_if_has(fname)
+      emit saved()
+   end
+end
+
+class MyWidget < Qt::MainWindow
+   slots 'text_changed()', 'saved()'
+   def initialize()
+      super
+      @editor = MyTextEditor.new(self)
+      connect(@editor, SIGNAL('textChanged()'), self, SLOT('text_changed()'))
+      connect(@editor, SIGNAL('saved()'), self, SLOT('saved()'))
+
+      fileTools = Qt::ToolBar.new(self, "file operations")
+      fileMenu = Qt::PopupMenu.new(self)
+
+      actions = [
+         RAction.new("&New",  Icons::FILE_NEW, @editor, SLOT('new()'), [fileTools, fileMenu]),
+         RAction.new("&Open...", Icons::FILE_OPEN, @editor, SLOT('open()'), [fileTools, fileMenu]),
+         @save = RAction.new("Save &As...", Icons::FILE_SAVE_AS, @editor, SLOT('save_as()'), [fileTools, fileMenu]),
+         RSeperator.new([fileMenu]),
+         RAction.new("E&xit", Icons::EXIT, $qApp, SLOT('quit()'), [fileMenu])
+      ]
+
+      build_actions(actions)
+
+      menubar = Qt::MenuBar.new(self)
+      menubar.insertItem("&File", fileMenu)
+
+      self.setCentralWidget(@editor)
+   end
+   def saved
+      @save.action.setEnabled(false)
+   end
+   def text_changed
+      @save.action.setEnabled(true)
+   end
+end
+
+a = Qt::Application.new(ARGV)
+
+w = MyWidget.new
+w.show
+
+a.setMainWidget(w)
+a.exec()
+exit