source: Dev/trunk/src/client/dojox/calendar/_RendererMixin.js @ 485

Last change on this file since 485 was 483, checked in by hendrikvanantwerpen, 11 years ago

Added Dojo 1.9.3 release.
File size: 8.7 KB
Line 
1define(["dojo/_base/declare", "dojo/_base/lang", "dojo/dom-style", "dojo/dom-class", "dojo/Stateful"],
2         
3        function(declare, lang, domStyle, domClass, Stateful){
4       
5        return declare("dojox.calendar._RendererMixin", Stateful, {
6               
7                // summary:
8                //              This class is the base class of calendar renderers.
9               
10                // item: Object
11                //              The layout item displayed by this renderer.
12                item: null,
13               
14                // owner: dojox/calendar/_ViewBase
15                //              The view that contains this renderer.
16                owner: null,
17               
18                // edited: Boolean
19                //              Indicates that the item displayed by this renderer is in editing mode.
20                edited: false,
21               
22                // focused: Boolean
23                //              Indicates that the item displayed by this renderer is focused.
24                focused: false,
25               
26                // hovered: Boolean
27                //              Indicates that the item displayed by this renderer is hovered.
28                hovered: false,
29               
30                // selected: Boolean
31                //              Indicates that the item displayed by this renderer is selected.
32                selected: false,
33               
34                // storeState: Boolean
35                //              Indicates that the item displayed by this renderer is not in the store, being saved to the store or in the store.
36                storeState: false,
37               
38                // moveEnabled: Boolean
39                //              Whether the event displayed by this renderer can be moved.
40                moveEnabled: true,
41               
42                // resizeEnabled: Boolean
43                //              Whether the event displayed by this renderer can be resized.
44                resizeEnabled: true,
45               
46                _orientation: "vertical",
47                _displayValue: "block",         
48               
49                _displayValueMap: {},
50               
51                visibilityLimits: {
52                        resizeStartHandle: 50,
53                        resizeEndHandle: -1,
54                        summaryLabel: 15,
55                        startTimeLabel: 45,
56                        endTimeLabel: 50
57                },             
58               
59                _setSelectedAttr: function(value){                     
60                        this._setState("selected", value, "Selected");
61                },
62               
63                _setFocusedAttr: function(value){
64                        this._setState("focused", value, "Focused");
65                },
66
67                _setEditedAttr: function(value){
68                        this._setState("edited", value, "Edited");
69                },
70               
71                _setHoveredAttr: function(value){
72                        this._setState("hovered", value, "Hovered");
73                },
74               
75                _setStoreStateAttr: function(value){
76                        var cssClass = null;
77                        switch(value){
78                                case "storing":
79                                        cssClass = "Storing";
80                                        break;
81                                case "unstored":
82                                        cssClass = "Unstored";
83                                        break;
84                                default:
85                                        cssClass = null;
86                        }
87                        var tn = this.stateNode || this.domNode;                               
88                        domClass.remove(tn, "Storing");
89                        domClass.remove(tn, "Unstored");
90                       
91                        this._set("storeState", value);
92                       
93                        if(cssClass != null){           
94                                domClass.add(tn, cssClass);
95                        }
96                },
97               
98                _setState: function(prop, value, cssClass){
99                        if(this[prop] != value){
100                                var tn = this.stateNode || this.domNode;                               
101                                domClass[value ? "add" : "remove"](tn, cssClass);                       
102                                this._set(prop, value);
103                        }       
104                },
105               
106                _setItemAttr: function(value){
107                        if(value == null){
108                                if(this.item && this.item.cssClass){
109                                        domClass.remove(this.domNode, this.item.cssClass);
110                                }
111                                this.item = null;
112                        }else{
113                                if(this.item != null){
114                                        if(this.item.cssClass != value.cssClass){
115                                                if(this.item.cssClass){
116                                                        domClass.remove(this.domNode, this.item.cssClass);
117                                                }
118                                        }
119                                        this.item = lang.mixin(this.item, value);
120                                        if(value.cssClass){
121                                                domClass.add(this.domNode, value.cssClass);
122                                        }
123                                }else{
124                                        this.item = value;
125                                        if(value.cssClass){
126                                                domClass.add(this.domNode, value.cssClass);
127                                        }
128                                }
129                        }
130                },
131               
132                _setText: function(node, text, allowHTML){
133                        // summary:
134                        //              Set the text to the specified node.
135                        // node: Node
136                        //              The parent node.
137                        // text: String
138                        //              The text to display.
139                        // allowHTML: Boolean
140                        //              Whether text is containing HTML formatting.
141                        // tags:
142                        //              protected
143                       
144                        if(this.owner){
145                                this.owner._setText(node, text, allowHTML);
146                        }                       
147                },
148               
149                _isElementVisible: function(elt, startHidden, endHidden, size){
150                        // summary:
151                        //              Determine whether the item renderer sub element is visible or not.
152                        // elt: String
153                        //              The element node.
154                        // startHidden: Boolean
155                        //              Indicates that the start of time interval displayed by this item renderer is not the start of the displayed event.
156                        // endHidden: Boolean
157                        //              Indicates that the end of time interval displayed by this item renderer is not the end of the displayed event.
158                        // size: Integer
159                        //              The size of the item renderer on the time axis.
160                        // tags:
161                        //              protected
162                        var visible;
163                        var limit = this.visibilityLimits[elt];
164                       
165                        switch(elt){
166                                case "moveHandle":
167                                        visible = this.moveEnabled;
168                                        break;
169                                case "resizeStartHandle":
170                                        if(this.mobile){
171                                                visible = this.resizeEnabled && !startHidden && this.edited && (limit == -1 || size>limit);
172                                        }else{
173                                                visible = this.resizeEnabled && !startHidden && (limit == -1 || size>limit);
174                                        }
175                                        break;
176                                case "resizeEndHandle":
177                                        if(this.mobile){
178                                                visible = this.resizeEnabled && !endHidden && this.edited && (limit == -1 || size>limit);
179                                        }else{
180                                                visible = this.resizeEnabled && !endHidden && (limit == -1 || size>limit);
181                                        }
182                                        break;
183                                case "startTimeLabel":
184                                        if(this.mobile){
185                                                visible = !startHidden && (!this.edited || this.edited && (limit == -1 || size>limit));
186                                        }else{
187                                                visible = !startHidden && (limit == -1 || size>limit);
188                                        }
189                                        break;
190                                case "endTimeLabel":
191                                       
192                                        visible = this.edited && !endHidden && (limit == -1 || size>limit);
193                                       
194                                        break;
195                                case "summaryLabel":
196                                        if(this.mobile){
197                                                visible = !this.edited || this.edited && (limit == -1 || size>limit);
198                                        }else{
199                                                visible = limit == -1 || size>limit;
200                                        }
201                                        break;
202                        }
203                       
204                        return visible;
205                },
206               
207                _formatTime: function(rd, d){
208                        // summary:
209                        //              Returns the time formatted string.
210                        // rd: Object
211                        //              The render data.
212                        // d: Date
213                        //              The time to format.
214                        // tags:
215                        //              protected
216                        if(this.owner){
217                                var f = this.owner.get("formatItemTimeFunc");
218                                if(f != null && typeof f === "function"){
219                                        return f(d, rd);
220                                }
221                        }
222                        return rd.dateLocaleModule.format(d, {selector: 'time'});
223                },
224               
225                getDisplayValue: function(part){
226                        return this._displayValue;
227                },
228               
229                updateRendering: function (w, h) {
230                        // summary:
231                        //              Updates the visual appearance of the renderer according the new values of the properties and the new size of the component.
232                        // w: Number?
233                        //              The width in pixels of the renderer.
234                        // h: Number?
235                        //              The height in pixels of the renderer.
236               
237                        h = h || this.item.h;
238                        w = w || this.item.w;
239                       
240                        if(!h && !w){
241                                return;
242                        }
243                       
244                        this.item.h = h;
245                        this.item.w = w;
246                       
247                        var size = this._orientation == "vertical" ? h : w;
248       
249                        var rd = this.owner.renderData;
250
251                        var startHidden = rd.dateModule.compare(this.item.range[0], this.item.startTime) != 0;
252                        var endHidden =  rd.dateModule.compare(this.item.range[1], this.item.endTime) != 0;
253                       
254                        var visible;
255                       
256                        if(this.beforeIcon != null) {
257                                visible = this._orientation != "horizontal" || this.isLeftToRight() ? startHidden : endHidden;
258                                domStyle.set(this.beforeIcon, "display", visible ? this.getDisplayValue("beforeIcon") : "none");
259                        }
260
261                        if(this.afterIcon != null) {
262                                visible = this._orientation != "horizontal" || this.isLeftToRight() ? endHidden : startHidden;
263                                domStyle.set(this.afterIcon, "display", visible ? this.getDisplayValue("afterIcon") : "none");
264                        }
265                       
266                        if(this.moveHandle){
267                                visible = this._isElementVisible("moveHandle", startHidden, endHidden, size);
268                                domStyle.set(this.moveHandle, "display", visible?this.getDisplayValue("moveHandle"):"none");                           
269                        }
270                       
271                        if(this.resizeStartHandle){
272                                visible = this._isElementVisible("resizeStartHandle", startHidden, endHidden, size);
273                                domStyle.set(this.resizeStartHandle, "display", visible?this.getDisplayValue("resizeStartHandle"):"none");                             
274                        }
275                       
276                        if(this.resizeEndHandle){
277                                visible = this._isElementVisible("resizeEndHandle", startHidden, endHidden, size);
278                                domStyle.set(this.resizeEndHandle, "display", visible?this.getDisplayValue("resizeEndHandle"):"none");                         
279                        }
280                       
281                        if(this.startTimeLabel) {
282                                visible = this._isElementVisible("startTimeLabel", startHidden, endHidden, size);
283                               
284                                domStyle.set(this.startTimeLabel, "display", visible?this.getDisplayValue("startTimeLabel"):"none");
285                                if(visible) {
286                                        this._setText(this.startTimeLabel, this._formatTime(rd, this.item.startTime));
287                                }
288                        }
289                       
290                        if(this.endTimeLabel) {
291                                visible = this._isElementVisible("endTimeLabel", startHidden, endHidden, size);
292                                domStyle.set(this.endTimeLabel, "display", visible?this.getDisplayValue("endTimeLabel"):"none");
293                                if(visible) {
294                                        this._setText(this.endTimeLabel, this._formatTime(rd, this.item.endTime));
295                                }
296                        }
297                       
298                        if(this.summaryLabel) {
299                                visible = this._isElementVisible("summaryLabel", startHidden, endHidden, size);
300                                domStyle.set(this.summaryLabel, "display", visible?this.getDisplayValue("summaryLabel"):"none");
301                                if(visible){
302                                        this._setText(this.summaryLabel, this.item.summary, true);
303                                }
304                        }
305                }
306        });
307});
Note: See TracBrowser for help on using the repository browser.