hotcocoa 0.5.1 → 0.6.0pre

data/lib/hotcocoa/mappings/appkit/slider.rb

@@ -0,0 +1,23 @@
+HotCocoa::Mappings.map slider: NSSlider do
+
+  defaults frame: CGRectZero, layout: {}
+
+  def init_with_options button, options
+    button.initWithFrame options.delete :frame
+  end
+
+  custom_methods do
+    def min= value
+      setMinValue value
+    end
+
+    def max= value
+      setMaxValue value
+    end
+
+    def tic_marks= value
+      setNumberOfTickMarks value
+    end
+  end
+
+end

data/lib/hotcocoa/mappings/appkit/sound.rb

@@ -0,0 +1,9 @@
+HotCocoa::Mappings.map sound: NSSound do
+
+  defaults by_reference: true
+
+  def init_with_options sound, options
+    sound.initWithContentsOfFile options.delete(:file), byReference: options.delete(:by_reference)
+  end
+
+end

data/lib/hotcocoa/mappings/appkit/speech_synthesizer.rb

@@ -0,0 +1,22 @@
+HotCocoa::Mappings.map speech_synthesizer: NSSpeechSynthesizer do
+
+  def init_with_options obj, options
+    if voice = options.delete(:voice)
+      obj.initWithVoice voice
+    else
+      obj.init
+    end
+  end
+
+  custom_methods do
+    def speak what, to = nil
+      if to
+        url = to.is_a? String ?  NSURL.fileURLWithPath(to) : to
+        startSpeakingString what, toURL: url
+      else
+        startSpeakingString what
+      end
+    end
+  end
+
+end

data/lib/hotcocoa/mappings/appkit/split_view.rb

@@ -0,0 +1,19 @@
+HotCocoa::Mappings.map split_view: NSSplitView do
+
+  defaults layout: {}
+
+  def init_with_options split_view, options
+    split_view.initWithFrame options.delete :frame
+  end
+
+  custom_methods do
+    def horizontal= value
+      setVertical !value
+    end
+
+    def set_position position, of_divider_at_index: index
+      setPosition position, ofDividerAtIndex: index
+    end
+  end
+
+end

data/lib/hotcocoa/mappings/appkit/status_bar.rb

@@ -0,0 +1,7 @@
+HotCocoa::Mappings.map status_bar: NSStatusBar do
+
+  def alloc_with_options options
+    NSStatusBar.systemStatusBar
+  end
+
+end

data/lib/hotcocoa/mappings/appkit/status_item.rb

@@ -0,0 +1,9 @@
+HotCocoa::Mappings.map status_item: NSStatusItem do
+
+  defaults length: NSVariableStatusItemLength
+
+  def alloc_with_options options
+    HotCocoa.status_bar.statusItemWithLength options.delete :length
+  end
+
+end

data/lib/hotcocoa/mappings/appkit/table_view.rb

@@ -0,0 +1,108 @@
+HotCocoa::Mappings.map table_view: NSTableView do
+
+  defaults column_resize: :uniform, frame: CGRectZero, 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 { |column| addTableColumn column }
+    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/appkit/text_field.rb

@@ -0,0 +1,36 @@
+##
+# @cocoa NSTextField
+#
+# @example
+#   @field = text_field(text: 'your text here', layout: {start: false}, frame: [0, 0, 300, 300])
+#   @field.text = 'New text'
+#
+# @adc 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: CGRectZero
+
+  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/appkit/text_view.rb

@@ -0,0 +1,13 @@
+HotCocoa::Mappings.map text_view: NSTextView do
+
+  defaults layout: {}, frame: CGRectZero
+
+  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/appkit/toolbar.rb

@@ -0,0 +1,99 @@
+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.map! { |x| x.is_a? NSToolbarItem ? x.itemIdentifier : x }
+        @allowed.map! { |x| x.is_a? NSToolbarItem ? x.itemIdentifier : x }
+
+        @custom_items = {}
+        ary.each { |x| @custom_items[x.itemIdentifier] = x }
+        @allowed.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, required: true,  parameters: [:itemForItemIdentifier, :willBeInsertedIntoToolbar]
+  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/appkit/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
+    unless 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/appkit/tracking_area.rb

