vr-corelib 0.0.36

data/lib/IconHash.rb

@@ -0,0 +1,22 @@
+module VR
+
+  class IconHash < Hash # :nodoc:
+  
+  	def initialize(path,width=nil,height=nil)
+  		Dir.glob(path + "/*.png").each do |f|
+  			ext = File.basename(f, ".png")
+  			if width.nil?
+  			  self[ext] = Gdk::Pixbuf.new(f)
+  			else
+  			  self[ext] = Gdk::Pixbuf.new(f,width,height)
+  			end
+  		end
+  	end
+  
+  	def get_icon(file_name)
+  		ext = File.extname(file_name).gsub(".", "")
+  		self.has_key?(ext) ? self[ext] : self["unknown"] 
+  	end
+  end
+
+end

data/lib/SimpleComboBoxEntry.rb

@@ -0,0 +1,14 @@
+
+module VR
+
+	class SimpleComboBoxEntry < Gtk::ComboBoxEntry
+		def initialize(active_choice, *choices)
+			super(true)
+			append_text(active_choice)
+			choices.each { |c|  append_text(c) if c != active_choice }
+			self.active = 0
+		end
+	end
+
+
+end

data/lib/Thread.rb

@@ -0,0 +1,59 @@
+module VR
+  class Thread
+    def self.new(*args,&block)
+      ::Thread.new(*args,&block)
+    end
+
+    def self.init
+      @@mutex = Mutex.new
+      @@pending_calls = []
+      @@running = true
+      GLib::Timeout.add(100) do
+        @@mutex.synchronize do
+          @@pending_calls.each do |closuer|
+            closuer.call
+          end
+          @@pending_calls = []
+        end
+        @@running
+      end
+    end
+    
+    def self.destroy
+      @@running = false
+    end
+    
+    def self.protect(&block)
+      if ::Thread.current == ::Thread.main
+        block.call
+      else
+        @@mutex.synchronize do
+          @@pending_calls << block
+        end
+      end
+    end
+    
+    def self.protect_call(obj,sym,*args)
+      if ::Thread.current == ::Thread.main
+        obj.__send__(sym,*args)
+      else
+        @@mutex.synchronize do
+          @@pending_calls << Proc.new do
+            obj.__send__(sym,*args)
+          end
+        end
+      end
+    end
+    
+    def self.flush
+      if @@mutex.try_lock
+        @@pending_calls.each do |closuer|
+          closuer.call
+        end
+        
+        @@pending_calls = []
+        @@mutex.unlock
+      end
+    end
+  end
+end

data/lib/Widget.rb

@@ -0,0 +1,37 @@
+module Gtk
+
+  class Widget
+  
+  	attr_accessor :dragged_widget
+  
+  	def drag_array(element = nil)
+  		@dnd ||= [] 
+  		@dnd.push(element) if not element.nil?
+  		return @dnd
+  	end
+  
+
+  	def drag_to(target_widget = self, button = Gdk::Window::BUTTON1_MASK)
+
+  		@target_widgets ||= []
+  		@target_widgets.push(target_widget)
+
+  		target = Gtk::Drag::TARGET_SAME_APP #useless
+  		action = Gdk::DragContext::ACTION_MOVE #useless
+			dest =  Gtk::Drag::DEST_DEFAULT_ALL #useless
+
+      Gtk::Drag.source_set(self, button, [ [self.object_id.to_s, target, 0] ],  action)	
+  		ar = target_widget.drag_array([ self.object_id.to_s, target, 0])
+  		Gtk::Drag.dest_set(target_widget, dest , ar , action) 
+  		if not @done
+  			@done = true
+    		self.signal_connect("drag_begin") do |widget, context|
+    			@target_widgets.each { |widg| widg.dragged_widget = self } 
+    		end				
+  		end
+  
+  	end
+  
+  end
+
+end

data/lib/treeview/FileTreeView.rb

