docs/source/PluginManager.html

   1 <!DOCTYPE html>
   2 <html>
   3 <head>
   4   <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
   5   <title>The source code</title>
   6   <link href="../resources/prettify/prettify.css" type="text/css" rel="stylesheet" />
   7   <script type="text/javascript" src="../resources/prettify/prettify.js"></script>
   8   <style type="text/css">
   9     .highlight { display: block; background-color: #ddd; }
  10   </style>
  11   <script type="text/javascript">
  12     function highlight() {
  13       document.getElementById(location.hash.replace(/#/, "")).className = "highlight";
  14     }
  15   </script>
  16 </head>
  17 <body onload="prettyPrint(); highlight();">
  18   <pre class="prettyprint lang-js"><span id='Ext-PluginManager'>/**
  19 </span> * @singleton
  20  *
  21  * Provides a registry of available Plugin classes indexed by a mnemonic code known as the Plugin's ptype.
  22  *
  23  * A plugin may be specified simply as a *config object* as long as the correct `ptype` is specified:
  24  *
  25  *     {
  26  *         ptype: 'gridviewdragdrop',
  27  *         dragText: 'Drag and drop to reorganize'
  28  *     }
  29  *
  30  * Or just use the ptype on its own:
  31  *
  32  *     'gridviewdragdrop'
  33  *
  34  * Alternatively you can instantiate the plugin with Ext.create:
  35  *
  36  *     Ext.create('Ext.view.plugin.AutoComplete', {
  37  *         ptype: 'gridviewdragdrop',
  38  *         dragText: 'Drag and drop to reorganize'
  39  *     })
  40  */
  41 Ext.define('Ext.PluginManager', {
  42     extend: 'Ext.AbstractManager',
  43     alternateClassName: 'Ext.PluginMgr',
  44     singleton: true,
  45     typeName: 'ptype',
  46
  47 <span id='Ext-PluginManager-method-create'>    /**
  48 </span>     * Creates a new Plugin from the specified config object using the config object's ptype to determine the class to
  49      * instantiate.
  50      * @param {Object} config A configuration object for the Plugin you wish to create.
  51      * @param {Function} defaultType (optional) The constructor to provide the default Plugin type if the config object does not
  52      * contain a `ptype`. (Optional if the config contains a `ptype`).
  53      * @return {Ext.Component} The newly instantiated Plugin.
  54      */
  55     //create: function(plugin, defaultType) {
  56     //    if (plugin instanceof this) {
  57     //        return plugin;
  58     //    } else {
  59     //        var type, config = {};
  60     //
  61     //        if (Ext.isString(plugin)) {
  62     //            type = plugin;
  63     //        }
  64     //        else {
  65     //            type = plugin[this.typeName] || defaultType;
  66     //            config = plugin;
  67     //        }
  68     //
  69     //        return Ext.createByAlias('plugin.' + type, config);
  70     //    }
  71     //},
  72
  73     create : function(config, defaultType){
  74         if (config.init) {
  75             return config;
  76         } else {
  77             return Ext.createByAlias('plugin.' + (config.ptype || defaultType), config);
  78         }
  79
  80         // Prior system supported Singleton plugins.
  81         //var PluginCls = this.types[config.ptype || defaultType];
  82         //if (PluginCls.init) {
  83         //    return PluginCls;
  84         //} else {
  85         //    return new PluginCls(config);
  86         //}
  87     },
  88
  89 <span id='Ext-PluginManager-method-findByType'>    /**
  90 </span>     * Returns all plugins registered with the given type. Here, 'type' refers to the type of plugin, not its ptype.
  91      * @param {String} type The type to search for
  92      * @param {Boolean} defaultsOnly True to only return plugins of this type where the plugin's isDefault property is
  93      * truthy
  94      * @return {Ext.AbstractPlugin[]} All matching plugins
  95      */
  96     findByType: function(type, defaultsOnly) {
  97         var matches = [],
  98             types   = this.types;
  99
 100         for (var name in types) {
 101             if (!types.hasOwnProperty(name)) {
 102                 continue;
 103             }
 104             var item = types[name];
 105
 106             if (item.type == type &amp;&amp; (!defaultsOnly || (defaultsOnly === true &amp;&amp; item.isDefault))) {
 107                 matches.push(item);
 108             }
 109         }
 110
 111         return matches;
 112     }
 113 }, function() {
 114 <span id='Ext-method-preg'>    /**
 115 </span>     * Shorthand for {@link Ext.PluginManager#registerType}
 116      * @param {String} ptype The ptype mnemonic string by which the Plugin class
 117      * may be looked up.
 118      * @param {Function} cls The new Plugin class.
 119      * @member Ext
 120      * @method preg
 121      */
 122     Ext.preg = function() {
 123         return Ext.PluginManager.registerType.apply(Ext.PluginManager, arguments);
 124     };
 125 });
 126 </pre>
 127 </body>
 128 </html>