hotcocoa 0.5

data/lib/hotcocoa/mappings/table_view.rb

@@ -0,0 +1,110 @@
+HotCocoa::Mappings.map :table_view => :NSTableView do
+  
+  defaults :column_resize => :uniform, :frame => DefaultEmptyRect, :layout => {}
+  
+  constant :column_resize, {
+    :none               => NSTableViewNoColumnAutoresizing,
+    :uniform            => NSTableViewUniformColumnAutoresizingStyle,
+    :sequential         => NSTableViewSequentialColumnAutoresizingStyle,
+    :reverse_sequential => NSTableViewReverseSequentialColumnAutoresizingStyle,
+    :last_column_only   => NSTableViewLastColumnOnlyAutoresizingStyle,
+    :first_column_only  => NSTableViewFirstColumnOnlyAutoresizingStyle
+  }
+  
+  constant :grid_style, { 
+    :none               => NSTableViewGridNone, 
+    :vertical           => NSTableViewSolidVerticalGridLineMask, 
+    :horizontal         => NSTableViewSolidHorizontalGridLineMask, 
+  	:both               => NSTableViewSolidVerticalGridLineMask | NSTableViewSolidHorizontalGridLineMask 
+  }
+
+  constant :selection_style, {
+    :regular            => NSTableViewSelectionHighlightStyleRegular,
+    :source_list        => NSTableViewSelectionHighlightStyleSourceList
+  }
+
+  def init_with_options(table_view, options)
+    table_view.initWithFrame(options.delete(:frame))
+  end
+
+  custom_methods do
+    
+    def data=(data_source)
+      data_source = HotCocoa::TableDataSource.new(data_source) if data_source.kind_of?(Array)
+      setDataSource(data_source)
+    end
+    
+    def columns=(columns)
+      columns.each do |column|
+        addTableColumn(column)
+      end
+    end
+    
+    def column=(column)
+      addTableColumn(column)
+    end
+    
+    def auto_size
+      setAutoresizingMask(NSViewHeightSizable|NSViewWidthSizable)
+    end
+    
+    def column_resize=(style)
+      setColumnAutoresizingStyle(style)
+    end
+
+    def reload 
+   	  reloadData 
+   	end 
+   	
+   	def grid_style=(value) 
+   	  setGridStyleMask(value) 
+   	end
+
+    def on_double_action=(behavior)
+      if target && (
+        target.instance_variable_get("@action_behavior") || 
+        target.instance_variable_get("@double_action_behavior"))
+          object.instance_variable_set("@double_action_behavior", behavior)
+          object = target
+      else
+        object = Object.new
+        object.instance_variable_set("@double_action_behavior", behavior)
+        setTarget(object)
+      end
+      def object.perform_double_action(sender)
+        @double_action_behavior.call(sender)
+      end
+      setDoubleAction("perform_double_action:")
+    end
+   
+    def on_double_action(&behavior)
+      self.on_double_action = behavior
+      self
+    end
+
+  end
+
+  delegating "tableView:willDisplayCell:forTableColumn:row:",               :to => :will_display_cell,      :parameters => [:willDisplayCell, :forTableColumn, :row]
+  delegating "tableView:dataCellForTableColumn:row:",                       :to => :data_cell,              :parameters => [:dataCellForTableColumn, :row]
+  delegating "tableView:shouldShowCellExpansionForTableColumn:row:",        :to => :expand_cell?,           :parameters => [:shouldShowCellExpansionForTableColumn, :row]
+  delegating "tableView:isGroupRow:",                                       :to => :is_group_row?,          :parameters => [:isGroupRow]
+  delegating "tableView:shouldEditTableColumn:row:",                        :to => :edit_table_column?,     :parameters => [:shouldEditTableColumn, :row]
+  delegating "tableView:heightOfRow:",                                      :to => :height_of_row,          :parameters => [:heightOfRow]
+  delegating "selectionShouldChangeInTableView:",                           :to => :change_selection?
+  delegating "tableView:shouldSelectRow:",                                  :to => :select_row?,            :parameters => [:shouldSelectRow]
+  delegating "tableView:selectionIndexesForProposedSelection:",             :to => :indexes_for_selection,  :parameters => [:selectIndexesForProposedSelection]
+  delegating "tableView:shouldSelectTableColumn:",                          :to => :select_column?,         :parameters => [:shouldSelectTableColumn]
+  delegating "tableViewSelectionIsChanging:",                               :to => :selection_changing,     :parameters => [:tableViewSelectionIsChanging]
+  delegating "tableViewSelectionDidChange:",                                :to => :selection_changed,      :parameters => [:tableViewSelectionDidChange]
+  delegating "tableView:shouldTypeSelectForEvent:withCurrentSearchString:", :to => :type_select_for_event?, :parameters => [:shouldTypeSelectForEvent, :withCurrentSearchString]
+  delegating "tableView:typeSelectStringForTableColumn:row:",               :to => :type_select_string,     :parameters => [:typeSelectStringForTableColumn, :row]
+  delegating "tableView:nextTypeSelectMatchFromRow:toRow:forString:",       :to => :find_in_range,          :parameters => [:nextTypeSelectMatchFromRow, :toRow, :forString]
+  delegating "tableView:didDragTableColumn:",                               :to => :dragged_column,         :parameters => [:didDragTableColumn]
+  delegating "tableViewColumnDidMove:",                                     :to => :column_moved,           :parameters => [:tableViewColumnDidMove]
+  delegating "tableViewColumnDidResize:",                                   :to => :column_resized,         :parameters => [:tableViewColumnDidResize]
+  delegating "tableView:didClickTableColumn:",                              :to => :clicked_column,         :parameters => [:didClickTableColumn]
+  delegating "tableView:mouseDownInHeaderOfTableColumn:",                   :to => :header_clicked,         :parameters => [:mouseDownInHeaderOfTableColumn]
+  delegating "tableView:shouldTrackCell:forTableColumn:row:",               :to => :track_cell?,            :parameters => [:shouldTrackCell, :forTableColumn, :row]
+  delegating "tableView:toolTipForCell:rect:tableColumn:row:mouseLocation:",:to => :tooltip_for_cell,       :parameters => [:toolTipForCell, :rect, :tableColumn, :row, :mouseLocation]
+
+end

