Gelmiş geçmiş en büyük porno sitemiz olan 2pe de her zaman en kaliteli pornoları sunmayı hedefledik. Diğer video sitemiz olan vuam da ise hd porno ağırlıklı çalışmalara başladık.

  1. #251
    Sencha User
    Join Date
    Mar 2011
    Posts
    9
    Vote Rating
    0
    eCoast is on a distinguished road

      0  

    Default


    Has anyone found the solution for using an HTML Editor in a wizard card???

    Quote Originally Posted by sean.zhou View Post
    After more extensive search, it seems that ExtJs does have some problems with htmleditor. After played with layout-browser.html in ExtJs examples, I found htmleditor did not work when it is inside of a card panel. I have tried with the suggested fixes from other thread discussions, such as using
    Code:
    deferredRender:false
    and/or
    Code:
    hideMode: 'offsets'
    on the card panel and failed to get it work. Here is the example that shows the problem by replacing

    Code:
    id: 'card-1',
    html: '<p>Step 2 of 3</p><p>Almost there.  Please click the "Next" button to continue...</p>'
    with

    Code:
    id: 'card-1', deferredRender:false,
    items: [{xtype:'htmleditor', hideMode: 'offsets', fieldLabel: 'abcd'}]
    inside of cardWizard in examples/layout-browser/layouts/basic.js. Then start examples/layout-browser/layout-browser.html. The same exception will be thrown to the firebug console in Firefox.

  2. #252
    Sencha User
    Join Date
    Mar 2011
    Posts
    9
    Vote Rating
    0
    eCoast is on a distinguished road

      0  

    Default SOLVED

    SOLVED


    I tracked the case of the broken HTMLEditor into ToolbarLayout.js.
    I included this file as per suggestion in one of the Ext.ux.Wiz posts adn it broke all HTML editors - not just the one in the wizard.

    Here is the code to ToolbarLayout.js (I don't think I've modified anything since copying it from the forum)

    PHP Code:
    /*
     * @class Ext.layout.ToolbarLayout
     * @extends Ext.layout.ContainerLayout
     */
    Ext.layout.ToolbarLayout Ext.extend(Ext.layout.ContainerLayout, {

        
    // private
        
    onLayout : function(cttarget){
            if(!
    this.leftTr){
                
    target.addClass('x-toolbar-layout-ct');
                
    target.createChild([
                  {
    tag:'table'cls:'x-toolbar-left'cellspacing0cn: {tag'tbody'cn: {tag'tr'}}},
                  {
    tag:'table'cls:'x-toolbar-right'cellspacing0cn: {tag'tbody'cn: {tag'tr'}}}
                ]);
                
    this.leftTr target.child('.x-toolbar-left tr'true);
                
    this.rightTr target.child('.x-toolbar-right tr'true);
            } else {
              
    this.align this.container.initialConfig.align;
              while(
    this.leftTr.lastChildthis.leftTr.removeChild(this.leftTr.lastChild);
              while(
    this.rightTr.lastChildthis.rightTr.removeChild(this.rightTr.lastChild);
            }

    //    Layout all the items.
            
    var items ct.items.items;
            for(var 
    0len items.lengthleni++) {
                
    this.renderItem(items[i], itarget);
            }
        },

        
    // private
      
    getNextCell : function(c){
        return (((
    c.align == 'right') || (this.container.align == 'right') || (this.align == 'right')) ? this.rightTr this.leftTr).appendChild(document.createElement('td'));
        },

        
    // private
        
    renderItem : function(cpositiontarget){
            if(
    c) {
              if (
    c.isFill) { // A Fill just switches sides
                
    this.align 'right';
              } else {
                if (
    instanceof Ext.Element) {
                  
    this.getNextCell().appendChild(c.dom);
                } else {
                  if (
    c.rendered){
                    if (
    this.renderOnLayout) {
                      
    c.el.remove();
                      
    delete c.el;
                      
    c.rendered false;
                    } else {
                      
    this.getNextCell(c).appendChild(c[c.wrap 'wrap' 'el'].dom);
                    }
                  } else {
                      
    c.render(this.getNextCell(c));
                  }
              }
          }
            }
        }
        
    /**
         * @property activeItem
         * @hide
         */
    });

    Ext.Container.LAYOUTS['toolbar'] = Ext.layout.ToolbarLayout;

    /**
     * @class Ext.Toolbar
     * @extends Ext.Container
     * Basic Toolbar class. Toolbar elements can be created explicitly via their constructors, or implicitly
     * via their xtypes.  Some items also have shortcut strings for creation.
     * @constructor
     * Creates a new Toolbar
     * @param {Object/Array} config A config object or an array of buttons to add
     */
     
    Ext.Toolbar = function(config){
        if(
    Ext.isArray(config)){
            
    config = {itemsconfiglayout'toolbar'};
        } else {
          
    config Ext.apply({
            
    layout'toolbar'
          
    }, config);
          if (
    config.buttons) {
            
    config.items config.buttons;
          }
        }
        
    Ext.Toolbar.superclass.constructor.call(thisconfig);
    };

    (function(){

    var 
    Ext.Toolbar;

    Ext.extend(TExt.Container, {

        
    defaultType'tbbutton',

        
    trackMenus true,

        
    // private
        
    autoCreate: {
            
    cls:'x-toolbar x-small-editor'
        
    },

        
    // private
        
    onRender : function(ctposition){
            
    this.el ct.createChild(Ext.apply({ idthis.id },this.autoCreate), position);
        },

        
    /**
         * Adds element(s) to the toolbar -- this function takes a variable number of
         * arguments of mixed type and adds them to the toolbar.
         * @param {Mixed} arg1 The following types of arguments are all valid:<br />
         * <ul>
         * <li>{@link Ext.Toolbar.Button} config: A valid button config object (equivalent to {@link #addButton})</li>
         * <li>HtmlElement: Any standard HTML element (equivalent to {@link #addElement})</li>
         * <li>Field: Any form field (equivalent to {@link #addField})</li>
         * <li>Item: Any subclass of {@link Ext.Toolbar.Item} (equivalent to {@link #addItem})</li>
         * <li>String: Any generic string (gets wrapped in a {@link Ext.Toolbar.TextItem}, equivalent to {@link #addText}).
         * Note that there are a few special strings that are treated differently as explained next.</li>
         * <li>'separator' or '-': Creates a separator element (equivalent to {@link #addSeparator})</li>
         * <li>' ': Creates a spacer element (equivalent to {@link #addSpacer})</li>
         * <li>'->': Creates a fill element (equivalent to {@link #addFill})</li>
         * </ul>
         * @param {Mixed} arg2
         * @param {Mixed} etc.
         */
        
    add : function(){
            var 
    argumentsa.length;
            for(var 
    0li++){
                var 
    el a[i];
                if(
    el.isFormField){ // some kind of form field
                    
    this.addField(el);
                }else if(
    el.render){ // some kind of Toolbar.Item
                    
    this.addItem(el);
                }else if(
    typeof el == "string"){ // string
                    
    if(el == "separator" || el == "-"){
                        
    this.addSeparator();
                    }else if(
    el == " "){
                        
    this.addSpacer();
                    }else if(
    el == "->"){
                        
    this.addFill();
                    }else{
                        
    this.addText(el);
                    }
                }else if(
    el.tag){ // DomHelper spec
                    
    this.addDom(el);
                }else if(
    el.tagName){ // element
                    
    this.addElement(el);
                }else if(
    typeof el == "object"){ // must be button config?
                    
    if(el.xtype){
                        
    this.addItem(Ext.ComponentMgr.create(el'button'));
                    }else{
                        
    this.addButton(el);
                    }
                }
            }
        },

        
    /**
         * Adds a separator
         * @return {Ext.Toolbar.Item} The separator item
         */
        
    addSeparator : function(){
            return 
    this.addItem(new T.Separator());
        },

        
    /**
         * Adds a spacer element
         * @return {Ext.Toolbar.Spacer} The spacer item
         */
        
    addSpacer : function(){
            return 
    this.addItem(new T.Spacer());
        },

        
    /**
         * Forces subsequent additions into the float:right toolbar
         */
        
    addFill : function(){
          
    this.addItem(new T.Fill());
        },

        
    /**
         * Adds any standard HTML element to the toolbar
         * @param {Mixed} el The element or id of the element to add
         * @return {Ext.Toolbar.Item} The element's item
         */
        
    addElement : function(el){
          var 
    item = new T.Item({el:el});
            
    this.addItem(item);
            return 
    item;
        },

        
    /**
         * Adds any Toolbar.Item or subclass
         * @param {Ext.Toolbar.Item} item
         * @return {Ext.Toolbar.Item} The item
         */
        
    addItem : function(item){
          
    Ext.Toolbar.superclass.add.apply(thisarguments);
          return 
    item;
        },

        
    /**
         * Adds a button (or buttons). See {@link Ext.Toolbar.Button} for more info on the config.
         * @param {Object/Array} config A button config or array of configs
         * @return {Ext.Toolbar.Button/Array}
         */
        
    addButton : function(config){
            if(
    Ext.isArray(config)){
                var 
    buttons = [];
                for(var 
    0len config.lengthleni++) {
                    
    buttons.push(this.addButton(config[i]));
                }
                return 
    buttons;
            }
            var 
    config;
            if(!(
    config instanceof T.Button)){
                
    config.split ?
                    new 
    T.SplitButton(config) :
                    new 
    T.Button(config);
            }
            
    this.initMenuTracking(b);
            
    this.addItem(b);
            return 
    b;
        },

        
    // private
        
    initMenuTracking : function(item){
            if(
    this.trackMenus && item.menu){
                
    item.on({
                    
    'menutriggerover' this.onButtonTriggerOver,
                    
    'menushow' this.onButtonMenuShow,
                    
    'menuhide' this.onButtonMenuHide,
                    
    scopethis
                
    })
            }
        },

        
    /**
         * Adds text to the toolbar
         * @param {String} text The text to add
         * @return {Ext.Toolbar.Item} The element's item
         */
        
    addText : function(text){
          var 
    = new T.TextItem(text);
            
    this.addItem(t);
            return 
    t;
        },

        
    /**
         * Inserts any {@link Ext.Toolbar.Item}/{@link Ext.Toolbar.Button} at the specified index.
         * @param {Number} index The index where the item is to be inserted
         * @param {Object/Ext.Toolbar.Item/Ext.Toolbar.Button/Array} item The button, or button config object to be
         * inserted, or an array of buttons/configs.
         * @return {Ext.Toolbar.Button/Item}
         */
        
    insertButton : function(indexitem){
            if(
    Ext.isArray(item)){
                var 
    buttons = [];
                for(var 
    0len item.lengthleni++) {
                   
    buttons.push(this.insertButton(index iitem[i]));
                }
                return 
    buttons;
            }
            if (!(
    item instanceof T.Button)){
               
    item = new T.Button(item);
            }
            
    Ext.Toolbar.superclass.insert.call(thisindexitem);
            return 
    item;
        },

        
    /**
         * Adds a new element to the toolbar from the passed {@link Ext.DomHelper} config
         * @param {Object} config
         * @return {Ext.Toolbar.Item} The element's item
         */
        
    addDom : function(config){
          var 
    item = new T.Item({autoElconfig});
            
    this.addItem(item);
            return 
    item;
        },

        
    /**
         * Adds a dynamically rendered Ext.form field (TextField, ComboBox, etc). Note: the field should not have
         * been rendered yet. For a field that has already been rendered, use {@link #addElement}.
         * @param {Ext.form.Field} field
         * @return {Ext.ToolbarItem}
         */
        
    addField : function(field){
          
    this.addItem(field);
          return 
    field;
        },

        
    // private
        
    onDisable : function(){
            
    this.items.each(function(item){
                 if(
    item.disable){
                     
    item.disable();
                 }
            });
        },

        
    // private
        
    onEnable : function(){
            
    this.items.each(function(item){
                 if(
    item.enable){
                     
    item.enable();
                 }
            });
        },

        
    // private
        
    onButtonTriggerOver : function(btn){
            if(
    this.activeMenuBtn && this.activeMenuBtn != btn){
                
    this.activeMenuBtn.hideMenu();
                
    btn.showMenu();
                
    this.activeMenuBtn btn;
            }
        },

        
    // private
        
    onButtonMenuShow : function(btn){
            
    this.activeMenuBtn btn;
        },

        
    // private
        
    onButtonMenuHide : function(btn){
            
    delete this.activeMenuBtn;
        }
    });
    Ext.reg('toolbar'Ext.Toolbar);

    /**
     * @class Ext.Toolbar.Item
     * The base class that other non-ineracting Toolbar Item classes should extend in order to
     * get some basic common toolbar item functionality.
     * @constructor
     * Creates a new Item
     * @param {HTMLElement} el
     */
    T.Item Ext.extend(Ext.BoxComponent, {
        
    hideParenttrue//  Hiding a Toolbar.Item hides its containing TD
        
    enable:Ext.emptyFn,
        
    disable:Ext.emptyFn,
        
    focus:Ext.emptyFn
    });
    Ext.reg('tbitem'T.Item);

    /**
     * @class Ext.Toolbar.Separator
     * @extends Ext.Toolbar.Item
     * A simple class that adds a vertical separator bar between toolbar items.  Example usage:
     * <pre><code>
    new Ext.Panel({
      tbar : [
        'Item 1',
        {xtype: 'tbseparator'}, // or '-'
        'Item 2'
      ]
    });
    </code></pre>
     * @constructor
     * Creates a new Separator
     */
    T.Separator Ext.extend(T.Item, {
        
    onRender : function(ctposition){
            
    this.el ct.createChild({tag:'span'cls:'ytb-sep'}, position);
        }
    });
    Ext.reg('tbseparator'T.Separator);

    /**
     * @class Ext.Toolbar.Spacer
     * @extends Ext.Toolbar.Item
     * A simple element that adds extra horizontal space between items in a toolbar.
     * <pre><code>
    new Ext.Panel({
      tbar : [
        'Item 1',
        {xtype: 'tbspacer'}, // or ' '
        'Item 2'
      ]
    });
    </code></pre>
     * @constructor
     * Creates a new Spacer
     */
    T.Spacer Ext.extend(T.Item, {
        
    onRender : function(ctposition){
            
    this.el ct.createChild({tag:'div'cls:'ytb-spacer'}, position);
        }
    });
    Ext.reg('tbspacer'T.Spacer);

    /**
     * @class Ext.Toolbar.Fill
     * @extends Ext.Toolbar.Spacer
     * A non-rendering placeholder item which instructs the Toolbar's Layout to begin using
     * the right-justified button container.
     * <pre><code>
    new Ext.Panel({
      tbar : [
        'Item 1',
        {xtype: 'tbfill'}, // or '->'
        'Item 2'
      ]
    });
    </code></pre>
     * @constructor
     * Creates a new Fill
     */
    T.Fill Ext.extend(T.Item, {
        
    // private
        
    render Ext.emptyFn,
        
    isFill true
    });
    Ext.reg('tbfill'T.Fill);

    /**
     * @class Ext.Toolbar.TextItem
     * @extends Ext.Toolbar.Item
     * A simple class that renders text directly into a toolbar.
     * <pre><code>
    new Ext.Panel({
      tbar : [
        {xtype: 'tbtext', text: 'Item 1'} // or simply 'Item 1'
      ]
    });
    </code></pre>
     * @constructor
     * Creates a new TextItem
     * @param {String/Object} text A text string, or a config object containing a <tt>text</tt> property
     */
    T.TextItem Ext.extend(T.Item, {
      
    constructor: function(config){
        if (
    typeof config == 'string') {
          
    config = { autoEl: { cls'ytb-text'htmlconfig }};
        } else {
          
    config.autoEl = { cls'ytb-text'htmlconfig.text || ''};
        }
          
    T.TextItem.superclass.constructor.call(thisconfig);
      },
        
    setText: function(t) {
          if (
    this.rendered) {
            
    this.el.dom.innerHTML t;
          } else {
            
    this.autoEl.html t;
          }
        }
    });
    Ext.reg('tbtext'T.TextItem);

    /**
     * @class Ext.Toolbar.Button
     * @extends Ext.Button
     * A button that renders into a toolbar. Use the <tt>handler</tt> config to specify a callback function
     * to handle the button's click event.
     * <pre><code>
    new Ext.Panel({
      tbar : [
        {text: 'OK', handler: okHandler} // tbbutton is the default xtype if not specified
      ]
    });
    </code></pre>
     * @constructor
     * Creates a new Button
     * @param {Object} config A standard {@link Ext.Button} config object
     */
    T.Button Ext.extend(Ext.Button, {
        
    hideParent true,

        
    onDestroy : function(){
            
    T.Button.superclass.onDestroy.call(this);
            if(
    this.container){
                
    this.container.remove();
            }
        }
    });
    Ext.reg('tbbutton'T.Button);

    /**
     * @class Ext.Toolbar.SplitButton
     * @extends Ext.SplitButton
     * A split button that renders into a toolbar.
     * <pre><code>
    new Ext.Panel({
      tbar : [
        {
          xtype: 'tbsplit',
            text: 'Options',
            handler: optionsHandler, // handle a click on the button itself
            menu: new Ext.menu.Menu({
                items: [
                  // These items will display in a dropdown menu when the split arrow is clicked
                  {text: 'Item 1', handler: item1Handler},
                  {text: 'Item 2', handler: item2Handler},
                ]
            })
        }
      ]
    });
    </code></pre>
     * @constructor
     * Creates a new SplitButton
     * @param {Object} config A standard {@link Ext.SplitButton} config object
     */
    T.SplitButton Ext.extend(Ext.SplitButton, {
        
    hideParent true,

        
    onDestroy : function(){
            
    T.SplitButton.superclass.onDestroy.call(this);
            if(
    this.container){
                
    this.container.remove();
            }
        }
    });

    Ext.reg('tbsplit'T.SplitButton);
    // backwards compat
    T.MenuButton T.SplitButton;

    })(); 

  3. #253
    Sencha User
    Join Date
    Apr 2008
    Posts
    330
    Vote Rating
    0
    Jack_S is on a distinguished road

      0  

    Exclamation Combobox Detached List in - ux.Card (IE 8)

    Combobox Detached List in - ux.Card (IE 8)


    Hello,

    I'm using the wizard ux that you created and I'm running in a problem in IE 8 with a combobox which has scrollable list.

    There list appears detached from the combobox. I've tried using the standard work around 'bodyStyle: 'position:relative' but nothing seems to work. I've tested several methods and can't get anything to work.

    I just wanted to mention that I'm using the version which was enhanced for 3.1 was

    Does anyone have any suggestions?

    Thanks

    Jan

  4. #254
    Sencha User
    Join Date
    Mar 2013
    Posts
    1
    Vote Rating
    0
    wpenton is on a distinguished road

      0  

    Default any further update for this plugin?

    any further update for this plugin?


    I have been tasked to take over an older project at work that uses ExtJS 3.2.1 and I need to replace a homebrew wizard and I am looking at using this. I am just wanting to know if there was a package that includes all of the different addons included in this thread that are not in the Google SVN repo? (like card skipping). BTW this looks like it is an excellent plugin and thanks to all for your hard work.

Thread Participants: 96

  1. Animal (2 Posts)
  2. franklt69 (1 Post)
  3. jay@moduscreate.com (1 Post)
  4. Digital God (1 Post)
  5. mystix (4 Posts)
  6. fangzhouxing (3 Posts)
  7. mike1993 (2 Posts)
  8. KRavEN (1 Post)
  9. jsakalos (2 Posts)
  10. Ylodi (1 Post)
  11. Fabyo (2 Posts)
  12. anestesiadorhvs (1 Post)
  13. John Sourcer (1 Post)
  14. kmiyashiro (3 Posts)
  15. anjelika (6 Posts)
  16. cutigersfan (1 Post)
  17. mjlecomte (1 Post)
  18. kevinwu8 (2 Posts)
  19. JEBriggs (3 Posts)
  20. CutterBl (5 Posts)
  21. gelleneu (1 Post)
  22. Spirit (1 Post)
  23. Michelangelo (9 Posts)
  24. wm003 (1 Post)
  25. Juvs (3 Posts)
  26. Mthor (2 Posts)
  27. sean.zhou (2 Posts)
  28. donssmith (3 Posts)
  29. sigaref (1 Post)
  30. ajaxvador (1 Post)
  31. prodigy7 (2 Posts)
  32. mask_hot (2 Posts)
  33. ec-cts (1 Post)
  34. dorgan (2 Posts)
  35. DhakouaniM (1 Post)
  36. Romantik (2 Posts)
  37. franck34 (4 Posts)
  38. sirioz10 (1 Post)
  39. razor (15 Posts)
  40. chalu (2 Posts)
  41. cirvine (2 Posts)
  42. ClemsonJeeper (1 Post)
  43. GOTTMODUS (1 Post)
  44. rnfbr1 (2 Posts)
  45. walldorff (2 Posts)
  46. jlowe (1 Post)
  47. moegal (1 Post)
  48. johnstontrav (1 Post)
  49. mirko (1 Post)
  50. J.B (1 Post)
  51. niaz (1 Post)
  52. Jack_S (2 Posts)
  53. knarz (1 Post)
  54. hatch79 (1 Post)
  55. Eki (1 Post)
  56. accilies (3 Posts)
  57. SamuraiJack1 (1 Post)
  58. gthe (2 Posts)
  59. Scorpie (1 Post)
  60. supercharge2 (1 Post)
  61. lucasmarin (1 Post)
  62. alienwebz (7 Posts)
  63. kellyt (2 Posts)
  64. charleshimmer (20 Posts)
  65. nomdeguerre (3 Posts)
  66. perdar (2 Posts)
  67. agalue (2 Posts)
  68. pablitobs (4 Posts)
  69. jmariani (4 Posts)
  70. wemerson.januario (3 Posts)
  71. mschwartz (2 Posts)
  72. Stju (3 Posts)
  73. TheColonel (1 Post)
  74. lakilevi (1 Post)
  75. roque (2 Posts)
  76. Jangla (8 Posts)
  77. cchic (1 Post)
  78. MH61 (2 Posts)
  79. MasterAM (1 Post)
  80. pezze (8 Posts)
  81. phpfreak (1 Post)
  82. talha06 (1 Post)
  83. swarm (7 Posts)
  84. udalaitz (2 Posts)
  85. esh (1 Post)
  86. reci (1 Post)
  87. ccrotty (3 Posts)
  88. CarlosLuiz (3 Posts)
  89. guyfomi (1 Post)
  90. yugikhoi (1 Post)
  91. drunkmoose (1 Post)
  92. occiso (2 Posts)
  93. slckysr (3 Posts)
  94. samir_ware (1 Post)
  95. eCoast (2 Posts)
  96. wpenton (1 Post)