visual.rb in spiderfw-0.5.11

- old
+ new

@@ -59,41 +59,43 @@
         
         def visual_params
             @visual_params ||= {}
         end
         
-        def init_widgets(template)
+        def init_widgets(template, layout=nil)
             widget_target = @request.params['_wt']
             widget_execute = @request.params['_we']
             if (widget_target && !@rendering_error)
                 first, rest = widget_target.split('/', 2)
-                @_widget = find_widget(first)
+                @_widget = template.find_widget(first)
+                @_widget = layout.find_widget(first) if !@_widget && layout
                 raise Spider::Controller::NotFound.new("Widget #{widget_target}") unless @_widget
                 @_widget.is_target = true unless rest
                 @_widget.set_action(widget_execute) if widget_execute
                 @_widget.target_mode = true
                 @_widget.widget_target = rest
             end
             template.do_widgets_before
+            layout.do_widgets_before if layout
             if @_widget
                 @_widget.execute
                 done
             end
         end
         
         def execute(action='', *params)
             @visual_params = @executed_format_params
-            @is_target = false if @request.params['_wt']
+            @is_target = false if @request.params['_wt'] && !self.is_a?(Spider::Widget)
             if (self.is_a?(Widget) && @is_target && @request.params['_wp'])
                 params = @request.params['_wp']
             elsif (@visual_params.is_a?(Hash) && @visual_params[:params])
                 p_first, p_rest = action.split('/')
                 params = format_params[:params].call(p_rest) if p_rest
             end
             super(action, *params)
             return unless @visual_params.is_a?(Hash)
-            @template = init_template if !@template && @visual_params[:template]
+            @template = get_template if !@template && @visual_params[:template]
             init_widgets(@template) if @template
             if @visual_params[:call]
                 send(@visual_params[:call], *params)
             end
             if @visual_params[:template] && !@_widget && !done?
@@ -136,49 +138,43 @@
         def template_exists?(name)
             self.class.template_exists?(name)
         end
         
         
-        def init_template(path=nil, scene=nil, options={})
+        def get_template(path=nil, scene=nil, options={})
             return @template if @template && @loaded_template_path == path
             scene ||= @scene
             scene ||= get_scene
             if (!path)
                 format_params = @visual_params || self.class.output_format_params(@executed_method, @executed_format)
                 return unless format_params && format_params[:template]
                 path = format_params[:template]
                 options = format_params.merge(options)
             end
             template = load_template(path)
-            do_template_init(template, options)            
+            init_template(template, options)            
             @template = template
             @loaded_template_path = path
 
             return template
         end
         
-        def do_template_init(template, options={})
+        def init_template(template, options={})
+            prepare_template(template) unless template.owner # if called directly
             template.init(scene)
             if (@request.params['_action'])
                 template._widget_action = @request.params['_action']
             else
                 template._action_to = options[:action_to]
                 template._action = @controller_action
             end
             return template
         end
-        
-        def render_layout(path, content={})
-            layout = self.class.load_layout(path)
-            layout.request = @request
-            layout.render(content)
-        end
-        
+                
         def init_layout(layout)
             l = layout.is_a?(Layout) ? layout : self.class.load_layout(layout)
-            l.owner = self
-            l.request = request
+            prepare_template(l)
             return l
         end
         
         def render(path=nil, options={})
             scene = options[:scene] || @scene
@@ -187,25 +183,29 @@
             request = options[:request] || @request
             response = options[:response] || @response
             if (path.is_a?(Spider::Template))
                 template = path
             else
-                template = init_template(path, scene, options)
+                template = get_template(path, scene, options)
             end
-            init_widgets(template)
-            return template if done?
+            layout = nil
             chosen_layouts = options[:layout] || @layout
             chosen_layouts = [chosen_layouts] if chosen_layouts && !chosen_layouts.is_a?(Array)
             if (chosen_layouts)
                 t = template
-                l = nil
+                layout = nil
                 (chosen_layouts.length-1).downto(0) do |i|
-                    l = init_layout(chosen_layouts[i])
-                    l.template = t
-                    t = l
+                    layout = init_layout(chosen_layouts[i])
+                    layout.template = t
+                    t = layout
                 end
-                l.render(scene)
+            end
+            layout.init(scene) if layout
+            init_widgets(template, layout)
+            return template if done?
+            if layout
+                layout.render(scene)
             else
                 template.render(scene)
             end
             return template
         end
@@ -263,10 +263,10 @@
                 begin
                     @scene.devel = true
                     @scene.backtrace = build_backtrace(exc)
                     client_editor = Spider.conf.get('client.text_editor')
                     prefix = 'txmt://open?url=' if client_editor == 'textmate'
-                    @scene.exception = "#{exc.class.name}: #{exc.message}"
+                    @scene.exception = "#{exc.class.name}: #{CGI.escapeHTML(exc.message)}"
                     cnt = 0
                     @scene.backtrace.each do |tr|
                         tr[:index] = cnt
                         cnt += 1
                         suffix = ''