data/lib/hotcocoa/mappings/text_field.rb

@@ -0,0 +1,41 @@
+# NSTextField mappings
+# 
+# Usage example:
+#   @field = text_field(:text => "your text here", :layout => {:start => false}, :frame => [0, 0, 300, 300])
+#   @field.text = "New text"
+
+# Cocoa Documentation:
+#  http://developer.apple.com/documentation/Cocoa/Reference/ApplicationKit/Classes/NSTextField_Class/Reference/Reference.html
+#
+#
+
+HotCocoa::Mappings.map :text_field => :NSTextField do
+
+  constant :text_align, {
+    :right  => NSRightTextAlignment,
+    :left   => NSLeftTextAlignment,
+    :center => NSCenterTextAlignment
+  }
+  
+  defaults :selectable => true, :editable => true, :layout => {}, :frame => DefaultEmptyRect
+  
+  def init_with_options(text_field, options)
+    text_field.initWithFrame options.delete(:frame)
+  end
+  
+  custom_methods do
+
+    def text_align=(value)
+      setAlignment(value)
+    end
+    
+  end
+  
+  delegating "control:textShouldBeginEditing:", :to => :should_begin_editing?, :parameters => [:textShouldBeginEditing]
+  delegating "control:textShouldEndEditing:", :to => :should_end_editing?, :parameters => [:textShouldEndEditing]
+  delegating "controlTextDidBeginEditing:", :to => :did_begin_editing, :parameters => ["controlTextDidBeginEditing.userInfo['NSFieldEditor']"]
+  delegating "controlTextDidEndEditing:", :to => :did_end_editing, :parameters => ["controlTextDidEndEditing.userInfo['NSFieldEditor']"]
+  delegating "controlTextDidChange:", :to => :did_change, :parameters => ["controlTextDidChange.userInfo['NSFieldEditor']"]
+
+
+end

