вторник, 21 августа 2012 г.

ExtJS Events События

Для событий связанных с DOM в ExtJS предусмотрен метод аналогичный jQuery.bind.

Пример для обработки клика представлен ниже:

Ext.onReady(function(){
    var ex1=Ext.get('ex1'); ex1.on('click',function(){alert('click');})
    // или так:
    Ext.EventManager.addListener('ex1', 'click',function(){ alert('click #2')});
});

Поскольку в примере введены два обработчика события, то они сработают оба, точно так же как и в jQuery.

Этот же метод позволяет вытащить информацию о самом событиии, источнике события и изменить ход события.
В примере ниже обработчику события передаются два параметра.
Один - EventObject, а другой - DOM-объект источника события.
В примере мы ввели ненужные в данном случае дополнительные операции по предотвращению всплывание события (stopPropagation) и выполнения дефотлной операции клика (preventDefault). Например при клике по ссылке можно предотвратить переход по этой ссылке.

function handleClick(event, target){ // обработчик события
    event.preventDefault(); // предотвращает событие навешанное по дефолту
    event.stopPropagation(); // предотвращает всплывание
    event.stopEvent(); // это лишнее, оно предотвращает и всплывание  и дефолт 
    var s= 'Target: '+target.innerHTML // вытаскивает информацию о событии                        
        +'XY: ' + event.getPageX() +':' + event.getPageY();                      
    alert(s);        
}

var ex2 = Ext.get(«ex2»); // ссылка на Ext.Element

ex2.on(
    'click',// событие
    handleClick // обработчик события
);

Есть еще несколько вариантов форы записи этого метода, например:

el.on(eventName, handler, scope,params); 

eventName - событие (click, dblclick, mousemove, mouseout, mouseover, mousedown, mouseup).
handler - функция обработччик события.
scope - контекст события (по умолчанию this).
params - дополнительные параметры, которые могут в частности заменять функции stopEvent, preventDefault и т. д.

Четвертым параметром передается объект, в котором можно передать дополнительные параметры обработки, например:

ex1.on('click', this.onClick, this, {preventDefault: true});
ex1.on('click', this.onClick, this, {stopEvent: true});
exl.on('click', this.onClick, this, {stopPropagation: true});

// вызывать обработчик через 100 милисекунд
el.on('click', this.onClick, this, {delay: 100});

// не допускать вызова обработчика чаще чем раз в 100 милисекунд
el.on('click', this.onClick, this, {buffer: 100});

Помимо низкоуровневых событий, привязанных к DOM, ExtJS так же позволяет создавать собственные события, которые можно при необходимости вызвать программно. Делается это так:

// привязка событий myEvent1,myEvent2 к какому-нибудь объекту (компоненту) obj
obj.addEvents('myEvent1', 'myEvent2');

// описание обработчика события
function myEvent1Listener(event, target, {params}){…}

// вызов события из объекта (компонента) obj
this.fireEvent('myEvent', this,  {params});

ExtJS Шаблоны

var d=['Петров', 'Иван', 'Семенович'];
var tpl= new Ext.Template("<div class='domexample'><b>{0}</b> {1} {2}</div>");
tpl.append('ex1', d);
tpl.append('ex1',['Васнецов', 'Виктор', 'Анатольевич']);

В первой строке создается шаблон.
Во втрой строке находится элемент c id='ex1', куда будет вставлен результат работы шаблона.

Затем в шаблон подставляюся данные из массива.
{0} - первый элемент массива, {1} - второй и так далее.

Так же как и в PHP-шаблонизаторах типа Smarty для ускорения работы шаблонов в ExtJS их можно скомпилировать, то есть перевети в какой-то внутренний объект, с помощь которого парсинг будет выполняться быстрее.

tpl.compile(); // компиляция шаблона
tpl.append('ex2',['Бодров', 'Павел', 'Андреевич']);

Можно парсить не только массивы, но и литерально заданные объекты (JSON):

var tpl3=new Ext.Template("<div class='domexample'><b>{f}</b> {i} {o}</div>");
tpl3.append('ex3',{f:'Антонов', i:'Дмитрий', o:'Владимирович'});

В шаблонах также предусмотрены циклы.

var data = {
    text: 'Президиум',
    member: [
        {name: 'Путин В.В.', member: 'председатель партии «Единая Россия»',age:58},
        {name: 'Жириновский В.В.', member: 'Генеральный секретарь ЛДПР',age:68},
         {name: 'Зюганов В.В.', member: 'председатель Президиума ЦК КПРФ(б)',age:66}
    ]
};

