Import src directory from OpenRico 2.1
[misc/kostenrechnung] / lib / rico / ricoBehaviors.js
1 /**
2   *  (c) 2005-2007 Richard Cowin (http://openrico.org)
3   *
4   *  Rico is licensed under the Apache License, Version 2.0 (the "License"); you may not use this
5   *  file except in compliance with the License. You may obtain a copy of the License at
6   *   http://www.apache.org/licenses/LICENSE-2.0
7   **/
8
9 /** @ignore */
10 Rico.selectionSet = function(set, options){
11   new Rico.SelectionSet(set, options);
12 };
13
14 Rico.SelectionSet = Class.create(
15 /** @lends Rico.SelectionSet# */
16 {
17 /**
18  * @class
19  * @constructs
20  * @param selectionSet collection of DOM elements (or a CSS selection string)
21  * @param options object may contain any of the following:<dl>
22  *   <dt>selectedClass</dt><dd>class name to add when element is selected, default is "selected"</dd>
23  *   <dt>selectNode   </dt><dd>optional function that returns the element to be selected</dd>
24  *   <dt>onSelect     </dt><dd>optional function that gets called when element is selected</dd>
25  *   <dt>onFirstSelect</dt><dd>optional function that gets called the first time element is selected</dd>
26  *   <dt>noDefault    </dt><dd>when true, no element in the set is initially selected, default is false</dd>
27  *   <dt>selectedIndex</dt><dd>index of the element that should be initially selected, default is 0</dd>
28  *   <dt>cookieName   </dt><dd>optional name of cookie to use to remember selected element. If specified, and the cookie exists, then the cookie value overrides selectedIndex.</dd>
29  *   <dt>cookieDays   </dt><dd>specifies how long cookie should persist (in days). If unspecified, then the cookie persists for the current session.</dd>
30  *   <dt>cookiePath   </dt><dd>optional cookie path</dd>
31  *   <dt>cookieDomain </dt><dd>optional cookie domain</dd>
32  *</dl>
33  */
34         initialize: function(selectionSet, options){
35                 this.options = options || {};
36     if (typeof selectionSet == 'string')
37       selectionSet = $$(selectionSet);
38           this.previouslySelected = [];
39                 this.selectionSet = selectionSet;
40                 this.selectedClassName = this.options.selectedClass || "selected";
41                 this.selectNode = this.options.selectNode || function(e){return e;};
42                 this.onSelect = this.options.onSelect;
43     this.onFirstSelect = this.options.onFirstSelect;
44                 this.clickHandler = this.click.bind(this);
45                 selectionSet.each(function(e) {Event.observe(e, "click", new Rico.EventWrapper(this.clickHandler,e).wrapper);}.bind(this));
46     if (!this.options.noDefault) {
47                   var cookieIndex=this.options.cookieName ? this.getCookie() : 0;
48       this.selectIndex(cookieIndex || this.options.selectedIndex || 0);
49     }
50         },
51   getCookie: function() {
52     var cookie = RicoUtil.getCookie(this.options.cookieName);
53     if (!cookie) return 0;
54     var index = parseInt(cookie);
55     return index < this.selectionSet.length ? index : 0;
56         },
57         reset: function(){
58           this.previouslySelected = [];
59           this.notifySelected(this.selected);
60         },
61         select: function(element){
62                 if (this.selected == element)
63                         return;
64
65                 if (this.selected)
66                   Element.removeClassName(this.selectNode(this.selected), this.selectedClassName);
67
68     this.notifySelected(element);
69
70                 this.selected = element;
71     Element.addClassName(this.selectNode(this.selected), this.selectedClassName);
72         },
73         notifySelected: function(element){
74     var index = this.selectionSet.indexOf(element);
75                 if (this.options.cookieName)
76       RicoUtil.setCookie(this.options.cookieName, index, this.options.cookieDays, this.options.cookiePath, this.options.cookieDomain);
77     if (this.onFirstSelect && !this.previouslySelected[index]){
78       this.onFirstSelect(element, index);
79       this.previouslySelected[index] = true;
80     }
81         if (this.onSelect)
82       try{
83             this.onSelect(element, index);
84       } catch (e) {};
85         },
86         selectIndex: function(index){
87                 this.select(this.selectionSet[index]);
88         },
89         nextSelectItem: function(){
90     var index = this.selectionSet.indexOf(this.selected);
91     if (index + 1 >= this.selectionSet.length)
92       return this.selectionSet[index - 1];
93     else
94       return this.selectionSet[index + 1];
95         },
96         selectNext: function(){
97     var index = this.selectionSet.indexOf(this.selected);
98     if (index >= this.selectionSet.length)
99       this.selectIndex(index - 1);
100     else
101       this.selectIndex(index + 1);
102         },
103         click: function(event,target) {
104                 this.select(target);
105         },
106         add: function(item){
107         //      this.selectionSet.push(item)
108           if (item.constructur == Array) {
109             item.each(function(e){
110                 Event.observe(e, "click", new Rico.EventWrapper(this.clickHandler,item).wrapper);
111             }.bind(this));
112           } else {
113                   Event.observe(item, "click", new Rico.EventWrapper(this.clickHandler,item).wrapper);
114     }
115         },
116         remove: function(item){
117           this.selectionSet = this.selectionSet.without(item);
118                         //Todo: need to cleanup all events on item - need to keep track of eventwrappers
119         },
120         removeAll: function(){
121         }
122  });
123
124 Rico.HoverSet = Class.create(
125 /** @lends Rico.HoverSet# */
126 {
127 /**
128  * @class
129  * @constructs
130  * @param hoverSet collection of DOM elements
131  * @param options object may contain any of the following:<dl>
132  *   <dt>hoverClass</dt><dd> class name to add when mouse is over element, default is "hover"</dd>
133  *   <dt>hoverNodes</dt><dd> optional function to select/filter which nodes are in the set</dd>
134  *</dl>
135  */
136   initialize: function(hoverSet, options){
137     options = options || [];
138     this.hoverSet = hoverSet;
139     this.hoverClassName = options.hoverClass || "hover";
140     this.hoverNodes = options.hoverNodes || function(e){return [e];};
141     this.listenerHover    = this._onHover.bind(this);
142     this.listenerEndHover = this._onUnHover.bind(this);
143     for (var i=0; i<this.hoverSet.length; i++) this.add(this.hoverSet[i]);
144   },
145   _onHover: function(event,target) {
146     this.hover(target);
147   },
148   _onUnHover: function(event,target) {
149     this.unHover(target);
150   },
151   hover: function(target) {
152     this.hoverNodes(target).each((function(t){Element.addClassName(t,this.hoverClassName);}).bind(this));
153   },
154   unHover: function(target) {
155     this.hoverNodes(target).each((function(t){Element.removeClassName(t,this.hoverClassName);}).bind(this));
156   },
157   add: function(item){
158     Event.observe(item, "mousemove", new Rico.EventWrapper(this.listenerHover,item).wrapper);
159     Event.observe(item, "mouseout", new Rico.EventWrapper(this.listenerEndHover,item).wrapper);
160   }
161 });
162
163
164 /**
165  * @namespace
166  */
167 Rico.Hover = {
168   groups: {},
169   clearCurrent: function(group) {
170     var last_hover = Rico.Hover.groups[group];
171     if(!last_hover) return;
172     clearTimeout(last_hover[0]);
173     last_hover[1].end();
174     Rico.Hover.groups[group] = null;
175   },
176   end: function(group) {
177         Rico.Hover.groups[group][1].end();
178   },
179   endWith: function(hover, group) {
180         var timer = setTimeout('Rico.Hover.end("'+ group + '")', hover.exitDelay);
181     Rico.Hover.groups[group] = [timer, hover];
182   }
183 };
184
185 Rico.HoverDisplay = Class.create(
186 /** @lends Rico.HoverDisplay# */
187 {
188 /**
189  * @class
190  * @constructs
191  * @param element
192  * @param options object may contain any of the following:<dl>
193  *   <dt>group</dt><dd> </dd>
194  *   <dt>delay</dt><dd> </dd>
195  *</dl>
196  */
197   initialize: function(element, options) {
198         this.element = element;
199         this.options = options || {};
200         this.group = this.options.group;
201         this.exitDelay = this.options.delay || 1000;
202   },
203   begin: function() {
204     Rico.Hover.clearCurrent(this.group);
205                 Element.show(this.element);
206   },
207   end: function(delay) {
208     if(delay)
209       Rico.Hover.endWith(this, this.group);
210     else
211                   Element.hide(this.element);
212   }
213 });
214
215
216 Rico.EventWrapper = Class.create(
217 /** @lends Rico.EventWrapper# */
218 {
219 /**
220  * @class
221  * @constructs
222  * @param handler
223  * @param target
224  */
225   initialize: function(handler, target){
226     this.handler = handler;
227     this.target = target;
228     this.wrapper = this.wrapperCall.bindAsEventListener(this);
229   },
230   wrapperCall: function(event){
231     this.handler(event, this.target);
232   }
233 });
234
235 Rico.includeLoaded('ricoBehaviors.js');