visualruby 1.0.19 → 3.0.2

data/vrlib/lib/treeview/FileTreeView.rb

@@ -0,0 +1,113 @@
+
+module VR
+
+  class FileTreeView < VR::TreeView # :nodoc:
+  
+  	include GladeGUI
+  
+  	attr_accessor :root, :glob, :test_block
+  
+  	def initialize(root = Dir.pwd, icon_path = nil, glob = "*")
+      @root = root
+      @glob = glob
+      super(:file => {:pix => Gdk::Pixbuf, :file_name => String}, :empty => TrueClass, :path => String, :modified_date => VR::DateCol, :sort_on => String)
+      col_visible( :path => false, :modified_date => false, :sort_on => false, :empty => false)
+      self.headers_visible = false
+      @icons = File.directory?(icon_path) ? VR::IconHash.new(icon_path) : nil
+      parse_signals()
+      model.set_sort_column_id(id(:sort_on), :ascending )
+			self.set_enable_search(false)
+      refresh
+			self.visible = true # necessary!
+    end	
+
+    # flags:  :root => root path, :open_folders => array of paths to open
+  	def refresh(flags={}) 
+			@root = flags[:root] if flags[:root]
+			open_folders = flags[:open_folders] ? flags[:open_folders] : get_open_folders()
+  		model.clear
+			@root_iter = add_file(@root, nil)
+  		fill_folder(@root_iter)
+			expand_row(@root_iter.path, false)
+  		open_folders(open_folders)
+    end
+  
+  	def fill_folder(parent_iter)
+  		model.remove(parent_iter.first_child)   #remove dummy record
+  	  files = Dir.glob(File.join(parent_iter[id(:path)],@glob))
+  		files = files.select &@test_block if @test_block
+  		files.each do |fn|
+   			add_file(fn, parent_iter)
+    	end	
+  	end
+  
+  	def self__row_expanded(view, iter, path)
+  		iter = model.get_iter(path)  #bug fix
+     	fill_folder(iter) if iter[id(:empty)]
+  		expand_row(iter.path, false)
+  	end
+
+		def expand_or_collapse_folder()
+  		return unless row = selected_rows.first
+  		if row_expanded?(row.path)
+  			collapse_row(row.path)
+  		else
+  			self__row_expanded(self, row, row.path) 
+  		end
+		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)
+  		model.each do |model, path, iter| 
+  			if folder_paths.include?(iter[id(:path)]) 	
+  				expand_row(path, false) 
+  			end
+  		end
+  	end	
+  
+  	def add_file(filename, parent = @root_iter)
+			my_path = File.dirname(filename)
+			model.each do |model, path, iter|
+				return if iter[id(:path)] == filename # duplicate
+				parent = iter if iter[id(:path)] == my_path
+			end
+      fn = filename.gsub("\\", "/")
+      parent[id(:empty)] = false unless parent.nil?
+      child = add_row(parent)
+      child[:pix] = @icons.get_icon(File.directory?(fn) ? "x.folder" : fn) 	if @icons
+      child[:file_name] = File.basename(fn)
+      child[:path] = fn
+      if File.directory?(fn)
+      child[:sort_on] = "0" + child[:file_name]
+      child[:empty] = true
+      add_row(child) # dummy record so expander appears	
+      else
+      child[id(:sort_on)] = "1" + child[id(:file_name)]			
+        end
+  		return child
+  	end
+  
+  	def set_show_expanders(expand)
+  		self.show_expanders = expand
+  		self.level_indentation  = expand ? 0 : 12
+  	end
+  
+  	def folder?(iter) 
+			iter[id(:sort_on)][0,1] == "0" 
+		end  
+  
+  	def get_selected_path() (selection.selected ? selection.selected[id(:path)] : nil) end
+  
+  end	
+  
+  
+  
+
+end
+
+

data/vrlib/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/vrlib/lib/treeview/ListView.rb

@@ -0,0 +1,85 @@
+module VR
+
+
+  class ListView < Gtk::TreeView
+  
+  	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/vrlib/lib/treeview/TreeView.rb