data/lib/hotcocoa/mappings/text_view.rb

@@ -0,0 +1,13 @@
+HotCocoa::Mappings.map :text_view => :NSTextView do
+
+  defaults :layout => {}, :frame => DefaultEmptyRect
+  
+  def init_with_options(text_view, options)
+    if options[:container]
+      text_view.initWithFrame options.delete(:frame), :textContainer => options.delete(:container)
+    else
+      text_view.initWithFrame options.delete(:frame)
+    end
+  end
+  
+end

data/lib/hotcocoa/mappings/timer.rb

@@ -0,0 +1,25 @@
+HotCocoa::Mappings.map :timer => :NSTimer do
+
+  defaults :scheduled => true, :repeats => false
+
+  def alloc_with_options(options)
+    raise ArgumentError, "timer requires :interval" unless options.has_key?(:interval)
+    target = options.delete(:target)
+    selector = options.delete(:selector)
+    if !target || !selector
+      raise ArgumentError, "timer requires either :target and :selector or :on_action" unless options.has_key?(:on_action)
+      target = Object.new
+      target.instance_variable_set(:@block, options.delete(:on_action))
+      def target.fire(timer)
+        @block.call(timer)
+      end
+      selector = "fire:"
+    end
+    if options.delete(:scheduled)
+      NSTimer.scheduledTimerWithTimeInterval(options.delete(:interval), target:target, selector:selector, userInfo:options.delete(:info), repeats:options.delete(:repeats))
+    else
+      NSTimer.timerWithTimeInterval(options.delete(:interval), target:target, selector:selector, userInfo:options.delete(:info), repeats:options.delete(:repeats))
+    end
+  end
+  
+end

data/lib/hotcocoa/mappings/toolbar.rb