var tpl4 = new Ext.XTemplate(
    '<b>{text}:</b>',
    '<tpl for="member">', // начало цикла для массива member
    '<p>{#}  {name} ({member})</p>',
    '</tpl>' // конец цикла
);

tpl4.append('ex4',data);

Точно так же как и циклы при помощи тегов <tpl> в шаблоны вводятся условия. Ниже приведен пример только одного шаблона. Из тех же данных что и в предыдущем примере введем ограничение по возрасту.

var tpl5 = new Ext.XTemplate(
    '<b>{text}:</b>',
    '<tpl for="member">', // начало цикла для массива member
    '<tpl if=«age< 60»>', //  ограничение по возрасту
    '<p>{#} {name} ({member})</p>',
    '</tpl>',
    '</tpl>' // конец цикла
);

ExtJS DOM Манипуляции с узлами DOM: добавление и удаление узлов

Изменение содержимого узла:

Ext.get('ex1').update('<b>UPDATE</b>'); // изменение innerHTML

Добавление узла:

Ext.get('ex21A').createChild('<div class="domexample">createChild #ex21A</div>');

HTML для createChild можно задавать непосредственно строкой, как сделано выше, а можно по-другому:

Вариант 1.
Ext.get('ex21B').createChild({ // вставка в #ex21B элемента DIV
    tag:'div',             // тег, который нужно вставить
    id: 'ex21Another', // ID этого тега
    cls:'domexample',      // CSS-класс
    html:'<b>Another create method</b>'  // html-содержимое
});

Вариант 2.
Ext.get('ex21C').createChild({ // вставка в #ex21C списка UL
    tag:'ul', // тег, который нужно вставить
    children: [ // дочерние елементы
        {tag: 'li', id: 'item0', html: 'List Item 0'},
        {tag: 'li', id: 'item1', html: 'List Item 1'},
        {tag: 'li', id: 'item2', html: 'List Item 2'}
    ]
});

Вариант 3.
var el = new Ext.Element(document.createElement('b'));
el.update('appendChild'); // изменение innerHTML
Ext.get('ex22').appendChild(el); 

Вариант 4.
var ex23A=Ext.get('ex23A');
var ex23B=Ext.get('ex23B');
var ex23C=Ext.get('ex23C');

ex23A.insertAfter(ex23C);
ex23B.insertBefore('ex23A');



Удаление узла:

Ext.get('example').remove();

Удаление Ext.Element, кроме удаления DOM-элемента, сопровождается очисткой всего что с ним связано, в том числе событий.

ExtJS DOM Установка стилей, классов и атрибутов

Приведем примеры методов установки в ExtJS стилей, классов и атрибутов.

Ext.onReady(function(){
    var ex1=Ext.select('#ex1');
    ex1.setStyle({'border':'5px solid red'}); // установить стиль
    ex1.setHeight(50); // установить высоту
    ex1.setWidth(150); // установить ширину
    ex1.setOpacity(.25); // установить прозрасность
    ex1.addCls('red'); // добавить CSS-класс
    ex1.removeCls('red'); // удалить CSS-класс
    ex1.set({title:'set title'}) // установить аттрибут
});

В результате выполнения кода ExtJS изменит оформление данного элемента.



Эти методы работают как с Ext.Element так и c Ext.CompositeElement, то есть первую строку можно свободно заменить на:

var ex1=Ext.get('ex1');

Чтение стилей, классов, атрибутов.

var ex2=Ext.get('ex2');
var s= 'width:'+ex2.getWidth() // считать ширину
+ '; height:'+ex2.getHeight() // считать высоту
+ '; id:'+ex2.getAttribute('id') // определить атрибут ID
+ '; hasCls:'+ex2.hasCls('red'); // определить наличие класса
ex2.createChild(' '+s+''); // вывод результата в #ex2;

ExtJS Методы по управлению DOM

Методы ExtJS по управлению DOM.