@@ -0,0 +1,43 @@
+
+module VR
+#  
+#  TreeView is almost identical to VR::ListView.  The only difference
+#  is how rows are added, and that they use a different model class.
+#  See VR::ListView for in-depth docs.  Also, see Gtk::TreeView for more.
+#  
+#  Also, most of the useful methods for VR::TreeView are found in VR::ViewCommon.
+#  All the methods in VR::ViewCommon work on VR::TreeViews and VR::ListViews. 
+#
+	class TreeView < Gtk::TreeView
+	
+		include ViewCommon
+
+#  See VR::ListView constructor. (exactly the same)
+
+		def initialize(cols)
+			super()
+			self.model = Gtk::TreeStore.new(*flatten_hash(cols).values)
+			load_columns(cols)
+		end
+#
+#  Adds row to the model.  This will return a "row" type iter that responds
+#  to column IDs (symbols).  You need to provide a parent row (iter).
+#  See GtkTreeView#append for more.
+#
+#  The iter is a GtkTreeIter object for the parent or nil for the root of the tree.  The hash argument is a Hash of values to add:
+# 
+#  @view.add_row(iter, :name => "Chester", :email => "chester@chesterizer.com")
+#
+#	
+
+
+
+ 		def add_row(parent, hash = {})
+			row = vr_row(model.append(parent))
+			hash.each_pair { |key, val| row[key] = val }
+  		return row
+  	end
+
+	end
+
+end

data/vrlib/lib/treeview/ViewCommon.rb

