Ticket #4252: 4252_4.patch

File 4252_4.patch, 11.1 KB (added by Garry Yao, 11 years ago)
  • _source/core/ui.js

     
    7575                if ( command )
    7676                        command.uiItems.push( result );
    7777
     78                // Replace the registered items with created instances.
     79                this._.items[ name ] = result;
     80
    7881                return result;
    7982        },
    8083
  • _source/plugins/richcombo/plugin.js

     
    273273                                        me.setState( CKEDITOR.TRISTATE_OFF );
    274274                                };
    275275
     276                        panel.on( 'showBlock', function()
     277                        {
     278                                this.fire( 'open', panel );
     279                        }, this );
     280
    276281                        if ( this.init )
    277282                                this.init();
    278283                },
     
    351356        }
    352357});
    353358
     359CKEDITOR.event.implementOn( CKEDITOR.ui.richCombo.prototype, true );
    354360CKEDITOR.ui.prototype.addRichCombo = function( name, definition )
    355361{
    356362        this.add( name, CKEDITOR.UI_RICHCOMBO, definition );
  • _source/plugins/menu/plugin.js

     
    151151                                        },
    152152                                        this );
    153153
     154                                        panel.on( 'showBlock', function()
     155                                        {
     156                                                this.fire( 'open', panel );
     157                                        }, this );
     158
     159
    154160                                        // Create an autosize block inside the panel.
    155161                                        var block = panel.addBlock( this.id );
    156162                                        block.autoSize = true;
     
    241247                }
    242248        });
    243249
     250        CKEDITOR.event.implementOn( CKEDITOR.menu.prototype, true );
     251
    244252        function sortItems( items )
    245253        {
    246254                items.sort( function( itemA, itemB )
  • _source/plugins/keystrokes/plugin.js

     
    8383        {
    8484                // The DOM event object is passed by the "data" property.
    8585                event = event.data;
    86 
    8786                var keyCombination = event.getKeystroke();
    8887                var command = this.keystrokes[ keyCombination ];
    8988                var editor = this._.editor;
  • _source/plugins/floatpanel/plugin.js

     
    217217                                                        if ( panel.isLoaded )
    218218                                                                setHeight();
    219219                                                        else
    220                                                                 panel.onLoad = setHeight;
     220                                                                panel.on( 'load', setHeight );
    221221                                                }
    222222                                                else
    223                                                         element.getFirst().removeStyle( 'height' );
     223                                                        element.getFirst().removeStyle('height');
    224224
     225                                                panel.isLoaded ?
     226                                                        this.fire( 'showBlock', block )
     227                                                        : panel.on( 'load', function( evt )
     228                                                          {
     229                                                                  evt.removeListener();
     230                                                                  this.fire( 'showBlock', block );
     231                                                          }, this );
     232
    225233                                                // Set the IFrame focus, so the blur event gets fired.
    226234                                                CKEDITOR.tools.setTimeout( function()
    227235                                                        {
     
    322330                        }
    323331                }
    324332        });
     333
     334        CKEDITOR.event.implementOn( CKEDITOR.ui.floatPanel.prototype, true );
     335
    325336})();
  • _source/plugins/dialog/plugin.js

     
    26802680                                var storedDialogs = this._.storedDialogs ||
    26812681                                        ( this._.storedDialogs = {} );
    26822682
    2683                                 var dialog = storedDialogs[ dialogName ] ||
    2684                                         ( storedDialogs[ dialogName ] = new CKEDITOR.dialog( this, dialogName ) );
    2685 
     2683                                var dialog = storedDialogs[ dialogName ];
     2684                                if( !dialog )
     2685                                {
     2686                                        dialog = ( storedDialogs[ dialogName ] = new CKEDITOR.dialog( this, dialogName ) );
     2687                                        dialog.on( 'show', function()
     2688                                        {
     2689                                                this.fire( 'dialogOpen', dialog );
     2690                                        }, this );
     2691                                }
    26862692                                dialog.show();
    26872693
    26882694                                return dialog;
  • _source/plugins/toolbar/plugin.js

     
    193193                                                                        }
    194194
    195195                                                                        var itemObj = item.render( editor, output );
     196                                                                        item.toolbarItem = itemObj;
    196197                                                                        index = toolbarObj.items.push( itemObj ) - 1;
    197198
    198199                                                                        if ( index > 0 )
  • _source/plugins/panelbutton/plugin.js

     
    133133                                                                _.on = 0;
    134134                                                                me.setState( CKEDITOR.TRISTATE_OFF );
    135135                                                };
     136                                panel.on( 'showBlock', function()
     137                                {
     138                                        this.fire( 'open', panel );
     139                                }, this );
    136140                        }
    137141                }
    138142        });
    139143
     144        CKEDITOR.event.implementOn( CKEDITOR.ui.panelButton.prototype, true );
     145
    140146})();
  • _source/core/test.js

     
    6868                }
    6969
    7070                sel.selectRanges( ranges );
    71         }
    72        
     71        },
     72
     73        toolbar :
     74        {
     75                /**
     76                 * Click on a specific toolbar button and the {@param callback} will be
     77                 * fed with the consequential UI object which has been opened by this click.
     78                 *
     79                 * @param itemName The toolbar item definition name.
     80                 * @callback The callback function which is called after the affiliate
     81                 * button behavior has completed.
     82                 * @example
     83                 *
     84                 * // Click on 'Format' combo.
     85                 * CKEDITOR.test.toolbar.clickButton( 'Format' ,
     86                 * function( combo )
     87                 * {
     88                 *      alert( combo instanceof CKEDITOR.ui.richCombo );        // true
     89                 * });
     90                 *
     91                 * // Click on 'Image' dialog.
     92                 * CKEDITOR.test.toolbar.clickButton( 'Image' ,
     93                 * function( dialog )
     94                 * {
     95                 *      alert( dialog instanceof CKEDITOR.dialog );     // true
     96                 * });
     97                 */
     98                clickButton : function( editor, itemName, callback, context )
     99                {
     100                        var ui = editor.ui,
     101                                // Find the corresponding ui instances of the toolbar item.
     102                                uiItems = ui._.items,
     103                                uiItem =uiItems[ itemName ],
     104                                // Back reference the toolbar item instance.
     105                                toolbarItem = uiItem.toolbarItem,
     106                                // Find the command instance registered on this ui item.
     107                                command = editor.getCommand( uiItem.command );
     108
     109                        // Special treatments for different types of button.
     110                        if( uiItem instanceof CKEDITOR.ui.button )
     111                        {
     112                                // button of style command.
     113                                if( command && command.style )
     114                                {
     115                                        editor.on( 'selectionChange', function( evt )
     116                                        {
     117                                                evt.removeListener();
     118                                                callback.call( context );
     119                                        }, null, null, 1000 );
     120                                }
     121                                // button of dialog command.
     122                                if( command && command.dialogName )
     123                                {
     124                                        editor.on( 'dialogOpen', function( evt )
     125                                        {
     126                                                evt.removeListener();
     127                                                callback.call( context, evt.data );
     128                                        }, null, null, 1000 );
     129                                }
     130                                // button of panel.
     131                                else if( uiItem instanceof CKEDITOR.ui.panelButton )
     132                                {
     133                                        uiItem.on( 'open', function( evt )
     134                                        {
     135                                                evt.removeListener();
     136                                                callback.call( context, uiItem );
     137                                        }, null, 1000 );
     138                                }
     139                                // Trigger button.
     140                                toolbarItem.execute();
     141                        }
     142                        else if( uiItem instanceof CKEDITOR.ui.richCombo )
     143                        {
     144                                uiItem.on( 'open', function( evt )
     145                                {
     146                                        evt.removeListener();
     147                                        callback.call( context, uiItem );
     148                                }, null, 1000 );
     149
     150                                // Trigger combo.
     151                                var comboEntry = YAHOO.util.Selector.query( 'a', toolbarItem.id, true );
     152                                comboEntry.onclick();
     153                        }
     154                }
     155
     156        },
     157
     158        dialog :
     159        {
     160                /**
     161                 * Filling the assigned dialog with a specified set of field values and finally close it.
     162                 * @param dialog {CKEDITOR.dialog} The dialog instance to populate.
     163                 * @param profile {Object} The page - field - value map to be filled into the dialog.
     164                 * @example
     165                 * CKEDITOR.test.dialog.fill( imageDialog,
     166                 *       {
     167                 *               info :
     168                 *               {
     169                 *                        txtUrl : 'http://ckeditor.com/logos.gif'
     170                 *               },
     171                 *               Link :
     172                 *               {
     173                 *                       txtUrl : 'http://ckeditor.com'
     174                 *               },
     175                 *               advanced :
     176                 *               {
     177                 *                       linkId : 'link_id1',
     178                 *                       txtGenClass : 'cls'
     179                 *               }
     180                 *       } );
     181                 *
     182                 */
     183                fill : function ( dialog, profile )
     184                {
     185                        var field, page;
     186                        for( var pageName in profile )
     187                        {
     188                                // Activate the page.
     189                                dialog.selectPage( pageName );
     190
     191                                page = profile[ pageName ];
     192                                for( var fieldId in page )
     193                                {
     194                                        field = dialog.getContentElement( pageName, fieldId );
     195                                        // Populate the field.
     196                                        field.setValue( page[ fieldId ] );
     197                                }
     198                        }
     199                        dialog.click( 'ok' );
     200                }
     201
     202        },
     203
     204        editor :
     205        {
     206                /**
     207                 * Load the editor with specified content and the denoted selection within it.
     208                 * @param editor
     209                 * @param data {String} String presentation of the HTML and selection range marker.
     210                 * @example
     211                 * CKEDITOR.test.editor.loadDataWithSelection( editor,
     212                 *       "<p>This is some <strong>[sample text]</strong>.</p>" );
     213                 */
     214                loadDataWithSelection : function( editor, data )
     215                {
     216                        var docBody = editor.document.getBody();
     217                        CKEDITOR.test.setHtmlWithSelection( docBody, data );
     218                },
     219
     220                /**
     221                 * Set the editor selection to what the start/end position denote.
     222                 * @param editor
     223                 * @param {Array} startPosition The expected range startContainer address plus startOffset.
     224                 * @param {Array} endPosition The expected range endContainer address plus endOffset.
     225                 * @example
     226                 * // Make the selection as: <p>[text] selection</p>
     227                 * CKEDITOR.test.editor.makeSelection( editor, [ 1, 0, 0, 0 ], [ 1, 0, 0, 4 ] );
     228                 */
     229                makeSelection : function( editor, startPosition, endPosition )
     230                {
     231                        editor.getSelection().selectBookmarks( [ {
     232                                        start : startPosition.slice( 0, startPosition.length - 1 ),
     233                                        startOffset : startPosition[ startPosition.length -1 ],
     234                                        end : endPosition == true ? null : endPosition.slice( 0, endPosition.length - 1 ),
     235                                        endOffset : endPosition[ endPosition.length -1 ],
     236                                        is2: true
     237                                } ] );
     238                }               
     239        }
    73240};
    74241
    75242// Inherit generic testing APIs from CKTESTER.
  • _source/plugins/panel/plugin.js

     
    141141                                if ( CKEDITOR.env.isCustomDomain() )
    142142                                        doc.$.domain = document.domain;
    143143
    144                                 var onLoad = CKEDITOR.tools.addFunction( CKEDITOR.tools.bind( function( ev )
     144                                var onLoad = CKEDITOR.tools.addFunction( CKEDITOR.tools.bind( function()
    145145                                        {
    146146                                                this.isLoaded = true;
    147                                                 if ( this.onLoad )
    148                                                         this.onLoad();
     147                                                this.fire( 'load', this );
     148
    149149                                        }, this ) );
    150150
    151151                                doc.$.write(
     
    233233        }
    234234};
    235235
     236CKEDITOR.event.implementOn( CKEDITOR.ui.panel.prototype, true );
    236237CKEDITOR.ui.panel.block = CKEDITOR.tools.createClass(
    237238{
    238239        $ : function( blockHolder )
© 2003 – 2019 CKSource – Frederico Knabben. All rights reserved. | Terms of use | Privacy policy