@@ -0,0 +1,91 @@
+
+module VR
+
+class FileTreeView < TreeView # :nodoc:
+
+  unless defined? FILETREEVIEW_GTYPE
+    FILETREEVIEW_GTYPE = self.name.split(":").collect {|x| x.empty? ? nil : x}.compact.join("_")
+    type_register(FILETREEVIEW_GTYPE)
+  end
+
+	def initialize(icon_path = nil, width = nil, height = nil) #, &block)
+		super(:file => {:pix => Gdk::Pixbuf, :file_name => String}, :path => String, :modified_date => VR::DateCol, :sort_on => String)
+		col_visible( :path => false, :modified_date => false, :sort_on => false)
+		self.headers_visible = false
+		model.set_sort_column_id(id(:sort_on))
+		@icons = File.directory?(icon_path.to_s) ? VR::IconHash.new(icon_path,width,height) : nil
+  end
+
+	def get_open_folders()
+		expanded = []
+		map_expanded_rows {|view, path| expanded << model.get_iter(path)[id(:path)] }
+		return expanded
+	end
+
+	def open_folders(folder_paths)
+		collapse_all
+		model.each do |model, path, iter| 
+			if folder_paths.include?(iter[id(:path)]) 	
+				expand_row(path, false) 
+			end
+		end
+	end	
+
+	def refresh(root = Dir.pwd, glob = File.join(root, "**","*"))
+	  @root_dir = root
+		expanded_folders = get_open_folders()
+		self.model.clear
+		add_file(root, nil)
+  	Dir.glob(glob).each do |fn|
+ 			insert(fn)
+  	end
+		open_folders(expanded_folders)
+		self.expand_row(self.model.iter_first.path, false)
+	end
+
+	def insert(fn)  #fn is absolute path
+		fn.gsub!("\\", "/")
+		return if not File.exists?(fn) or get_iter_from_path(fn) or not fn.match(/^#{model.iter_first[id(:path)]}/)
+		if not parent_iter = get_iter_from_path(File.dirname(fn))
+			parent_iter = insert(File.dirname(fn))
+		end
+		return add_file(fn, parent_iter)
+	end
+	
+	def get_iter_from_path(fn)
+		model.each do | model, path, iter|
+			if iter[id(:path)] == fn 
+				return iter 
+			end
+		end 
+		return false	
+	end
+
+	def add_file(fn, parent)
+			fn.gsub!("\\", "/")
+  		child = model.append(parent)
+  		if @root_dir == fn && @icons.get_icon("x.project")
+  		  child[id(:pix)] = @icons.get_icon("x.project")
+  		else
+  		  child[id(:pix)] = @icons.get_icon(File.directory?(fn) ? "x.folder" : fn)
+  		end
+  		child[id(:file_name)] = File.basename(fn)
+  		child[id(:path)] = fn
+			child[id(:sort_on)] = (File.directory?(fn) ? "0" : "1") + child[id(:file_name)]
+			return child
+	end
+	
+
+	def folder?(iter) iter[id(:sort_on)][0,1] == "0" end
+	def file_name(iter) iter ? iter[id(:path)] : nil end
+	def get_selected_file_name() 
+		selection.selected ? selection.selected[id(:file_name)] : nil
+	end
+	def get_selected_path() (selection.selected ? selection.selected[id(:path)] : nil) end
+	def delete_selected()	self.model.remove(selection.selected) if selection.selected end
+
+end	
+
+end
+
+

data/lib/treeview/IterMethods.rb

@@ -0,0 +1,82 @@
+
+module VR
+
+#  The IterMethods module extends the GtkTreeIter class so it can work with
+#  visualruby's colum ID symbols as well as Gtk's column numbers. 
+#  
+
+module IterMethods
+
+		attr_accessor :column_keys
+		@column_keys = nil
+
+#  The [] method returns the value from the specified column in the iter:
+#  
+#   val = iter[:name]
+#  
+#  - col_id -- Either a visualruby column ID symbol, as above, or an integer.
+#  
+	
+		def [](col_id)
+			get_value(id(col_id))
+		end
+
+		def []=(col_id,val)
+			i = id(col_id)
+			set_value(i, val)
+		end
+
+#  The id() method translates visualruby's colum ID symbols into integers that
+#  GtkTreeIter can use:
+#  
+#   iter = model.append
+#   iter[id(:name)] = "Henry"
+#  
+#  Normally, its best to use VR's "rows" instead.  They will already use the column ID symbols.
+#  
+		def id(col_id) # :nodoc:
+			return (col_id.is_a? Fixnum) ? col_id : @column_keys.index(col_id)
+		end
+
+#  This will load the values of any object into the iter.  It will look at all the
+#  instance variables, methods, and ActiveRecord fields and match them to
+#  columns in a VR::ListView or VR::TreeView.  For example, if your object
+#  has an instance variable, @name, this will fill in a column with the symbol :name.
+#  
+#   class MyClass
+#     @name = "Henry"
+#   end
+#  
+#   @view = VR::ListView.new(:name => String)
+#   my = MyClass.new
+#   row = @view.add_row()
+#   row.load_object(my)  # assigns "Henry" to first cell
+#  
+#  
+#  -obj--any ruby object or object subclassed from ActiveRecord::Base.
+#  
+		def load_object(obj)
+			class_sym = obj.class.name.to_sym
+			self[class_sym] = obj if @column_keys.include?(class_sym)
+			@column_keys.each do |k|
+				begin
+				self[k] = obj.send(k) if obj.respond_to?(k.to_s)
+				rescue
+				end
+			end
+			keys = @column_keys.inject([]) { |ar, e| ar << e.to_s }
+			matches = obj.attributes.keys & keys if obj.attributes.is_a? Hash
+			matches.each do |field| 
+				begin
+				self[field.to_sym] = obj.attributes[field] 
+				rescue
+				end
+			end 
+			obj.instance_variables.each do |name|
+				self[name] = instance_variable_get(name) if @column_keys.include?(name) 
+			end
+		end
+	
+
+end
+end

data/lib/treeview/ListView.rb

@@ -0,0 +1,90 @@
+module VR
+
+
+  class ListView < Gtk::TreeView
+
+  unless defined? LISTVIEW_GTYPE
+    LISTVIEW_GTYPE = self.name.split(":").collect {|x| x.empty? ? nil : x}.compact.join("_")
+    type_register(LISTVIEW_GTYPE)
+  end
+
+  	include ViewCommon
+
+#The new() constructor takes a Hash that defines the columns as its only argument.  The Hash defines
+#symbols as the keys to give an ID to each column.  The Hash also defines the type (class) of the column.
+#A simple constructor looks like this:
+#
+# @view = VR::ListView.new(:name => String, :date => DateTime)
+#
+#You can create columns with any type of data including your own classes, and classes subclassed
+#from ActiveRecordBase.  The common types that are included by default are:
+#
+#- String - Displays and edits as a String.
+#- Integer - Displays number, edits like a String.
+#- FixNum - ditto
+#- Integer - ditto
+#- Float - ditto
+#- DateTime - Displays in a default date format(editable), edits like a String
+#- TrueClass - Displays as a GtkCheckButton, click checkbox to edit
+#- GdkPixbuf - Just an Image, uneditable
+#- VR::CalendarCol - Displays in a default date format(editable), calendar window to edit.
+#- VR::SpinCol - Displays as a number with default number of digits, edits like a GtkSpinButton
+#- VR::ComboCol - Displays String, edits like a GtkComboBoxEntry
+#- VR::ProgressCol - Displays a GtkProgressBar, uneditable
+#- VR::TextCol - For long strings.  Displays first 20 characters in view, edits with simple text editor.
+#
+#You can also add your own user-defined column types.  See: {Adding Your Own Objects to ListView}[link:/site/ListView%20Tutorial.html#objects].
+#
+
+    def initialize(cls)
+    	super()
+      hash = flatten_hash(cls)
+      vals = hash.values
+    	self.model = Gtk::ListStore.new(*vals)
+    	load_columns(cls)
+    end
+
+		def add_active_record_rows(ar) # :nodoc:
+			ar.each do |obj|
+				row = add_row()
+				matches = obj.attributes.keys & @column_keys #intersection
+				matches.each { |field| row[field] = obj.attributes[field] }   
+			end
+		end
+
+  	def []( row )	# :nodoc:
+  		model.get_iter(Gtk::TreePath.new("#{row}"))
+  	end
+  
+  	def []( row, col )	# :nodoc:
+  		model.get_iter(Gtk::TreePath.new("#{row}"))[col]
+  	end
+
+#This method will select a given row number.  The row will be hilighted, and the
+#GtkSelection object will point to that row.  It uses the GtkTreeView#set_cursor
+#method to move the cursor to the specified row.
+#
+#- row_number:  Integer (FixNum)
+#
+
+		def select_row(row_number = 0)
+			set_cursor(Gtk::TreePath.new(row_number), nil, false)
+		end  
+
+#This will add a row to the data model, and fill-in the values from a Hash.
+#This example would add a row to the model and set the name and email fields:
+#
+# @view.add_row(:name => "Chester", :email => "chester@chester.com")
+#
+#
+#- hash: A ruby Hash object with pairs of column ISs (symbols) and values.
+
+  	def add_row(hash = {})
+			row = vr_row(model.append)
+			hash.each_pair { |key, val| row[key] = val }
+  		return row
+  	end
+  
+  end
+
+ end

data/lib/treeview/ModelRow.rb

@@ -0,0 +1,31 @@
+#module VR
+#
+#	class VR::TreeIter < Gtk::TreeIter
+#
+#		def initialize(iter, keys)
+#			self = iter
+#			@keys = keys
+#		end
+#
+#		def [](id)
+#			super[id_to_int(id)]
+#		end
+#
+#		def []=(id,val)
+#			i = id_to_int(id)
+#			super[i] = val
+#		end
+#
+#		def id_to_int(id)
+#			return (id.is_a? Fixnum or id.is_a? Integer) ? id : @keys.index(id)
+#		end
+#	
+#		def load_object(obj)
+#			@keys.each do |k|
+#				super[id_to_int(k)] = obj.send(k) if obj.respond_to(k.to_s)
+#			end
+#		end
+#
+#	end
+#
+#end

data/lib/treeview/TreeIter.rb

@@ -0,0 +1,33 @@
+#module VR
+#
+#	class TreeIter  < Gtk::TreeIter
+#
+#		attr_accessor :keys
+#
+#		def initialize(iter, keys)
+#  		@keys = keys
+#  		super()
+#		end
+#
+#		def [](id)
+#			super[id_to_int(id)]
+#		end
+#
+#		def []=(id,val)
+#			i = id_to_int(id)
+#			super[i] = val
+#		end
+#
+#		def id_to_int(id)
+#			return (id.is_a? Fixnum or id.is_a? Integer) ? id : @keys.index(id)
+#		end
+#	
+#		def load_object(obj)
+#			@keys.each do |k|
+#				super[id_to_int(k)] = obj.send(k) if obj.respond_to(k.to_s)
+#			end
+#		end
+#
+#	end
+#
+#end