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="../prettify/prettify.css" type="text/css" rel="stylesheet" />
   7   <script type="text/javascript" src="../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> * @class Ext.PluginManager
  20  * @extends Ext.AbstractManager
  21  * &lt;p&gt;Provides a registry of available Plugin &lt;i&gt;classes&lt;/i&gt; indexed by a mnemonic code known as the Plugin's ptype.
  22  * The &lt;code&gt;{@link Ext.Component#xtype xtype}&lt;/code&gt; provides a way to avoid instantiating child Components
  23  * when creating a full, nested config object for a complete Ext page.&lt;/p&gt;
  24  * &lt;p&gt;A child Component may be specified simply as a &lt;i&gt;config object&lt;/i&gt;
  25  * as long as the correct &lt;code&gt;{@link Ext.Component#xtype xtype}&lt;/code&gt; is specified so that if and when the Component
  26  * needs rendering, the correct type can be looked up for lazy instantiation.&lt;/p&gt;
  27  * &lt;p&gt;For a list of all available &lt;code&gt;{@link Ext.Component#xtype xtypes}&lt;/code&gt;, see {@link Ext.Component}.&lt;/p&gt;
  28  * @singleton
  29  */
  30 Ext.define('Ext.PluginManager', {
  31     extend: 'Ext.AbstractManager',
  32     alternateClassName: 'Ext.PluginMgr',
  33     singleton: true,
  34     typeName: 'ptype',
  35
  36 <span id='Ext-PluginManager-method-create'>    /**
  37 </span>     * Creates a new Plugin from the specified config object using the
  38      * config object's ptype to determine the class to instantiate.
  39      * @param {Object} config A configuration object for the Plugin you wish to create.
  40      * @param {Constructor} defaultType The constructor to provide the default Plugin type if
  41      * the config object does not contain a &lt;code&gt;ptype&lt;/code&gt;. (Optional if the config contains a &lt;code&gt;ptype&lt;/code&gt;).
  42      * @return {Ext.Component} The newly instantiated Plugin.
  43      */
  44     //create: function(plugin, defaultType) {
  45     //    if (plugin instanceof this) {
  46     //        return plugin;
  47     //    } else {
  48     //        var type, config = {};
  49     //
  50     //        if (Ext.isString(plugin)) {
  51     //            type = plugin;
  52     //        }
  53     //        else {
  54     //            type = plugin[this.typeName] || defaultType;
  55     //            config = plugin;
  56     //        }
  57     //
  58     //        return Ext.createByAlias('plugin.' + type, config);
  59     //    }
  60     //},
  61
  62     create : function(config, defaultType){
  63         if (config.init) {
  64             return config;
  65         } else {
  66             return Ext.createByAlias('plugin.' + (config.ptype || defaultType), config);
  67         }
  68
  69         // Prior system supported Singleton plugins.
  70         //var PluginCls = this.types[config.ptype || defaultType];
  71         //if (PluginCls.init) {
  72         //    return PluginCls;
  73         //} else {
  74         //    return new PluginCls(config);
  75         //}
  76     },
  77
  78 <span id='Ext-PluginManager-method-findByType'>    /**
  79 </span>     * Returns all plugins registered with the given type. Here, 'type' refers to the type of plugin, not its ptype.
  80      * @param {String} type The type to search for
  81      * @param {Boolean} defaultsOnly True to only return plugins of this type where the plugin's isDefault property is truthy
  82      * @return {Array} All matching plugins
  83      */
  84     findByType: function(type, defaultsOnly) {
  85         var matches = [],
  86             types   = this.types;
  87
  88         for (var name in types) {
  89             if (!types.hasOwnProperty(name)) {
  90                 continue;
  91             }
  92             var item = types[name];
  93
  94             if (item.type == type &amp;&amp; (!defaultsOnly || (defaultsOnly === true &amp;&amp; item.isDefault))) {
  95                 matches.push(item);
  96             }
  97         }
  98
  99         return matches;
 100     }
 101 }, function() {
 102 <span id='Ext-method-preg'>    /**
 103 </span>     * Shorthand for {@link Ext.PluginManager#registerType}
 104      * @param {String} ptype The ptype mnemonic string by which the Plugin class
 105      * may be looked up.
 106      * @param {Constructor} cls The new Plugin class.
 107      * @member Ext
 108      * @method preg
 109      */
 110     Ext.preg = function() {
 111         return Ext.PluginManager.registerType.apply(Ext.PluginManager, arguments);
 112     };
 113 });
 114 </pre>
 115 </body>
 116 </html>