@@ -0,0 +1,24 @@
+HotCocoa::Mappings.map tracking_area: NSTrackingArea do
+  defaults rect: CGRectZero
+
+  constant :options, {
+    mouse_entered_and_exited: NSTrackingMouseEnteredAndExited,
+    mouse_moved:              NSTrackingMouseMoved,
+    cursor_update:            NSTrackingCursorUpdate,
+    active_in_key_window:     NSTrackingActiveInKeyWindow,
+    active_first_responder:   NSTrackingActiveWhenFirstResponder,
+    active_in_active_app:     NSTrackingActiveInActiveApp,
+    active_always:            NSTrackingActiveAlways,
+    assume_inside:            NSTrackingAssumeInside,
+    in_visible_rectangle:     NSTrackingInVisibleRect,
+    enabled_during_drag:      NSTrackingEnabledDuringMouseDrag
+  }
+  
+  def init_with_options tracking_area, options
+    rect = options.delete(:rect)
+    tracking_area.initWithRect rect,
+                      options: options.delete(:options),
+                        owner: options.delete(:owner),
+                     userInfo: nil
+  end
+end

data/lib/hotcocoa/mappings/appkit/view.rb

@@ -0,0 +1,65 @@
+HotCocoa::Mappings.map view: NSView do
+
+  defaults frame: CGRectZero, 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
+
+    # @todo We can use alias_method instead. How, you ask? With hacks
+    #       of course. Give the module created by custom_methods an
+    #       implementation of Module#included that iterates over a list
+    #       of methods to alias.
+    def << view
+      addSubview view
+    end
+
+    def layout= options
+      @layout = HotCocoa::LayoutOptions.new self, options
+      @layout.update_layout_views!
+    end
+
+    attr_reader :layout
+
+    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/appkit/window.rb

@@ -0,0 +1,124 @@
+##
+# @cocoa NSWindow
+#
+# @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
+#
+# @adc 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]
+      width, height = (options.delete(:size) || [400, 400])
+
+      screen_frame = NSScreen.mainScreen.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] = CGRectMake(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/foundation/net_service.rb

@@ -0,0 +1,65 @@
+HotCocoa::Mappings.map bonjour_service: NSNetService do
+
+  defaults domain: ''
+
+  constant :error_keys, {
+    code:   NSNetServicesErrorCode,
+    domain: NSNetServicesErrorDomain
+  }
+
+  constant :error, {
+    unknown:              NSNetServicesUnknownError,
+    collision:            NSNetServicesCollisionError,
+    not_found:            NSNetServicesNotFoundError,
+    activity_in_progress: NSNetServicesActivityInProgress,
+    bad_argument:         NSNetServicesBadArgumentError,
+    cancelled:            NSNetServicesCancelledError,
+    invalid:              NSNetServicesInvalidError,
+    timeout:              NSNetServicesTimeoutError
+  }
+
+  constant :options, {
+    no_auto_rename: NSNetServiceNoAutoRename
+  }
+
+  ##
+  # @key [String] domain specify the domain to advertise in, defaults to
+  #                      an empty string which advertises in all domains
+  # @key [String] type specify the type of service to advertise, such as
+  #                    '_http._tcp.' for an HTTP service or '_ssh._tcp.'
+  #                    for SSH; can only be set at initialization
+  # @key [String] name specify the name for the service, this can be free
+  #                    form but should avoid non-ascii characters; can
+  #                    only be set at initialization
+  # @key [Fixnum] port specify the port to advertise the service on, must
+  #                    be set at initialization
+  def init_with_options service, opts
+    selector = 'initWithDomain:type:name:'
+    args     = [ opts.delete(:domain),
+                 opts.delete(:type),
+                 opts.delete(:name) ]
+
+    if opts.has_key? :port
+      selector << 'port:'
+      args     << opts.delete(:port)
+    end
+
+    service.send( selector, *args )
+  end
+
+  custom_methods do
+    def resolve timeout = 60.0
+      resolveWithTimeout timeout
+    end
+  end
+
+  delegating 'netServiceWillPublish:',              to: :will_publish
+  delegating 'netService:didNotPublish:',           to: :did_not_publish,             parameters: ['didNotPublish']
+  delegating 'netServiceDidPublish:',               to: :did_publish
+  delegating 'netServiceWillResolve:',              to: :will_resolve
+  delegating 'netService:didNotResolve:',           to: :did_not_resolve,             parameters: ['didNotResolve']
+  delegating 'netServiceDidResolveAddress:',        to: :did_resolve
+  delegating 'netService:didUpdateTXTRecordData:',  to: :did_update_txt_record_data,  parameters: ['didUpdateTXTRecordData']
+  delegating 'netServiceDidStop:',                  to: :did_stop
+
+end