@@ -0,0 +1,370 @@
+module VR
+
+#  This module holds all the methods that both VR::ListView
+#  and VR::TreeView use.  All the methods listed here can be called from a
+#  VR::ListView or a VR::TreeView.
+#  
+#  ==The col_<propery>, ren_<property>, col_attr, and ren_attr methods
+#  
+#  All of these methods do the same thing:  set the properties of your VR::ListView.
+#  
+#  The way to configure a VR::ListView or VR::TreeView is to set the properties
+#  of its columns (and renderers).  For example,
+#  setting the "title" property of a column will set the title that appears at the top.
+#  
+#  The normal Gtk approach to setting properties of a GtkTreeViewColumn, (or renderer) is to set
+#  them individually:
+#  
+#   col = Gtk::TreeViewColumn.new()
+#   col.title = "My Title"
+#  
+#  This is slow, and tedious.  However, you can completely configure any VR::ListView or
+#  VR::TreeView object with only a few lines of code using the above methods.  They can set many properties on many columns
+#  at once.  
+#  
+#  The first thing to understand is that there are several ways to set properties.  In fact all
+#  of these lines of code do the exact same thing:
+#  
+#   column(:name).title = "Person's Name"
+#   col_title(:name => "Person's Name")
+#   ren_title(:name => "Person's Name")
+#   col_attr(:name, :title => "Person's Name")
+#   ren_attr(:name, :title => "Person's Name")
+#  
+#  All the above lines of code simply set the title of the :name column.  So why
+#  is one method better than another?   Answer:  because you can set multiple
+#  properties on multiple columns with one line of code.  For example, you can set all the titles
+#  with this line:
+#  
+#   col_titles(:name => "Name", :email => "Address", :phone => "Phone Number")
+#  
+#  The col_<property> method is very good at setting <b>multiple columns</b>.
+#  
+#  Likewise, the VR::ListView#col_attr method is good at setting the same property on multiple columns:
+#  
+#   col_attr(:name, :email, :phone, :width => 200, :weight => 700) #bold
+#  
+#  Either way, you can set everything with one line of code.  Also, if you want to set
+#  a propery for all the columns, simply omit any column IDs:
+#  
+#   col_width(200)
+#   ren_background("yellow")
+#   col_attr(:font => "Sans")
+#   ren_attr(:visible => true)
+#  
+#  There are many, many possibilities of properties you can set using these methods.
+#  You need to know the name of the property that you want to set from consulting
+#  the docs for GtkTreeViewColumn and the docs for the column's renderer type (listed on the left of this webpage)
+#  
+#  Any of the properties of these classes can be set using the above methods.
+#  
+#  If you consult, GtkCellRendererText for example, you'll see that it has a "background" property.
+#  Therefore you can use ren_background() to set the color of the background of that column.
+#  
+#  Method names like "col_title" are just one possibility of methods you can use.
+#  You could call any of these as well:
+#  
+#   col_width
+#   col_xalign  # (0.00 to 1.00, 1 = right justify)
+#   col_weight  # (100 to 900)
+#   col_background
+#   col_foreground
+#   col_font
+#   col_markup
+#   col_size
+#   col_spacing
+#  
+#  You'll notice that some of the methods listed above don't look valid.  For example,
+#  col_background doesn't seem to make sense because the GtkTreeViewColumn doesn't
+#  have a <b>background</b> property.  The <b>background</b> property belongs to the
+#  renderer, GtkCellRendererText.  But, the col_<attribute> method is programmed
+#  to try to set the property on the column first, and if the column object doesn't
+#  support the propery, it will look in the renderer.  If the renderer doesn't support it,
+#  it DOES NOTHING.
+#  
+#  Likewise, the ren_<property> method will look first in the renderer for the property, then
+#  the column.  The only difference between the ren_<property> and col_<propery> methods
+#  is that the ren_<property> looks in the renderer object first.  These two methods
+#  are almost interchangable.  In fact, I always just use the col_<propery> method
+#  because it looks better.  The only time I have a problem is when the column and the renderer
+#  have the same property (i.e. "visible" and "xalign").  Then, I simply substitute the ren_<property> method.
+#  
+#  ==Summary
+#  
+#  - To set the <b>same attribute value</b> on multiple columns use col_attr() or ren_attr()
+#  - To set <b>different attribute values</b> on multiple columns, use col_<property> or ren_<property>
+#  - The ren_<property> and col_<property> methods are almost interchangable.
+#  - The ren_attr() and col_attr() methods are almost interchangable.
+#  - To set the properties of <b>all</b> the columns, omit any column iDs
+#  - Consult the documentation for GtkTreeViewColumn to learn about properties to set.
+#  - Consult the Gtk docs for the renderer by locating the type on the left of this webpage.
+#  
+#  Some examples are:
+#   ren_background(:name => "yellow", :email => black)  #renderer for :name bg = yellow
+#   col_editable(false) #makes all columns un-editable
+#   col_width(:name => 300, email => 200)
+#   ren_xalign(:email => 1)  # right justify email 
+#   ren_attr(:name, :email, :font => "Courier") 
+#   ren_attr(:font => "Sans") # all columns now Sans font
+#   col_attr(:name, :email, :visible => true)
+#  
+
+  module ViewCommon
+
+attr_accessor :vr_renderer, :vr_column
+  
+  	def load_columns(cols) # :nodoc:
+			@vr_renderer = {}
+			@vr_column = {}
+  		model_col = 0
+  		cols.each_pair do | sym, type|
+  			col = VR::TreeViewColumn.new(self, model_col, sym, type)
+  			model_col = model_col + (type.class == Hash ? type.size : 1)
+  			self.append_column(col)
+  		end
+  		turn_on_comboboxes()
+			@column_keys = flatten_hash(cols).keys
+  	end
+  
+   	def method_missing(meth, *args) # :nodoc:
+    	unless m = /^(ren_|col_)(.+)$/.match(meth.to_s)
+				super
+				return
+			end     
+  		if args.first.is_a? Hash
+  			args.first.each_pair { |key, val| method(m[1] + "attr").call(key, m[2] => val) }
+  		else
+  			method(m[1] + "attr").call(m[2] => args.first) 
+  		end
+    end
+
+# Sets properties on renderers (and columns)  See VR::ViewCommon#col_attr for more.
+
+  	def ren_attr(*args)
+			cols = args.select { |arg| !arg.is_a? Hash }
+			return unless hash = args.detect { |arg| arg.is_a? Hash }
+			cols = @column_keys if cols.empty?
+  		cols.each do |c|
+  			hash.each_pair do | key, val |
+  				if renderer(c).respond_to?(key.to_s + "=")  
+   					renderer(c).send(key.to_s + '=', val) 
+  				elsif column(c).respond_to?(key.to_s + "=")
+  					column(c).send(key.to_s + '=', val) 
+  				end 
+  			end
+			end		
+		end	
+
+#  Sets properties on many columns at once.  It can be called with many columns and many attributes.
+#  Also, if you don't specify any columns, it will set the properties on all of them.  There are
+#  many ways to call this method, here are a few:
+#  
+#   @view.col_attr(:name, :date, :background => "yellow", foreground => "black")
+#   @view.col_attr(:background => "yellow", foreground => "black") #sets all columns
+#   @view.col_attr(:name, :date, :editable => true) # both editable now
+#   @view.col_attr(:editable => false) # turns off editing to all columns
+#  
+#  Also, if the column VR::TreeViewColumn object doesn't support the property, it will try to
+#  set the property on the renderer instead.  In the above example, the col_attr() method tries to
+#  set teh "<b>background</b>" property of a VR:TreeViewColumn.  However, that object doesn't
+#  support the "background" property, but the renderer for the column, VR::CellRendererText does.
+#  So it sets the renderer's property instead.  So, in this example this line of code would do exactly the same
+#  thing:
+#  
+#   @view.ren_attr(:name, :date, :background => "yellow", foreground => "black")
+#  
+#  In the vast majority of cases, VR::ViewCommon#col_attr and VR::ViewCommon#ren_attr are interchangable.
+  
+
+  	def col_attr(*args)
+			cols = args.select { |arg| !arg.is_a? Hash }
+			return unless hash = args.detect { |arg| arg.is_a? Hash }
+			cols = @column_keys if cols.empty?
+  		cols.each do |c|
+  			hash.each_pair do | key, val |
+  				if column(c).respond_to?(key.to_s + "=")
+  					column(c).send(key.to_s + '=', val)
+  				elsif renderer(c).respond_to?(key.to_s + "=")  
+   					renderer(c).send(key.to_s + '=', val) 
+  				end 
+  			end
+			end		
+		end
+
+
+#  Returns an array of rows that are selected in the VR::TreeView or VR::ListView.
+#  If nothing is selected, it returns an empty array.  If you've configured your
+#  listview to accept multiple selections, it will return all of them.  In single 
+#  selection mode, it will return an array with one row.  These rows are
+#  able to respond to column IDs.  They are the same types of rows as returned by
+#  VR::ViewCommon#vr_row.
+		
+		def selected_rows()
+			rows = []
+			selection.each do |model, path, iter|
+				rows << vr_row(iter) 
+			end
+			rows
+		end  
+
+		def delete_selected()
+			refs = []
+			selection.each do  |mod, path, iter|
+				refs << Gtk::TreeRowReference.new(mod, path)
+			end
+			refs.each do |ref|
+				model.remove(model.get_iter(ref.path))
+			end	 
+		end
+  
+  	def turn_on_comboboxes() # :nodoc:
+  		# detect if comboboxes are present:
+  		found = false
+  		self.each_renderer do |r|
+  			if r.is_a? VR::CellRendererCombo
+  				found = true
+  				break
+  			end
+  		end	
+  		return unless found
+    	self.signal_connect("cursor_changed") do |view|
+      	next unless iter = view.selection.selected 
+    		view.each_renderer do |r|
+    			r.set_model( iter[r.model_col] ) if r.is_a? VR::CellRendererCombo
+  			end
+    	end		
+  	end
+
+		def flatten_hash(hash) # :nodoc:
+			h = {}
+			hash.each do | k, v |
+				if v.class == Hash
+					v.each_pair { |key, val| h[key] = val }
+				else
+					h[k] = v
+				end
+			end 
+ 			return h
+		end
+
+#  Enumerates each row in the model and returns an instance of GtkTreeIter.
+#  However, the iters returned have been converted into a "row" using VR::ViewCommon#vr_row
+#  so they will respond to colum IDs (symbols).  Like this:
+#  
+#   @view.each_row { |row| puts row[:name] }  # works!
+#
+
+		def each_row
+			self.model.each { |mod, pth, itr| yield vr_row(itr) }
+		end
+
+#  Converts a normal GtkTreeIter to use VR's column IDs.  You can use it like this:
+#  
+#   row = @view.vr_row(iter)   # iter is a Gtk::TreeIter
+#   row[:name] = "Chester"  # works!
+
+
+		def vr_row(iter)
+			unless iter.respond_to?(:id)
+				iter.extend(VR::IterMethods)
+				iter.column_keys = @column_keys
+			end
+			return iter
+		end 
+
+		def get_iter(path)
+			vr_row(model.get_iter(path))
+		end
+
+
+#  Returns a VR::TreeViewColumn object for the column.  You can pass this method either
+#  a column ID (symbol) or the column number.  Since, VR::TreeViewColumn is a subclass
+#  of Gtk::TreeViewColumn, you should consult Gtk::TreeViewColumn's documentation to
+#  see all the properties you can set on this object:
+#  
+#   @view.column(:name).title = "Person's Name"
+#   @view.column(:ok).visible = false
+#   @view.column(:name).class.name  # => VR:TreeViewColumn
+#   
+#  Even though the above statements are valid, its usually easier to use the col_<property>
+#  methods instead.  See VR::ViewCommon for more.
+
+  
+  	def column(id)
+  		@vr_column[id] 
+  	end
+  	
+  	def each_renderer
+  		self.columns.each do |c| 
+  			c.cells.each do |r| 
+  				yield r 
+  			end
+  		end
+  	end
+
+#Returns the renderer for a given column ID.
+#
+#In VR::ListView#new (and VR::TreeView#new) method, a data model (VR::ListStore or VR::TreeStore) is automatically contstructed.
+#Then the class will automatically assign a renderer to show it on the screen.  These renderers
+#simply convert a piece of data to something visual on the screen.  For example, a column in the model
+#might contain a value "true," but the renderer converts it to a GtkCheckButton which shows a check-mark.
+#The VR::ListView class will 
+#automatically assign renderers to each column based on its type:
+#
+#String, Fixnum, Integer, Float => VR::CellRendererText
+#TrueClass => VR::CellRendererToggle
+#GdkPixbuf => VR::CellRendererPixbuf
+#DateTime => VR::CellRendererDate
+#VR::CalendarCol, VR::TextCol => VR::CellRendererObject
+#VR::SpinCol => VR::CellRendererSpin
+#VR::ProgressCol => VR::CellRendererProgress
+#VR::ComboCol => VR::CellRendererCombo
+#
+#The renderer() method will return one of these renderers:
+#
+# ren = @view.renderer(:ok)
+# puts ren.class.name  # VR::CellRendererToggle  (:ok column is a TrueClass)
+# puts @view.renderer(:name).class.name # =>  VR::CellRendererText
+#
+#All the types of renderers are subclasses of Gtk renderers.  For example,  VR::CellRendererText
+#is a subclass of Gtk::CellRendererText.  So, you can use these objects just as you would use a 
+#normal Gtk renderer:
+# 
+# @view.renderer(:name).width = 100
+#
+#This is perfectly valid even though there are better ways of setting these properties in visualruby.
+
+		def renderer(sym)
+			@vr_renderer[sym]
+		end
+ 
+#  	def renderer(id)
+#  		each_renderer do |r| 
+#  			return r if r.model_col == id(id) 
+#  		end
+#  		return nil
+#  	end
+
+#  Returns the number of the given column ID.  This is very useful when you're
+#  working with Gtk's methods because they require column numbers (not Column IDs)
+#  This method converts the column ID symbols from the VR::ListView#new constructor
+#  to Integers:
+#  
+#   @view = VR::ListView.new(:name => String, :date => VR::CalendarCol)
+#   
+#   Later in code...
+#  
+#   iter = get_iter(path)
+#   col_num = id(:date)  # 1
+#   iter[col_num]
+#  
+#  You won't need to use this when adding rows with VR::ListView#add_row, and
+#  you also have the option of converting the whole iter to use column IDs (symbols)
+#  using VR::ViewCommon#vr_row.
+
+		def id(id)
+			return (id.is_a? Fixnum or id.is_a? Integer) ? id : @column_keys.index(id)
+		end  
+
+  end
+end