@@ -0,0 +1,97 @@
+HotCocoa::Mappings.map :toolbar => :NSToolbar do
+
+  constant :size, {
+    :default  => NSToolbarSizeModeDefault,
+    :regular  => NSToolbarSizeModeRegular,
+    :small    => NSToolbarSizeModeSmall
+  }
+
+  constant :display, {
+    :default        => NSToolbarDisplayModeDefault,
+    :icon_and_label => NSToolbarDisplayModeIconAndLabel,
+    :icon           => NSToolbarDisplayModeIconOnly,
+    :label          => NSToolbarDisplayModeLabelOnly
+  }
+
+  defaults :identifier => 'DefaultToolbarIdentifier',
+           :allowed => [:separator, :space, :flexible_space, :show_colors,
+                        :show_fonts, :customize, :print],
+           :default => [],
+           :allow_customization => true,
+           :size => :default
+
+  def init_with_options(toolbar, options)
+    toolbar = toolbar.initWithIdentifier options.delete(:identifier)
+    toolbar.allowsUserCustomization = options.delete(:allow_customization)
+    toolbar
+  end
+  
+  custom_methods do
+
+    def size=(mode)
+      setSizeMode(mode)
+    end
+
+    def display=(mode)
+      setDisplayMode(mode)
+    end
+    
+    def default=(list)
+      @default = list.dup
+      build_custom_items
+    end
+    
+    def allowed=(list)
+      @allowed = list.dup
+      build_custom_items
+    end
+    
+    private
+    
+      def build_custom_items
+        if @allowed && @default
+          ary = @default.select { |x| x.is_a?(NSToolbarItem) }
+          @default -= ary
+          @custom_items = {}
+          ary.each { |x| @custom_items[x.itemIdentifier] = x } 
+          @allowed.concat(@custom_items.keys)
+          @default.concat(@custom_items.keys)
+
+          [@allowed, @default].each do |a|
+            a.map! do |i|
+              case i
+                when :separator
+                  NSToolbarSeparatorItemIdentifier
+                when :space
+                  NSToolbarSpaceItemIdentifier
+                when :flexible_space
+                  NSToolbarFlexibleSpaceItemIdentifier
+                when :show_colors
+                  NSToolbarShowColorsItemIdentifier
+                when :show_fonts
+                  NSToolbarShowFontsItemIdentifier
+                when :customize
+                  NSToolbarCustomizeToolbarItemIdentifier
+                when :print
+                  NSToolbarPrintItemIdentifier
+                else
+                  i
+              end
+            end 
+          end
+          allowed_items { @allowed }
+          default_items { @default }
+          item_for_identifier { |identifier, will_be_inserted| @custom_items[identifier] }
+        end
+      end
+    
+  end
+
+  delegating "toolbar:itemForItemIdentifier:willBeInsertedIntoToolbar:", :to => :item_for_identifier,         :parameters => [:itemForItemIdentifier, :willBeInsertedIntoToolbar], :required => true
+  delegating "toolbarAllowedItemIdentifiers:",                           :to => :allowed_items, :required => true
+  delegating "toolbarDefaultItemIdentifiers:",                           :to => :default_items, :required => true
+  delegating "toolbarSelectableItemIdentifiers:",                        :to => :selectable_items
+  delegating "toolbarDidRemoveItem:",                                    :to => :did_remove_item,             :parameters => ["toolbarDidRemoveItem.userInfo['item']"]
+  delegating "toolbarWillAddItem:",                                      :to => :will_add_item,               :parameters => ["toolbarWillAddItem.userInfo['item']"]
+
+end

data/lib/hotcocoa/mappings/toolbar_item.rb

@@ -0,0 +1,36 @@
+HotCocoa::Mappings.map :toolbar_item => :NSToolbarItem do
+  
+  defaults :priority => :standard
+  
+  constant :priority, {
+    :standard => NSToolbarItemVisibilityPriorityStandard,
+    :low      => NSToolbarItemVisibilityPriorityLow,
+    :high     => NSToolbarItemVisibilityPriorityHigh,
+    :user     => NSToolbarItemVisibilityPriorityUser
+  }
+
+  def init_with_options(toolbar_item, options)
+    if !options.has_key?(:label) && !options.has_key?(:identifier)
+      raise ArgumentError, ":identifier or :label required" 
+    end
+    label = options[:label]
+    toolbar_item.initWithItemIdentifier(options.delete(:identifier) || label.tr(' ', '_'))
+    toolbar_item.paletteLabel = label if label
+    toolbar_item
+  end
+
+  custom_methods do
+    
+    include HotCocoa::Mappings::TargetActionConvenience
+    
+    def priority=(value)
+      setVisibilityPriority(value)
+    end
+    
+    def priority
+      visibilityPriority
+    end
+    
+  end
+
+end

data/lib/hotcocoa/mappings/view.rb

