class Vizkit::PluginSpec

# File lib/vizkit/plugin.rb, line 419
def initialize(plugin_name)
    PluginHelper.normalize_obj(plugin_name)
    @plugin_name = PluginHelper.normalize_obj(plugin_name,false).first
    @creation_method = nil
    @callback_specs = Array.new
    @created_plugins = Array.new
    @extensions = Array.new
    @file_names = Array.new
    @flags = {:deprecated => false}
    @on_create_hook = nil
end

# File lib/vizkit/plugin.rb, line 470
def callback_spec(value,callback_type=nil,default=nil,method_name=nil,&block)
    spec = if value.is_a? CallbackSpec
               value
           else
               CallbackSpec.new(value,callback_type,default,method_name,&block)
           end
    spec2 = find_callback_spec!({:argument => spec.argument ,:callback_type => spec.callback_type})
    if spec2
        Vizkit.warn "#{plugin_name}: Ignoring callback for #{spec.argument} and callback type #{spec.callback_type}"
        Vizkit.warn "because only one callback per value and callback type is allowed."
        Vizkit.warn "Please remove the register_widget_for #{plugin_name},#{spec.argument} statement from"
        Vizkit.warn file_names
        return self
    end
    @callback_specs << spec
    self
end

# File lib/vizkit/plugin.rb, line 435
def clone
    obj = self.dup
    obj.instance_variable_set(:@callback_specs,@callback_specs.map{|element| element.clone})
    obj.instance_variable_set(:@flags,@flags.clone)
    obj
end

# File lib/vizkit/plugin.rb, line 546
def create_plugin(parent=nil)
    raise "Plugin #{plugin_name} cannot be created: No creation method was specified" unless @creation_method 
    plugin = if @creation_method.arity == 1
                 @creation_method.call(parent)
             else
                 @creation_method.call()
             end
    extend_plugin(plugin)
end

# File lib/vizkit/plugin.rb, line 556
def created_plugins
    @created_plugins
end

# File lib/vizkit/plugin.rb, line 453
def creation_method(method=nil,&block)
    if(method || block)
        @creation_method = (method || block)
        if @creation_method.respond_to? :to_sym
            klass = PluginHelper.class_from_string plugin_name
            raise "Cannot create class #{plugin_name} to look for creation method #{method}" unless klass
            if method.to_sym != :new && !klass.method_defined?(method)
                raise "Class #{plugin_name} has no method called #{method} which is specified as creation method"
            end
            @creation_method = klass.method(method)
        end
        self
    else
        @creation_method
    end
end

# File lib/vizkit/plugin.rb, line 560
def extend_plugin(plugin)
    return unless plugin
    if !plugin.respond_to?:plugin_spec
        if plugin.instance_variable_defined?:@__plugin_spec
            raise "Cannot add instance variable @__plugin_spec to plugin #{plugin_name} because it is already defined!"
        end
        plugin.instance_variable_set(:@__plugin_spec__,self)
        def plugin.plugin_spec
            @__plugin_spec__
        end
        def plugin.pretty_print(pp)
            pp plugin_spec
        end
    else
        #we have to overwrite it if the widget was created via ui -file
        #because the ui loader will add a plugin spec
        plugin.instance_variable_set(:@__plugin_spec__,self)
    end
    @extensions.each do |extension|
        plugin.extend extension
    end
    if @on_create_hook
        @on_create_hook.call(plugin)
    end
    @created_plugins << plugin 
    plugin
end

# File lib/vizkit/plugin.rb, line 449
def extension(mod=nil,&block)
    extensions(mod || block)
end

# File lib/vizkit/plugin.rb, line 431
def file_name(name)
    file_names(name)
end

# File lib/vizkit/plugin.rb, line 505
def find_all_callback_specs(*pattern)
    return Array.new if pattern.empty? 
    @callback_specs.find_all do |spec|
        spec.match?(*pattern)
    end
end

# File lib/vizkit/plugin.rb, line 535
def find_all_callbacks(*pattern)
    find_all_callback_specs(*pattern).map do |spec|
        spec.callback
    end
end

# File lib/vizkit/plugin.rb, line 541
def find_callback!(*pattern)
    spec = find_callback_spec!(*pattern)
    return spec.callback if spec 
end

# File lib/vizkit/plugin.rb, line 512
def find_callback_spec!(*pattern)
    return if pattern.empty?
    pattern = pattern.first
    names = PluginHelper.normalize_obj(pattern[:argument])
    names << nil if names.empty?
    pattern = pattern.dup
    pattern[:exact] = true
    specs = Array.new
    names.each do |name|
        pattern[:argument] = name
        result = find_all_callback_specs(pattern)
        if !result.empty?
            specs = result
            break
        end
    end
    if specs.size > 1
        raise ArgumentError, "Vizkit faild to find the right plugin callback for plugin #{plugin_name} and search pattern #{pattern.inspect}." + 
                             " #{specs.size} callbacks were found and vizkit cannot decide which one is right."
    end
    specs.first
end

# File lib/vizkit/plugin.rb, line 494
def match?(*pattern)
    return if pattern.empty?
    pattern = pattern.first
    pattern, subpattern= Kernel.filter_options pattern,:plugin_name=> nil,:cplusplus_name => nil,:flags =>nil
    return if pattern[:plugin_name] && plugin_name != pattern[:plugin_name]
    return if pattern[:cplusplus_name] && cplusplus_name !=  pattern[:cplusplus_name]
    return if pattern[:flags] && flags.merge(pattern[:flags]) != flags
    return if !subpattern.empty? && find_all_callback_specs(subpattern).empty?
    true
end

# File lib/vizkit/plugin.rb, line 444
def on_create(&block)
    @on_create_hook = block
    self
end

# File lib/vizkit/plugin.rb, line 588
def pretty_print(pp)
    pp.text "=========================================================="
    pp.breakable
    pp.text "Plugin name: #{plugin_name}"
    pp.breakable
    pp.text "Plugin type: #{plugin_type}"
    pp.breakable
    pp.text "C++ name: #{cplusplus_name}"
    pp.breakable
    pp.text "Lib name: #{lib_name}"
    pp.breakable
    pp.text "file name(s): #{file_names.join(",")}"
    pp.breakable
    if doc
        pp.text @doc
        pp.breakable
    end
    if !flags.empty?
        pp.text "Flags:"
        pp.nest(2) do 
            flags.each_pair do |key,val|
                pp.breakable
                pp.text "#{key} => #{val}"
            end
        end
        pp.breakable
    end
    pp.text "Extensions: "
    pp.breakable
    @extensions.each do |ext|
        pp.text "  Module name: #{ext.name||"Unknown"}"
        pp.breakable
        pp.text "    Methods:"
        pp.breakable
        ext.instance_methods.each do |m|
            pp.text "      #{m.to_s}"
            pp.breakable
        end
    end
    pp.text "Registered for: "
    pp.nest(2) do
        pp.breakable
        @callback_specs.each do |spec|
            spec.pretty_print(pp)
        end
    end
end