Методы параметры результат
Ext.get(el)
Ext.fly(el)
el - ID или DOM-элемент Объект Ext.core.Element
Ext.select(selector)
Ext.core.Element.select(selector, unique, root)
selector - строковое значение CSS/XPath-селектора,
или массив значений CSS/XPath-селекторов
Объект Ext.CompositeElementLite
или Ext.CompositeElement
Ext.query(selector)
Ext.DomQuery.select(selector,root)
selector - строковое значение CSS/XPath-селектора,
или массив значений CSS/XPath-селекторов
Массив DOM-узлов
Ext.getBody(),Ext.getDoc(), Ext.getHead() - Метод позволяет получить Body, Document, Head как объект Ext.core.Element
Ext.getDom(el) el - ID или DOM-элемент DOM-узел

Ext.core.Element (он же Ext.Element) - объект в котором инкапсулирован DOM и набор методов для манипуляции с ними. Фактически это основной метод работы с DOM.

Ext.CompositeElementLite и Ext.CompositeElement - еще один класс, в котором согласно документации инкапсулировано, то же что и Ext.core.Element.

Все примеры на этой странице вызываются по готовности DOM.

<script type="text/javascript">
    Ext.onReady(function(){
        // Выполнить функцию по готовности DOM.
    });
</script>

Ext.get позволяет определить елемент DOM и полуцчить соответствующий ему Ext.core.Element пo id.

var ex1 = Ext.get('ex1');  // Выделили DOM-элемент с id="ex1"

ex1.createChild('< div>Ex1< /div>'); // Разместили в нем HTML

Точно так же в get в качестве параметров можно добавить и DOM-элемент.

Ext.get(document.getElementById('ex2')).createChild('<div>Ex2</div>');

Ext.select - этот метод отдаленно похож на метод навигации в jQuery.
Он позволяет получить объект Ext.CompositeElement по CSS/Xpath-селектору заданному строкой.

Ext.select('blockquote').createChild('select by tag "blockquote"');

Ext.select('.ex4').createChild('select by class "ex4"');

Ext.select('#ex4').createChild('select by id "ex4"');

Ext.select('#ex8 div').createChild('select #ex8 div ');

Метод Ext.select позволяет использовать селекторы CSS2-CSS3, аналогично jQuery.

Ext.select('span > b');           // выборка всех  элементов b явл. прямыми потомками span
Ext.select('span + b');           // выборка всех  элементов b перед которыми стоит span
Ext.select('div:first');          // выборка первого div
Ext.select('div:last');           // выборка последнего div
Ext.select('div:even');           // выборка четных div
Ext.select('div:odd');            // выборка нечетных div
Ext.select('div[title]');         // выборка всех div с атрибутом title
Ext.select('div[title='bar']');   // выборка всех div с атрибутом title=my
Ext.select('div[title!='bar']');  // выборка всех div с атрибутом title не равного 'bar'
Ext.select('div[title^='bar']');  // выборка всех div с атрибутом title начинающихся с 'bar'
Ext.select('div[title$='my']');   // выборка всех div с атрибутом title заканчивающихся на 'bar'
Ext.select('div[title*='my']');   // выборка всех div с атрибутом title содержащим 'bar'
Ext.select('input:checked]');     // выборка всех input c checked = true
Ext.select('div{display=none}');  // выборка всех div с CSS-стилем display=none
Ext.select('div{display!=none}'); // выборка всех div с CSS-стилем display!=none
Ext.select('div{height%=2}');     // выборка всех div с CSS-стилем в котором высота делится на два
Ext.select('div:not(form)')       // выборка div, не содержащих формы
Ext.select('div:has(a)')          // выборка div, содержащих ссылку
Ext.select('input:checked')       // выборка включенных чекбоксов

Метод Ext.fly аналогичен методу Ext.get с той разницей, что он оптимизирован под сборку мусора.

Разработчики рекомендуют использовать его в тех случаях, когда нет необходимости в многократном использовании полученного элемента DOM.

Ext.fly('ex5').createChild('select by id "ex5"');

Для метода select можно организовать то же самое, но для этого нужно указать дополнительный параметр unique.

Ext.query - этот метод аналогичен select, но на выходе выдает не объект Ext.Element, а набор DOM-элементов.

var ex20=Ext.query('.ex20');
for (var i in ex20) ex20[i].innerHTML='<strong>.ex20'+i+'</strong>';

getHead, getBody, getDoc и getDom.
Ext.getHead() - возвращает head как Ext.Element
Ext.getBody() - возвращает body как Ext.Element
Ext.getDoc() - возвращает весь документ как Ext.Element
Ext.getDom(param) - возвращает узел (node) DOM и принимает на входе: id, DOM, Ext.Element