@@ -0,0 +1,67 @@
+
+HotCocoa::Mappings.map :view => :NSView do
+
+  defaults :frame => DefaultEmptyRect,
+           :layout => {}
+
+  constant :auto_resize, {
+    :none   => NSViewNotSizable,
+    :width  => NSViewWidthSizable,
+    :height => NSViewHeightSizable,
+    :min_x  => NSViewMinXMargin,
+    :min_y  => NSViewMinYMargin,
+    :max_x  => NSViewMaxXMargin,
+    :max_y  => NSViewMaxYMargin
+  }
+  
+  constant :border, {
+    :none           => NSNoBorder,
+    :line           => NSLineBorder,
+    :bezel          => NSBezelBorder,
+    :groove         => NSGrooveBorder
+  }
+
+  def init_with_options(view, options)
+    view.initWithFrame options.delete(:frame)
+  end
+  
+  custom_methods do
+
+    def auto_resize=(value)
+      setAutoresizingMask(value)
+    end
+    
+    def <<(view)
+      addSubview(view)
+    end
+    
+    def layout=(options)
+      @layout = HotCocoa::LayoutOptions.new(self, options)
+      @layout.update_layout_views!
+    end
+    
+    def layout
+      @layout
+    end
+
+    def on_notification(options={}, &block)
+      options[:sent_by] = self
+      NotificationListener.new(options, &block)
+    end
+
+    def remove(subview, options = {})
+      raise ArgumentError, "#{subview} is not a subview of #{self} and cannot be removed." unless subview.superview == self
+      options[:needs_display] == false ? subview.removeFromSuperviewWithoutNeedingDisplay : subview.removeFromSuperview
+    end
+    
+    def enter_full_screen(options={})
+      enterFullScreenMode((options.delete(:screen) || NSScreen.mainScreen), withOptions:options)
+    end
+    
+    def leave_full_screen(options={})
+      exitFullScreenModeWithOptions(options)
+    end
+    
+  end
+    
+end

data/lib/hotcocoa/mappings/web_view.rb

@@ -0,0 +1,22 @@
+HotCocoa::Mappings.map :web_view => :WebView , :framework => :WebKit do
+
+  defaults :layout => {}, :frame => DefaultEmptyRect
+
+  def init_with_options(web_view, options)
+    web_view.initWithFrame(options.delete(:frame))
+  end
+  
+  custom_methods do
+    
+    def url=(url)
+      url = url.kind_of?(String) ? NSURL.alloc.initWithString(url) : url
+      mainFrame.loadRequest(NSURLRequest.requestWithURL(url))
+    end
+
+    def auto_size
+      setAutoresizingMask(NSViewHeightSizable|NSViewWidthSizable)
+    end
+    
+  end
+
+end

data/lib/hotcocoa/mappings/window.rb

