git.sur5r.net Git - bacula/bacula/blob - 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 });