Class: MetaRuby::GUI::RenderingManager

Inherits:
Qt::Object
  • Object
show all
Defined in:
lib/metaruby/gui/rendering_manager.rb

Overview

Management of HTML rendering of objects of different types

Objects of this class allow to register a set of renderers, dedicated to rendering objects of a certain type (defined as a superclass) and automatically switch between the rendering objects.

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(page = nil) ⇒ RenderingManager

Create a rendering manager that acts on a given page



22
23
24
25
26
 
# File 'lib/metaruby/gui/rendering_manager.rb', line 22

def initialize(page = nil)
    super()
    @page = page
    @available_renderers = Hash.new
end

Instance Attribute Details

#available_renderers ⇒ {Model=>Object} (readonly)

Returns set of rendering objects that are declared. The Model is a class or module that represents the set of models that the renderer can handle. It is ordered by order of priority, i.e. the first model that matches will be used. Do not modify directly, use #register_type instead.

Returns:

  • ({Model=>Object}) —

    set of rendering objects that are declared. The Model is a class or module that represents the set of models that the renderer can handle. It is ordered by order of priority, i.e. the first model that matches will be used. Do not modify directly, use #register_type instead



17
18
19
 
# File 'lib/metaruby/gui/rendering_manager.rb', line 17

def available_renderers
  @available_renderers
end

#current_renderer ⇒ Object (readonly)

The rendering object used last in #render



19
20
21
 
# File 'lib/metaruby/gui/rendering_manager.rb', line 19

def current_renderer
  @current_renderer
end

#page ⇒ #push

Returns the page object on which we render.

Returns:

  • (#push) —

    the page object on which we render



10
11
12
 
# File 'lib/metaruby/gui/rendering_manager.rb', line 10

def page
  @page
end

Instance Method Details

#clear ⇒ Object

Clear the current renderer



105
106
107
108
109
 
# File 'lib/metaruby/gui/rendering_manager.rb', line 105

def clear
    if current_renderer
        current_renderer.clear
    end
end

#disable ⇒ Object

Disable the current renderer



91
92
93
94
95
 
# File 'lib/metaruby/gui/rendering_manager.rb', line 91

def disable
    if current_renderer
        current_renderer.disable
    end
end

#enable ⇒ Object

Enable the current renderer



98
99
100
101
102
 
# File 'lib/metaruby/gui/rendering_manager.rb', line 98

def enable
    if current_renderer
        current_renderer.enable
    end
end

#find_renderer(mod) ⇒ (Class,(#render,Hash))?

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Find a rendering object for the given object

Parameters:

  • mod (Object) —

    the object we need to render

Returns:

  • ((Class,(#render,Hash)), nil) —

    either the base class, rendering object and rendering options that should be used for the given object, or nil if there are no matching rendering objects



84
85
86
87
88
 
# File 'lib/metaruby/gui/rendering_manager.rb', line 84

def find_renderer(mod)
    available_renderers.find do |model, _|
        mod.kind_of?(model) || (mod.kind_of?(Module) && model.kind_of?(Module) && mod <= model)
    end
end

#register_type(type, rendering_class, render_options = Hash.new) ⇒ Object

Registers a certain kind of model as well as the information needed to display it

It registers the given type on the model browser so that it gets displayed there.

Parameters:

  • type (Class) —

    objects whose class or ancestry include ‘type’ will be rendered using the provided rendering class. If more tha none matches, the first one is used.

  • rendering_class (Class) —

    a class from which a relevant rendering object can be created. The generated instances must follow the rules described in the documentation of ModelBrowser

  • render_options (Hash) (defaults to: Hash.new) —

    a set of options that must be passed to the renderer’s #render method



53
54
55
56
57
58
59
60
61
 
# File 'lib/metaruby/gui/rendering_manager.rb', line 53

def register_type(type, rendering_class, render_options = Hash.new)
    render = if rendering_class.kind_of?(Class)
                 rendering_class.new(page)
             else
                 rendering_class
             end
    available_renderers[type] = [render, render_options]
    connect(render, SIGNAL('updated()'), self, SIGNAL('updated()'))
end

#registered_exceptions ⇒ Array<Exception>

A list of exceptions that happened during rendering

Returns:

  • (Array<Exception>) 


31
32
33
34
35
36
 
# File 'lib/metaruby/gui/rendering_manager.rb', line 31

def registered_exceptions
    if current_renderer.respond_to?(:registered_exceptions)
        current_renderer.registered_exceptions
    else []
    end
end

#render(object, **push_options) ⇒ Object

Call to render the given model

The renderer that has been used is made active (enabled) and stored in #current_renderer. The previous one is disabled and cleared.

Parameters:

  • object (Model) —

    the model that should be rendered

  • push_options (Hash) —

    options that should be passed to the object’s renderer #render method

Raises:

  • (ArgumentError) —

    if there is no view available for the given model



122
123
124
125
126
127
128
129
130
131
132
133
134
135
 
# File 'lib/metaruby/gui/rendering_manager.rb', line 122

def render(object, **push_options)
    _, (renderer, render_options) = find_renderer(object)
    if renderer
        if current_renderer
            current_renderer.clear
            current_renderer.disable
        end
        renderer.enable
        renderer.render(object, render_options.merge(push_options))
        @current_renderer = renderer
    else
        Kernel.raise ArgumentError, "no view available for #{object} (#{object.class})"
    end
end