@@ -0,0 +1,118 @@
+# Cocoa Reference: NSWindow
+#
+# Usage example:
+# ==============
+#
+#   window :frame => [100, 100, 604, 500], :title => "My app", :style => [:titled, :closable, :miniaturizable, :resizable] do |win|
+#     win.contentView.margin  = 0
+#     win.background_color    = color(:name => 'white')  
+#     win.will_close { exit }
+#   end
+#
+# Apple Developer Connection url: http://developer.apple.com/documentation/Cocoa/Reference/ApplicationKit/Classes/NSWindow_Class/Reference/Reference.html
+#
+
+HotCocoa::Mappings.map :window => :NSWindow do
+    
+  defaults  :style => [:titled, :closable, :miniaturizable, :resizable],
+            :backing => :buffered, 
+            :defer => true,
+            :show => true,
+            :view => :layout,
+            :default_layout => {}
+            
+  constant :backing, :buffered => NSBackingStoreBuffered
+  
+  constant :style,   {
+    :borderless         => NSBorderlessWindowMask, 
+    :titled             => NSTitledWindowMask, 
+    :closable           => NSClosableWindowMask, 
+    :miniaturizable     => NSMiniaturizableWindowMask, 
+    :resizable          => NSResizableWindowMask,
+    :textured           => NSTexturedBackgroundWindowMask
+  }
+
+  def init_with_options(window, options)
+    unless options[:frame]
+      size = (options.delete(:size) || [400,400])
+      width, height = size
+      screen_frame = NSScreen.screens[0].visibleFrame
+      center = options.delete(:center)
+      x = screen_frame.origin.x + (center ? (screen_frame.size.width - width)/2    : 30)
+      y = screen_frame.origin.y + (center ? (screen_frame.size.height - height)/2 : (screen_frame.size.height - height - 30))
+      options[:frame] = [x, y, width, height]
+    end
+    window = window.initWithContentRect options.delete(:frame), 
+                               styleMask:options.delete(:style), 
+                               backing:options.delete(:backing), 
+                               defer:options.delete(:defer)
+    default_layout = options.delete(:default_layout)
+    if options[:view] == :layout
+      options.delete(:view)
+      window.setContentView(HotCocoa::LayoutView.alloc.initWithFrame([0,0,window.contentView.frameSize.width, window.contentView.frameSize.height]))
+      window.contentView.default_layout = default_layout
+    elsif options[:view] == :nolayout
+      options.delete(:view)
+    end
+    window
+  end
+    
+  custom_methods do
+    
+    def <<(control)
+      contentView.addSubview control
+    end
+    
+    def view
+      contentView
+    end
+
+    def view=(view)
+      setContentView(view)
+    end
+
+    def on_notification(options={}, &block)
+      options[:sent_by] = self
+      NotificationListener.new(options, &block)
+    end
+    
+    def show
+      display
+      makeKeyAndOrderFront(nil)
+      orderFrontRegardless
+    end
+    
+    def has_shadow?
+      hasShadow
+    end
+    
+  end
+  
+  delegating "window:shouldDragDocumentWithEvent:from:withPasteboard:", :to => :should_drag_document?,    :parameters => [:shouldDragDocumentWithEvent, :from, :withPasteboard]
+  delegating "window:shouldPopUpDocumentPathMenu:",                     :to => :should_popup_path_menu?,  :parameters => [:shouldPopUpDocumentPathMenu]
+  delegating "window:willPositionSheet:usingRect:",                     :to => :will_position_sheet,      :parameters => [:willPositionSheet, :usingRect]
+  delegating "windowDidBecomeKey:",                                     :to => :did_become_key
+  delegating "windowDidBecomeMain:",                                    :to => :did_become_main
+  delegating "windowDidChangeScreen:",                                  :to => :did_change_screen
+  delegating "windowDidChangeScreenProfile:",                           :to => :did_change_screen_profile
+  delegating "windowDidDeminiaturize:",                                 :to => :did_deminiturize
+  delegating "windowDidEndSheet:",                                      :to => :did_end_sheet
+  delegating "windowDidExpose:",                                        :to => :did_expose,               :parameters => ["windowDidExpose.userInfo['NSExposedRect']"]
+  delegating "windowDidMiniaturize:",                                   :to => :did_miniaturize
+  delegating "windowDidMove:",                                          :to => :did_move
+  delegating "windowDidResignKey:",                                     :to => :did_resign_key
+  delegating "windowDidResignMain:",                                    :to => :did_resign_main
+  delegating "windowDidResize:",                                        :to => :did_resize
+  delegating "windowDidUpdate:",                                        :to => :did_update
+  delegating "windowShouldClose:",                                      :to => :should_close?
+  delegating "windowShouldZoom:toFrame:",                               :to => :should_zoom?,             :parameters => [:toFrame]
+  delegating "windowWillBeginSheet:",                                   :to => :will_begin_sheet
+  delegating "windowWillClose:",                                        :to => :will_close
+  delegating "windowWillMiniaturize:",                                  :to => :will_miniaturize
+  delegating "windowWillMove:",                                         :to => :will_move
+  delegating "windowWillResize:toSize:",                                :to => :will_resize,              :parameters => [:toSize]
+  delegating "windowWillReturnFieldEditor:toObject:",                   :to => :returning_field_editor,   :parameters => [:toObject]
+  delegating "windowWillReturnUndoManager:",                            :to => :returning_undo_manager
+  delegating "windowWillUseStandardFrame:defaultFrame:",                :to => :will_use_standard_frame,  :parameters => [:defaultFrame]
+
+end

data/lib/hotcocoa/mappings/xml_parser.rb

