window_rails 0.1.5 → 0.2.0

data/CHANGELOG.rdoc

@@ -1,3 +1,6 @@
+== v0.2.0
+* Rebuild off jquery-ui dialogs
+
 == v0.1.4
 * Fix to #update_window method to accept content not key
 

data/LICENSE

@@ -1,6 +1,6 @@
 Current WindowRails License:
 
-Copyright (c) 2010 Chris Roberts <chrisroberts.code@gmail.com>
+Copyright (c) 2011 Chris Roberts <chrisroberts.code@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
@@ -20,25 +20,3 @@ LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-
-Original Prototype Window License:
-
-Copyright (c) 2006 Sébastien Gruhier (http://xilinus.com, http://itseb.com)
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -1,33 +1,26 @@
-== WindowRails
+== WindowRails (for jQuery)
 
 WindowRails is a plugin for Rails that provides easy to use AJAXy windows. It is based
-completely on {Prototype Window}[http://prototype-window.xilinus.com/] with helpers for
-Rails to make it easy to use from a Rails app.
+completely on {jquery-ui}[http://jquery-ui.com] and the [jQuery Window Plugin}[http://fstoke.me/jquery/window/]
+with helpers for Rails to make it easy to use from a Rails app.
 
-== Configuration
+== Requirements
 
-After install, add these in the head of your application.html.erb file:
+* jQuery
+* jQuery-UI with Dialog widget enabled
 
-  <%= javascript_include_tag 'window_rails/window' %>
-  <%= stylesheet_link_tag *%w(/themes/alphacube /themes/default /themes/alert) %>
-  
-Alphacube is the default theme used by window_rails. Be sure to add the css link if you plan on using other themes.
-
-=== Gem based installs
-
-Gem based installs (bundler) will need to run the install task. For rails versions < 3 the task
-must be added to the Rakefile:
-
-  require 'window_rails/tasks'
-
-Then run the install:
+== Installation
 
   rake window_rails:install
 
 === Basic examples to get you started
 
 ==== Linking to a window
-  <%= link_to_window('Link', :url => {:controller => :my_controller, :action => :my_action}, :modal => true, :className => 'alphacube', :window => 'some_name') %>
+===== Load an entire HTML page into an IFrame
+  <%= link_to_window('Link', :iframe => {:controller => :my_controller, :action => :my_action}, :window => 'some_name') %>
+
+===== Load a partial page directly into the DOM within the window
+  <%= link_to_window('Link', :url => {:controller => :my_controller, :action => :my_action}, :width => 400, :height => 300, :window => 'some_name') %>
   
 ==== Opening a window via AJAX
   def open_my_window
@@ -35,7 +28,7 @@ Then run the install:
       format.html
       format.js do
         render :update do |page|
-          page.open_window({:partial => 'my_partial'}, :modal => true, :width => 400, :height => 200, :window => 'my_window')
+          page.open_window({:partial => 'my_partial'}, :width => 400, :height => 200, :window => 'my_window')
         end
       end
     end
@@ -73,11 +66,6 @@ Then run the install:
 
 {Issues}[http://github.com/chrisroberts/window_rails/issues]
 
-== Thanks
-
-* Many thanks to Sébastien Gruhier (creator of {Prototype Window}[http://prototype-window.xilinus.com/])
-
 == License
 
-* Prototype Window was released under the MIT license
-* WindowRails continues on under the MIT license
+* WindowRails is released under an MIT license

data/app/controllers/window_rails_controller.rb

@@ -1,5 +1,7 @@
-class WindowRailsController < ActionController::Base
-  
+class WindowRailsController < ApplicationController
+
+  unloadable
+
   # Make sure we kick any thing out that is making a request other
   # than openning a new window
   before_filter :redirect_out, :except => :open_window
@@ -26,10 +28,23 @@ class WindowRailsController < ActionController::Base
         redirect_to '/'
       end
       format.js do
+        opts = {}
+        content = nil
+        if(params[:window_url].blank?)
+          content = {:url => params[:iframe_url]}
+        else
+          content = {:content_url => params[:window_url]}
+        end
+        base_key = params[:window_options] ? :window_options : 'window_options'
+        if(params[base_key])
+          params[base_key].keys.each do |key|
+            opts[key.to_sym] = params[base_key][key]
+          end
+        end
         render :update do |page|
-          page.open_window({:url => params[:window_url]}, params[:window_options])
+          page.open_window(content, opts || {})
         end
       end
     end
   end
-end
+end

data/lib/window_rails.rb

@@ -1,5 +1,9 @@
 require 'window_rails/version'
 
-if(defined?(Rails))
-  require File.join(File.dirname(__FILE__), '..', 'init')
+if(defined?(Rails::Engine))
+  require 'window_rails/engine'
+else
+  %w(window_rails_generators window_rails_view).each do |part|
+    require "window_rails/#{part}"
+  end
 end

data/lib/window_rails/engine.rb

@@ -0,0 +1,15 @@
+module WindowRails
+  class Engine < Rails::Engine
+    
+    rake_tasks do
+      require 'window_rails/tasks'
+    end
+
+    # We do all our setup in here
+    config.to_prepare do
+      %w(window_rails_generators window_rails_view).each do |part|
+        require "window_rails/#{part}"
+      end
+    end
+  end
+end

data/lib/window_rails/tasks.rb

@@ -1,7 +1,69 @@
-namespace :window_rails  do 
-  desc 'Install required library items'
+require 'fileutils'
+
+namespace :window_rails  do
+
+  desc 'Install window_rails'
   task :install do
-    require File.join(File.dirname(__FILE__), '..', '..', 'install.rb')
+    FileUtils.mkdir_p(File.join(Rails.root, 'public', 'window_rails'))
+    Rake::Task['window_rails:install_javascripts'].invoke
+    Rake::Task['window_rails:install_stylesheets'].invoke
+    Rake::Task['window_rails:install_assets'].invoke
+    Rake::Task['window_rails:install_version'].invoke
+    puts '*' * 50
+    puts 'WindowRails installation is complete.'
+    puts 'NOTE: Please refer to README file for any additional setup.'
+    puts '*' * 50
+  end
+
+  task :upgrade do
+    Rake::Task['window_rails:install_javascripts'].invoke
+    Rake::Task['window_rails:install_stylesheets'].invoke
+    Rake::Task['window_rails:install_assets'].invoke
+    puts 'WindowRails files have been updated to most current version'
+  end
+
+  task :install_javascripts do
+    install_items('javascripts')
+  end
+
+  task :install_stylesheets do
+    install_items('stylesheets')
   end
+
+  task :install_assets do
+    install_items('images')
+  end
+
+  task :install_version do
+    f = File.open(File.join(Rails.root, 'public', 'window_rails', 'version'), 'w')
+    f.write WindowRails::VERSION
+    f.close
+    puts 'Version file written'
+  end
+
+  desc 'Output current version information'
+  task :version do
+    asset_version = nil
+    if(File.exists?(File.join(Rails.root, 'public', 'window_rails', 'version')))
+      asset_version = File.read(File.join(Rails.root, 'public', 'window_rails', 'version')).strip
+    end
+    puts "Current WindowRails version: #{WindowRails::VERSION}"
+    puts "Current WindowRails assets version: #{asset_version}"
+    if(WindowRails::VERSION != asset_version.to_s)
+      puts "WARNING #{'*' * 50}"
+      puts 'WindowRails assets within project are out of date'
+      puts 'Please run: rake window_rails:upgrade'
+      puts "WARNING #{'*' * 50}"
+    end
+  end
+end
+
+def install_items(item)
+  FileUtils.mkdir_p(File.join(Rails.root, 'public', 'window_rails', item))
+  FileUtils.cp_r(
+    File.join(File.dirname(__FILE__), '..', '..', 'files', item, File::SEPARATOR, '.'), 
+    File.join(Rails.root, 'public', 'window_rails', item)
+  )
+  puts "#{item.titleize} files installed."
 end
 

data/lib/window_rails/version.rb

@@ -1,3 +1,3 @@
 module WindowRails
-  VERSION = '0.1.5'
+  VERSION = '0.2.0'
 end

data/lib/window_rails/window_rails_generators.rb

@@ -1,5 +1,8 @@
+require 'rails_javascript_helpers'
+
 module WindowRailsGenerators
-  
+
+  include RailsJavaScriptHelpers
   include ActionView::Helpers::JavaScriptHelper
   include ActionView::Helpers::TagHelper
   
@@ -8,7 +11,27 @@ module WindowRailsGenerators
   # Opens an alert window
   def open_alert_window(msg, options={})
     options[:width] ||= 200
-    self << "Dialog.alert('#{escape_javascript(msg)}', {#{options.map{|k,v|"#{escape_javascript(k.to_s)}:'#{escape_javascript(v.to_s)}'"}.join(',')}});"
+    options[:modal] = true
+    options[:title] ||= 'Alert!'
+    options[:buttons] ||= {'OK' => 'function(){ jQuery(this).dialog("close");}'}
+    store_content(msg, 'alert_modal');
+    self << "
+      if(jQuery('#alert_modal').size() == 0){
+        jQuery('<div id=\"alert_modal\"></div>')
+          .html(window_rails_contents['alert_modal'])
+            .dialog(#{format_type_to_js(options)});
+      } else {
+        jQuery('#alert_modal')
+          .html(window_rails_contents['alert_modal'])
+            .dialog(#{format_type_to_js(options)}).focus();
+      }"
+      nil
+  end
+
+  # Closes alert window
+  def close_alert_window
+    self << 'jQuery("#alert_modal").dialog("close");'
+    nil
   end
 
   # msg:: Confirmation message
@@ -16,7 +39,21 @@ module WindowRailsGenerators
   # Opens a confirmation window
   def open_confirm_window(msg, options={})
     options[:width] ||= 200
-    self << "Dialog.confirm('#{escape_javascript(msg)}', {#{options.map{|k,v|"#{escape_javascript(k.to_s)}:'#{escape_javascript(v.to_s)}'"}.join(',')}});"
+    options[:modal] = true
+    options[:title] ||= 'Confirm'
+    options[:buttons] ||= {'OK' => 'function(){ jQuery(this).dialog("close");}'}
+    store_content(msg, 'confirmation_modal')
+    self << "
+      if(jQuery('#confirmation_modal').size() == 0){
+        jQuery('<div id=\"confirmation_modal\"></div>')
+          .html(window_rails_contents['confirmation_modal'])
+            .dialog(#{format_type_to_js(options)});
+      } else {
+        jQuery('#confirmation_modal')
+          .html(window_rails_contents['confirmation_modal'])
+            .dialog(#{format_type_to_js(options)}).focus();
+      }"
+    nil
   end
   
   # msg:: Information message
@@ -24,19 +61,62 @@ module WindowRailsGenerators
   # Open an information window
   def open_info_window(msg, options={})
     options[:width] ||= 200
-    self << "Dialog.info('#{escape_javascript(msg)}', {#{options.map{|k,v|"#{escape_javascript(k.to_s)}:'#{escape_javascript(v.to_s)}'"}.join(',')}});"
+    options[:modal] = true
+    options[:title] ||= 'Information'
+    options[:close_on_escape] = false
+    store_content(msg, 'information_modal')
+    self << "
+      if(jQuery('#information_modal').size() == 0){
+        jQuery('<div id=\"information_modal\"></div>')
+          .html(window_rails_contents['information_modal'])
+            .dialog(#{format_type_to_js(options)});
+      } else {
+        jQuery('#information_modal')
+          .html(window_rails_contents['information_modal'])
+            .dialog(#{format_type_to_js(options)}).focus();
+      }"
+    nil
   end
   
   # Close an information window
   def close_info_window
-    self << "Dialog.closeInfo();"
+    self << 'jQuery("#information_modal").dialog("close");'
+    nil
   end
   
   # Update the contents of an information window
   def update_info_window(msg)
-    self << "Dialog.setInfoMessage('#{escape_javascript(msg)}');"
+    self << 'jQuery("#information_modal").html(#{format_type_to_js(msg)});'
+    nil
   end
-  
+
+  def window_setup
+    @set ||= false
+    unless(@set)
+      self << '
+        if(typeof(window.window_rails_windows) == "undefined") {
+          window.window_rails_windows = {};
+        } if(typeof(window_rails_windows_array) == "undefined") {
+          window.window_rails_windows_array = new Array();
+        }
+        '
+    end
+    @set = true
+    nil
+  end
+
+  def window(dom_id)
+    window_setup
+    unless(dom_id.blank?)
+      dom_id = dom_id.to_s.dup
+      dom_id.slice!(0) if dom_id.start_with?('#')
+      self << "window.window_rails_windows['#{dom_id}']"
+    else
+      self << "window.window_rails_windows[window.window_rails_windows_array[0]]"
+    end
+    self
+  end
+
   # content:: content
   # options:: Hash of options
   #   * window -> Name of the window to update (defaults to last window)
@@ -49,7 +129,8 @@ module WindowRailsGenerators
     win = options.delete(:window)
     error = options.delete(:error)
     key = store_content(content)
-    self << check_for_window(win, error){ update_window_contents(key, win) }
+    self << check_for_window(win, error){ update_window_contents(key, win, options) }
+    nil
   end
   
   # name:: Name of the window
@@ -57,67 +138,46 @@ module WindowRailsGenerators
   # Checks for a window of the given name. If a block is provided, it will be executed
   # if the window is found
   def check_for_window(name, error=true)
+    name = name.to_s.dup
+    name.slice!(0) if name.start_with?('#')
+    window_setup
     if(name.blank?)
-      self <<  "if(Windows.windows.values().size() > 0){"
+      self << "if(window.window_rails_windows.length > 0){"
     else
-      self << "if(Windows.existsByName('#{escape_javascript(name)}')){"
+      self << "if(window.window_rails_windows['#{name}']){"
     end
     yield if block_given?
     self << "}"
     self << "else { alert('Unexpected error. Failed to locate window for output.'); }" if error
-  end
-  
-  # Simply wraps a block within an else statement
-  def else_block
-    self << "else {"
-    yield if block_given?
-    self << "}"
+    nil
   end
   
   # key:: Content key location
   # win:: Name of window
   # Updates the contents of the window. If no window name is provided, the topmost window
   # will be updated
-  def update_window_contents(key, win=nil)
-    unless(win.blank?)
-      self << "Windows.getWindowByName('#{escape_javascript(win)}').setHTMLContent(window_rails_contents.get('#{key}'));"
-    else
-      self << "Windows.windows.values().last().setHTMLContent(window_rails_contents.get('#{key}'));"
-    end
+  def update_window_contents(key, win, options)
+    window(win) << ".html(window.window_rails_contents[#{format_type_to_js(key.to_s)}]);"
+    nil
   end
 
   # win:: Name of window
   # Will focus the window. If no name provided, topmost window will be focused
   def focus_window(win=nil)
-    unless(win.blank?)
-      self << "Windows.focus(Windows.getWindowByName('#{escape_javascript(win)}').getId());"
-    else
-      self << "Windows.focus(Windows.windows.values().last().getId());"
-    end
+    window(win) << '.dialog("focus");'
+    nil
   end
 
   # win:: Name of window
   # Will maximize the window. If no name provided, topmost window will be maximized
   def maximize_window(win=nil)
-    check_for_window(name) do
-      if(name)
-        self << "Windows.getWindowByName('#{escape_javascript(win)}').maximize();"
-      else
-        self << "Windows.windows.values().last().maximize();"
-      end
-    end
+    # noop
   end
 
   # win:: Name of window
   # Will minimize the window. If no name provided, topmost window will be minimized
   def minimize_window(win)
-    check_for_window(name) do
-      if(name)
-        self << "Windows.getWindowByName('#{escape_javascript(win)}').minimize();"
-      else
-        self << "Windows.windows.values().last().minimize();"
-      end
-    end
+    # noop
   end
 
   # key:: Content key location
@@ -126,10 +186,56 @@ module WindowRailsGenerators
   # Creates a new window. Generally this should not be called,
   # rather #open_window should be used
   def create_window(key, win, options)
-    self << "var myWin = new Window({#{options.map{|k,v|"#{escape_javascript(k.to_s)}:'#{escape_javascript(v.to_s)}'"}.join(', ')}});"
-    self << "Windows.registerByName('#{escape_javascript(win)}', myWin);" unless win.blank?
-    self << "myWin.setHTMLContent(window_rails_contents.get('#{key}'));"
-    self << "myWin.setCloseCallback(function(win){ win.destroy(); return true; });"
+    options[:auto_open] ||= false
+    options[:close] = "function(event,ui){ 
+      #{
+        if(options[:close])
+          "callback = #{options[:close]}; callback();"
+        end
+      }
+      jQuery('##{win}').dialog('destroy'); 
+      window.window_rails_windows['#{win}'] = null;
+      window.window_rails_windows_array.splice(window.window_rails_windows_array.indexOf('#{win}'), 1);
+      jQuery('##{win}').remove();
+    }"
+    unless(win.is_a?(String))
+      win = win.to_s
+    end
+    if(win.start_with?('#'))
+      win.slice!(0)
+    end
+    window_setup
+    self << "
+      if(jQuery('#window_rails_windows').size() == 0){
+        jQuery('body').append('<div id=\"window_rails_windows\" style=\"visibility:hidden;display:none;\"></div>');
+      }
+      if(jQuery('##{win}').size() == 0){
+        jQuery('#window_rails_windows').append('<div id=\"#{win}\"></div>');
+      }
+      window.window_rails_windows['#{win}'] = jQuery('##{win}');
+      window.window_rails_windows_array.push('#{win}');
+    "
+    if(key == :url)
+      options[:auto_open] = true
+      self << "
+        jQuery.get(
+          '#{options.delete(:url)}',
+          function(data){
+            window.window_rails_windows['#{win}']
+              .html(data)
+                .dialog(#{format_type_to_js(options)})
+                  .dialog('open');
+          }
+        );
+      "
+    else
+      self << "
+        window.window_rails_windows['#{win}']
+          .html(window.window_rails_contents['#{key}'])
+            .dialog(#{format_type_to_js(options)});
+      "
+    end
+    nil
   end
   
   # win:: Name of window
@@ -137,30 +243,15 @@ module WindowRailsGenerators
   # Shows the window centered on the screen. If no window name is provided
   # it will default to the last created window. Generally this should not
   # be called, rather #open_window should be used
+  # NOTE: No modal mode currently
   def show_window(win, modal)
-    s = nil
-    unless(win.blank?)
-      s = "Windows.getWindowByName('#{escape_javascript(win)}')"
-    else
-      s = 'Windows.windows.values().last()'
-    end
-    self << "#{s}.showCenter(#{modal ? 'true' : 'false'});"
-  end
-  
-  # win:: Name of window
-  # constraints:: Constaint hash {:left, :right, :top, :bottom}
-  # Sets the constraints on the window. Generally this should not be used,
-  # rather #open_window should be used
-  def apply_window_constraints(win, constraints)
-    opts = {:left => 0, :right => 0, :top => 0, :bottom => 0}
-    opts.merge!(constraints) if constraints.is_a?(Hash)
-    s = nil
-    unless(win.blank?)
-      s = "Windows.getWindowByName('#{escape_javascript(win)}')"
-    else
-      s = "Windows.windows.values().last()"
+    modal ||= false
+    check_for_window(win) do
+      window(win) << ".dialog('option', 'modal', #{format_type_to_js(modal)});"
+      window(win) << ".dialog('option', 'autoOpen', true);"
+      window(win) << '.dialog("open");'
     end
-    self << "#{s}.setConstraint(true, {#{opts.map{|k,v|"#{escape_javascript(k.to_s)}:'#{escape_javascript(v.to_s)}'"}.join(', ')}});"
+    nil
   end
   
   # content:: Content for window
@@ -171,7 +262,6 @@ module WindowRailsGenerators
   #   * :iframe -> URL to load within an IFrame in the window
   #   * :width -> Width of the window
   #   * :height -> Height of the window
-  #   * :className -> Theme name for the window
   #   * :no_update -> Set to true to force creation of a new window even if window of same name already exists (defaults to false)
   # Creates a new window and displays it at the center of the viewport. Content can be provided as
   # a string, or as a Hash. If :url is defined, the window will be loaded with the contents of the request. If not, the hash
@@ -183,14 +273,16 @@ module WindowRailsGenerators
   #   be isolated from the current page, but this isolation means it cannot communicate with other windows on the page (including
   #   its own).
   def open_window(content, options={})
-    modal = options.delete(:modal)
-    win = options.delete(:window)
-    constraints = options.delete(:constraints)
-    no_update = options.delete(:no_update)
-    options[:className] = 'alphacube' unless options[:className]
+    key = nil
+    if(options[:iframe])
+      iframe = @context.url_for(options.delete(:iframe))
+    end
     if(content.is_a?(Hash))
       if(content[:url])
-        options[:url] = @context.url_for(content[:url])
+        options[:iframe] = @context.url_for(content[:url])
+        content = nil
+      elsif(content[:content_url])
+        options[:url] = @context.url_for(content[:content_url])
         content = nil
       else
         content = @context.render(content)
@@ -198,34 +290,42 @@ module WindowRailsGenerators
     end
     options[:width] ||= 300
     options[:height] ||= 200
-    key = store_content(content)
-    if(no_update)
+    modal = options[:modal]
+    if(options[:on_close])
+      options[:close] = options.delete(:on_close)
+    end
+    if(options[:iframe])
+      key = :iframe
+    elsif(options[:url])
+      key = :url
+    else
+      key = store_content(content)
+    end
+    win = options.delete(:window) || "win_#{rand(99999)}"
+    if(options.delete(:no_update))
       create_window(key, win, options)
-      unless(constraints == false)
-        apply_window_constraints(win, constraints)
-      end
       show_window(win, modal)
     else
       check_for_window(win, false) do
-        update_window_contents(key, win)
+        update_window_contents(key, win, options)
         focus_window(win)
       end
       else_block do
         create_window(key, win, options)
-        unless(constraints == false)
-          apply_window_constraints(win, constraints)
-        end
         show_window(win, modal)
       end
     end
+    nil
   end
 
-  def store_content(content)
-    key = rand.to_s
-    key.slice!(0,2)
+  def store_content(content, key=nil)
+    unless(key)
+      key = rand.to_s
+      key.slice!(0,2)
+    end
     c = content.is_a?(Hash) ? @context.render(content) : content.to_s
-    self << "if(typeof(window_rails_contents) == 'undefined'){ var window_rails_contents = new Hash(); }"
-    self << "window_rails_contents.set('#{key}', '#{escape_javascript(c)}')"
+    self << "if(typeof(window.window_rails_contents) == 'undefined'){ window.window_rails_contents = {}; }"
+    self << "window.window_rails_contents[#{format_type_to_js(key.to_s)}] = #{format_type_to_js(c)};"
     key
   end
   
@@ -233,24 +333,37 @@ module WindowRailsGenerators
   #   * :window -> name of window to close
   # Close the window of the provided name or the last opened window
   def close_window(options = {})
-    win = options.is_a?(Hash) ? options.delete(:window) : options.to_s
-    self << "var myWin = null;"
-    unless(win.blank?)
-      self << "myWin = Windows.getWindowByName('#{escape_javascript(win)}');"
+    win_name = if(options.is_a?(Hash))
+      (options[:window] || options[:name]).to_s
+    elsif(options.is_a?(Array))
+      options.map(&:to_s)
     else
-      self << "if(Windows.windows.values().last()){ myWin = Windows.windows.values().last(); }"
+      options.to_s
+    end
+    win_name.each do |win|
+      window(win) << '.dialog("close");'
     end
-    self << "if(myWin){ myWin.close(); }"
   end
   
   # Close all open windows
   def close_all_windows
-    self << "Windows.closeAll();"
+    setup_windows
+    self << '
+      jQuery.each(
+        window_rails_windows_array,
+        function(name, win){
+          window.window_rails_windows[win].dialog("close");
+        }
+      );
+    '
   end
   
   # args:: List of window names to refresh (All will be refreshed if :all is included)
   # Refresh window contents
+  # NOTE: Currently does nothing
+  # NOTE: Deprecated (remaining temporarily for compatibility reasons)
   def refresh_window(*args)
+  return
     self << "var myWin = null;"
     if(args.include?(:all))
       self << "Windows.windows.values().each(function(win){ win.refresh(); });"
@@ -266,7 +379,10 @@ module WindowRailsGenerators
   # options:: Options
   # Helper for observing fields that have been dynamically loaed into the DOM. Works like
   # #observe_field but not as full featured. 
-  def observe_dynamically_loaded_field(field_id, options={})
+  # NOTE: Currently does nothing
+  # NOTE: Deprecated (remaining temporarily for compatibility reasons)
+  def observe_dynamically_loaded_field(field_id, options={}) # :nodoc
+  return
     f = options.delete(:function)
     unless(f)
       f = "function(event){ new Ajax.Request('#{escape_javascript(@context.url_for(options[:url]).to_s)}', {asynchronous:true, evalScripts:true,parameters:'#{escape_javascript(options[:with].to_s)}='+$('#{escape_javascript(options[:with].to_s)}').getValue()})}"
@@ -275,5 +391,16 @@ module WindowRailsGenerators
     end
     self << "if($('#{escape_javascript(field_id.to_s)}')){ $('#{escape_javascript(field_id.to_s)}').observe('change', #{f}); }"
   end
-  
+
+  private
+
+  # Simply wraps a block within an else statement
+  def else_block
+    self << "else {"
+    yield if block_given?
+    self << "}"
+    nil
+  end
+
 end
+ActionView::Helpers::PrototypeHelper::JavaScriptGenerator::GeneratorMethods.send :include, WindowRailsGenerators