├── .gitignore
├── .ruby-version
├── Gemfile
├── Gemfile.lock
├── Procfile
├── Rakefile
├── app
├── controllers
│ ├── application_controller.rb
│ ├── corrections_controller.rb
│ ├── home_controller.rb
│ ├── results_controller.rb
│ ├── stats_controller.rb
│ └── votes_controller.rb
├── helpers
│ └── application_helper.rb
├── models
│ ├── article.rb
│ ├── normalized_tagging.rb
│ ├── normalized_term.rb
│ ├── tagging.rb
│ ├── term.rb
│ └── vote.rb
└── views
│ ├── corrections
│ └── new.html.erb
│ ├── home
│ └── index.html.erb
│ ├── layouts
│ └── application.html.erb
│ ├── results
│ ├── _pagination.html.erb
│ └── index.html.erb
│ ├── stats
│ └── index.html.erb
│ └── votes
│ ├── done.html.erb
│ └── new.html.erb
├── bin
├── bundle
├── rails
├── rake
├── setup
├── update
└── yarn
├── config.ru
├── config
├── application.rb
├── boot.rb
├── cable.yml
├── database.yml
├── environment.rb
├── environments
│ ├── development.rb
│ ├── production.rb
│ └── test.rb
├── initializers
│ ├── application_controller_renderer.rb
│ ├── assets.rb
│ ├── backtrace_silencers.rb
│ ├── content_security_policy.rb
│ ├── cookies_serializer.rb
│ ├── filter_parameter_logging.rb
│ ├── inflections.rb
│ ├── mime_types.rb
│ ├── new_framework_defaults_5_2.rb
│ ├── session_store.rb
│ └── wrap_parameters.rb
├── locales
│ └── en.yml
├── routes.rb
├── spring.rb
└── storage.yml
├── db
├── migrate
│ ├── 20090706224559_initial_models.rb
│ ├── 20090714204353_add_term_tables.rb
│ └── 20090719224733_vote_against_normalized_taggings.rb
├── schema.rb
└── seeds.rb
├── latest.dump
├── lib
├── assets
│ └── .gitkeep
└── tasks
│ └── .gitkeep
├── log
└── .gitkeep
├── public
├── 404.html
├── 422.html
├── 500.html
├── assets
│ └── manifest.yml
├── favicon.ico
├── images
│ └── rails.png
├── javascripts
│ ├── application.js
│ ├── controls.js
│ ├── dragdrop.js
│ ├── effects.js
│ └── prototype.js
├── robots.txt
└── stylesheets
│ ├── basic.css
│ ├── reset-min.css
│ └── screen.css
├── script
├── link_results
├── parse-results.rb
└── rails
└── test
├── functional
└── .gitkeep
├── integration
└── .gitkeep
├── performance
└── browsing_test.rb
├── test_helper.rb
└── unit
└── .gitkeep
/.gitignore:
--------------------------------------------------------------------------------
1 | /tmp
2 | /log
3 | /db/*.sqlite3
4 | /config/database.yml
5 | /doc
6 |
--------------------------------------------------------------------------------
/.ruby-version:
--------------------------------------------------------------------------------
1 | 2.5.1
2 |
--------------------------------------------------------------------------------
/Gemfile:
--------------------------------------------------------------------------------
1 | source "https://rubygems.org"
2 | ruby "2.5.1"
3 |
4 | gem "rails"
5 | gem "pg"
6 | gem "thin"
7 | gem "will_paginate"
8 |
9 | group :development do
10 | gem "listen"
11 | end
12 |
--------------------------------------------------------------------------------
/Gemfile.lock:
--------------------------------------------------------------------------------
1 | GEM
2 | remote: https://rubygems.org/
3 | specs:
4 | actioncable (5.2.0)
5 | actionpack (= 5.2.0)
6 | nio4r (~> 2.0)
7 | websocket-driver (>= 0.6.1)
8 | actionmailer (5.2.0)
9 | actionpack (= 5.2.0)
10 | actionview (= 5.2.0)
11 | activejob (= 5.2.0)
12 | mail (~> 2.5, >= 2.5.4)
13 | rails-dom-testing (~> 2.0)
14 | actionpack (5.2.0)
15 | actionview (= 5.2.0)
16 | activesupport (= 5.2.0)
17 | rack (~> 2.0)
18 | rack-test (>= 0.6.3)
19 | rails-dom-testing (~> 2.0)
20 | rails-html-sanitizer (~> 1.0, >= 1.0.2)
21 | actionview (5.2.0)
22 | activesupport (= 5.2.0)
23 | builder (~> 3.1)
24 | erubi (~> 1.4)
25 | rails-dom-testing (~> 2.0)
26 | rails-html-sanitizer (~> 1.0, >= 1.0.3)
27 | activejob (5.2.0)
28 | activesupport (= 5.2.0)
29 | globalid (>= 0.3.6)
30 | activemodel (5.2.0)
31 | activesupport (= 5.2.0)
32 | activerecord (5.2.0)
33 | activemodel (= 5.2.0)
34 | activesupport (= 5.2.0)
35 | arel (>= 9.0)
36 | activestorage (5.2.0)
37 | actionpack (= 5.2.0)
38 | activerecord (= 5.2.0)
39 | marcel (~> 0.3.1)
40 | activesupport (5.2.0)
41 | concurrent-ruby (~> 1.0, >= 1.0.2)
42 | i18n (>= 0.7, < 2)
43 | minitest (~> 5.1)
44 | tzinfo (~> 1.1)
45 | arel (9.0.0)
46 | builder (3.2.3)
47 | concurrent-ruby (1.0.5)
48 | crass (1.0.4)
49 | daemons (1.1.9)
50 | erubi (1.7.1)
51 | eventmachine (1.0.9.1)
52 | ffi (1.9.25)
53 | globalid (0.4.1)
54 | activesupport (>= 4.2.0)
55 | i18n (1.0.1)
56 | concurrent-ruby (~> 1.0)
57 | listen (3.1.5)
58 | rb-fsevent (~> 0.9, >= 0.9.4)
59 | rb-inotify (~> 0.9, >= 0.9.7)
60 | ruby_dep (~> 1.2)
61 | loofah (2.2.2)
62 | crass (~> 1.0.2)
63 | nokogiri (>= 1.5.9)
64 | mail (2.7.0)
65 | mini_mime (>= 0.1.1)
66 | marcel (0.3.2)
67 | mimemagic (~> 0.3.2)
68 | method_source (0.9.0)
69 | mimemagic (0.3.2)
70 | mini_mime (1.0.0)
71 | mini_portile2 (2.3.0)
72 | minitest (5.11.3)
73 | nio4r (2.3.1)
74 | nokogiri (1.8.3)
75 | mini_portile2 (~> 2.3.0)
76 | pg (1.0.0)
77 | rack (2.0.5)
78 | rack-test (1.0.0)
79 | rack (>= 1.0, < 3)
80 | rails (5.2.0)
81 | actioncable (= 5.2.0)
82 | actionmailer (= 5.2.0)
83 | actionpack (= 5.2.0)
84 | actionview (= 5.2.0)
85 | activejob (= 5.2.0)
86 | activemodel (= 5.2.0)
87 | activerecord (= 5.2.0)
88 | activestorage (= 5.2.0)
89 | activesupport (= 5.2.0)
90 | bundler (>= 1.3.0)
91 | railties (= 5.2.0)
92 | sprockets-rails (>= 2.0.0)
93 | rails-dom-testing (2.0.3)
94 | activesupport (>= 4.2.0)
95 | nokogiri (>= 1.6)
96 | rails-html-sanitizer (1.0.4)
97 | loofah (~> 2.2, >= 2.2.2)
98 | railties (5.2.0)
99 | actionpack (= 5.2.0)
100 | activesupport (= 5.2.0)
101 | method_source
102 | rake (>= 0.8.7)
103 | thor (>= 0.18.1, < 2.0)
104 | rake (12.3.1)
105 | rb-fsevent (0.10.3)
106 | rb-inotify (0.9.10)
107 | ffi (>= 0.5.0, < 2)
108 | ruby_dep (1.5.0)
109 | sprockets (3.7.2)
110 | concurrent-ruby (~> 1.0)
111 | rack (> 1, < 3)
112 | sprockets-rails (3.2.1)
113 | actionpack (>= 4.0)
114 | activesupport (>= 4.0)
115 | sprockets (>= 3.0.0)
116 | thin (1.6.2)
117 | daemons (>= 1.0.9)
118 | eventmachine (>= 1.0.0)
119 | rack (>= 1.0.0)
120 | thor (0.20.0)
121 | thread_safe (0.3.6)
122 | tzinfo (1.2.5)
123 | thread_safe (~> 0.1)
124 | websocket-driver (0.7.0)
125 | websocket-extensions (>= 0.1.0)
126 | websocket-extensions (0.1.3)
127 | will_paginate (3.1.6)
128 |
129 | PLATFORMS
130 | ruby
131 |
132 | DEPENDENCIES
133 | listen
134 | pg
135 | rails
136 | thin
137 | will_paginate
138 |
139 | RUBY VERSION
140 | ruby 2.5.1p57
141 |
142 | BUNDLED WITH
143 | 1.16.2
144 |
--------------------------------------------------------------------------------
/Procfile:
--------------------------------------------------------------------------------
1 | web: bundle exec thin start -p $PORT -e $RACK_ENV
2 |
--------------------------------------------------------------------------------
/Rakefile:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env rake
2 | # Add your own tasks in files placed in lib/tasks ending in .rake,
3 | # for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
4 |
5 | require File.expand_path('../config/application', __FILE__)
6 |
7 | KillOrCure::Application.load_tasks
8 |
--------------------------------------------------------------------------------
/app/controllers/application_controller.rb:
--------------------------------------------------------------------------------
1 | # Filters added to this controller apply to all controllers in the application.
2 | # Likewise, all the methods added will be available for all controllers.
3 |
4 | class ApplicationController < ActionController::Base
5 | helper :all # include all helpers, all the time
6 | protect_from_forgery # See ActionController::RequestForgeryProtection for details
7 |
8 | before_action :load_percent_complete
9 |
10 | def load_percent_complete
11 | @percent_complete = [(Vote.count * 100) / (Article.count * 3), 100].min
12 | end
13 |
14 | # Scrub sensitive parameters from your log
15 | # filter_parameter_logging :password
16 | end
17 |
--------------------------------------------------------------------------------
/app/controllers/corrections_controller.rb:
--------------------------------------------------------------------------------
1 | class CorrectionsController < ApplicationController
2 | def new
3 | @backlink = request.env["HTTP_REFERER"] || "/"
4 | @tagging = NormalizedTagging.find_by_article_id_and_normalized_term_id_and_good(params[:article_id], params[:normalized_term_id], params[:good]=="1")
5 | end
6 |
7 | def create
8 | NormalizedTagging.increment_counter(:votes_against, params[:id])
9 | redirect_to params[:backlink]
10 | end
11 | end
12 |
13 |
--------------------------------------------------------------------------------
/app/controllers/home_controller.rb:
--------------------------------------------------------------------------------
1 | class HomeController < ApplicationController
2 | def index
3 | end
4 | end
5 |
--------------------------------------------------------------------------------
/app/controllers/results_controller.rb:
--------------------------------------------------------------------------------
1 | class ResultsController < ApplicationController
2 | def index
3 | @letters = NormalizedTerm.connection.select_all("SELECT DISTINCT LOWER(SUBSTR(value, 1, 1)) AS letter FROM normalized_terms").map{ |r| r["letter"] }.sort
4 | if params[:page]
5 | @terms = NormalizedTerm.paginate(
6 | :page => params[:page],
7 | :order => "LOWER(normalized_terms.value) ASC",
8 | :include => [:articles])
9 | else
10 | @letter = ((params[:letter] || '')[/^./] || 'a').downcase
11 | @terms =
12 | NormalizedTerm.where(
13 | [
14 | "normalized_terms.value LIKE ? OR normalized_terms.value LIKE ?",
15 | @letter + "%",
16 | @letter.upcase + "%"
17 | ]
18 | ).
19 | where(
20 | "EXISTS (SELECT 1 FROM normalized_taggings
21 | WHERE normalized_taggings.normalized_term_id = normalized_terms.id
22 | AND normalized_taggings.votes_against < 3)"
23 | ).
24 | order("LOWER(normalized_terms.value) ASC").
25 | includes(:articles).
26 | all
27 | end
28 | end
29 | end
30 |
--------------------------------------------------------------------------------
/app/controllers/stats_controller.rb:
--------------------------------------------------------------------------------
1 | class StatsController < ApplicationController
2 | def index
3 | @articles = Article.most_voted.paginate(:page => params[:page], :include => [:votes])
4 | end
5 | end
6 |
--------------------------------------------------------------------------------
/app/controllers/votes_controller.rb:
--------------------------------------------------------------------------------
1 | class VotesController < ApplicationController
2 | def new
3 | @article = Article.to_do.first
4 | @vote = @article.votes.build
5 | end
6 |
7 | def create
8 | attributes = {:article_id => params[:vote][:article_id], :general => params[:vote][:general]}
9 | if params[:prevent]
10 | attributes[:effect] = "prevent"
11 | elsif params[:cause]
12 | attributes[:effect] = "cause"
13 | else
14 | attributes[:effect] = "skip"
15 | end
16 | if attributes[:effect] == "skip" || attributes[:general].present?
17 | Vote.create!(attributes)
18 | end
19 | redirect_to new_vote_path
20 | end
21 | end
22 |
--------------------------------------------------------------------------------
/app/helpers/application_helper.rb:
--------------------------------------------------------------------------------
1 | # Methods added to this helper will be available to all templates in the application.
2 | module ApplicationHelper
3 | end
4 |
--------------------------------------------------------------------------------
/app/models/article.rb:
--------------------------------------------------------------------------------
1 | class Article < ActiveRecord::Base
2 | has_many :votes
3 | has_many :taggings
4 | has_many :terms, :through => :taggings
5 | has_many :normalized_terms, :through => :normalized_taggings
6 |
7 | scope :to_do, -> { order("articles.votes_count ASC, RANDOM()") }
8 | scope :most_voted, -> { order("articles.votes_count DESC") }
9 |
10 | def causes
11 | votes.select{ |v| v.effect == "cause" }.map{ |v| v.things }.flatten.sort.uniq
12 | end
13 |
14 | def preventors
15 | votes.select{ |v| v.effect == "prevent" }.map{ |v| v.things }.flatten.sort.uniq
16 | end
17 | end
18 |
--------------------------------------------------------------------------------
/app/models/normalized_tagging.rb:
--------------------------------------------------------------------------------
1 | class NormalizedTagging < ActiveRecord::Base
2 | belongs_to :article
3 | belongs_to :normalized_term
4 | scope :uncontroversial, -> { where("votes_against < 3") }
5 | end
6 |
--------------------------------------------------------------------------------
/app/models/normalized_term.rb:
--------------------------------------------------------------------------------
1 | class NormalizedTerm < ActiveRecord::Base
2 | has_many :terms
3 | has_many :normalized_taggings
4 | has_many :articles,
5 | :through => :normalized_taggings
6 |
7 | def uncontroversial_taggings
8 | normalized_taggings.uncontroversial
9 | end
10 |
11 | def self.[](value)
12 | n = find_by_value(value) || create!(:value => value)
13 | end
14 |
15 | def causes_articles
16 | uncontroversial_taggings.select{ |t| !t.good? }.map{ |t| t.article }
17 | end
18 |
19 | def prevents_articles
20 | uncontroversial_taggings.select{ |t| t.good? }.map{ |t| t.article }
21 | end
22 |
23 | def causes?
24 | uncontroversial_taggings.any?{ |t| !t.good? }
25 | end
26 |
27 | def prevents?
28 | uncontroversial_taggings.any?{ |t| t.good? }
29 | end
30 |
31 | def effect
32 | case [!!prevents?, !!causes?]
33 | when [false, true]
34 | :cause
35 | when [true, false]
36 | :prevent
37 | when [true, true]
38 | :both
39 | end
40 | end
41 |
42 | def plural?
43 | value =~ /s$/i
44 | end
45 | end
46 |
--------------------------------------------------------------------------------
/app/models/tagging.rb:
--------------------------------------------------------------------------------
1 | class Tagging < ActiveRecord::Base
2 | belongs_to :article
3 | belongs_to :term
4 | end
5 |
--------------------------------------------------------------------------------
/app/models/term.rb:
--------------------------------------------------------------------------------
1 | class Term < ActiveRecord::Base
2 | belongs_to :normalized_term
3 | has_many :taggings
4 | has_many :articles, :through => :taggings
5 |
6 | def self.[](value)
7 | n = find_by_value(value) || create!(:value => value)
8 | end
9 | end
10 |
--------------------------------------------------------------------------------
/app/models/vote.rb:
--------------------------------------------------------------------------------
1 | class Vote < ActiveRecord::Base
2 | belongs_to :article, :counter_cache => true
3 |
4 | scope :causing, -> { where(effect: 'cause') }
5 | scope :preventing, -> { where(effect: 'prevent') }
6 |
7 | def things
8 | (general || "").split(/,\s*/).map{ |t| t.downcase }
9 | end
10 | end
11 |
--------------------------------------------------------------------------------
/app/views/corrections/new.html.erb:
--------------------------------------------------------------------------------
1 | If this entry is incorrect, i.e. it doesn't refer to the item mentioned, or the conclusion is invalid, please submit a report. The item will be removed from the results in due course.
2 | <% form_tag corrections_path(:id => @tagging.id) do %>
3 |
4 |
5 | Thing
6 | <%= h(@tagging.normalized_term.value) %>
7 |
8 |
9 | Effect
10 | <%= @tagging.good? ? "Prevents cancer" : "Causes cancer" %>
11 |
12 |
13 | Headline
14 | <%= h(@tagging.article.title) %>
15 |
16 |
17 | Summary
18 | <%= h(@tagging.article.summary) %>
19 |
20 |
21 | URL
22 | <%= link_to(@tagging.article.link, @tagging.article.link, :target => "_blank") %>
23 |
24 |
25 |
26 | <%= hidden_field_tag "backlink", @backlink %>
27 |
28 |
29 |
32 | <% end %>
33 |
--------------------------------------------------------------------------------
/app/views/home/index.html.erb:
--------------------------------------------------------------------------------
1 |
2 | As Ben Goldacre wrote :
3 |
4 |
5 |
6 | The Daily Mail, as you know, is engaged in a philosophical project of
7 | mythic proportions: for many years now it has diligently been sifting
8 | through all the inanimate objects in the world, soberly dividing them into
9 | the ones which either cause – or cure – cancer.
10 |
11 |
12 |
13 | The Daily Mail frequently brings us news of which objects have been
14 | discovered to cause cancer, and which have been shown to
15 | prevent it. In some cases, they do both.
16 |
17 |
18 | In order to make sense of this vast resource of clinical information, I’ve
19 | scraped the Daily Mail’s website for articles mentioning cancer. To distil
20 | this wisdom down into an easily comprehensible form, though, I need some help.
21 |
22 |
23 | You can assist me by classifying articles, saying
24 |
25 |
26 |
27 | What the article refers to, e.g. wine or Facebook .
28 |
29 |
30 | Whether the thing in question causes or prevents cancer.
31 |
32 |
33 |
34 | I’ll then collate your research into a summary so that we
35 | all know how best to live our lives.
36 |
37 | <% if @percent_complete < 100 %>
38 |
39 | <%= link_to "Get started!", new_vote_path %>
40 |
41 | <% else %>
42 |
43 | We’ve done it! <%= link_to "See the results.", "/" %> You can still <%= link_to "try voting", new_vote_path %> if you’re interested in seeing how it worked.
44 |
45 | <% end %>
46 |
--------------------------------------------------------------------------------
/app/views/layouts/application.html.erb:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | Kill or cure?
6 | <%= stylesheet_link_tag "reset-min", "basic", "screen" %>
7 |
8 |
9 |
18 |
19 | <%= yield %>
20 |
21 |
28 |
29 |
32 |
33 |
34 |
--------------------------------------------------------------------------------
/app/views/results/_pagination.html.erb:
--------------------------------------------------------------------------------
1 |
10 |
--------------------------------------------------------------------------------
/app/views/results/index.html.erb:
--------------------------------------------------------------------------------
1 | <%= render :partial => "pagination" %>
2 |
3 |
4 | If any of these results seems incorrect, please report it using the link next to the article.
5 |
6 |
7 | <% @terms.each do |term| %>
8 | <% next unless term.articles.any? %>
9 |
10 |
11 | <%= h(term.value) %>
12 | <% case term.effect; when :cause %>
13 | cause<%= "s" unless term.plural? %>
14 | <% when :prevent %>
15 | prevent<%= "s" unless term.plural? %>
16 | <% when :both %>
17 | both cause<%= "s" unless term.plural? %>
18 | and prevent<%= "s" unless term.plural? %>
19 | <% end %>
20 | cancer
21 | #
22 |
23 |
24 | <% if term.causes? %>
25 |
26 | <% term.causes_articles.each do |article| %>
27 |
28 | <%= link_to article.title, article.link %>
29 |
30 | <% end %>
31 |
32 | <% end %>
33 |
34 | <% if term.prevents? %>
35 |
36 | <% term.prevents_articles.each do |article| %>
37 |
38 | <%= link_to article.title, article.link %>
39 |
40 | <% end %>
41 |
42 | <% end %>
43 | <% end %>
44 |
45 | <%= render :partial => "pagination" %>
46 |
--------------------------------------------------------------------------------
/app/views/stats/index.html.erb:
--------------------------------------------------------------------------------
1 |
2 |
3 | Title
4 | Votes
5 | Cause
6 | Prevent
7 |
8 | <% @articles.each do |article| %>
9 |
10 | <%= h(truncate(article.title, :length => 50)) %>
11 | <%= article.votes.length %>
12 | <%= h(article.causes * ", ") %>
13 | <%= h(article.preventors * ", ") %>
14 |
15 | <% end %>
16 |
17 |
18 | <%= will_paginate @articles %>
19 |
20 |
--------------------------------------------------------------------------------
/app/views/votes/done.html.erb:
--------------------------------------------------------------------------------
1 | All done
2 |
3 | Thanks for all your efforts! We've now classifed all the articles. You can <%= link_to "browse the interim results", "/stats" %>, and I'll make the full dataset available shortly.
4 |
5 |
--------------------------------------------------------------------------------
/app/views/votes/new.html.erb:
--------------------------------------------------------------------------------
1 |
2 |
<%= link_to h(@article.title), @article.link, :target => "_blank" %>
3 |
<%= h @article.summary %>
4 |
7 | <% form_for @vote do |f| %>
8 | <%= f.hidden_field :article_id %>
9 |
10 |
11 | <%= f.label :general, "What kind of a thing is it?" %>
12 | <%= f.text_field :general %>
13 |
14 |
15 |
16 |
17 | Be as terse as possible , e.g. “wine”, “sun”, “HRT”.
18 |
19 |
20 | If the article refers to more than one thing, separate them with commas , e.g.
21 | “fruit, vegetables”.
22 |
23 |
24 | Capital letters don’t matter .
25 |
26 |
27 | If the article isn’t about something that causes or prevents cancer, or if it’s ambiguous, choose neither .
28 |
29 |
30 |
31 |
32 | <%= f.submit "Causes cancer", :name => "cause" %>
33 | <%= f.submit "Prevents cancer", :name => "prevent" %>
34 | <%= f.submit "Neither", :name => "skip" %>
35 |
36 |
37 | <% end %>
38 |
The page you were looking for doesn't exist (404)
9 |
21 |
22 |
23 |
24 |
25 |
26 |
The page you were looking for doesn't exist.
27 |
You may have mistyped the address or the page may have moved.
28 |
The change you wanted was rejected (422)
9 |
21 |
22 |
23 |
24 |
25 |
26 |
The change you wanted was rejected.
27 |
Maybe you tried to change something you didn't have access to.
28 |
We're sorry, but something went wrong (500)
9 |
21 |
22 |
23 |
24 |
25 |
26 |
We're sorry, but something went wrong.
27 |
We've been notified about this issue and we'll take a look at it shortly.
28 |
" + elem.substr(0, entry.length) + " " +
441 | elem.substr(entry.length) + "" + elem.substr(0, foundPos) + "" +
447 | elem.substr(foundPos, entry.length) + " " + elem.substr(
448 | foundPos + entry.length) + " ");
449 | break;
450 | }
451 | }
452 |
453 | foundPos = instance.options.ignoreCase ?
454 | elem.toLowerCase().indexOf(entry.toLowerCase(), foundPos + 1) :
455 | elem.indexOf(entry, foundPos + 1);
456 |
457 | }
458 | }
459 | if (partial.length)
460 | ret = ret.concat(partial.slice(0, instance.options.choices - ret.length));
461 | return "";
462 | }
463 | }, options || { });
464 | }
465 | });
466 |
467 | // AJAX in-place editor and collection editor
468 | // Full rewrite by Christophe Porteneuve (April 2007).
469 |
470 | // Use this if you notice weird scrolling problems on some browsers,
471 | // the DOM might be a bit confused when this gets called so do this
472 | // waits 1 ms (with setTimeout) until it does the activation
473 | Field.scrollFreeActivate = function(field) {
474 | setTimeout(function() {
475 | Field.activate(field);
476 | }, 1);
477 | };
478 |
479 | Ajax.InPlaceEditor = Class.create({
480 | initialize: function(element, url, options) {
481 | this.url = url;
482 | this.element = element = $(element);
483 | this.prepareOptions();
484 | this._controls = { };
485 | arguments.callee.dealWithDeprecatedOptions(options); // DEPRECATION LAYER!!!
486 | Object.extend(this.options, options || { });
487 | if (!this.options.formId && this.element.id) {
488 | this.options.formId = this.element.id + '-inplaceeditor';
489 | if ($(this.options.formId))
490 | this.options.formId = '';
491 | }
492 | if (this.options.externalControl)
493 | this.options.externalControl = $(this.options.externalControl);
494 | if (!this.options.externalControl)
495 | this.options.externalControlOnly = false;
496 | this._originalBackground = this.element.getStyle('background-color') || 'transparent';
497 | this.element.title = this.options.clickToEditText;
498 | this._boundCancelHandler = this.handleFormCancellation.bind(this);
499 | this._boundComplete = (this.options.onComplete || Prototype.emptyFunction).bind(this);
500 | this._boundFailureHandler = this.handleAJAXFailure.bind(this);
501 | this._boundSubmitHandler = this.handleFormSubmission.bind(this);
502 | this._boundWrapperHandler = this.wrapUp.bind(this);
503 | this.registerListeners();
504 | },
505 | checkForEscapeOrReturn: function(e) {
506 | if (!this._editing || e.ctrlKey || e.altKey || e.shiftKey) return;
507 | if (Event.KEY_ESC == e.keyCode)
508 | this.handleFormCancellation(e);
509 | else if (Event.KEY_RETURN == e.keyCode)
510 | this.handleFormSubmission(e);
511 | },
512 | createControl: function(mode, handler, extraClasses) {
513 | var control = this.options[mode + 'Control'];
514 | var text = this.options[mode + 'Text'];
515 | if ('button' == control) {
516 | var btn = document.createElement('input');
517 | btn.type = 'submit';
518 | btn.value = text;
519 | btn.className = 'editor_' + mode + '_button';
520 | if ('cancel' == mode)
521 | btn.onclick = this._boundCancelHandler;
522 | this._form.appendChild(btn);
523 | this._controls[mode] = btn;
524 | } else if ('link' == control) {
525 | var link = document.createElement('a');
526 | link.href = '#';
527 | link.appendChild(document.createTextNode(text));
528 | link.onclick = 'cancel' == mode ? this._boundCancelHandler : this._boundSubmitHandler;
529 | link.className = 'editor_' + mode + '_link';
530 | if (extraClasses)
531 | link.className += ' ' + extraClasses;
532 | this._form.appendChild(link);
533 | this._controls[mode] = link;
534 | }
535 | },
536 | createEditField: function() {
537 | var text = (this.options.loadTextURL ? this.options.loadingText : this.getText());
538 | var fld;
539 | if (1 >= this.options.rows && !/\r|\n/.test(this.getText())) {
540 | fld = document.createElement('input');
541 | fld.type = 'text';
542 | var size = this.options.size || this.options.cols || 0;
543 | if (0 < size) fld.size = size;
544 | } else {
545 | fld = document.createElement('textarea');
546 | fld.rows = (1 >= this.options.rows ? this.options.autoRows : this.options.rows);
547 | fld.cols = this.options.cols || 40;
548 | }
549 | fld.name = this.options.paramName;
550 | fld.value = text; // No HTML breaks conversion anymore
551 | fld.className = 'editor_field';
552 | if (this.options.submitOnBlur)
553 | fld.onblur = this._boundSubmitHandler;
554 | this._controls.editor = fld;
555 | if (this.options.loadTextURL)
556 | this.loadExternalText();
557 | this._form.appendChild(this._controls.editor);
558 | },
559 | createForm: function() {
560 | var ipe = this;
561 | function addText(mode, condition) {
562 | var text = ipe.options['text' + mode + 'Controls'];
563 | if (!text || condition === false) return;
564 | ipe._form.appendChild(document.createTextNode(text));
565 | };
566 | this._form = $(document.createElement('form'));
567 | this._form.id = this.options.formId;
568 | this._form.addClassName(this.options.formClassName);
569 | this._form.onsubmit = this._boundSubmitHandler;
570 | this.createEditField();
571 | if ('textarea' == this._controls.editor.tagName.toLowerCase())
572 | this._form.appendChild(document.createElement('br'));
573 | if (this.options.onFormCustomization)
574 | this.options.onFormCustomization(this, this._form);
575 | addText('Before', this.options.okControl || this.options.cancelControl);
576 | this.createControl('ok', this._boundSubmitHandler);
577 | addText('Between', this.options.okControl && this.options.cancelControl);
578 | this.createControl('cancel', this._boundCancelHandler, 'editor_cancel');
579 | addText('After', this.options.okControl || this.options.cancelControl);
580 | },
581 | destroy: function() {
582 | if (this._oldInnerHTML)
583 | this.element.innerHTML = this._oldInnerHTML;
584 | this.leaveEditMode();
585 | this.unregisterListeners();
586 | },
587 | enterEditMode: function(e) {
588 | if (this._saving || this._editing) return;
589 | this._editing = true;
590 | this.triggerCallback('onEnterEditMode');
591 | if (this.options.externalControl)
592 | this.options.externalControl.hide();
593 | this.element.hide();
594 | this.createForm();
595 | this.element.parentNode.insertBefore(this._form, this.element);
596 | if (!this.options.loadTextURL)
597 | this.postProcessEditField();
598 | if (e) Event.stop(e);
599 | },
600 | enterHover: function(e) {
601 | if (this.options.hoverClassName)
602 | this.element.addClassName(this.options.hoverClassName);
603 | if (this._saving) return;
604 | this.triggerCallback('onEnterHover');
605 | },
606 | getText: function() {
607 | return this.element.innerHTML.unescapeHTML();
608 | },
609 | handleAJAXFailure: function(transport) {
610 | this.triggerCallback('onFailure', transport);
611 | if (this._oldInnerHTML) {
612 | this.element.innerHTML = this._oldInnerHTML;
613 | this._oldInnerHTML = null;
614 | }
615 | },
616 | handleFormCancellation: function(e) {
617 | this.wrapUp();
618 | if (e) Event.stop(e);
619 | },
620 | handleFormSubmission: function(e) {
621 | var form = this._form;
622 | var value = $F(this._controls.editor);
623 | this.prepareSubmission();
624 | var params = this.options.callback(form, value) || '';
625 | if (Object.isString(params))
626 | params = params.toQueryParams();
627 | params.editorId = this.element.id;
628 | if (this.options.htmlResponse) {
629 | var options = Object.extend({ evalScripts: true }, this.options.ajaxOptions);
630 | Object.extend(options, {
631 | parameters: params,
632 | onComplete: this._boundWrapperHandler,
633 | onFailure: this._boundFailureHandler
634 | });
635 | new Ajax.Updater({ success: this.element }, this.url, options);
636 | } else {
637 | var options = Object.extend({ method: 'get' }, this.options.ajaxOptions);
638 | Object.extend(options, {
639 | parameters: params,
640 | onComplete: this._boundWrapperHandler,
641 | onFailure: this._boundFailureHandler
642 | });
643 | new Ajax.Request(this.url, options);
644 | }
645 | if (e) Event.stop(e);
646 | },
647 | leaveEditMode: function() {
648 | this.element.removeClassName(this.options.savingClassName);
649 | this.removeForm();
650 | this.leaveHover();
651 | this.element.style.backgroundColor = this._originalBackground;
652 | this.element.show();
653 | if (this.options.externalControl)
654 | this.options.externalControl.show();
655 | this._saving = false;
656 | this._editing = false;
657 | this._oldInnerHTML = null;
658 | this.triggerCallback('onLeaveEditMode');
659 | },
660 | leaveHover: function(e) {
661 | if (this.options.hoverClassName)
662 | this.element.removeClassName(this.options.hoverClassName);
663 | if (this._saving) return;
664 | this.triggerCallback('onLeaveHover');
665 | },
666 | loadExternalText: function() {
667 | this._form.addClassName(this.options.loadingClassName);
668 | this._controls.editor.disabled = true;
669 | var options = Object.extend({ method: 'get' }, this.options.ajaxOptions);
670 | Object.extend(options, {
671 | parameters: 'editorId=' + encodeURIComponent(this.element.id),
672 | onComplete: Prototype.emptyFunction,
673 | onSuccess: function(transport) {
674 | this._form.removeClassName(this.options.loadingClassName);
675 | var text = transport.responseText;
676 | if (this.options.stripLoadedTextTags)
677 | text = text.stripTags();
678 | this._controls.editor.value = text;
679 | this._controls.editor.disabled = false;
680 | this.postProcessEditField();
681 | }.bind(this),
682 | onFailure: this._boundFailureHandler
683 | });
684 | new Ajax.Request(this.options.loadTextURL, options);
685 | },
686 | postProcessEditField: function() {
687 | var fpc = this.options.fieldPostCreation;
688 | if (fpc)
689 | $(this._controls.editor)['focus' == fpc ? 'focus' : 'activate']();
690 | },
691 | prepareOptions: function() {
692 | this.options = Object.clone(Ajax.InPlaceEditor.DefaultOptions);
693 | Object.extend(this.options, Ajax.InPlaceEditor.DefaultCallbacks);
694 | [this._extraDefaultOptions].flatten().compact().each(function(defs) {
695 | Object.extend(this.options, defs);
696 | }.bind(this));
697 | },
698 | prepareSubmission: function() {
699 | this._saving = true;
700 | this.removeForm();
701 | this.leaveHover();
702 | this.showSaving();
703 | },
704 | registerListeners: function() {
705 | this._listeners = { };
706 | var listener;
707 | $H(Ajax.InPlaceEditor.Listeners).each(function(pair) {
708 | listener = this[pair.value].bind(this);
709 | this._listeners[pair.key] = listener;
710 | if (!this.options.externalControlOnly)
711 | this.element.observe(pair.key, listener);
712 | if (this.options.externalControl)
713 | this.options.externalControl.observe(pair.key, listener);
714 | }.bind(this));
715 | },
716 | removeForm: function() {
717 | if (!this._form) return;
718 | this._form.remove();
719 | this._form = null;
720 | this._controls = { };
721 | },
722 | showSaving: function() {
723 | this._oldInnerHTML = this.element.innerHTML;
724 | this.element.innerHTML = this.options.savingText;
725 | this.element.addClassName(this.options.savingClassName);
726 | this.element.style.backgroundColor = this._originalBackground;
727 | this.element.show();
728 | },
729 | triggerCallback: function(cbName, arg) {
730 | if ('function' == typeof this.options[cbName]) {
731 | this.options[cbName](this, arg);
732 | }
733 | },
734 | unregisterListeners: function() {
735 | $H(this._listeners).each(function(pair) {
736 | if (!this.options.externalControlOnly)
737 | this.element.stopObserving(pair.key, pair.value);
738 | if (this.options.externalControl)
739 | this.options.externalControl.stopObserving(pair.key, pair.value);
740 | }.bind(this));
741 | },
742 | wrapUp: function(transport) {
743 | this.leaveEditMode();
744 | // Can't use triggerCallback due to backward compatibility: requires
745 | // binding + direct element
746 | this._boundComplete(transport, this.element);
747 | }
748 | });
749 |
750 | Object.extend(Ajax.InPlaceEditor.prototype, {
751 | dispose: Ajax.InPlaceEditor.prototype.destroy
752 | });
753 |
754 | Ajax.InPlaceCollectionEditor = Class.create(Ajax.InPlaceEditor, {
755 | initialize: function($super, element, url, options) {
756 | this._extraDefaultOptions = Ajax.InPlaceCollectionEditor.DefaultOptions;
757 | $super(element, url, options);
758 | },
759 |
760 | createEditField: function() {
761 | var list = document.createElement('select');
762 | list.name = this.options.paramName;
763 | list.size = 1;
764 | this._controls.editor = list;
765 | this._collection = this.options.collection || [];
766 | if (this.options.loadCollectionURL)
767 | this.loadCollection();
768 | else
769 | this.checkForExternalText();
770 | this._form.appendChild(this._controls.editor);
771 | },
772 |
773 | loadCollection: function() {
774 | this._form.addClassName(this.options.loadingClassName);
775 | this.showLoadingText(this.options.loadingCollectionText);
776 | var options = Object.extend({ method: 'get' }, this.options.ajaxOptions);
777 | Object.extend(options, {
778 | parameters: 'editorId=' + encodeURIComponent(this.element.id),
779 | onComplete: Prototype.emptyFunction,
780 | onSuccess: function(transport) {
781 | var js = transport.responseText.strip();
782 | if (!/^\[.*\]$/.test(js)) // TODO: improve sanity check
783 | throw('Server returned an invalid collection representation.');
784 | this._collection = eval(js);
785 | this.checkForExternalText();
786 | }.bind(this),
787 | onFailure: this.onFailure
788 | });
789 | new Ajax.Request(this.options.loadCollectionURL, options);
790 | },
791 |
792 | showLoadingText: function(text) {
793 | this._controls.editor.disabled = true;
794 | var tempOption = this._controls.editor.firstChild;
795 | if (!tempOption) {
796 | tempOption = document.createElement('option');
797 | tempOption.value = '';
798 | this._controls.editor.appendChild(tempOption);
799 | tempOption.selected = true;
800 | }
801 | tempOption.update((text || '').stripScripts().stripTags());
802 | },
803 |
804 | checkForExternalText: function() {
805 | this._text = this.getText();
806 | if (this.options.loadTextURL)
807 | this.loadExternalText();
808 | else
809 | this.buildOptionList();
810 | },
811 |
812 | loadExternalText: function() {
813 | this.showLoadingText(this.options.loadingText);
814 | var options = Object.extend({ method: 'get' }, this.options.ajaxOptions);
815 | Object.extend(options, {
816 | parameters: 'editorId=' + encodeURIComponent(this.element.id),
817 | onComplete: Prototype.emptyFunction,
818 | onSuccess: function(transport) {
819 | this._text = transport.responseText.strip();
820 | this.buildOptionList();
821 | }.bind(this),
822 | onFailure: this.onFailure
823 | });
824 | new Ajax.Request(this.options.loadTextURL, options);
825 | },
826 |
827 | buildOptionList: function() {
828 | this._form.removeClassName(this.options.loadingClassName);
829 | this._collection = this._collection.map(function(entry) {
830 | return 2 === entry.length ? entry : [entry, entry].flatten();
831 | });
832 | var marker = ('value' in this.options) ? this.options.value : this._text;
833 | var textFound = this._collection.any(function(entry) {
834 | return entry[0] == marker;
835 | }.bind(this));
836 | this._controls.editor.update('');
837 | var option;
838 | this._collection.each(function(entry, index) {
839 | option = document.createElement('option');
840 | option.value = entry[0];
841 | option.selected = textFound ? entry[0] == marker : 0 == index;
842 | option.appendChild(document.createTextNode(entry[1]));
843 | this._controls.editor.appendChild(option);
844 | }.bind(this));
845 | this._controls.editor.disabled = false;
846 | Field.scrollFreeActivate(this._controls.editor);
847 | }
848 | });
849 |
850 | //**** DEPRECATION LAYER FOR InPlace[Collection]Editor! ****
851 | //**** This only exists for a while, in order to let ****
852 | //**** users adapt to the new API. Read up on the new ****
853 | //**** API and convert your code to it ASAP! ****
854 |
855 | Ajax.InPlaceEditor.prototype.initialize.dealWithDeprecatedOptions = function(options) {
856 | if (!options) return;
857 | function fallback(name, expr) {
858 | if (name in options || expr === undefined) return;
859 | options[name] = expr;
860 | };
861 | fallback('cancelControl', (options.cancelLink ? 'link' : (options.cancelButton ? 'button' :
862 | options.cancelLink == options.cancelButton == false ? false : undefined)));
863 | fallback('okControl', (options.okLink ? 'link' : (options.okButton ? 'button' :
864 | options.okLink == options.okButton == false ? false : undefined)));
865 | fallback('highlightColor', options.highlightcolor);
866 | fallback('highlightEndColor', options.highlightendcolor);
867 | };
868 |
869 | Object.extend(Ajax.InPlaceEditor, {
870 | DefaultOptions: {
871 | ajaxOptions: { },
872 | autoRows: 3, // Use when multi-line w/ rows == 1
873 | cancelControl: 'link', // 'link'|'button'|false
874 | cancelText: 'cancel',
875 | clickToEditText: 'Click to edit',
876 | externalControl: null, // id|elt
877 | externalControlOnly: false,
878 | fieldPostCreation: 'activate', // 'activate'|'focus'|false
879 | formClassName: 'inplaceeditor-form',
880 | formId: null, // id|elt
881 | highlightColor: '#ffff99',
882 | highlightEndColor: '#ffffff',
883 | hoverClassName: '',
884 | htmlResponse: true,
885 | loadingClassName: 'inplaceeditor-loading',
886 | loadingText: 'Loading...',
887 | okControl: 'button', // 'link'|'button'|false
888 | okText: 'ok',
889 | paramName: 'value',
890 | rows: 1, // If 1 and multi-line, uses autoRows
891 | savingClassName: 'inplaceeditor-saving',
892 | savingText: 'Saving...',
893 | size: 0,
894 | stripLoadedTextTags: false,
895 | submitOnBlur: false,
896 | textAfterControls: '',
897 | textBeforeControls: '',
898 | textBetweenControls: ''
899 | },
900 | DefaultCallbacks: {
901 | callback: function(form) {
902 | return Form.serialize(form);
903 | },
904 | onComplete: function(transport, element) {
905 | // For backward compatibility, this one is bound to the IPE, and passes
906 | // the element directly. It was too often customized, so we don't break it.
907 | new Effect.Highlight(element, {
908 | startcolor: this.options.highlightColor, keepBackgroundImage: true });
909 | },
910 | onEnterEditMode: null,
911 | onEnterHover: function(ipe) {
912 | ipe.element.style.backgroundColor = ipe.options.highlightColor;
913 | if (ipe._effect)
914 | ipe._effect.cancel();
915 | },
916 | onFailure: function(transport, ipe) {
917 | alert('Error communication with the server: ' + transport.responseText.stripTags());
918 | },
919 | onFormCustomization: null, // Takes the IPE and its generated form, after editor, before controls.
920 | onLeaveEditMode: null,
921 | onLeaveHover: function(ipe) {
922 | ipe._effect = new Effect.Highlight(ipe.element, {
923 | startcolor: ipe.options.highlightColor, endcolor: ipe.options.highlightEndColor,
924 | restorecolor: ipe._originalBackground, keepBackgroundImage: true
925 | });
926 | }
927 | },
928 | Listeners: {
929 | click: 'enterEditMode',
930 | keydown: 'checkForEscapeOrReturn',
931 | mouseover: 'enterHover',
932 | mouseout: 'leaveHover'
933 | }
934 | });
935 |
936 | Ajax.InPlaceCollectionEditor.DefaultOptions = {
937 | loadingCollectionText: 'Loading options...'
938 | };
939 |
940 | // Delayed observer, like Form.Element.Observer,
941 | // but waits for delay after last key input
942 | // Ideal for live-search fields
943 |
944 | Form.Element.DelayedObserver = Class.create({
945 | initialize: function(element, delay, callback) {
946 | this.delay = delay || 0.5;
947 | this.element = $(element);
948 | this.callback = callback;
949 | this.timer = null;
950 | this.lastValue = $F(this.element);
951 | Event.observe(this.element,'keyup',this.delayedListener.bindAsEventListener(this));
952 | },
953 | delayedListener: function(event) {
954 | if(this.lastValue == $F(this.element)) return;
955 | if(this.timer) clearTimeout(this.timer);
956 | this.timer = setTimeout(this.onTimerEvent.bind(this), this.delay * 1000);
957 | this.lastValue = $F(this.element);
958 | },
959 | onTimerEvent: function() {
960 | this.timer = null;
961 | this.callback(this.element, $F(this.element));
962 | }
963 | });
--------------------------------------------------------------------------------
/public/javascripts/dragdrop.js:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2005-2008 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
2 | // (c) 2005-2008 Sammi Williams (http://www.oriontransfer.co.nz, sammi@oriontransfer.co.nz)
3 | //
4 | // script.aculo.us is freely distributable under the terms of an MIT-style license.
5 | // For details, see the script.aculo.us web site: http://script.aculo.us/
6 |
7 | if(Object.isUndefined(Effect))
8 | throw("dragdrop.js requires including script.aculo.us' effects.js library");
9 |
10 | var Droppables = {
11 | drops: [],
12 |
13 | remove: function(element) {
14 | this.drops = this.drops.reject(function(d) { return d.element==$(element) });
15 | },
16 |
17 | add: function(element) {
18 | element = $(element);
19 | var options = Object.extend({
20 | greedy: true,
21 | hoverclass: null,
22 | tree: false
23 | }, arguments[1] || { });
24 |
25 | // cache containers
26 | if(options.containment) {
27 | options._containers = [];
28 | var containment = options.containment;
29 | if(Object.isArray(containment)) {
30 | containment.each( function(c) { options._containers.push($(c)) });
31 | } else {
32 | options._containers.push($(containment));
33 | }
34 | }
35 |
36 | if(options.accept) options.accept = [options.accept].flatten();
37 |
38 | Element.makePositioned(element); // fix IE
39 | options.element = element;
40 |
41 | this.drops.push(options);
42 | },
43 |
44 | findDeepestChild: function(drops) {
45 | deepest = drops[0];
46 |
47 | for (i = 1; i < drops.length; ++i)
48 | if (Element.isParent(drops[i].element, deepest.element))
49 | deepest = drops[i];
50 |
51 | return deepest;
52 | },
53 |
54 | isContained: function(element, drop) {
55 | var containmentNode;
56 | if(drop.tree) {
57 | containmentNode = element.treeNode;
58 | } else {
59 | containmentNode = element.parentNode;
60 | }
61 | return drop._containers.detect(function(c) { return containmentNode == c });
62 | },
63 |
64 | isAffected: function(point, element, drop) {
65 | return (
66 | (drop.element!=element) &&
67 | ((!drop._containers) ||
68 | this.isContained(element, drop)) &&
69 | ((!drop.accept) ||
70 | (Element.classNames(element).detect(
71 | function(v) { return drop.accept.include(v) } ) )) &&
72 | Position.within(drop.element, point[0], point[1]) );
73 | },
74 |
75 | deactivate: function(drop) {
76 | if(drop.hoverclass)
77 | Element.removeClassName(drop.element, drop.hoverclass);
78 | this.last_active = null;
79 | },
80 |
81 | activate: function(drop) {
82 | if(drop.hoverclass)
83 | Element.addClassName(drop.element, drop.hoverclass);
84 | this.last_active = drop;
85 | },
86 |
87 | show: function(point, element) {
88 | if(!this.drops.length) return;
89 | var drop, affected = [];
90 |
91 | this.drops.each( function(drop) {
92 | if(Droppables.isAffected(point, element, drop))
93 | affected.push(drop);
94 | });
95 |
96 | if(affected.length>0)
97 | drop = Droppables.findDeepestChild(affected);
98 |
99 | if(this.last_active && this.last_active != drop) this.deactivate(this.last_active);
100 | if (drop) {
101 | Position.within(drop.element, point[0], point[1]);
102 | if(drop.onHover)
103 | drop.onHover(element, drop.element, Position.overlap(drop.overlap, drop.element));
104 |
105 | if (drop != this.last_active) Droppables.activate(drop);
106 | }
107 | },
108 |
109 | fire: function(event, element) {
110 | if(!this.last_active) return;
111 | Position.prepare();
112 |
113 | if (this.isAffected([Event.pointerX(event), Event.pointerY(event)], element, this.last_active))
114 | if (this.last_active.onDrop) {
115 | this.last_active.onDrop(element, this.last_active.element, event);
116 | return true;
117 | }
118 | },
119 |
120 | reset: function() {
121 | if(this.last_active)
122 | this.deactivate(this.last_active);
123 | }
124 | };
125 |
126 | var Draggables = {
127 | drags: [],
128 | observers: [],
129 |
130 | register: function(draggable) {
131 | if(this.drags.length == 0) {
132 | this.eventMouseUp = this.endDrag.bindAsEventListener(this);
133 | this.eventMouseMove = this.updateDrag.bindAsEventListener(this);
134 | this.eventKeypress = this.keyPress.bindAsEventListener(this);
135 |
136 | Event.observe(document, "mouseup", this.eventMouseUp);
137 | Event.observe(document, "mousemove", this.eventMouseMove);
138 | Event.observe(document, "keypress", this.eventKeypress);
139 | }
140 | this.drags.push(draggable);
141 | },
142 |
143 | unregister: function(draggable) {
144 | this.drags = this.drags.reject(function(d) { return d==draggable });
145 | if(this.drags.length == 0) {
146 | Event.stopObserving(document, "mouseup", this.eventMouseUp);
147 | Event.stopObserving(document, "mousemove", this.eventMouseMove);
148 | Event.stopObserving(document, "keypress", this.eventKeypress);
149 | }
150 | },
151 |
152 | activate: function(draggable) {
153 | if(draggable.options.delay) {
154 | this._timeout = setTimeout(function() {
155 | Draggables._timeout = null;
156 | window.focus();
157 | Draggables.activeDraggable = draggable;
158 | }.bind(this), draggable.options.delay);
159 | } else {
160 | window.focus(); // allows keypress events if window isn't currently focused, fails for Safari
161 | this.activeDraggable = draggable;
162 | }
163 | },
164 |
165 | deactivate: function() {
166 | this.activeDraggable = null;
167 | },
168 |
169 | updateDrag: function(event) {
170 | if(!this.activeDraggable) return;
171 | var pointer = [Event.pointerX(event), Event.pointerY(event)];
172 | // Mozilla-based browsers fire successive mousemove events with
173 | // the same coordinates, prevent needless redrawing (moz bug?)
174 | if(this._lastPointer && (this._lastPointer.inspect() == pointer.inspect())) return;
175 | this._lastPointer = pointer;
176 |
177 | this.activeDraggable.updateDrag(event, pointer);
178 | },
179 |
180 | endDrag: function(event) {
181 | if(this._timeout) {
182 | clearTimeout(this._timeout);
183 | this._timeout = null;
184 | }
185 | if(!this.activeDraggable) return;
186 | this._lastPointer = null;
187 | this.activeDraggable.endDrag(event);
188 | this.activeDraggable = null;
189 | },
190 |
191 | keyPress: function(event) {
192 | if(this.activeDraggable)
193 | this.activeDraggable.keyPress(event);
194 | },
195 |
196 | addObserver: function(observer) {
197 | this.observers.push(observer);
198 | this._cacheObserverCallbacks();
199 | },
200 |
201 | removeObserver: function(element) { // element instead of observer fixes mem leaks
202 | this.observers = this.observers.reject( function(o) { return o.element==element });
203 | this._cacheObserverCallbacks();
204 | },
205 |
206 | notify: function(eventName, draggable, event) { // 'onStart', 'onEnd', 'onDrag'
207 | if(this[eventName+'Count'] > 0)
208 | this.observers.each( function(o) {
209 | if(o[eventName]) o[eventName](eventName, draggable, event);
210 | });
211 | if(draggable.options[eventName]) draggable.options[eventName](draggable, event);
212 | },
213 |
214 | _cacheObserverCallbacks: function() {
215 | ['onStart','onEnd','onDrag'].each( function(eventName) {
216 | Draggables[eventName+'Count'] = Draggables.observers.select(
217 | function(o) { return o[eventName]; }
218 | ).length;
219 | });
220 | }
221 | };
222 |
223 | /*--------------------------------------------------------------------------*/
224 |
225 | var Draggable = Class.create({
226 | initialize: function(element) {
227 | var defaults = {
228 | handle: false,
229 | reverteffect: function(element, top_offset, left_offset) {
230 | var dur = Math.sqrt(Math.abs(top_offset^2)+Math.abs(left_offset^2))*0.02;
231 | new Effect.Move(element, { x: -left_offset, y: -top_offset, duration: dur,
232 | queue: {scope:'_draggable', position:'end'}
233 | });
234 | },
235 | endeffect: function(element) {
236 | var toOpacity = Object.isNumber(element._opacity) ? element._opacity : 1.0;
237 | new Effect.Opacity(element, {duration:0.2, from:0.7, to:toOpacity,
238 | queue: {scope:'_draggable', position:'end'},
239 | afterFinish: function(){
240 | Draggable._dragging[element] = false
241 | }
242 | });
243 | },
244 | zindex: 1000,
245 | revert: false,
246 | quiet: false,
247 | scroll: false,
248 | scrollSensitivity: 20,
249 | scrollSpeed: 15,
250 | snap: false, // false, or xy or [x,y] or function(x,y){ return [x,y] }
251 | delay: 0
252 | };
253 |
254 | if(!arguments[1] || Object.isUndefined(arguments[1].endeffect))
255 | Object.extend(defaults, {
256 | starteffect: function(element) {
257 | element._opacity = Element.getOpacity(element);
258 | Draggable._dragging[element] = true;
259 | new Effect.Opacity(element, {duration:0.2, from:element._opacity, to:0.7});
260 | }
261 | });
262 |
263 | var options = Object.extend(defaults, arguments[1] || { });
264 |
265 | this.element = $(element);
266 |
267 | if(options.handle && Object.isString(options.handle))
268 | this.handle = this.element.down('.'+options.handle, 0);
269 |
270 | if(!this.handle) this.handle = $(options.handle);
271 | if(!this.handle) this.handle = this.element;
272 |
273 | if(options.scroll && !options.scroll.scrollTo && !options.scroll.outerHTML) {
274 | options.scroll = $(options.scroll);
275 | this._isScrollChild = Element.childOf(this.element, options.scroll);
276 | }
277 |
278 | Element.makePositioned(this.element); // fix IE
279 |
280 | this.options = options;
281 | this.dragging = false;
282 |
283 | this.eventMouseDown = this.initDrag.bindAsEventListener(this);
284 | Event.observe(this.handle, "mousedown", this.eventMouseDown);
285 |
286 | Draggables.register(this);
287 | },
288 |
289 | destroy: function() {
290 | Event.stopObserving(this.handle, "mousedown", this.eventMouseDown);
291 | Draggables.unregister(this);
292 | },
293 |
294 | currentDelta: function() {
295 | return([
296 | parseInt(Element.getStyle(this.element,'left') || '0'),
297 | parseInt(Element.getStyle(this.element,'top') || '0')]);
298 | },
299 |
300 | initDrag: function(event) {
301 | if(!Object.isUndefined(Draggable._dragging[this.element]) &&
302 | Draggable._dragging[this.element]) return;
303 | if(Event.isLeftClick(event)) {
304 | // abort on form elements, fixes a Firefox issue
305 | var src = Event.element(event);
306 | if((tag_name = src.tagName.toUpperCase()) && (
307 | tag_name=='INPUT' ||
308 | tag_name=='SELECT' ||
309 | tag_name=='OPTION' ||
310 | tag_name=='BUTTON' ||
311 | tag_name=='TEXTAREA')) return;
312 |
313 | var pointer = [Event.pointerX(event), Event.pointerY(event)];
314 | var pos = Position.cumulativeOffset(this.element);
315 | this.offset = [0,1].map( function(i) { return (pointer[i] - pos[i]) });
316 |
317 | Draggables.activate(this);
318 | Event.stop(event);
319 | }
320 | },
321 |
322 | startDrag: function(event) {
323 | this.dragging = true;
324 | if(!this.delta)
325 | this.delta = this.currentDelta();
326 |
327 | if(this.options.zindex) {
328 | this.originalZ = parseInt(Element.getStyle(this.element,'z-index') || 0);
329 | this.element.style.zIndex = this.options.zindex;
330 | }
331 |
332 | if(this.options.ghosting) {
333 | this._clone = this.element.cloneNode(true);
334 | this._originallyAbsolute = (this.element.getStyle('position') == 'absolute');
335 | if (!this._originallyAbsolute)
336 | Position.absolutize(this.element);
337 | this.element.parentNode.insertBefore(this._clone, this.element);
338 | }
339 |
340 | if(this.options.scroll) {
341 | if (this.options.scroll == window) {
342 | var where = this._getWindowScroll(this.options.scroll);
343 | this.originalScrollLeft = where.left;
344 | this.originalScrollTop = where.top;
345 | } else {
346 | this.originalScrollLeft = this.options.scroll.scrollLeft;
347 | this.originalScrollTop = this.options.scroll.scrollTop;
348 | }
349 | }
350 |
351 | Draggables.notify('onStart', this, event);
352 |
353 | if(this.options.starteffect) this.options.starteffect(this.element);
354 | },
355 |
356 | updateDrag: function(event, pointer) {
357 | if(!this.dragging) this.startDrag(event);
358 |
359 | if(!this.options.quiet){
360 | Position.prepare();
361 | Droppables.show(pointer, this.element);
362 | }
363 |
364 | Draggables.notify('onDrag', this, event);
365 |
366 | this.draw(pointer);
367 | if(this.options.change) this.options.change(this);
368 |
369 | if(this.options.scroll) {
370 | this.stopScrolling();
371 |
372 | var p;
373 | if (this.options.scroll == window) {
374 | with(this._getWindowScroll(this.options.scroll)) { p = [ left, top, left+width, top+height ]; }
375 | } else {
376 | p = Position.page(this.options.scroll);
377 | p[0] += this.options.scroll.scrollLeft + Position.deltaX;
378 | p[1] += this.options.scroll.scrollTop + Position.deltaY;
379 | p.push(p[0]+this.options.scroll.offsetWidth);
380 | p.push(p[1]+this.options.scroll.offsetHeight);
381 | }
382 | var speed = [0,0];
383 | if(pointer[0] < (p[0]+this.options.scrollSensitivity)) speed[0] = pointer[0]-(p[0]+this.options.scrollSensitivity);
384 | if(pointer[1] < (p[1]+this.options.scrollSensitivity)) speed[1] = pointer[1]-(p[1]+this.options.scrollSensitivity);
385 | if(pointer[0] > (p[2]-this.options.scrollSensitivity)) speed[0] = pointer[0]-(p[2]-this.options.scrollSensitivity);
386 | if(pointer[1] > (p[3]-this.options.scrollSensitivity)) speed[1] = pointer[1]-(p[3]-this.options.scrollSensitivity);
387 | this.startScrolling(speed);
388 | }
389 |
390 | // fix AppleWebKit rendering
391 | if(Prototype.Browser.WebKit) window.scrollBy(0,0);
392 |
393 | Event.stop(event);
394 | },
395 |
396 | finishDrag: function(event, success) {
397 | this.dragging = false;
398 |
399 | if(this.options.quiet){
400 | Position.prepare();
401 | var pointer = [Event.pointerX(event), Event.pointerY(event)];
402 | Droppables.show(pointer, this.element);
403 | }
404 |
405 | if(this.options.ghosting) {
406 | if (!this._originallyAbsolute)
407 | Position.relativize(this.element);
408 | delete this._originallyAbsolute;
409 | Element.remove(this._clone);
410 | this._clone = null;
411 | }
412 |
413 | var dropped = false;
414 | if(success) {
415 | dropped = Droppables.fire(event, this.element);
416 | if (!dropped) dropped = false;
417 | }
418 | if(dropped && this.options.onDropped) this.options.onDropped(this.element);
419 | Draggables.notify('onEnd', this, event);
420 |
421 | var revert = this.options.revert;
422 | if(revert && Object.isFunction(revert)) revert = revert(this.element);
423 |
424 | var d = this.currentDelta();
425 | if(revert && this.options.reverteffect) {
426 | if (dropped == 0 || revert != 'failure')
427 | this.options.reverteffect(this.element,
428 | d[1]-this.delta[1], d[0]-this.delta[0]);
429 | } else {
430 | this.delta = d;
431 | }
432 |
433 | if(this.options.zindex)
434 | this.element.style.zIndex = this.originalZ;
435 |
436 | if(this.options.endeffect)
437 | this.options.endeffect(this.element);
438 |
439 | Draggables.deactivate(this);
440 | Droppables.reset();
441 | },
442 |
443 | keyPress: function(event) {
444 | if(event.keyCode!=Event.KEY_ESC) return;
445 | this.finishDrag(event, false);
446 | Event.stop(event);
447 | },
448 |
449 | endDrag: function(event) {
450 | if(!this.dragging) return;
451 | this.stopScrolling();
452 | this.finishDrag(event, true);
453 | Event.stop(event);
454 | },
455 |
456 | draw: function(point) {
457 | var pos = Position.cumulativeOffset(this.element);
458 | if(this.options.ghosting) {
459 | var r = Position.realOffset(this.element);
460 | pos[0] += r[0] - Position.deltaX; pos[1] += r[1] - Position.deltaY;
461 | }
462 |
463 | var d = this.currentDelta();
464 | pos[0] -= d[0]; pos[1] -= d[1];
465 |
466 | if(this.options.scroll && (this.options.scroll != window && this._isScrollChild)) {
467 | pos[0] -= this.options.scroll.scrollLeft-this.originalScrollLeft;
468 | pos[1] -= this.options.scroll.scrollTop-this.originalScrollTop;
469 | }
470 |
471 | var p = [0,1].map(function(i){
472 | return (point[i]-pos[i]-this.offset[i])
473 | }.bind(this));
474 |
475 | if(this.options.snap) {
476 | if(Object.isFunction(this.options.snap)) {
477 | p = this.options.snap(p[0],p[1],this);
478 | } else {
479 | if(Object.isArray(this.options.snap)) {
480 | p = p.map( function(v, i) {
481 | return (v/this.options.snap[i]).round()*this.options.snap[i] }.bind(this));
482 | } else {
483 | p = p.map( function(v) {
484 | return (v/this.options.snap).round()*this.options.snap }.bind(this));
485 | }
486 | }}
487 |
488 | var style = this.element.style;
489 | if((!this.options.constraint) || (this.options.constraint=='horizontal'))
490 | style.left = p[0] + "px";
491 | if((!this.options.constraint) || (this.options.constraint=='vertical'))
492 | style.top = p[1] + "px";
493 |
494 | if(style.visibility=="hidden") style.visibility = ""; // fix gecko rendering
495 | },
496 |
497 | stopScrolling: function() {
498 | if(this.scrollInterval) {
499 | clearInterval(this.scrollInterval);
500 | this.scrollInterval = null;
501 | Draggables._lastScrollPointer = null;
502 | }
503 | },
504 |
505 | startScrolling: function(speed) {
506 | if(!(speed[0] || speed[1])) return;
507 | this.scrollSpeed = [speed[0]*this.options.scrollSpeed,speed[1]*this.options.scrollSpeed];
508 | this.lastScrolled = new Date();
509 | this.scrollInterval = setInterval(this.scroll.bind(this), 10);
510 | },
511 |
512 | scroll: function() {
513 | var current = new Date();
514 | var delta = current - this.lastScrolled;
515 | this.lastScrolled = current;
516 | if(this.options.scroll == window) {
517 | with (this._getWindowScroll(this.options.scroll)) {
518 | if (this.scrollSpeed[0] || this.scrollSpeed[1]) {
519 | var d = delta / 1000;
520 | this.options.scroll.scrollTo( left + d*this.scrollSpeed[0], top + d*this.scrollSpeed[1] );
521 | }
522 | }
523 | } else {
524 | this.options.scroll.scrollLeft += this.scrollSpeed[0] * delta / 1000;
525 | this.options.scroll.scrollTop += this.scrollSpeed[1] * delta / 1000;
526 | }
527 |
528 | Position.prepare();
529 | Droppables.show(Draggables._lastPointer, this.element);
530 | Draggables.notify('onDrag', this);
531 | if (this._isScrollChild) {
532 | Draggables._lastScrollPointer = Draggables._lastScrollPointer || $A(Draggables._lastPointer);
533 | Draggables._lastScrollPointer[0] += this.scrollSpeed[0] * delta / 1000;
534 | Draggables._lastScrollPointer[1] += this.scrollSpeed[1] * delta / 1000;
535 | if (Draggables._lastScrollPointer[0] < 0)
536 | Draggables._lastScrollPointer[0] = 0;
537 | if (Draggables._lastScrollPointer[1] < 0)
538 | Draggables._lastScrollPointer[1] = 0;
539 | this.draw(Draggables._lastScrollPointer);
540 | }
541 |
542 | if(this.options.change) this.options.change(this);
543 | },
544 |
545 | _getWindowScroll: function(w) {
546 | var T, L, W, H;
547 | with (w.document) {
548 | if (w.document.documentElement && documentElement.scrollTop) {
549 | T = documentElement.scrollTop;
550 | L = documentElement.scrollLeft;
551 | } else if (w.document.body) {
552 | T = body.scrollTop;
553 | L = body.scrollLeft;
554 | }
555 | if (w.innerWidth) {
556 | W = w.innerWidth;
557 | H = w.innerHeight;
558 | } else if (w.document.documentElement && documentElement.clientWidth) {
559 | W = documentElement.clientWidth;
560 | H = documentElement.clientHeight;
561 | } else {
562 | W = body.offsetWidth;
563 | H = body.offsetHeight;
564 | }
565 | }
566 | return { top: T, left: L, width: W, height: H };
567 | }
568 | });
569 |
570 | Draggable._dragging = { };
571 |
572 | /*--------------------------------------------------------------------------*/
573 |
574 | var SortableObserver = Class.create({
575 | initialize: function(element, observer) {
576 | this.element = $(element);
577 | this.observer = observer;
578 | this.lastValue = Sortable.serialize(this.element);
579 | },
580 |
581 | onStart: function() {
582 | this.lastValue = Sortable.serialize(this.element);
583 | },
584 |
585 | onEnd: function() {
586 | Sortable.unmark();
587 | if(this.lastValue != Sortable.serialize(this.element))
588 | this.observer(this.element)
589 | }
590 | });
591 |
592 | var Sortable = {
593 | SERIALIZE_RULE: /^[^_\-](?:[A-Za-z0-9\-\_]*)[_](.*)$/,
594 |
595 | sortables: { },
596 |
597 | _findRootElement: function(element) {
598 | while (element.tagName.toUpperCase() != "BODY") {
599 | if(element.id && Sortable.sortables[element.id]) return element;
600 | element = element.parentNode;
601 | }
602 | },
603 |
604 | options: function(element) {
605 | element = Sortable._findRootElement($(element));
606 | if(!element) return;
607 | return Sortable.sortables[element.id];
608 | },
609 |
610 | destroy: function(element){
611 | element = $(element);
612 | var s = Sortable.sortables[element.id];
613 |
614 | if(s) {
615 | Draggables.removeObserver(s.element);
616 | s.droppables.each(function(d){ Droppables.remove(d) });
617 | s.draggables.invoke('destroy');
618 |
619 | delete Sortable.sortables[s.element.id];
620 | }
621 | },
622 |
623 | create: function(element) {
624 | element = $(element);
625 | var options = Object.extend({
626 | element: element,
627 | tag: 'li', // assumes li children, override with tag: 'tagname'
628 | dropOnEmpty: false,
629 | tree: false,
630 | treeTag: 'ul',
631 | overlap: 'vertical', // one of 'vertical', 'horizontal'
632 | constraint: 'vertical', // one of 'vertical', 'horizontal', false
633 | containment: element, // also takes array of elements (or id's); or false
634 | handle: false, // or a CSS class
635 | only: false,
636 | delay: 0,
637 | hoverclass: null,
638 | ghosting: false,
639 | quiet: false,
640 | scroll: false,
641 | scrollSensitivity: 20,
642 | scrollSpeed: 15,
643 | format: this.SERIALIZE_RULE,
644 |
645 | // these take arrays of elements or ids and can be
646 | // used for better initialization performance
647 | elements: false,
648 | handles: false,
649 |
650 | onChange: Prototype.emptyFunction,
651 | onUpdate: Prototype.emptyFunction
652 | }, arguments[1] || { });
653 |
654 | // clear any old sortable with same element
655 | this.destroy(element);
656 |
657 | // build options for the draggables
658 | var options_for_draggable = {
659 | revert: true,
660 | quiet: options.quiet,
661 | scroll: options.scroll,
662 | scrollSpeed: options.scrollSpeed,
663 | scrollSensitivity: options.scrollSensitivity,
664 | delay: options.delay,
665 | ghosting: options.ghosting,
666 | constraint: options.constraint,
667 | handle: options.handle };
668 |
669 | if(options.starteffect)
670 | options_for_draggable.starteffect = options.starteffect;
671 |
672 | if(options.reverteffect)
673 | options_for_draggable.reverteffect = options.reverteffect;
674 | else
675 | if(options.ghosting) options_for_draggable.reverteffect = function(element) {
676 | element.style.top = 0;
677 | element.style.left = 0;
678 | };
679 |
680 | if(options.endeffect)
681 | options_for_draggable.endeffect = options.endeffect;
682 |
683 | if(options.zindex)
684 | options_for_draggable.zindex = options.zindex;
685 |
686 | // build options for the droppables
687 | var options_for_droppable = {
688 | overlap: options.overlap,
689 | containment: options.containment,
690 | tree: options.tree,
691 | hoverclass: options.hoverclass,
692 | onHover: Sortable.onHover
693 | };
694 |
695 | var options_for_tree = {
696 | onHover: Sortable.onEmptyHover,
697 | overlap: options.overlap,
698 | containment: options.containment,
699 | hoverclass: options.hoverclass
700 | };
701 |
702 | // fix for gecko engine
703 | Element.cleanWhitespace(element);
704 |
705 | options.draggables = [];
706 | options.droppables = [];
707 |
708 | // drop on empty handling
709 | if(options.dropOnEmpty || options.tree) {
710 | Droppables.add(element, options_for_tree);
711 | options.droppables.push(element);
712 | }
713 |
714 | (options.elements || this.findElements(element, options) || []).each( function(e,i) {
715 | var handle = options.handles ? $(options.handles[i]) :
716 | (options.handle ? $(e).select('.' + options.handle)[0] : e);
717 | options.draggables.push(
718 | new Draggable(e, Object.extend(options_for_draggable, { handle: handle })));
719 | Droppables.add(e, options_for_droppable);
720 | if(options.tree) e.treeNode = element;
721 | options.droppables.push(e);
722 | });
723 |
724 | if(options.tree) {
725 | (Sortable.findTreeElements(element, options) || []).each( function(e) {
726 | Droppables.add(e, options_for_tree);
727 | e.treeNode = element;
728 | options.droppables.push(e);
729 | });
730 | }
731 |
732 | // keep reference
733 | this.sortables[element.id] = options;
734 |
735 | // for onupdate
736 | Draggables.addObserver(new SortableObserver(element, options.onUpdate));
737 |
738 | },
739 |
740 | // return all suitable-for-sortable elements in a guaranteed order
741 | findElements: function(element, options) {
742 | return Element.findChildren(
743 | element, options.only, options.tree ? true : false, options.tag);
744 | },
745 |
746 | findTreeElements: function(element, options) {
747 | return Element.findChildren(
748 | element, options.only, options.tree ? true : false, options.treeTag);
749 | },
750 |
751 | onHover: function(element, dropon, overlap) {
752 | if(Element.isParent(dropon, element)) return;
753 |
754 | if(overlap > .33 && overlap < .66 && Sortable.options(dropon).tree) {
755 | return;
756 | } else if(overlap>0.5) {
757 | Sortable.mark(dropon, 'before');
758 | if(dropon.previousSibling != element) {
759 | var oldParentNode = element.parentNode;
760 | element.style.visibility = "hidden"; // fix gecko rendering
761 | dropon.parentNode.insertBefore(element, dropon);
762 | if(dropon.parentNode!=oldParentNode)
763 | Sortable.options(oldParentNode).onChange(element);
764 | Sortable.options(dropon.parentNode).onChange(element);
765 | }
766 | } else {
767 | Sortable.mark(dropon, 'after');
768 | var nextElement = dropon.nextSibling || null;
769 | if(nextElement != element) {
770 | var oldParentNode = element.parentNode;
771 | element.style.visibility = "hidden"; // fix gecko rendering
772 | dropon.parentNode.insertBefore(element, nextElement);
773 | if(dropon.parentNode!=oldParentNode)
774 | Sortable.options(oldParentNode).onChange(element);
775 | Sortable.options(dropon.parentNode).onChange(element);
776 | }
777 | }
778 | },
779 |
780 | onEmptyHover: function(element, dropon, overlap) {
781 | var oldParentNode = element.parentNode;
782 | var droponOptions = Sortable.options(dropon);
783 |
784 | if(!Element.isParent(dropon, element)) {
785 | var index;
786 |
787 | var children = Sortable.findElements(dropon, {tag: droponOptions.tag, only: droponOptions.only});
788 | var child = null;
789 |
790 | if(children) {
791 | var offset = Element.offsetSize(dropon, droponOptions.overlap) * (1.0 - overlap);
792 |
793 | for (index = 0; index < children.length; index += 1) {
794 | if (offset - Element.offsetSize (children[index], droponOptions.overlap) >= 0) {
795 | offset -= Element.offsetSize (children[index], droponOptions.overlap);
796 | } else if (offset - (Element.offsetSize (children[index], droponOptions.overlap) / 2) >= 0) {
797 | child = index + 1 < children.length ? children[index + 1] : null;
798 | break;
799 | } else {
800 | child = children[index];
801 | break;
802 | }
803 | }
804 | }
805 |
806 | dropon.insertBefore(element, child);
807 |
808 | Sortable.options(oldParentNode).onChange(element);
809 | droponOptions.onChange(element);
810 | }
811 | },
812 |
813 | unmark: function() {
814 | if(Sortable._marker) Sortable._marker.hide();
815 | },
816 |
817 | mark: function(dropon, position) {
818 | // mark on ghosting only
819 | var sortable = Sortable.options(dropon.parentNode);
820 | if(sortable && !sortable.ghosting) return;
821 |
822 | if(!Sortable._marker) {
823 | Sortable._marker =
824 | ($('dropmarker') || Element.extend(document.createElement('DIV'))).
825 | hide().addClassName('dropmarker').setStyle({position:'absolute'});
826 | document.getElementsByTagName("body").item(0).appendChild(Sortable._marker);
827 | }
828 | var offsets = Position.cumulativeOffset(dropon);
829 | Sortable._marker.setStyle({left: offsets[0]+'px', top: offsets[1] + 'px'});
830 |
831 | if(position=='after')
832 | if(sortable.overlap == 'horizontal')
833 | Sortable._marker.setStyle({left: (offsets[0]+dropon.clientWidth) + 'px'});
834 | else
835 | Sortable._marker.setStyle({top: (offsets[1]+dropon.clientHeight) + 'px'});
836 |
837 | Sortable._marker.show();
838 | },
839 |
840 | _tree: function(element, options, parent) {
841 | var children = Sortable.findElements(element, options) || [];
842 |
843 | for (var i = 0; i < children.length; ++i) {
844 | var match = children[i].id.match(options.format);
845 |
846 | if (!match) continue;
847 |
848 | var child = {
849 | id: encodeURIComponent(match ? match[1] : null),
850 | element: element,
851 | parent: parent,
852 | children: [],
853 | position: parent.children.length,
854 | container: $(children[i]).down(options.treeTag)
855 | };
856 |
857 | /* Get the element containing the children and recurse over it */
858 | if (child.container)
859 | this._tree(child.container, options, child);
860 |
861 | parent.children.push (child);
862 | }
863 |
864 | return parent;
865 | },
866 |
867 | tree: function(element) {
868 | element = $(element);
869 | var sortableOptions = this.options(element);
870 | var options = Object.extend({
871 | tag: sortableOptions.tag,
872 | treeTag: sortableOptions.treeTag,
873 | only: sortableOptions.only,
874 | name: element.id,
875 | format: sortableOptions.format
876 | }, arguments[1] || { });
877 |
878 | var root = {
879 | id: null,
880 | parent: null,
881 | children: [],
882 | container: element,
883 | position: 0
884 | };
885 |
886 | return Sortable._tree(element, options, root);
887 | },
888 |
889 | /* Construct a [i] index for a particular node */
890 | _constructIndex: function(node) {
891 | var index = '';
892 | do {
893 | if (node.id) index = '[' + node.position + ']' + index;
894 | } while ((node = node.parent) != null);
895 | return index;
896 | },
897 |
898 | sequence: function(element) {
899 | element = $(element);
900 | var options = Object.extend(this.options(element), arguments[1] || { });
901 |
902 | return $(this.findElements(element, options) || []).map( function(item) {
903 | return item.id.match(options.format) ? item.id.match(options.format)[1] : '';
904 | });
905 | },
906 |
907 | setSequence: function(element, new_sequence) {
908 | element = $(element);
909 | var options = Object.extend(this.options(element), arguments[2] || { });
910 |
911 | var nodeMap = { };
912 | this.findElements(element, options).each( function(n) {
913 | if (n.id.match(options.format))
914 | nodeMap[n.id.match(options.format)[1]] = [n, n.parentNode];
915 | n.parentNode.removeChild(n);
916 | });
917 |
918 | new_sequence.each(function(ident) {
919 | var n = nodeMap[ident];
920 | if (n) {
921 | n[1].appendChild(n[0]);
922 | delete nodeMap[ident];
923 | }
924 | });
925 | },
926 |
927 | serialize: function(element) {
928 | element = $(element);
929 | var options = Object.extend(Sortable.options(element), arguments[1] || { });
930 | var name = encodeURIComponent(
931 | (arguments[1] && arguments[1].name) ? arguments[1].name : element.id);
932 |
933 | if (options.tree) {
934 | return Sortable.tree(element, arguments[1]).children.map( function (item) {
935 | return [name + Sortable._constructIndex(item) + "[id]=" +
936 | encodeURIComponent(item.id)].concat(item.children.map(arguments.callee));
937 | }).flatten().join('&');
938 | } else {
939 | return Sortable.sequence(element, arguments[1]).map( function(item) {
940 | return name + "[]=" + encodeURIComponent(item);
941 | }).join('&');
942 | }
943 | }
944 | };
945 |
946 | // Returns true if child is contained within element
947 | Element.isParent = function(child, element) {
948 | if (!child.parentNode || child == element) return false;
949 | if (child.parentNode == element) return true;
950 | return Element.isParent(child.parentNode, element);
951 | };
952 |
953 | Element.findChildren = function(element, only, recursive, tagName) {
954 | if(!element.hasChildNodes()) return null;
955 | tagName = tagName.toUpperCase();
956 | if(only) only = [only].flatten();
957 | var elements = [];
958 | $A(element.childNodes).each( function(e) {
959 | if(e.tagName && e.tagName.toUpperCase()==tagName &&
960 | (!only || (Element.classNames(e).detect(function(v) { return only.include(v) }))))
961 | elements.push(e);
962 | if(recursive) {
963 | var grandchildren = Element.findChildren(e, only, recursive, tagName);
964 | if(grandchildren) elements.push(grandchildren);
965 | }
966 | });
967 |
968 | return (elements.length>0 ? elements.flatten() : []);
969 | };
970 |
971 | Element.offsetSize = function (element, type) {
972 | return element['offset' + ((type=='vertical' || type=='height') ? 'Height' : 'Width')];
973 | };
--------------------------------------------------------------------------------
/public/javascripts/effects.js:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2005-2008 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
2 | // Contributors:
3 | // Justin Palmer (http://encytemedia.com/)
4 | // Mark Pilgrim (http://diveintomark.org/)
5 | // Martin Bialasinki
6 | //
7 | // script.aculo.us is freely distributable under the terms of an MIT-style license.
8 | // For details, see the script.aculo.us web site: http://script.aculo.us/
9 |
10 | // converts rgb() and #xxx to #xxxxxx format,
11 | // returns self (or first argument) if not convertable
12 | String.prototype.parseColor = function() {
13 | var color = '#';
14 | if (this.slice(0,4) == 'rgb(') {
15 | var cols = this.slice(4,this.length-1).split(',');
16 | var i=0; do { color += parseInt(cols[i]).toColorPart() } while (++i<3);
17 | } else {
18 | if (this.slice(0,1) == '#') {
19 | if (this.length==4) for(var i=1;i<4;i++) color += (this.charAt(i) + this.charAt(i)).toLowerCase();
20 | if (this.length==7) color = this.toLowerCase();
21 | }
22 | }
23 | return (color.length==7 ? color : (arguments[0] || this));
24 | };
25 |
26 | /*--------------------------------------------------------------------------*/
27 |
28 | Element.collectTextNodes = function(element) {
29 | return $A($(element).childNodes).collect( function(node) {
30 | return (node.nodeType==3 ? node.nodeValue :
31 | (node.hasChildNodes() ? Element.collectTextNodes(node) : ''));
32 | }).flatten().join('');
33 | };
34 |
35 | Element.collectTextNodesIgnoreClass = function(element, className) {
36 | return $A($(element).childNodes).collect( function(node) {
37 | return (node.nodeType==3 ? node.nodeValue :
38 | ((node.hasChildNodes() && !Element.hasClassName(node,className)) ?
39 | Element.collectTextNodesIgnoreClass(node, className) : ''));
40 | }).flatten().join('');
41 | };
42 |
43 | Element.setContentZoom = function(element, percent) {
44 | element = $(element);
45 | element.setStyle({fontSize: (percent/100) + 'em'});
46 | if (Prototype.Browser.WebKit) window.scrollBy(0,0);
47 | return element;
48 | };
49 |
50 | Element.getInlineOpacity = function(element){
51 | return $(element).style.opacity || '';
52 | };
53 |
54 | Element.forceRerendering = function(element) {
55 | try {
56 | element = $(element);
57 | var n = document.createTextNode(' ');
58 | element.appendChild(n);
59 | element.removeChild(n);
60 | } catch(e) { }
61 | };
62 |
63 | /*--------------------------------------------------------------------------*/
64 |
65 | var Effect = {
66 | _elementDoesNotExistError: {
67 | name: 'ElementDoesNotExistError',
68 | message: 'The specified DOM element does not exist, but is required for this effect to operate'
69 | },
70 | Transitions: {
71 | linear: Prototype.K,
72 | sinoidal: function(pos) {
73 | return (-Math.cos(pos*Math.PI)/2) + .5;
74 | },
75 | reverse: function(pos) {
76 | return 1-pos;
77 | },
78 | flicker: function(pos) {
79 | var pos = ((-Math.cos(pos*Math.PI)/4) + .75) + Math.random()/4;
80 | return pos > 1 ? 1 : pos;
81 | },
82 | wobble: function(pos) {
83 | return (-Math.cos(pos*Math.PI*(9*pos))/2) + .5;
84 | },
85 | pulse: function(pos, pulses) {
86 | return (-Math.cos((pos*((pulses||5)-.5)*2)*Math.PI)/2) + .5;
87 | },
88 | spring: function(pos) {
89 | return 1 - (Math.cos(pos * 4.5 * Math.PI) * Math.exp(-pos * 6));
90 | },
91 | none: function(pos) {
92 | return 0;
93 | },
94 | full: function(pos) {
95 | return 1;
96 | }
97 | },
98 | DefaultOptions: {
99 | duration: 1.0, // seconds
100 | fps: 100, // 100= assume 66fps max.
101 | sync: false, // true for combining
102 | from: 0.0,
103 | to: 1.0,
104 | delay: 0.0,
105 | queue: 'parallel'
106 | },
107 | tagifyText: function(element) {
108 | var tagifyStyle = 'position:relative';
109 | if (Prototype.Browser.IE) tagifyStyle += ';zoom:1';
110 |
111 | element = $(element);
112 | $A(element.childNodes).each( function(child) {
113 | if (child.nodeType==3) {
114 | child.nodeValue.toArray().each( function(character) {
115 | element.insertBefore(
116 | new Element('span', {style: tagifyStyle}).update(
117 | character == ' ' ? String.fromCharCode(160) : character),
118 | child);
119 | });
120 | Element.remove(child);
121 | }
122 | });
123 | },
124 | multiple: function(element, effect) {
125 | var elements;
126 | if (((typeof element == 'object') ||
127 | Object.isFunction(element)) &&
128 | (element.length))
129 | elements = element;
130 | else
131 | elements = $(element).childNodes;
132 |
133 | var options = Object.extend({
134 | speed: 0.1,
135 | delay: 0.0
136 | }, arguments[2] || { });
137 | var masterDelay = options.delay;
138 |
139 | $A(elements).each( function(element, index) {
140 | new effect(element, Object.extend(options, { delay: index * options.speed + masterDelay }));
141 | });
142 | },
143 | PAIRS: {
144 | 'slide': ['SlideDown','SlideUp'],
145 | 'blind': ['BlindDown','BlindUp'],
146 | 'appear': ['Appear','Fade']
147 | },
148 | toggle: function(element, effect) {
149 | element = $(element);
150 | effect = (effect || 'appear').toLowerCase();
151 | var options = Object.extend({
152 | queue: { position:'end', scope:(element.id || 'global'), limit: 1 }
153 | }, arguments[2] || { });
154 | Effect[element.visible() ?
155 | Effect.PAIRS[effect][1] : Effect.PAIRS[effect][0]](element, options);
156 | }
157 | };
158 |
159 | Effect.DefaultOptions.transition = Effect.Transitions.sinoidal;
160 |
161 | /* ------------- core effects ------------- */
162 |
163 | Effect.ScopedQueue = Class.create(Enumerable, {
164 | initialize: function() {
165 | this.effects = [];
166 | this.interval = null;
167 | },
168 | _each: function(iterator) {
169 | this.effects._each(iterator);
170 | },
171 | add: function(effect) {
172 | var timestamp = new Date().getTime();
173 |
174 | var position = Object.isString(effect.options.queue) ?
175 | effect.options.queue : effect.options.queue.position;
176 |
177 | switch(position) {
178 | case 'front':
179 | // move unstarted effects after this effect
180 | this.effects.findAll(function(e){ return e.state=='idle' }).each( function(e) {
181 | e.startOn += effect.finishOn;
182 | e.finishOn += effect.finishOn;
183 | });
184 | break;
185 | case 'with-last':
186 | timestamp = this.effects.pluck('startOn').max() || timestamp;
187 | break;
188 | case 'end':
189 | // start effect after last queued effect has finished
190 | timestamp = this.effects.pluck('finishOn').max() || timestamp;
191 | break;
192 | }
193 |
194 | effect.startOn += timestamp;
195 | effect.finishOn += timestamp;
196 |
197 | if (!effect.options.queue.limit || (this.effects.length < effect.options.queue.limit))
198 | this.effects.push(effect);
199 |
200 | if (!this.interval)
201 | this.interval = setInterval(this.loop.bind(this), 15);
202 | },
203 | remove: function(effect) {
204 | this.effects = this.effects.reject(function(e) { return e==effect });
205 | if (this.effects.length == 0) {
206 | clearInterval(this.interval);
207 | this.interval = null;
208 | }
209 | },
210 | loop: function() {
211 | var timePos = new Date().getTime();
212 | for(var i=0, len=this.effects.length;i= this.startOn) {
279 | if (timePos >= this.finishOn) {
280 | this.render(1.0);
281 | this.cancel();
282 | this.event('beforeFinish');
283 | if (this.finish) this.finish();
284 | this.event('afterFinish');
285 | return;
286 | }
287 | var pos = (timePos - this.startOn) / this.totalTime,
288 | frame = (pos * this.totalFrames).round();
289 | if (frame > this.currentFrame) {
290 | this.render(pos);
291 | this.currentFrame = frame;
292 | }
293 | }
294 | },
295 | cancel: function() {
296 | if (!this.options.sync)
297 | Effect.Queues.get(Object.isString(this.options.queue) ?
298 | 'global' : this.options.queue.scope).remove(this);
299 | this.state = 'finished';
300 | },
301 | event: function(eventName) {
302 | if (this.options[eventName + 'Internal']) this.options[eventName + 'Internal'](this);
303 | if (this.options[eventName]) this.options[eventName](this);
304 | },
305 | inspect: function() {
306 | var data = $H();
307 | for(property in this)
308 | if (!Object.isFunction(this[property])) data.set(property, this[property]);
309 | return '#';
310 | }
311 | });
312 |
313 | Effect.Parallel = Class.create(Effect.Base, {
314 | initialize: function(effects) {
315 | this.effects = effects || [];
316 | this.start(arguments[1]);
317 | },
318 | update: function(position) {
319 | this.effects.invoke('render', position);
320 | },
321 | finish: function(position) {
322 | this.effects.each( function(effect) {
323 | effect.render(1.0);
324 | effect.cancel();
325 | effect.event('beforeFinish');
326 | if (effect.finish) effect.finish(position);
327 | effect.event('afterFinish');
328 | });
329 | }
330 | });
331 |
332 | Effect.Tween = Class.create(Effect.Base, {
333 | initialize: function(object, from, to) {
334 | object = Object.isString(object) ? $(object) : object;
335 | var args = $A(arguments), method = args.last(),
336 | options = args.length == 5 ? args[3] : null;
337 | this.method = Object.isFunction(method) ? method.bind(object) :
338 | Object.isFunction(object[method]) ? object[method].bind(object) :
339 | function(value) { object[method] = value };
340 | this.start(Object.extend({ from: from, to: to }, options || { }));
341 | },
342 | update: function(position) {
343 | this.method(position);
344 | }
345 | });
346 |
347 | Effect.Event = Class.create(Effect.Base, {
348 | initialize: function() {
349 | this.start(Object.extend({ duration: 0 }, arguments[0] || { }));
350 | },
351 | update: Prototype.emptyFunction
352 | });
353 |
354 | Effect.Opacity = Class.create(Effect.Base, {
355 | initialize: function(element) {
356 | this.element = $(element);
357 | if (!this.element) throw(Effect._elementDoesNotExistError);
358 | // make this work on IE on elements without 'layout'
359 | if (Prototype.Browser.IE && (!this.element.currentStyle.hasLayout))
360 | this.element.setStyle({zoom: 1});
361 | var options = Object.extend({
362 | from: this.element.getOpacity() || 0.0,
363 | to: 1.0
364 | }, arguments[1] || { });
365 | this.start(options);
366 | },
367 | update: function(position) {
368 | this.element.setOpacity(position);
369 | }
370 | });
371 |
372 | Effect.Move = Class.create(Effect.Base, {
373 | initialize: function(element) {
374 | this.element = $(element);
375 | if (!this.element) throw(Effect._elementDoesNotExistError);
376 | var options = Object.extend({
377 | x: 0,
378 | y: 0,
379 | mode: 'relative'
380 | }, arguments[1] || { });
381 | this.start(options);
382 | },
383 | setup: function() {
384 | this.element.makePositioned();
385 | this.originalLeft = parseFloat(this.element.getStyle('left') || '0');
386 | this.originalTop = parseFloat(this.element.getStyle('top') || '0');
387 | if (this.options.mode == 'absolute') {
388 | this.options.x = this.options.x - this.originalLeft;
389 | this.options.y = this.options.y - this.originalTop;
390 | }
391 | },
392 | update: function(position) {
393 | this.element.setStyle({
394 | left: (this.options.x * position + this.originalLeft).round() + 'px',
395 | top: (this.options.y * position + this.originalTop).round() + 'px'
396 | });
397 | }
398 | });
399 |
400 | // for backwards compatibility
401 | Effect.MoveBy = function(element, toTop, toLeft) {
402 | return new Effect.Move(element,
403 | Object.extend({ x: toLeft, y: toTop }, arguments[3] || { }));
404 | };
405 |
406 | Effect.Scale = Class.create(Effect.Base, {
407 | initialize: function(element, percent) {
408 | this.element = $(element);
409 | if (!this.element) throw(Effect._elementDoesNotExistError);
410 | var options = Object.extend({
411 | scaleX: true,
412 | scaleY: true,
413 | scaleContent: true,
414 | scaleFromCenter: false,
415 | scaleMode: 'box', // 'box' or 'contents' or { } with provided values
416 | scaleFrom: 100.0,
417 | scaleTo: percent
418 | }, arguments[2] || { });
419 | this.start(options);
420 | },
421 | setup: function() {
422 | this.restoreAfterFinish = this.options.restoreAfterFinish || false;
423 | this.elementPositioning = this.element.getStyle('position');
424 |
425 | this.originalStyle = { };
426 | ['top','left','width','height','fontSize'].each( function(k) {
427 | this.originalStyle[k] = this.element.style[k];
428 | }.bind(this));
429 |
430 | this.originalTop = this.element.offsetTop;
431 | this.originalLeft = this.element.offsetLeft;
432 |
433 | var fontSize = this.element.getStyle('font-size') || '100%';
434 | ['em','px','%','pt'].each( function(fontSizeType) {
435 | if (fontSize.indexOf(fontSizeType)>0) {
436 | this.fontSize = parseFloat(fontSize);
437 | this.fontSizeType = fontSizeType;
438 | }
439 | }.bind(this));
440 |
441 | this.factor = (this.options.scaleTo - this.options.scaleFrom)/100;
442 |
443 | this.dims = null;
444 | if (this.options.scaleMode=='box')
445 | this.dims = [this.element.offsetHeight, this.element.offsetWidth];
446 | if (/^content/.test(this.options.scaleMode))
447 | this.dims = [this.element.scrollHeight, this.element.scrollWidth];
448 | if (!this.dims)
449 | this.dims = [this.options.scaleMode.originalHeight,
450 | this.options.scaleMode.originalWidth];
451 | },
452 | update: function(position) {
453 | var currentScale = (this.options.scaleFrom/100.0) + (this.factor * position);
454 | if (this.options.scaleContent && this.fontSize)
455 | this.element.setStyle({fontSize: this.fontSize * currentScale + this.fontSizeType });
456 | this.setDimensions(this.dims[0] * currentScale, this.dims[1] * currentScale);
457 | },
458 | finish: function(position) {
459 | if (this.restoreAfterFinish) this.element.setStyle(this.originalStyle);
460 | },
461 | setDimensions: function(height, width) {
462 | var d = { };
463 | if (this.options.scaleX) d.width = width.round() + 'px';
464 | if (this.options.scaleY) d.height = height.round() + 'px';
465 | if (this.options.scaleFromCenter) {
466 | var topd = (height - this.dims[0])/2;
467 | var leftd = (width - this.dims[1])/2;
468 | if (this.elementPositioning == 'absolute') {
469 | if (this.options.scaleY) d.top = this.originalTop-topd + 'px';
470 | if (this.options.scaleX) d.left = this.originalLeft-leftd + 'px';
471 | } else {
472 | if (this.options.scaleY) d.top = -topd + 'px';
473 | if (this.options.scaleX) d.left = -leftd + 'px';
474 | }
475 | }
476 | this.element.setStyle(d);
477 | }
478 | });
479 |
480 | Effect.Highlight = Class.create(Effect.Base, {
481 | initialize: function(element) {
482 | this.element = $(element);
483 | if (!this.element) throw(Effect._elementDoesNotExistError);
484 | var options = Object.extend({ startcolor: '#ffff99' }, arguments[1] || { });
485 | this.start(options);
486 | },
487 | setup: function() {
488 | // Prevent executing on elements not in the layout flow
489 | if (this.element.getStyle('display')=='none') { this.cancel(); return; }
490 | // Disable background image during the effect
491 | this.oldStyle = { };
492 | if (!this.options.keepBackgroundImage) {
493 | this.oldStyle.backgroundImage = this.element.getStyle('background-image');
494 | this.element.setStyle({backgroundImage: 'none'});
495 | }
496 | if (!this.options.endcolor)
497 | this.options.endcolor = this.element.getStyle('background-color').parseColor('#ffffff');
498 | if (!this.options.restorecolor)
499 | this.options.restorecolor = this.element.getStyle('background-color');
500 | // init color calculations
501 | this._base = $R(0,2).map(function(i){ return parseInt(this.options.startcolor.slice(i*2+1,i*2+3),16) }.bind(this));
502 | this._delta = $R(0,2).map(function(i){ return parseInt(this.options.endcolor.slice(i*2+1,i*2+3),16)-this._base[i] }.bind(this));
503 | },
504 | update: function(position) {
505 | this.element.setStyle({backgroundColor: $R(0,2).inject('#',function(m,v,i){
506 | return m+((this._base[i]+(this._delta[i]*position)).round().toColorPart()); }.bind(this)) });
507 | },
508 | finish: function() {
509 | this.element.setStyle(Object.extend(this.oldStyle, {
510 | backgroundColor: this.options.restorecolor
511 | }));
512 | }
513 | });
514 |
515 | Effect.ScrollTo = function(element) {
516 | var options = arguments[1] || { },
517 | scrollOffsets = document.viewport.getScrollOffsets(),
518 | elementOffsets = $(element).cumulativeOffset();
519 |
520 | if (options.offset) elementOffsets[1] += options.offset;
521 |
522 | return new Effect.Tween(null,
523 | scrollOffsets.top,
524 | elementOffsets[1],
525 | options,
526 | function(p){ scrollTo(scrollOffsets.left, p.round()); }
527 | );
528 | };
529 |
530 | /* ------------- combination effects ------------- */
531 |
532 | Effect.Fade = function(element) {
533 | element = $(element);
534 | var oldOpacity = element.getInlineOpacity();
535 | var options = Object.extend({
536 | from: element.getOpacity() || 1.0,
537 | to: 0.0,
538 | afterFinishInternal: function(effect) {
539 | if (effect.options.to!=0) return;
540 | effect.element.hide().setStyle({opacity: oldOpacity});
541 | }
542 | }, arguments[1] || { });
543 | return new Effect.Opacity(element,options);
544 | };
545 |
546 | Effect.Appear = function(element) {
547 | element = $(element);
548 | var options = Object.extend({
549 | from: (element.getStyle('display') == 'none' ? 0.0 : element.getOpacity() || 0.0),
550 | to: 1.0,
551 | // force Safari to render floated elements properly
552 | afterFinishInternal: function(effect) {
553 | effect.element.forceRerendering();
554 | },
555 | beforeSetup: function(effect) {
556 | effect.element.setOpacity(effect.options.from).show();
557 | }}, arguments[1] || { });
558 | return new Effect.Opacity(element,options);
559 | };
560 |
561 | Effect.Puff = function(element) {
562 | element = $(element);
563 | var oldStyle = {
564 | opacity: element.getInlineOpacity(),
565 | position: element.getStyle('position'),
566 | top: element.style.top,
567 | left: element.style.left,
568 | width: element.style.width,
569 | height: element.style.height
570 | };
571 | return new Effect.Parallel(
572 | [ new Effect.Scale(element, 200,
573 | { sync: true, scaleFromCenter: true, scaleContent: true, restoreAfterFinish: true }),
574 | new Effect.Opacity(element, { sync: true, to: 0.0 } ) ],
575 | Object.extend({ duration: 1.0,
576 | beforeSetupInternal: function(effect) {
577 | Position.absolutize(effect.effects[0].element);
578 | },
579 | afterFinishInternal: function(effect) {
580 | effect.effects[0].element.hide().setStyle(oldStyle); }
581 | }, arguments[1] || { })
582 | );
583 | };
584 |
585 | Effect.BlindUp = function(element) {
586 | element = $(element);
587 | element.makeClipping();
588 | return new Effect.Scale(element, 0,
589 | Object.extend({ scaleContent: false,
590 | scaleX: false,
591 | restoreAfterFinish: true,
592 | afterFinishInternal: function(effect) {
593 | effect.element.hide().undoClipping();
594 | }
595 | }, arguments[1] || { })
596 | );
597 | };
598 |
599 | Effect.BlindDown = function(element) {
600 | element = $(element);
601 | var elementDimensions = element.getDimensions();
602 | return new Effect.Scale(element, 100, Object.extend({
603 | scaleContent: false,
604 | scaleX: false,
605 | scaleFrom: 0,
606 | scaleMode: {originalHeight: elementDimensions.height, originalWidth: elementDimensions.width},
607 | restoreAfterFinish: true,
608 | afterSetup: function(effect) {
609 | effect.element.makeClipping().setStyle({height: '0px'}).show();
610 | },
611 | afterFinishInternal: function(effect) {
612 | effect.element.undoClipping();
613 | }
614 | }, arguments[1] || { }));
615 | };
616 |
617 | Effect.SwitchOff = function(element) {
618 | element = $(element);
619 | var oldOpacity = element.getInlineOpacity();
620 | return new Effect.Appear(element, Object.extend({
621 | duration: 0.4,
622 | from: 0,
623 | transition: Effect.Transitions.flicker,
624 | afterFinishInternal: function(effect) {
625 | new Effect.Scale(effect.element, 1, {
626 | duration: 0.3, scaleFromCenter: true,
627 | scaleX: false, scaleContent: false, restoreAfterFinish: true,
628 | beforeSetup: function(effect) {
629 | effect.element.makePositioned().makeClipping();
630 | },
631 | afterFinishInternal: function(effect) {
632 | effect.element.hide().undoClipping().undoPositioned().setStyle({opacity: oldOpacity});
633 | }
634 | });
635 | }
636 | }, arguments[1] || { }));
637 | };
638 |
639 | Effect.DropOut = function(element) {
640 | element = $(element);
641 | var oldStyle = {
642 | top: element.getStyle('top'),
643 | left: element.getStyle('left'),
644 | opacity: element.getInlineOpacity() };
645 | return new Effect.Parallel(
646 | [ new Effect.Move(element, {x: 0, y: 100, sync: true }),
647 | new Effect.Opacity(element, { sync: true, to: 0.0 }) ],
648 | Object.extend(
649 | { duration: 0.5,
650 | beforeSetup: function(effect) {
651 | effect.effects[0].element.makePositioned();
652 | },
653 | afterFinishInternal: function(effect) {
654 | effect.effects[0].element.hide().undoPositioned().setStyle(oldStyle);
655 | }
656 | }, arguments[1] || { }));
657 | };
658 |
659 | Effect.Shake = function(element) {
660 | element = $(element);
661 | var options = Object.extend({
662 | distance: 20,
663 | duration: 0.5
664 | }, arguments[1] || {});
665 | var distance = parseFloat(options.distance);
666 | var split = parseFloat(options.duration) / 10.0;
667 | var oldStyle = {
668 | top: element.getStyle('top'),
669 | left: element.getStyle('left') };
670 | return new Effect.Move(element,
671 | { x: distance, y: 0, duration: split, afterFinishInternal: function(effect) {
672 | new Effect.Move(effect.element,
673 | { x: -distance*2, y: 0, duration: split*2, afterFinishInternal: function(effect) {
674 | new Effect.Move(effect.element,
675 | { x: distance*2, y: 0, duration: split*2, afterFinishInternal: function(effect) {
676 | new Effect.Move(effect.element,
677 | { x: -distance*2, y: 0, duration: split*2, afterFinishInternal: function(effect) {
678 | new Effect.Move(effect.element,
679 | { x: distance*2, y: 0, duration: split*2, afterFinishInternal: function(effect) {
680 | new Effect.Move(effect.element,
681 | { x: -distance, y: 0, duration: split, afterFinishInternal: function(effect) {
682 | effect.element.undoPositioned().setStyle(oldStyle);
683 | }}); }}); }}); }}); }}); }});
684 | };
685 |
686 | Effect.SlideDown = function(element) {
687 | element = $(element).cleanWhitespace();
688 | // SlideDown need to have the content of the element wrapped in a container element with fixed height!
689 | var oldInnerBottom = element.down().getStyle('bottom');
690 | var elementDimensions = element.getDimensions();
691 | return new Effect.Scale(element, 100, Object.extend({
692 | scaleContent: false,
693 | scaleX: false,
694 | scaleFrom: window.opera ? 0 : 1,
695 | scaleMode: {originalHeight: elementDimensions.height, originalWidth: elementDimensions.width},
696 | restoreAfterFinish: true,
697 | afterSetup: function(effect) {
698 | effect.element.makePositioned();
699 | effect.element.down().makePositioned();
700 | if (window.opera) effect.element.setStyle({top: ''});
701 | effect.element.makeClipping().setStyle({height: '0px'}).show();
702 | },
703 | afterUpdateInternal: function(effect) {
704 | effect.element.down().setStyle({bottom:
705 | (effect.dims[0] - effect.element.clientHeight) + 'px' });
706 | },
707 | afterFinishInternal: function(effect) {
708 | effect.element.undoClipping().undoPositioned();
709 | effect.element.down().undoPositioned().setStyle({bottom: oldInnerBottom}); }
710 | }, arguments[1] || { })
711 | );
712 | };
713 |
714 | Effect.SlideUp = function(element) {
715 | element = $(element).cleanWhitespace();
716 | var oldInnerBottom = element.down().getStyle('bottom');
717 | var elementDimensions = element.getDimensions();
718 | return new Effect.Scale(element, window.opera ? 0 : 1,
719 | Object.extend({ scaleContent: false,
720 | scaleX: false,
721 | scaleMode: 'box',
722 | scaleFrom: 100,
723 | scaleMode: {originalHeight: elementDimensions.height, originalWidth: elementDimensions.width},
724 | restoreAfterFinish: true,
725 | afterSetup: function(effect) {
726 | effect.element.makePositioned();
727 | effect.element.down().makePositioned();
728 | if (window.opera) effect.element.setStyle({top: ''});
729 | effect.element.makeClipping().show();
730 | },
731 | afterUpdateInternal: function(effect) {
732 | effect.element.down().setStyle({bottom:
733 | (effect.dims[0] - effect.element.clientHeight) + 'px' });
734 | },
735 | afterFinishInternal: function(effect) {
736 | effect.element.hide().undoClipping().undoPositioned();
737 | effect.element.down().undoPositioned().setStyle({bottom: oldInnerBottom});
738 | }
739 | }, arguments[1] || { })
740 | );
741 | };
742 |
743 | // Bug in opera makes the TD containing this element expand for a instance after finish
744 | Effect.Squish = function(element) {
745 | return new Effect.Scale(element, window.opera ? 1 : 0, {
746 | restoreAfterFinish: true,
747 | beforeSetup: function(effect) {
748 | effect.element.makeClipping();
749 | },
750 | afterFinishInternal: function(effect) {
751 | effect.element.hide().undoClipping();
752 | }
753 | });
754 | };
755 |
756 | Effect.Grow = function(element) {
757 | element = $(element);
758 | var options = Object.extend({
759 | direction: 'center',
760 | moveTransition: Effect.Transitions.sinoidal,
761 | scaleTransition: Effect.Transitions.sinoidal,
762 | opacityTransition: Effect.Transitions.full
763 | }, arguments[1] || { });
764 | var oldStyle = {
765 | top: element.style.top,
766 | left: element.style.left,
767 | height: element.style.height,
768 | width: element.style.width,
769 | opacity: element.getInlineOpacity() };
770 |
771 | var dims = element.getDimensions();
772 | var initialMoveX, initialMoveY;
773 | var moveX, moveY;
774 |
775 | switch (options.direction) {
776 | case 'top-left':
777 | initialMoveX = initialMoveY = moveX = moveY = 0;
778 | break;
779 | case 'top-right':
780 | initialMoveX = dims.width;
781 | initialMoveY = moveY = 0;
782 | moveX = -dims.width;
783 | break;
784 | case 'bottom-left':
785 | initialMoveX = moveX = 0;
786 | initialMoveY = dims.height;
787 | moveY = -dims.height;
788 | break;
789 | case 'bottom-right':
790 | initialMoveX = dims.width;
791 | initialMoveY = dims.height;
792 | moveX = -dims.width;
793 | moveY = -dims.height;
794 | break;
795 | case 'center':
796 | initialMoveX = dims.width / 2;
797 | initialMoveY = dims.height / 2;
798 | moveX = -dims.width / 2;
799 | moveY = -dims.height / 2;
800 | break;
801 | }
802 |
803 | return new Effect.Move(element, {
804 | x: initialMoveX,
805 | y: initialMoveY,
806 | duration: 0.01,
807 | beforeSetup: function(effect) {
808 | effect.element.hide().makeClipping().makePositioned();
809 | },
810 | afterFinishInternal: function(effect) {
811 | new Effect.Parallel(
812 | [ new Effect.Opacity(effect.element, { sync: true, to: 1.0, from: 0.0, transition: options.opacityTransition }),
813 | new Effect.Move(effect.element, { x: moveX, y: moveY, sync: true, transition: options.moveTransition }),
814 | new Effect.Scale(effect.element, 100, {
815 | scaleMode: { originalHeight: dims.height, originalWidth: dims.width },
816 | sync: true, scaleFrom: window.opera ? 1 : 0, transition: options.scaleTransition, restoreAfterFinish: true})
817 | ], Object.extend({
818 | beforeSetup: function(effect) {
819 | effect.effects[0].element.setStyle({height: '0px'}).show();
820 | },
821 | afterFinishInternal: function(effect) {
822 | effect.effects[0].element.undoClipping().undoPositioned().setStyle(oldStyle);
823 | }
824 | }, options)
825 | );
826 | }
827 | });
828 | };
829 |
830 | Effect.Shrink = function(element) {
831 | element = $(element);
832 | var options = Object.extend({
833 | direction: 'center',
834 | moveTransition: Effect.Transitions.sinoidal,
835 | scaleTransition: Effect.Transitions.sinoidal,
836 | opacityTransition: Effect.Transitions.none
837 | }, arguments[1] || { });
838 | var oldStyle = {
839 | top: element.style.top,
840 | left: element.style.left,
841 | height: element.style.height,
842 | width: element.style.width,
843 | opacity: element.getInlineOpacity() };
844 |
845 | var dims = element.getDimensions();
846 | var moveX, moveY;
847 |
848 | switch (options.direction) {
849 | case 'top-left':
850 | moveX = moveY = 0;
851 | break;
852 | case 'top-right':
853 | moveX = dims.width;
854 | moveY = 0;
855 | break;
856 | case 'bottom-left':
857 | moveX = 0;
858 | moveY = dims.height;
859 | break;
860 | case 'bottom-right':
861 | moveX = dims.width;
862 | moveY = dims.height;
863 | break;
864 | case 'center':
865 | moveX = dims.width / 2;
866 | moveY = dims.height / 2;
867 | break;
868 | }
869 |
870 | return new Effect.Parallel(
871 | [ new Effect.Opacity(element, { sync: true, to: 0.0, from: 1.0, transition: options.opacityTransition }),
872 | new Effect.Scale(element, window.opera ? 1 : 0, { sync: true, transition: options.scaleTransition, restoreAfterFinish: true}),
873 | new Effect.Move(element, { x: moveX, y: moveY, sync: true, transition: options.moveTransition })
874 | ], Object.extend({
875 | beforeStartInternal: function(effect) {
876 | effect.effects[0].element.makePositioned().makeClipping();
877 | },
878 | afterFinishInternal: function(effect) {
879 | effect.effects[0].element.hide().undoClipping().undoPositioned().setStyle(oldStyle); }
880 | }, options)
881 | );
882 | };
883 |
884 | Effect.Pulsate = function(element) {
885 | element = $(element);
886 | var options = arguments[1] || { },
887 | oldOpacity = element.getInlineOpacity(),
888 | transition = options.transition || Effect.Transitions.linear,
889 | reverser = function(pos){
890 | return 1 - transition((-Math.cos((pos*(options.pulses||5)*2)*Math.PI)/2) + .5);
891 | };
892 |
893 | return new Effect.Opacity(element,
894 | Object.extend(Object.extend({ duration: 2.0, from: 0,
895 | afterFinishInternal: function(effect) { effect.element.setStyle({opacity: oldOpacity}); }
896 | }, options), {transition: reverser}));
897 | };
898 |
899 | Effect.Fold = function(element) {
900 | element = $(element);
901 | var oldStyle = {
902 | top: element.style.top,
903 | left: element.style.left,
904 | width: element.style.width,
905 | height: element.style.height };
906 | element.makeClipping();
907 | return new Effect.Scale(element, 5, Object.extend({
908 | scaleContent: false,
909 | scaleX: false,
910 | afterFinishInternal: function(effect) {
911 | new Effect.Scale(element, 1, {
912 | scaleContent: false,
913 | scaleY: false,
914 | afterFinishInternal: function(effect) {
915 | effect.element.hide().undoClipping().setStyle(oldStyle);
916 | } });
917 | }}, arguments[1] || { }));
918 | };
919 |
920 | Effect.Morph = Class.create(Effect.Base, {
921 | initialize: function(element) {
922 | this.element = $(element);
923 | if (!this.element) throw(Effect._elementDoesNotExistError);
924 | var options = Object.extend({
925 | style: { }
926 | }, arguments[1] || { });
927 |
928 | if (!Object.isString(options.style)) this.style = $H(options.style);
929 | else {
930 | if (options.style.include(':'))
931 | this.style = options.style.parseStyle();
932 | else {
933 | this.element.addClassName(options.style);
934 | this.style = $H(this.element.getStyles());
935 | this.element.removeClassName(options.style);
936 | var css = this.element.getStyles();
937 | this.style = this.style.reject(function(style) {
938 | return style.value == css[style.key];
939 | });
940 | options.afterFinishInternal = function(effect) {
941 | effect.element.addClassName(effect.options.style);
942 | effect.transforms.each(function(transform) {
943 | effect.element.style[transform.style] = '';
944 | });
945 | };
946 | }
947 | }
948 | this.start(options);
949 | },
950 |
951 | setup: function(){
952 | function parseColor(color){
953 | if (!color || ['rgba(0, 0, 0, 0)','transparent'].include(color)) color = '#ffffff';
954 | color = color.parseColor();
955 | return $R(0,2).map(function(i){
956 | return parseInt( color.slice(i*2+1,i*2+3), 16 );
957 | });
958 | }
959 | this.transforms = this.style.map(function(pair){
960 | var property = pair[0], value = pair[1], unit = null;
961 |
962 | if (value.parseColor('#zzzzzz') != '#zzzzzz') {
963 | value = value.parseColor();
964 | unit = 'color';
965 | } else if (property == 'opacity') {
966 | value = parseFloat(value);
967 | if (Prototype.Browser.IE && (!this.element.currentStyle.hasLayout))
968 | this.element.setStyle({zoom: 1});
969 | } else if (Element.CSS_LENGTH.test(value)) {
970 | var components = value.match(/^([\+\-]?[0-9\.]+)(.*)$/);
971 | value = parseFloat(components[1]);
972 | unit = (components.length == 3) ? components[2] : null;
973 | }
974 |
975 | var originalValue = this.element.getStyle(property);
976 | return {
977 | style: property.camelize(),
978 | originalValue: unit=='color' ? parseColor(originalValue) : parseFloat(originalValue || 0),
979 | targetValue: unit=='color' ? parseColor(value) : value,
980 | unit: unit
981 | };
982 | }.bind(this)).reject(function(transform){
983 | return (
984 | (transform.originalValue == transform.targetValue) ||
985 | (
986 | transform.unit != 'color' &&
987 | (isNaN(transform.originalValue) || isNaN(transform.targetValue))
988 | )
989 | );
990 | });
991 | },
992 | update: function(position) {
993 | var style = { }, transform, i = this.transforms.length;
994 | while(i--)
995 | style[(transform = this.transforms[i]).style] =
996 | transform.unit=='color' ? '#'+
997 | (Math.round(transform.originalValue[0]+
998 | (transform.targetValue[0]-transform.originalValue[0])*position)).toColorPart() +
999 | (Math.round(transform.originalValue[1]+
1000 | (transform.targetValue[1]-transform.originalValue[1])*position)).toColorPart() +
1001 | (Math.round(transform.originalValue[2]+
1002 | (transform.targetValue[2]-transform.originalValue[2])*position)).toColorPart() :
1003 | (transform.originalValue +
1004 | (transform.targetValue - transform.originalValue) * position).toFixed(3) +
1005 | (transform.unit === null ? '' : transform.unit);
1006 | this.element.setStyle(style, true);
1007 | }
1008 | });
1009 |
1010 | Effect.Transform = Class.create({
1011 | initialize: function(tracks){
1012 | this.tracks = [];
1013 | this.options = arguments[1] || { };
1014 | this.addTracks(tracks);
1015 | },
1016 | addTracks: function(tracks){
1017 | tracks.each(function(track){
1018 | track = $H(track);
1019 | var data = track.values().first();
1020 | this.tracks.push($H({
1021 | ids: track.keys().first(),
1022 | effect: Effect.Morph,
1023 | options: { style: data }
1024 | }));
1025 | }.bind(this));
1026 | return this;
1027 | },
1028 | play: function(){
1029 | return new Effect.Parallel(
1030 | this.tracks.map(function(track){
1031 | var ids = track.get('ids'), effect = track.get('effect'), options = track.get('options');
1032 | var elements = [$(ids) || $$(ids)].flatten();
1033 | return elements.map(function(e){ return new effect(e, Object.extend({ sync:true }, options)) });
1034 | }).flatten(),
1035 | this.options
1036 | );
1037 | }
1038 | });
1039 |
1040 | Element.CSS_PROPERTIES = $w(
1041 | 'backgroundColor backgroundPosition borderBottomColor borderBottomStyle ' +
1042 | 'borderBottomWidth borderLeftColor borderLeftStyle borderLeftWidth ' +
1043 | 'borderRightColor borderRightStyle borderRightWidth borderSpacing ' +
1044 | 'borderTopColor borderTopStyle borderTopWidth bottom clip color ' +
1045 | 'fontSize fontWeight height left letterSpacing lineHeight ' +
1046 | 'marginBottom marginLeft marginRight marginTop markerOffset maxHeight '+
1047 | 'maxWidth minHeight minWidth opacity outlineColor outlineOffset ' +
1048 | 'outlineWidth paddingBottom paddingLeft paddingRight paddingTop ' +
1049 | 'right textIndent top width wordSpacing zIndex');
1050 |
1051 | Element.CSS_LENGTH = /^(([\+\-]?[0-9\.]+)(em|ex|px|in|cm|mm|pt|pc|\%))|0$/;
1052 |
1053 | String.__parseStyleElement = document.createElement('div');
1054 | String.prototype.parseStyle = function(){
1055 | var style, styleRules = $H();
1056 | if (Prototype.Browser.WebKit)
1057 | style = new Element('div',{style:this}).style;
1058 | else {
1059 | String.__parseStyleElement.innerHTML = '
';
1060 | style = String.__parseStyleElement.childNodes[0].style;
1061 | }
1062 |
1063 | Element.CSS_PROPERTIES.each(function(property){
1064 | if (style[property]) styleRules.set(property, style[property]);
1065 | });
1066 |
1067 | if (Prototype.Browser.IE && this.include('opacity'))
1068 | styleRules.set('opacity', this.match(/opacity:\s*((?:0|1)?(?:\.\d*)?)/)[1]);
1069 |
1070 | return styleRules;
1071 | };
1072 |
1073 | if (document.defaultView && document.defaultView.getComputedStyle) {
1074 | Element.getStyles = function(element) {
1075 | var css = document.defaultView.getComputedStyle($(element), null);
1076 | return Element.CSS_PROPERTIES.inject({ }, function(styles, property) {
1077 | styles[property] = css[property];
1078 | return styles;
1079 | });
1080 | };
1081 | } else {
1082 | Element.getStyles = function(element) {
1083 | element = $(element);
1084 | var css = element.currentStyle, styles;
1085 | styles = Element.CSS_PROPERTIES.inject({ }, function(results, property) {
1086 | results[property] = css[property];
1087 | return results;
1088 | });
1089 | if (!styles.opacity) styles.opacity = element.getOpacity();
1090 | return styles;
1091 | };
1092 | }
1093 |
1094 | Effect.Methods = {
1095 | morph: function(element, style) {
1096 | element = $(element);
1097 | new Effect.Morph(element, Object.extend({ style: style }, arguments[2] || { }));
1098 | return element;
1099 | },
1100 | visualEffect: function(element, effect, options) {
1101 | element = $(element);
1102 | var s = effect.dasherize().camelize(), klass = s.charAt(0).toUpperCase() + s.substring(1);
1103 | new Effect[klass](element, options);
1104 | return element;
1105 | },
1106 | highlight: function(element, options) {
1107 | element = $(element);
1108 | new Effect.Highlight(element, options);
1109 | return element;
1110 | }
1111 | };
1112 |
1113 | $w('fade appear grow shrink fold blindUp blindDown slideUp slideDown '+
1114 | 'pulsate shake puff squish switchOff dropOut').each(
1115 | function(effect) {
1116 | Effect.Methods[effect] = function(element, options){
1117 | element = $(element);
1118 | Effect[effect.charAt(0).toUpperCase() + effect.substring(1)](element, options);
1119 | return element;
1120 | };
1121 | }
1122 | );
1123 |
1124 | $w('getInlineOpacity forceRerendering setContentZoom collectTextNodes collectTextNodesIgnoreClass getStyles').each(
1125 | function(f) { Effect.Methods[f] = Element[f]; }
1126 | );
1127 |
1128 | Element.addMethods(Effect.Methods);
--------------------------------------------------------------------------------
/public/robots.txt:
--------------------------------------------------------------------------------
1 | # See http://www.robotstxt.org/wc/norobots.html for documentation on how to use the robots.txt file
2 | #
3 | # To ban all spiders from the entire site uncomment the next two lines:
4 | # User-Agent: *
5 | # Disallow: /
6 |
--------------------------------------------------------------------------------
/public/stylesheets/basic.css:
--------------------------------------------------------------------------------
1 | /*** Basic styles ***/
2 |
3 | body {
4 | font-family: "Constantia", "Georgia", "Times", "Times New Roman", serif;
5 | line-height: 1.5em;
6 | }
7 |
8 | /* header fonts */
9 |
10 | h1, h2, h3, h4, h5, h6, th, dt, #header {
11 | font-family: "Helvetica", "Arial", sans-serif;
12 | font-weight: bold;
13 | letter-spacing: -0.1ex;
14 | line-height: 1em;
15 | }
16 |
17 | /* fixed-width fonts */
18 |
19 | pre, code, kbd, samp, tt {
20 | font-family: "Consolas", "Inconsolata", "Lucida Console", "Monaco", "Bitstream Vera Sans Mono", monospace;
21 | }
22 | pre, code {
23 | border: 1px solid #cde;
24 | background-color: #def;
25 | }
26 | pre code {
27 | border: none;
28 | }
29 | kbd {
30 | font-weight: bold;
31 | }
32 |
33 | /* basic spacing of block-level elements */
34 |
35 | p, ul, ol, dl, form, blockquote, h1, h2, h3, h4, h5, h6 {
36 | margin: 1em 0;
37 | }
38 |
39 | /* headers - margins are based on reciprocal of font size */
40 |
41 | h1 {
42 | font-size: 200%;
43 | margin: 0.5em 0;
44 | }
45 | h2 {
46 | font-size: 150%;
47 | margin: 0.67em 0;
48 | }
49 | h3 {
50 | font-size: 125%;
51 | margin: 0.8em 0;
52 | }
53 |
54 | /* links */
55 |
56 | a {
57 | text-decoration: underline;
58 | color: #05a;
59 | }
60 | a:visited {
61 | color: #50a;
62 | }
63 | a:hover, a:focus, a:active {
64 | }
65 | a:focus, a:active {
66 | }
67 |
68 | /* basic elements */
69 |
70 | img, a img {
71 | }
72 | small {
73 | }
74 | abbr, acronym {
75 | }
76 | blockquote {
77 | margin-left: 1.2em;
78 | padding-left: 0.8em;
79 | border-left: 2pt solid #000;
80 | font-style: italic;
81 | }
82 | blockquote em {
83 | font-style: normal;
84 | }
85 | cite {
86 | font-style: italic;
87 | }
88 | em {
89 | font-style: italic;
90 | }
91 | strong {
92 | font-weight: bold;
93 | }
94 |
95 | /* forms */
96 |
97 | form {
98 | }
99 | fieldset {
100 | }
101 | legend {
102 | }
103 | label {
104 | }
105 | input {
106 | }
107 | select {
108 | }
109 | option {
110 | }
111 | textarea {
112 | }
113 | input:focus, select:focus, option:focus, textarea:focus {
114 | }
115 |
116 | /* tables */
117 |
118 | td, th {
119 | border: 1pt solid #bbb;
120 | padding: 0.2em 0.5em;;
121 | }
122 | caption {
123 | font-style: italic;
124 | font-size: 85%;
125 | margin-bottom: 0.2em;
126 | }
127 |
128 | /* lists */
129 |
130 | ul, ol {
131 | margin-left: 2em;
132 | }
133 | li {
134 | list-style-position: outside;
135 | }
136 | ol li {
137 | list-style-type:decimal;
138 | }
139 | ul li {
140 | list-style-type: disc;
141 | }
142 | dd {
143 | padding-left: 2em;
144 | }
145 |
146 |
147 |
--------------------------------------------------------------------------------
/public/stylesheets/reset-min.css:
--------------------------------------------------------------------------------
1 | /*
2 | Copyright (c) 2008, Yahoo! Inc. All rights reserved.
3 | Code licensed under the BSD License:
4 | http://developer.yahoo.net/yui/license.txt
5 | version: 2.6.0
6 | */
7 | html{color:#000;background:#FFF;}body,div,dl,dt,dd,ul,ol,li,h1,h2,h3,h4,h5,h6,pre,code,form,fieldset,legend,input,textarea,p,blockquote,th,td{margin:0;padding:0;}table{border-collapse:collapse;border-spacing:0;}fieldset,img{border:0;}address,caption,cite,code,dfn,em,strong,th,var{font-style:normal;font-weight:normal;}li{list-style:none;}caption,th{text-align:left;}h1,h2,h3,h4,h5,h6{font-size:100%;font-weight:normal;}q:before,q:after{content:'';}abbr,acronym{border:0;font-variant:normal;}sup{vertical-align:text-top;}sub{vertical-align:text-bottom;}input,textarea,select{font-family:inherit;font-size:inherit;font-weight:inherit;}input,textarea,select{*font-size:100%;}legend{color:#000;}del,ins{text-decoration:none;}
--------------------------------------------------------------------------------
/public/stylesheets/screen.css:
--------------------------------------------------------------------------------
1 | #header {
2 | background-color: #444;
3 | color: #fff;
4 | border-bottom: 1px solid #000;
5 | padding: 0.5em 1em;
6 | }
7 | #header h1 {
8 | margin: 0;
9 | }
10 | #header h1 a {
11 | text-decoration: none;
12 | color: #fff;
13 | }
14 | #header p {
15 | margin: 0;
16 | font-weight: normal;
17 | }
18 | #main {
19 | padding: 1em;
20 | }
21 | #footer {
22 | left: 0;
23 | width: 100%;
24 | border-top: 1px solid #888;
25 | color: #888;
26 | }
27 | #footer p {
28 | margin: 0;
29 | padding: 0.5em 1em;
30 | }
31 | #footer p a {
32 | color: #888
33 | }
34 | #summary {
35 | border: 1px solid #ddd;
36 | background-color: #ffc;
37 | font-style: italic;
38 | padding: 0 1em;
39 | }
40 | #percentComplete {
41 | position: absolute;
42 | top: 0.5em;
43 | right: 1em;
44 | }
45 |
46 | h2.termHeading {
47 | font-weight: normal;
48 | }
49 | h2.termHeading em {
50 | font-weight: bold;
51 | font-style: normal;
52 | }
53 | h2.termHeading strong.cause {
54 | color: #b00;
55 | }
56 | h2.termHeading strong.prevent {
57 | color: #0b0;
58 | }
59 | h2.termHeading a.directLink {
60 | color: #888;
61 | }
62 | ul.cause {
63 | color: #b00;
64 | }
65 | ul.prevent {
66 | color: #0b0;
67 | }
68 | span.debug,
69 | span.debug a {
70 | font-size: 12px;
71 | color: #888;
72 | }
73 | ul.pagination {
74 | padding-left: 0;
75 | margin-left: 0;
76 | }
77 | ul.pagination li {
78 | display: inline;
79 | }
80 | ul.pagination li * {
81 | border: 1px solid #444;
82 | padding: 1px 4px;
83 | font-weight: normal;
84 | text-decoration: none;
85 | }
86 | ul.pagination li strong {
87 | color: #fff;
88 | background-color: #444;
89 | }
90 |
--------------------------------------------------------------------------------
/script/link_results:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env ruby
2 | require File.join(File.dirname(__FILE__), "..", "config", "environment")
3 | require "csv"
4 |
5 | [NormalizedTerm, Term, Tagging].each do |klass|
6 | klass.delete_all
7 | end
8 |
9 | CSV.open(ARGV.first, "r") do |row|
10 | t, n, = row
11 |
12 | next if ["x", "?"].include?(n)
13 |
14 | normalized_term = NormalizedTerm[n]
15 | term = Term[t]
16 | term.normalized_term = normalized_term
17 | term.save!
18 | end
19 |
20 | Article.all.each do |article|
21 | article.causes.each do |word|
22 | article.taggings.create!(:term => Term[word], :good => false)
23 | end
24 | article.preventors.each do |word|
25 | article.taggings.create!(:term => Term[word], :good => true)
26 | end
27 | end
28 |
29 | Tagging.all(:include => :term).each do |tagging|
30 | next if NormalizedTagging.find_by_article_id_and_normalized_term_id_and_good(
31 | tagging.article_id,
32 | tagging.term.normalized_term_id,
33 | tagging.good)
34 | NormalizedTagging.create!(
35 | :article_id => tagging.article_id,
36 | :normalized_term_id => tagging.term.normalized_term_id,
37 | :good => tagging.good)
38 | end
39 |
40 | NormalizedTerm.all.each do |nt|
41 | nt.destroy if nt.articles.empty?
42 | end
43 |
--------------------------------------------------------------------------------
/script/parse-results.rb:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env ruby
2 | require File.join(File.dirname(__FILE__), "..", "config", "environment")
3 | require "hpricot"
4 | require "fileutils"
5 | require "open-uri"
6 | require "digest/sha1"
7 | require "progressbar"
8 | require "iconv"
9 |
10 | SEARCH = "http://www.dailymail.co.uk/home/search.html?pageOffset=%d&pageSize=50&orderBy=relevDesc&searchPhrase=cancer+risk&contenttype=article"
11 | TEMP_DIR = File.join(Rails.root, "tmp")
12 | FileUtils.mkdir_p(TEMP_DIR)
13 |
14 | def fetch_with_cache(uri)
15 | cache_path = File.join(TEMP_DIR, Digest::SHA1.hexdigest(uri))
16 | unless File.exist?(cache_path)
17 | data = open(uri){ |f| f.read }
18 | open(cache_path, "w") do |cache|
19 | cache << data
20 | end
21 | return data
22 | end
23 | return File.read(cache_path)
24 | end
25 |
26 | first_page = fetch_with_cache(SEARCH % 1)
27 | pages = first_page[/Page 1 of (\d+)/, 1].to_i
28 | results = []
29 |
30 | pbar = ProgressBar.new("Fetch/parse", pages)
31 | iconv = Iconv.new("UTF-8", "Windows-1252")
32 | (1 .. pages).each do |page|
33 | uri = SEARCH % page
34 | doc = Hpricot(fetch_with_cache(uri))
35 |
36 | doc.search(".sch-result").each do |node|
37 | link = URI.parse(uri).merge(node.at("a").attributes["href"]).to_s
38 | title = iconv.iconv(node.at("h3").inner_text.strip)
39 | summary = iconv.iconv(node.at(".sch-res-preview").inner_text.strip)
40 |
41 | next if Article.find_by_link(link)
42 | Article.create!(:link => link, :title => title, :summary => summary)
43 | end
44 |
45 | pbar.inc
46 | end
47 | pbar.finish
48 |
--------------------------------------------------------------------------------
/script/rails:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env ruby1.9.1
2 | # This command will automatically be run when you run "rails" with Rails 3 gems installed from the root of your application.
3 |
4 | APP_PATH = File.expand_path('../../config/application', __FILE__)
5 | require File.expand_path('../../config/boot', __FILE__)
6 | require 'rails/commands'
7 |
--------------------------------------------------------------------------------
/test/functional/.gitkeep:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/threedaymonk/kill-or-cure/29fed0955b8f1e3c8915f365decb1e6cd0fc3bff/test/functional/.gitkeep
--------------------------------------------------------------------------------
/test/integration/.gitkeep:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/threedaymonk/kill-or-cure/29fed0955b8f1e3c8915f365decb1e6cd0fc3bff/test/integration/.gitkeep
--------------------------------------------------------------------------------
/test/performance/browsing_test.rb:
--------------------------------------------------------------------------------
1 | require 'test_helper'
2 | require 'rails/performance_test_help'
3 |
4 | class BrowsingTest < ActionDispatch::PerformanceTest
5 | # Refer to the documentation for all available options
6 | # self.profile_options = { :runs => 5, :metrics => [:wall_time, :memory]
7 | # :output => 'tmp/performance', :formats => [:flat] }
8 |
9 | def test_homepage
10 | get '/'
11 | end
12 | end
13 |
--------------------------------------------------------------------------------
/test/test_helper.rb:
--------------------------------------------------------------------------------
1 | ENV["RAILS_ENV"] = "test"
2 | require File.expand_path('../../config/environment', __FILE__)
3 | require 'rails/test_help'
4 |
5 | class ActiveSupport::TestCase
6 | # Setup all fixtures in test/fixtures/*.(yml|csv) for all tests in alphabetical order.
7 | #
8 | # Note: You'll currently still have to declare fixtures explicitly in integration tests
9 | # -- they do not yet inherit this setting
10 | fixtures :all
11 |
12 | # Add more helper methods to be used by all tests here...
13 | end
14 |
--------------------------------------------------------------------------------
/test/unit/.gitkeep:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/threedaymonk/kill-or-cure/29fed0955b8f1e3c8915f365decb1e6cd0fc3bff/test/unit/.gitkeep
--------------------------------------------------------------------------------