]> git.sur5r.net Git - bacula/bacula/blob - gui/baculum/debian/missing-sources/framework/Web/Javascripts/source/tinymce-405/classes/ui/MenuItem.js
baculum: Add missing-sources directory in debian metadata structure
[bacula/bacula] / gui / baculum / debian / missing-sources / framework / Web / Javascripts / source / tinymce-405 / classes / ui / MenuItem.js
1 /**
2  * MenuItem.js
3  *
4  * Copyright, Moxiecode Systems AB
5  * Released under LGPL License.
6  *
7  * License: http://www.tinymce.com/license
8  * Contributing: http://www.tinymce.com/contributing
9  */
10
11 /**
12  * Creates a new menu item.
13  *
14  * @-x-less MenuItem.less
15  * @class tinymce.ui.MenuItem
16  * @extends tinymce.ui.Control
17  */
18 define("tinymce/ui/MenuItem", [
19         "tinymce/ui/Widget",
20         "tinymce/ui/Factory"
21 ], function(Widget, Factory) {
22         "use strict";
23
24         return Widget.extend({
25                 Defaults: {
26                         border: 0,
27                         role: 'menuitem'
28                 },
29
30                 /**
31                  * Constructs a instance with the specified settings.
32                  *
33                  * @constructor
34                  * @param {Object} settings Name/value object with settings.
35                  * @setting {Boolean} selectable Selectable menu.
36                  * @setting {Array} menu Submenu array with items.
37                  * @setting {String} shortcut Shortcut to display for menu item. Example: Ctrl+X
38                  */
39                 init: function(settings) {
40                         var self = this;
41
42                         self.hasPopup = true;
43
44                         self._super(settings);
45
46                         settings = self.settings;
47
48                         self.addClass('menu-item');
49
50                         if (settings.menu) {
51                                 self.addClass('menu-item-expand');
52                         }
53
54                         if (settings.preview) {
55                                 self.addClass('menu-item-preview');
56                         }
57
58                         if (self._text === '-' || self._text === '|') {
59                                 self.addClass('menu-item-sep');
60                                 self.aria('role', 'separator');
61                                 self.canFocus = false;
62                                 self._text = '-';
63                         }
64
65                         if (settings.selectable) {
66                                 self.aria('role', 'menuitemcheckbox');
67                                 self.aria('checked', true);
68                                 self.addClass('menu-item-checkbox');
69                                 settings.icon = 'selected';
70                         }
71
72                         self.on('mousedown', function(e) {
73                                 e.preventDefault();
74                         });
75
76                         self.on('mouseenter click', function(e) {
77                                 if (e.control === self) {
78                                         if (!settings.menu && e.type === 'click') {
79                                                 self.parent().hideAll();
80                                                 self.fire('cancel');
81                                                 self.fire('select');
82                                         } else {
83                                                 self.showMenu();
84
85                                                 if (e.keyboard) {
86                                                         setTimeout(function() {
87                                                                 self.menu.items()[0].focus();
88                                                         }, 0);
89                                                 }
90                                         }
91                                 }
92                         });
93
94                         if (settings.menu) {
95                                 self.aria('haspopup', true);
96                         }
97                 },
98
99                 /**
100                  * Returns true/false if the menuitem has sub menu.
101                  *
102                  * @method hasMenus
103                  * @return {Boolean} True/false state if it has submenu.
104                  */
105                 hasMenus: function() {
106                         return !!this.settings.menu;
107                 },
108
109                 /**
110                  * Shows the menu for the menu item.
111                  *
112                  * @method showMenu
113                  */
114                 showMenu: function() {
115                         var self = this, settings = self.settings, menu, parent = self.parent();
116
117                         parent.items().each(function(ctrl) {
118                                 if (ctrl !== self) {
119                                         ctrl.hideMenu();
120                                 }
121                         });
122
123                         if (settings.menu) {
124                                 menu = self.menu;
125
126                                 if (!menu) {
127                                         menu = settings.menu;
128
129                                         // Is menu array then auto constuct menu control
130                                         if (menu.length) {
131                                                 menu = {
132                                                         type: 'menu',
133                                                         items: menu
134                                                 };
135                                         } else {
136                                                 menu.type = menu.type || 'menu';
137                                         }
138
139                                         if (parent.settings.itemDefaults) {
140                                                 menu.itemDefaults = parent.settings.itemDefaults;
141                                         }
142
143                                         menu = self.menu = Factory.create(menu).parent(self).renderTo(self.getContainerElm());
144                                         menu.reflow();
145                                         menu.fire('show');
146                                         menu.on('cancel', function() {
147                                                 self.focus();
148                                         });
149
150                                         menu.on('hide', function(e) {
151                                                 if (e.control === menu) {
152                                                         self.removeClass('selected');
153                                                 }
154                                         });
155                                 } else {
156                                         menu.show();
157                                 }
158
159                                 menu._parentMenu = parent;
160
161                                 menu.addClass('menu-sub');
162
163                                 var rel = menu.testMoveRel(self.getEl(), ['tr-tl', 'br-bl', 'tl-tr', 'bl-br']);
164                                 menu.moveRel(self.getEl(), rel);
165
166                                 rel = 'menu-sub-' + rel;
167                                 menu.removeClass(menu._lastRel);
168                                 menu.addClass(rel);
169                                 menu._lastRel = rel;
170
171                                 self.addClass('selected');
172                                 self.aria('expanded', true);
173                         }
174                 },
175
176                 /**
177                  * Hides the menu for the menu item.
178                  *
179                  * @method hideMenu
180                  */
181                 hideMenu: function() {
182                         var self = this;
183
184                         if (self.menu) {
185                                 self.menu.items().each(function(item) {
186                                         if (item.hideMenu) {
187                                                 item.hideMenu();
188                                         }
189                                 });
190
191                                 self.menu.hide();
192                                 self.aria('expanded', false);
193                         }
194
195                         return self;
196                 },
197
198                 /**
199                  * Renders the control as a HTML string.
200                  *
201                  * @method renderHtml
202                  * @return {String} HTML representing the control.
203                  */
204                 renderHtml: function() {
205                         var self = this, id = self._id, settings = self.settings, prefix = self.classPrefix, text = self.encode(self._text);
206                         var icon = self.settings.icon;
207
208                         if (icon) {
209                                 self.parent().addClass('menu-has-icons');
210                         }
211
212                         icon = prefix + 'ico ' + prefix + 'i-' + (self.settings.icon || 'none');
213
214                         return (
215                                 '<div id="' + id + '" class="' + self.classes() + '" tabindex="-1">' +
216                                         (text !== '-' ? '<i class="' + icon + '"></i>&nbsp;' : '') +
217                                         (text !== '-' ? '<span id="' + id + '-text" class="' + prefix + 'text">' + text + '</span>' : '') +
218                                         (settings.shortcut ? '<div id="' + id + '-shortcut" class="' + prefix + 'menu-shortcut">' +
219                                                 settings.shortcut + '</div>' : '') +
220                                         (settings.menu ? '<div class="' + prefix + 'caret"></div>' : '') +
221                                 '</div>'
222                         );
223                 },
224
225                 /**
226                  * Gets invoked after the control has been rendered.
227                  *
228                  * @method postRender
229                  */
230                 postRender: function() {
231                         var self = this, settings = self.settings;
232
233                         var textStyle = settings.textStyle;
234                         if (typeof(textStyle) == "function") {
235                                 textStyle = textStyle.call(this);
236                         }
237
238                         if (textStyle) {
239                                 var textElm = self.getEl('text');
240                                 if (textElm) {
241                                         textElm.setAttribute('style', textStyle);
242                                 }
243                         }
244
245                         return self._super();
246                 },
247
248                 /**
249                  * Removes the control and it's menus.
250                  *
251                  * @method remove
252                  */
253                 remove: function() {
254                         this._super();
255
256                         if (this.menu) {
257                                 this.menu.remove();
258                         }
259                 }
260         });
261 });