@@ -0,0 +1,41 @@
+HotCocoa::Mappings.map :xml_parser => :NSXMLParser do
+
+  def alloc_with_options(options)
+    if options[:url]
+      url = options.delete(:url)
+      url = NSURL.alloc.initWithString(url) if url.is_a?(String)
+      NSXMLParser.alloc.initWithContentsOfURL(url)
+    elsif options[:file]
+      NSXMLParser.alloc.initWithData(NSData.alloc.initWithContentsOfFile(options.delete(:file)))
+    elsif options[:data]
+      NSXMLParser.alloc.initWithData(options.delete(:data))
+    else
+      raise "Must provide either :url or :data when constructing an NSXMLParser"
+    end
+  end
+  
+  delegating "parserDidStartDocument:",                                                       :to => :on_start_document
+  delegating "parserDidEndDocument:",                                                         :to => :on_end_document
+  delegating "parser:didStartElement:namespaceURI:qualifiedName:attributes:",                 :to => :on_start_element,               :parameters => [:didStartElement, :namespaceURI, :qualifiedName, :attributes]
+  delegating "parser:didEndElement:namespaceURI:qualifiedName:",                              :to => :on_end_element,                 :parameters => [:didEndElement, :namespaceURI, :qualifiedName]
+  delegating "parser:didStartMappingPrefix:toURI:",                                           :to => :on_start_mapping_prefix,        :parameters => [:didStartMappingPrefix, :toURI]
+  delegating "parser:didEndMappingPrefix:",                                                   :to => :on_end_mapping_prefix,          :parameters => [:didEndMappingPrefix]
+  
+  delegating "parser:foundAttributeDeclarationWithName:forElement:type:defaultValue:",        :to => :on_attribute_declaration,       :parameters => [:foundAttributeDeclarationWithName, :forElement, :type, :defaultValue]
+  delegating "parser:foundCDATA:",                                                            :to => :on_cdata,                       :parameters => [:foundCDATA]
+  delegating "parser:foundCharacters:",                                                       :to => :on_characters,                  :parameters => [:foundCharacters]
+  delegating "parser:foundComment:",                                                          :to => :on_comment,                     :parameters => [:foundComment]
+  delegating "parser:foundElementDeclarationWithName:model:",                                 :to => :on_element_declaration,         :parameters => [:foundElementDeclarationWithName, :model]
+  delegating "parser:foundExternalEntityDeclarationWithName:publicID:systemID:",              :to => :on_external_entity_declaration, :parameters => [:foundExternalEntityDeclarationWithName, :publicID, :systemID]
+  delegating "parser:foundIgnorableWhitespace:",                                              :to => :on_ignorable_whitespace,        :parameters => [:foundIgnorableWhitespace]
+  delegating "parser:foundInternalEntityDeclarationWithName:value:",                          :to => :on_internal_entity_declaration, :parameters => [:foundInternalEntityDeclarationWithName, :value]
+  delegating "parser:foundNotationDeclarationWithName:publicID:systemID:",                    :to => :on_notation_declaration,        :parameters => [:foundNotationDeclarationWithName, :data]
+  delegating "parser:foundProcessingInstructionWithTarget:data:",                             :to => :on_processing_instruction,      :parameters => [:foundProcessingInstructionWithTarget, :data]
+  delegating "parser:foundUnparsedEntityDeclarationWithName:publicID:systemID:notationName:", :to => :on_unparsed_entity_declaration, :parameters => [:foundUnparsedEntityDeclarationWithName, :publicID, :systemID, :notationName]
+
+  delegating "parser:resolveExternalEntityName:systemID:",                                    :to => :resolve_external_entity_name,   :parameters => [:resolveExternalEntityName, :systemID]
+
+  delegating "parser:parseErrorOccurred:",                                                    :to => :on_parse_error,                 :parameters => [:parseErrorOccurred]
+  delegating "parser:validationErrorOccurred:",                                               :to => :on_validation_error,            :parameters => [:validationErrorOccurred]
+
+end