Цепочки запросов в ExtJS.

var parent=Ext.query('#ex1');
var table = Ext.query('table',parent);
var form=Ext.query('form',table);
var input=Ext.query('input',form);

Ext.get(input).setStyle({'border':'5px solid red'})

parent, prev, next, child для Ext.core.Element - эти методы применимы к Ext.core.Element, то есть к результату полученному при помощи Ext.get().
Эти методы не применимы к результату более универсального Ext.select().
Ext.select() возвращает совершенно другой объект Ext.CompositeElement, к которому эти методы напрямую неприменимы.

var сhild1=Ext.get('#ex1').child('div'); // первый дочерний элемент
child1.createChild(' <b>select "#ex1 child"</b>');

var ex1b=Ext.get('ex1b');
ex1b.next().createChild(' <b>select "#ex1b next"</b>'); // следующий сосед
ex1b.prev().createChild(' <b>select "#ex10 prev"</b>'); // предыдущий сосед
ex1b.parent().setStyle({'border':'5px solid red'}); // родительский элемент

Итератор Ext.each - отдельный метод ExtJS. Среди прочего он позволяет перебирать результаты DOM-выборки. Мы разберем здесь пример только для Ext.CompositeElement.

var ex3=Ext.select('.ex3'); ex3.each(function(el,c,index){
    this.createChild(' <b>".ex3 ('+ index+')"</b>'); // здесь this применяется к текущему элементу набора Ext.CompositeElement
}); 

Ext.filter - отфильтровывает из набора Ext.CompositeElement те элементы, которые соответствуют образцу выбора CSS/XPath.
Ext.add - добавляет в набор Ext.CompositeElement.
Ext.clear - удаляет элементы из набора Ext.CompositeElement, при этом не трогает сами DOM-элементы.
Ext.getCount - количество элементов в выборке.

var ex4=Ext.select('.ex4');// создается первичный набор CompositeElement
ext4.add('.ex5').add('.ex6'); // к нему добавляются дополнительные выборки
ex4.each(function(el,c,index){// перебираем полученный набор
    this.createChild('<b>".exAdd  ('+ index+')"</b>');
});

Приведем пример выполнения некотрых выборок DOM-элементов:

var ex5=ex4.filter('.exFilter'); // выбираем из набора только те элементы, которые имеют CSS-класс exFilter
ex5.each(function(el,c,index){ // перебираем полученный набор
    this.createChild('<b>".exFilter  ('+ index+')"</b>');
});

ExtJS Tree Drag and Drop Перетаскивание и изменение элементов дерева

В ExtJS предусмотрена сортировка узлов дерева с помощью функции Drag&Drop. Делается это добавлением всего одной строчки в конфигурацию.

var tree=Ext.create('Ext.tree.Panel', {
    viewConfig: {plugins: {ptype: 'treeviewdragdrop'}},        
});

После этого в полученном дереве становится возможным перетаскивать узлы с помощью мышки.



Получить необходимый узел дерева можно следующим способом.

Для начала получают корень дерева.

var root = tree.getRootNode(); // здесь получаем его корневой узел

Метод getRootNode отдает объект типа Ext.data.NodeInterface в котором предусмотрены методы и свойства работы с каждым узлом отдельно. В частности следующие свойства:

nextSibling - следующий сосед
previousSibling предыдущий сосед
parentNode - родитель
lastChild - последний дочерний узел
firstChild - первый дочерний узел
childNodes - массив дочерних узлов

Дополнительно к указанным свойствам есть метод позволяющий перебрать в цикле все дочерние узлы:

root.eachChild(function(childnode) {// сделать что-то с узлом});

Пример кода получения информации об узлах:

var tree=Ext.create('Ext.tree.Panel', {…}); 
   
var root = tree.getRootNode(); // здесь получаем корневой узел
var first=root.firstChild; // получаем первый дочерний узел
var next =first.nextSibling // получаем следующего соседа первого дочернего узла
var childs=root.childNodes; // получаем массив всех дочерних узлов
var last=root.lastChild;  // получаем последний дочерний узел
var s= // отладочная информация
     'FirstChild:'+first.data.text+'; '+        
     'Next:'+next.data.text+'; '+       
     'LastChild:'+last.data.text+';<br> ' + 
    'childNodes:'+childs+'; ';
                     
s+="<br>eachChild:" 
   
root.eachChild(function(childnode) {
    s=s+childnode.data.text+'; ';
});

Ext.get('ex21').update(s);

Добавление и удаление узлов.
Применительно к классу Ext.data.NodeInterface существует набор методов для удаления-добавления узлов: appendChild, InsertChild, insertBefore, insertAfter.

В примере выше мы определили корень дерева. Теперь добавим к этому корню  дочерний узел:

var parent = root.appendChild({text: 'root.appendChild'});

В результате appendChild возвращает ссылку на добавленный узел.

Добавлять можно не только отдельные узлы, но и целые деревья: 

parent.appendChild([
    {text: 'parent.appendChild 1',leaf: true},
    {text: 'parent.appendChild 2',leaf: true},
    {text: 'parent.appendChild 3',leaf: true}
]);

parent.expand(); // здесь мы раскрыли узел

Метод InsertChild используется для вставки узла перед узлом с известным индексом (индекс по порядку следования в наборе дочерних узлов 0, 1, 2…)

root.insertChild( // вставка перед третьим узлом
    2, {text: 'root.insertChild 2',leaf: true});

root.insertChild(// вставка перед первым узлом
    0, {text: 'root.insertChild 0',leaf: true});

Для методов insertBefore и insertAfter требуется указать узел после и перед которым нужно сделать вставку нового узла:

parent.insertBefore({text: 'insertBefore',leaf: true}, parent.firstChild);

Результат выполнения этих методов, применительно к дереву из предыдущего примера можно видеть ниже.



Удаляется узел с помощью следующего кода:

node.remove();

ExtJS Tree Деревья

Самый простой пример дерева в ExtJS - дерево, берущее свои данные из статического объекта.

var data1={ // корневой элемент
    text: 'Root', // текст корневого элемента
    expanded: true, // указание на то что узел развернут
    children: [ // массив дочерних элементов   
        {
            text: 'Child 1',// имя элемента
            leaf: true
        }, // указание на то, что дочерних элементов нет  
        {
            text: 'Child 2',
            leaf: true
        },
        {
            text: 'Child 3',
            expanded: true,
            children: [
                {
                    text: 'Child 31',
                    leaf: true
                }
            ]
        }
    ]
}

Ext.create('Ext.tree.Panel', { // создание панели с деревом
    rootVisible: false, // спрятать корневой узел
    renderTo: 'ex1', // рендерить в #ex1
    title: 'Simple Tree', // заголовок панели
    root: data1 // источник данных
});



В этом примере в качестве источника данных использовался статичный массив.
В следующем примере в качестве источника данных появляется прослойка - хранилище (Storage).

var data2={// структура данных та же, что и в примере выше.}  

var store2 = Ext.create('Ext.data.TreeStore', {root: data2// создается хранилище данных, взятых из data2});

Ext.create('Ext.tree.Panel', {
    rootVisible: false,  // спрятать корневой узел
    store: store2,  // указывается хранилище данных
    title: 'Simple Tree var2',
    renderTo: 'ex2',
    height: 200
});



Дерево, загружаемое через AJAX.

var store3 = Ext.create('Ext.data.TreeStore', {
     proxy: { // указание типа иисточника данных
         type: 'ajax', //  тип данных - ajax
         url: 'tree.php' //  урл источника данных
     }
});

Ext.create('Ext.tree.Panel', {
     store: store3,
     rootVisible: true,
     title: 'Ajax Tree',
     renderTo: 'ex3',
     height: 200
});

Отличие этого примера от предыдущего в том, что хранилище настроено на прием данных с сервера.
На стороне сервера скрипт tree.php выдает json-объект с такой же структурой данных, как было рассмотрено выше.

В результате выполнения данного кода ExtJS выведет на экран сформированное дерево.



treeGrid - комбинация дерева и таблицы.
Так же как и в таблице в treeGrid необходимо сначала определить поля для таблицы:

var cols=[
    {
        xtype: 'treecolumn', // тип поля - таблица
        text: 'Name', // текстовое название поля    
        dataIndex: 'name'// индекс поля
    },
    {
        text: 'Description',
        dataIndex: 'description'
    },
    {
        text: 'Owner',
        dataIndex: 'owner'
    }
];

var fields= ['name', 'description','owner']; // порядок отображения полей

Дальше идет схожий с предыдущими вариантами код, за исключением данных, в которых указываются те же поля, что и в fields.

Ext.create('Ext.tree.Panel', {
   renderTo: 'ex5',
   id:'tree',
   autoscroll:true,
   title: 'TreeGrid',
   height: 150,
   fields: fields,
   columns: cols,
   root: {
       name: 'Root',
       description: 'Root description',
       owner: 'Root owner',
       expanded: true,
       children: [
           {
               name: 'Child 1',
               description: 'Description 1',
               owner: 'owner 1',
               leaf: true
           },
           {
               name: 'Child 2',
               description: 'Description 2',
               owner: 'owner 2',
               leaf: true
           }
       ]
   }
});

ExtJS Form Формы, поля ввода, чебоксы и селекторы

Начнем с создания формы с единственным полем ввода input.

var name = new Ext.form.TextField({
    fieldLabel:'Фамилия И.О.',
    name:'name',
    value:'Неизвестнй Б.П.',
    id:ex1
});

var form = new Ext.FormPanel({// инициализация панели с формой
    renderTo: 'ex0',// результат поместить в контейнер с ID='ex0'
    items:[name] // массив элементов формы или их конфигураций
});

Выше расположенный код эквивалентен следующему:

var form = new Ext.FormPanel({ // инициализация панели с формой
    renderTo: 'ex0' // результат поместить в контейнер с ID='ex0'
    items:[{ // массив элементов формы или их конфигураций
        xtype:'textfield',
        fieldLabel:'Фамилия И.О.',
        name:'name',
        value:'Неизвестный Б.П.'
    }]
});

В результате выполнения данного кода ExtJS выведет на экран форму следующего вида.



Вывод простого текстового поля:

new Ext.form.TextField({
   fieldLabel:'Фамилия И.О.', // текст для label
   name:'fio', // параметр name для input
   value:'Неизвестный Б.П,', // дефотлное значение
   renderTo: 'ex1'// результат поместить в контейнер с ID='ex1'
});



То же самое поле но сделаное недоступным для ввода:

new Ext.form.TextField({
    fieldLabel:'должность',
    name:'position',
    value:'лаборант',
    renderTo: 'ex2',
    disabled: true
});



То же самое поле но с размещенной в нем подсказкой, которая появляется когда поле пустое.

new Ext.form.TextField({
    fieldLabel:'E-mail',
    name:'mail',
    emptyText:'Введите сюда любой адрес электронной почты',
    renderTo: 'ex3',
    width:500
});



Для использования поля ввода Textarea воспользуйтесь следующим кодом:

new Ext.form.field.TextArea({
    renderTo: 'ex4',
    name: 'message',
    fieldLabel: 'Биография',
    width:500
});



Так выводится поле для загрузки файлов:

new Ext.form.field.File({
    renderTo: 'ex5',
    name: 'photo',
    fieldLabel: 'Фото 3x6',
    labelWidth: 100,
    buttonText: 'Select Photo…'
});



Код поля для ввода чисел с селектором:

new Ext.form.field.Number({
    renderTo: 'ex6',
    name: 'age',
    fieldLabel: 'Возраст',
    value: 33,
    maxValue: 65,
    minValue: 16
});



Поле без окошка ввода, но с выводом текста, который также может быть оформлен с помощью CSS:

new Ext.form.field.Display({
    renderTo: 'ex8',
    fieldLabel: 'Просто Текст',
    name: 'any-text',
    value: 'просто какой-то текст'
    //  fieldCls :'red' - задать CSS-класс
    //  value: '<em>текст курсивом</em>' - вывести HTML
});



Код вывода селектора с выводом времени:

new Ext.form.field.Time({
    renderTo: 'ex9',
    name: 'time',
    format: 'H:i', //  формат времени: 24 часа в сутках
    fieldLabel: 'Время',
    minValue: '8:00',
    maxValue: '23:00',
    value:'15:00',
    increment: 30,
    anchor: '100%'
});



Поле ввода даты со всплывающим календарем:

new Ext.form.field.Date({
   new Ext.form.field.Date({
     renderTo: 'qqq',
     xtype: 'datefield',
     anchor: '100%',
     fieldLabel: 'From',
     name: 'from_date',
     maxValue: new Date() // Ограничено вводом текущей даты или ранее
 });
});



Скрытое поле:

<input type="hidden" name="hidden_field_1" value="value from hidden" />

new Ext.form.field.Hidden({
    renderTo: 'ex111',
    xtype: 'hiddenfield',
    name: 'hidden_field_1',
    value: 'value from hidden field'
});



WYSIWYG-редактор. Обычно его не используют.
Код для вывода редактора на экран:


Ext.create('Ext.form.HtmlEditor', {
    width: 580,
    height: 250,
    renderTo: 'ex2'
});



Комбобокс:

Ext.onReady(function(){ // отрабатывается по готовности DOM
    new Ext.form.ComboBox({
        renderTo: 'ex1',
        fieldLabel: 'Страна',
        store:  {            // конфигурация хранилища
                  fields: ['domen', 'name'],
                  data: [
                          {'domen':'ru', 'name':'Россия'},
                          {'domen':'ua', 'name':'Украина'},
                          {'domen'':'bf', 'name':'Буркино-Фасо'}
                        ]
                },
        displayField: 'name', // это текстовое значение <option>…</option>
        valueField: 'domen'   // а это значение поля <option value="…">
    });
});



Чекбоксы:

new Ext.form.FieldContainer({
    fieldLabel: 'Ваш заказ',
    defaultType: 'checkboxfield', // дефолное значение xtype
    items: [
        {
            xtype:  'checkboxfield', // если указан defaultType, то не обязательно
            boxLabel: 'Водка',
            name: 'order',
            inputValue: '1',
            checked: true // выбрано
        }, {
            boxLabel: 'Девочки',
            name: 'order',
            inputValue: '2'
        }, {
            boxLabel: 'Семечки',
            name: 'order',
            inputValue: '3'
        }
    ],
    renderTo: 'ex3'
});



Радио-кнопки:

new Ext.form.FieldContainer({
    fieldLabel: 'Ваш заказ',
    defaultType: 'radiofield', // дефолное значение xtype
    items: [
        {
            boxLabel: 'Водка',
            name: 'order2',
            inputValue: '1',
            checked: true,  // выбрано
            id: 'radio1'
        }
    ],
    renderTo: 'ex4'
});



Submit формы:

new Ext.form.FormPanel({ // инициализация панели с формой
    bodyStyle:'padding: 10px',
    width:400,
    renderTo: 'ex0', // результат поместить в контейнер с ID='ex0'
    id: 'login-form', // ID панели. Он понадобится для сабмита формы
    bodyStyle: 'padding:15px;',
    url:'test.php', // url по которому будет оправлена форма
    items: [ // массив полей формы
            {   xtype: 'textfield',
                fieldLabel: 'Login',
                name: 'login' // имя поля <input name="login"

            },
            {
                xtype: 'textfield',
                name: 'pass', // имя поля <input name="pass"
                fieldLabel: 'Password',
                inputType: 'password' // Не просто textfield, а  password

            }],
    buttons: [{  // Набор кнопок. Здесь она всего одна.
                text: 'Login',
                handler: function(){
                    Ext.getCmp('login-form') // По ID адресуемся к панели
                    .getForm() // берем форму
                    .submit();
                }
    }]
});



Для отправления сообщения в форму ввели кнопку, на которую навесили функцию отвечающую за отправление данных формы.

Сначала определяется форма, данные из которорй нужно отправить на сервер. При инициализации этой форме мы указали свой внутренний ID компонента id: 'login-form'.
Теперь к этому компоненту можно обратиться следующим образом:
Ext.getCmp('login-form') - getCmp посволяет получить компонент по id.
Из полученного компонента вытаскиваем форму Ext.getCmp('login-form').getForm()
Вызываем метод submit формы.

Теперь можно рассмотреть подробнее параметры Submit.

.getForm() // берем форму
.submit({  // сабмитим
        success: // устанавливаем обработчик нормального завершения
        function(form, action){ //  action.result - json отклик сервера Ext.Msg.alert(action.result.msg);}  
                                    },
        failure: // устанавливаем обработчик ошибки
        function(form, action){ Ext.Msg.alert(action.result.msg);}
});

В качестве данных передается объект, в котором указаны действия, которые отвечают за получение отклика сервера:
success - удачный результат;
failure - неудачный результат.

Сервер должен прислать ответ в формате JSON, в котором в качестве подтверждения должно быть свойство "success", которое свидетельствует о том что обработка прошла успешно.
Пример отклика сервера об успешной обработке:

{success:true,myFirstMsg:'OK!'}

Пример отклика сервера при ошибке:

{success:false,msg:'Error for example!'}

Через failure так же можно передавать поля и тексты для вывода сообщений об ошибке.