JavaScript: React, NodeJS, jQuery, Ext и т.д. + html 5 + Google App Engine

Динамическое предоставление томов в Kubernetes

2024-11-04T22:02:00.004+02:00

Динамическое предоставление томов дает возможность создания томов по требованию. Без динамического представления админисраторы кластера должны вручную обращаться к своим облачным хранилищам или службам хранения данных для создания новых томов, а затем создавать объекты персистентных томов PersistentVolume для представления этих хранилищ в Kubernetes. Функция динамического представления убирает необходимость предварительной подготовки хранилища администраторами кластера. Вместо этого, она автоматически представляет хранилище, когда пользователь создает объекты PersistentVolumeClaim.

Общая информация

Реализация динамического предоставления томов основана на объекте класса хранилища (StorageClass) в API, который находится в API группе storage.k8s.io. Администратор кластера может определить необходимое количество обьектов классов хранилища, в каждом их которых указывается плагин для тома (aka представитель), который предоставляет том и набор параметров для передачи представителю при предоставлении. Администратор кластера может определить и представить множество разновидностей хранилищ (от одной или разных систем хранения данных) в кластере, каждый с собственным набором параметров. Этот подход также избавляет конечного пользователя от сложностей и нюансов процесса выделения хранилища, но все еще дает возможность выбора из множества возможных хранилищ.

Дополнительную информацию о классах хранилищ можно найти по адресу: https://kubernetes.io/docs/concepts/storage/storage-classes/

Включение динамического предоставления

Чтобы включить динамическое предоставление, админисратору кластера нужно предварительно создать один или более объектов StorageClass для пользователей. Объекты StorageClass определяют какой надо использовать плагин преддоставления и какие параметры следует ему передавать когда будет вызвано динамическое предоставление. Имя объекта StorageClass должно быть валидным DNS именем субдомена.

Следующий манифест создает класс хранилища "slow" который предоставляет персистентные диски, похожие на стандартные.

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
name: slow
provisioner: kubernetes.io/gce-pd
parameters:
type: pd-standard

Следующий манифест создает класс хранилища "fast" который предоставляет персистентные диски, похожие на SSD.

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
name: fast
provisioner: kubernetes.io/gce-pd
parameters:
type: pd-ssd

Использование динамического предоставления

Пользователи запрашивают динамически-предоставляемые хранилища включая класс хранилища в свои манифесты PersistentVolumeClaim. До версии Kubernetes v1.6 это делалось через аннотацию volume.beta.kubernetes.io/storage-class. Однако, эта аннотация стала устаревшей с версии 1.9. Пользователи теперь могут и должны вместо этого использовать поле storageClassName объекта PersistentVolumeClaim. Значение этого поля должно совпадать с именем класса хранилища StorageClass, сконфигурированного администратором (смотри далее).

Чтобы выбрать класс хранилища "fast", пользователь должен был бы создать следующий PersistentVolumeClaim:

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
name: claim1
spec:
accessModes:
- ReadWriteOnce
storageClassName: fast
resources:
requests:
storage: 30Gi

Это требование повлечет автоматическое предоставление персистентного диска типа SSD. При удалении требования, том также будет удален.

Поведение по умолчанию

Может быть выставлено такое динамическое предоставление в кластере, что если не указан класс хранилища, то они все считаются динамическими. Администратор кластера может включить это поведение так:

Пометить один объект класса хранилищ по умолчанию;
Убедиться, что контроллер допуска DefaultStorageClass включен в API сервере.

Администратор может пометить конкретный StorageClass по умолчанию, добавив ему аннотацию storageclass.kubernetes.io/is-default-class. Когда в кластере существует класс хранилища по умолчанию и пользователь создает PersistentVolumeClaim, в котором не указан storageClassName, то контроллер допуска DefaultStorageClass автоматически добавляет поле storageClassName, которое указывает на класс по умолчанию.

Если создать более одного класса хранилищ по умолчанию в кластере, то в таком случае будет использоваться самый последний класс, назначенный классом по умолчанию.

В мульти-зональных кластерах Поды могут быть распределены по зонам в регионе. Однозональные сервисы хранения данных должны в этом случае присутствовать на всех зонах, где будут эти Поды. Это можно настроить установкой режима монтирования томов Volume Binding Mode.

Источник перевода: https://kubernetes.io/docs/concepts/storage/dynamic-provisioning/

Как сделать простое расширение для Chrome. Простой пример из документации. Перевод (вольный).

2022-02-15T09:28:00.005+02:00

Расширения - набор файлов, содержащих отдельные, но работающие совместно компоненты.

Эти компоненты могут быть фоновыми скриптами, контентными скриптами, страницами настроек, элементами пользовательского интерфейса и различными файлами с логикой. Для создания этих компонентов используются технологии интернет-разработки: HTML, CSS и JavaScript. Компоненты расширения могут выполнять различные функции и ни один компонент не является обязательным.

В этом примере мы создадим расширение, которое позволит пользователю менять цвет фона текущей просматриваемой в браузере страницы. Расширение будет использовать несколько компонентов платформы расширений, чтобы дать представление для начала работы с ними и связями между ними.

Для начала, создадим директорию, где будут находиться файлы расширения.

Создайте файл манифеста.

Работа расширения начинается с его манифеста. Создайте файл с именем manifest.json и скопируйте в него следующий код:

{

"name": "Getting Started Example",

"description": "Build an Extension!",

"version": "1.0",

"manifest_version": 3

}

Фактически мы уже создали расширение, которое можем загрузить в браузер. Директория, содержащая файл манифеста может быть добавлена как расширение в режиме разработчика. Для этого:

Откройте страницу управления расширениями chrome://extensions. Можно также найти ее через пункт в меню "Дополнительные инструменты - Расширения".

Включите режим разработчика с помощью переключателя справа.

Нажмите кнопку "Загрузить распакованное расширение" и выберите директорию с нашим расширением.

Вот и все! Расширение успешно установлено и мы можем видеть далее результаты нашей разработки. Мы пока еще не включили в манифест собственные иконки для отображения, поэтому браузер использовал стандартные.

Добавляем функциональность

Итак, расширение установлено, но оно пока ничего не делает, так как пока у нас есть только файл манифеста и все. Давайте исправим это и добавим немного кода для хранения значения цвета, который мы будем использовать для покраски фона открытой страницы.

Регистрация фонового скрипта в манифесте.

Фоновые скрипты, как многие другие важные компоненты расширения, должны быть зарегистрированы в манифесте. Это своего рода реестр ресурсов, которые может использовать расширение. Регистрация фонового скрипта в манифесте сообщит расширению ссылку на файл и как этот файл надо обрабатывать.

{

"name": "Getting Started Example",

"description": "Build an Extension!",

"version": "1.0",

"manifest_version": 3,

"background": {

"service_worker": "background.js"

}

Теперь Chrome знает, что расширение имеет сервисный обработчик (фоновый скрипт). Когда вы перезагрузите расширение, Chrome обнаружит указанные дополнительные инструкции, такие как важные события, которые необходимо отслеживать, например.

Создадим фоновый скрипт

Этому расширению необходимо получать информацию из какой то постоянной переменной после того как расширение будет установлено. Начнем с отслеживания события установки расширения runtime.onInstalled в фоновом скрипте. Внутри обработчика onInstalled расширение создаст и установит значение переменной в хранилище Storage API, используемом браузером для хранения информации. Это даст возможность нескольким компонентам расширения получать эту информацию и обновлять ее. В папке расширения создадим файл background.js и добавим следующий код:

// background.js

let color = '#3aa757';

chrome.runtime.onInstalled.addListener(() => {

chrome.storage.sync.set({ color });

console.log('Default background color set to %cgreen', `color: ${color}`);

});

Этот код просто записывает в хранилище расширения значение переменной color в момент установки расширения и выводит сообщение об этом в консоль страницы фонового скрипта расширения.

Добавление разрешения на работу с хранилищем

Большинство API, включая и API для работы с хранилищем, должны быть зарегистрированы в поле "permissions" в манифесте, чтобы расширение могло использовать эти API.

{

"name": "Getting Started Example",

"description": "Build an Extension!",

"version": "1.0",

"manifest_version": 3,

"background": {

"service_worker": "background.js"

"permissions": ["storage"]

}

Просмотр фонового скрипта в браузере.

Откройте страницу управления расширением и кликните на ссылку перезагрузки с круговой стрелкой. Появится новое поле Отладка страниц с синей ссылкой service worker.

Кликнем на эту ссылку и увидим вывод в консоли от фонового скрипта, "Default background color set to green".

Пользовательский интерфейс расширения.

Расширения могут иметь множество вариантов интерфейса пользователя; в нашем примере мы будем использовать popup - всплывающее окно. Создадим в папке расширения файл popup.html. Наше расширение будет использовать кнопку для изменения фонового цвета страницы. Вот код:

<!DOCTYPE html>

<html>

<head>

</head>

<body>

</body>

</html>

Как и в случае с фоновым скриптом, этот файл тоже должен быть объявлен в манифесте, чтобы указать браузеру Chrome, что он будет использоваться для вывода всплывающего окна расширения. Чтобы это сделать добавим поле action в манифест и установим в нем свойству default_popup значение с именем нашего скрипта popup.html.

{

"name": "Getting Started Example",

"description": "Build an Extension!",

"version": "1.0",

"manifest_version": 3,

"background": {

"service_worker": "background.js"

"permissions": ["storage"],

"action": {

"default_popup": "popup.html"

}

В нашем файле есть ссылка на внешнюю таблицу стилей button.css. Давайте напишем ее. Создадим файл button.css и добавим код:

button {

height: 30px;

width: 30px;

outline: none;

margin: 10px;

border: none;

border-radius: 2px;

}

button.current {

box-shadow: 0 0 0 2px white,

0 0 0 4px black;

}

Также добавим иконки панели инструментов в поле default_icons. Вы можете скачать их здесь.

Распакуйте их и поместите в папку расширения. Обновим манифест, чтобы браузер узнал о них.

{

"name": "Getting Started Example",

"description": "Build an Extension!",

"version": "1.0",

"manifest_version": 3,

"background": {

"service_worker": "background.js"

"permissions": ["storage"],

"action": {

"default_popup": "popup.html",

"default_icon": {

"16": "/images/get_started16.png",

"32": "/images/get_started32.png",

"48": "/images/get_started48.png",

"128": "/images/get_started128.png"

}

Расширение также показывает изображения на странице управления расширения, предупреждений о разрешениях от пользователя и избранном. Эти изображения-иконки также указываются в манифесте при необходимости:

{

"name": "Getting Started Example",

"description": "Build an Extension!",

"version": "1.0",

"manifest_version": 3,

"background": {

"service_worker": "background.js"

"permissions": ["storage"],

"action": {

"default_popup": "popup.html",

"default_icon": {

"16": "/images/get_started16.png",

"32": "/images/get_started32.png",

"48": "/images/get_started48.png",

"128": "/images/get_started128.png"

}

"icons": {

"16": "/images/get_started16.png",

"32": "/images/get_started32.png",

"48": "/images/get_started48.png",

"128": "/images/get_started128.png"

}

По-умолчанию, расширения появляются в меню расширений. Если его закрепить, то появится иконка расширения прямо на панели инструментов браузера.

Если на этом этапе перезагрузить расширение, оно будет включать уже свою иконку вместо иконки, подставляемых по-умолчанию при отсутствии собственных иконок. Если мы кликнем на эту иконку расширения в панели инструментов, то откроется небольшое всплывающее окошко, показывающее цвет, используемый для покраски фона страницы, который будет по-умолчанию.

Последний шаг для интерфейса этого окна это изменение цвета кнопки. Создадим для этого скрипт popup.js со следующим кодом и также добавим его в папку расширения:

// Инициализируем кнопку предпочитаемым пользователем цветом

let changeColor = document.getElementById("changeColor");

chrome.storage.sync.get("color", ({ color }) => {

changeColor.style.backgroundColor = color;

});

Этот код получает элемент кнопки из файла popup.html и запрашивает значение цвета из хранилища. Затем он применяет этот цвет в качестве фонового для самой кнопки. Подключим этот скрипт к странице popup.html.

<!DOCTYPE html>

<html>

<head>

</head>

<body>

</body>

</html>

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

Логика слоев

Теперь у расширения есть собственная иконка и всплывающее окно свойств с кнопкой и оно меняет фоновый цвет кнопки на то значение, которое записано в хранилище расширения (мы изначально записали это значение при установке расширения в фоновом скрипте). Дальше нам нужно логика для взаимодействия с пользователем. Обновим код popup.js, добавим строки в конец файла:

// При нажатии кнопки, инжектируем функцию setPageBackgroundColor в код текущей просматриваемой страницы в браузере.

changeColor.addEventListener("click", async () => {

let [tab] = await chrome.tabs.query({ active: true, currentWindow: true });

chrome.scripting.executeScript({

target: { tabId: tab.id },

function: setPageBackgroundColor,

});

// Эта функция выполнится как контентный скрипт внутри текущей открытой страницы

function setPageBackgroundColor() {

chrome.storage.sync.get("color", ({ color }) => {

document.body.style.backgroundColor = color;

});

}

Теперь обновленный код добавляем обработчик нажатия кнопки, который запускает функцию как контентный скрипт. Этот код присваивает цвету страницы значение фонового цвета кнопки расширения, а точнее значение, записанное в хранилище расширения для этой кнопки. Использование программной инжекции позволяет использовать вызываемые пользователем контентные скрипты вместо авто-вставки ненужного кода в сами вэб-страницы.

Нам понадобится добавить разрешение activeTab, чтобы позволить расширению доступ к текущей странице и скриптовое расширение для использования метода executeScript из Scripting API. Добавим их:

{

"name": "Getting Started Example",

...

"permissions": ["storage", "activeTab", "scripting"],

...

}

Теперь расширение полностью функционально. Перезагрузите его, обновите страницу, откройте всплывающее окно расширения и нажмите кнопку, чтобы перекрасить фон страницы в зеленый. Однако, некоторые пользователи захотят изменить этот фоновый цвет на другой.

Важная заметка!

Расширения не могут инжектировать контентные скрипты на внутренние страницы Chrome, такие как "chrome://extensions" и т.п. Тестируйте его на реальных интернет-сайтах, вроде https://google.com.

Дадим пользователю настройки расширения

На данный момент расширение позволяет изменять фоновый цвет страницы только на зеленый цвет. Подключение страницы настроек дает пользователям больше контроля над функциональностью расширения, а значит и браузера в целом.

Начните с создания в папке расширения файла options.html со следующим кодом.

<!DOCTYPE html>

<html>

<head>

</head>

<body>

</div>

<div>

<p>Choose a different background color!</p>

</div>

</body>

</html>

Теперь зарегистрируем эту страницу настроек в манифесте:

{

"name": "Getting Started Example",

...

"options_page": "options.html"

}

Перезагрузим расширение и кликнем на иконке расширения в панели браузера правой кнопкой мыши и выберем пункт Параметры.

Последний шаг это добавить логику параметров. Создадим файл с именем options.js в папке расширения и добавим в него код:

let page = document.getElementById("buttonDiv");

let selectedClassName = "current";

const presetButtonColors = ["#3aa757", "#e8453c", "#f9bb2d", "#4688f1"];

// обработаем нажатие кнопки окрасив выбранную кнопку и сохраняя выбор

function handleButtonClick(event) {

// Удалим стиль предыдущего выбранного цвета

let current = event.target.parentElement.querySelector(

`.${selectedClassName}`

);

if (current && current !== event.target) {

current.classList.remove(selectedClassName);

}

// Пометим кнопку как выбранную

let color = event.target.dataset.color;

event.target.classList.add(selectedClassName);

chrome.storage.sync.set({ color });

}

// Добавим кнопку на страницу для каждого предоставляемого цвета

function constructOptions(buttonColors) {

chrome.storage.sync.get("color", (data) => {

let currentColor = data.color;

// для каждого цвета мы ...

for (let buttonColor of buttonColors) {

// ... создаем кнопку этого цвета

let button = document.createElement("button");

button.dataset.color = buttonColor;

button.style.backgroundColor = buttonColor;

// …отмечает кнопку выбранного цвета…

if (buttonColor === currentColor) {

button.classList.add(selectedClassName);

}

// … и регистрируем обработчик нажатия кнопки

button.addEventListener("click", handleButtonClick);

page.appendChild(button);

}

});

}

// Инициализируем страницу, соберем настройки цвета

constructOptions(presetButtonColors);

На странице настроек будем представлено четыре кнопки с цветами и обработчиками событий. Когда пользователь нажимает на кнопку, она обновляет значение цвета в хранилище расширения. Так как все файлы расширения получают информацию об этом цвете из этого хранилища, больше ничего обновлять не требуется.

На этом простой пример создания расширения завершен.

Эта страница является переводом https://developer.chrome.com/docs/extensions/mv3/getstarted/ с небольшими отступлениями от точного текста.

Кратко о Google Apps Script

2015-03-23T08:11:00.000+02:00

Google App Script - это язык скриптов, основанный на JavaScript, с помощью которого вы можете разработать или добавить новый функционал для таких приложений Google, как Google Docs, Sheets и Forms.

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

Apps Script достаточно универсален. Вот некоторые функции, которые вы можете создать с его помощью:

- добавить собственные меню, диалоговые окна или панели в документах Google Docs, Sheets или Forms.

- создавать собственные функции для Google Sheets

- создавать приложения web apps и публиковать их как самостоятельные или встраиваемые в Google Sites

- взаимодействовать с другими сервисами Google: Adsense, Analytics, Calendar, Drive, Gmail и Maps.

Чтобы посмотреть работу App Script в действии, посмотрите 5-минутные быстрые примеры:

Макросы, меню и собственные функции - улучшите ваши Google Sheets с помощью дополнительных функций и создавайте собственные отчеты на основе таблиц.

Управляйте ответами на формы Google Forms - уведомляет через службу календаря всех пользователей, заполнивших форму.

Продолжение следует...

Google App Engine - система авторизации и аутентификации пользователей. Регулируем и экономим.

2014-04-03T15:15:00.002+03:00

Еще раз возвращаюсь к Google App Engine и обдумыванию реализации авторизации и аутентификации пользователей на сайте.
Конечно, можно предположить, что все наши посетители - пользователи Google и на этом сильно сэкономить :), однако предположим, что большинство из них не обладает учеткой Google, либо не хочет светить ее и акцептировать наш сайт.

Возьмем все труды по ведению базы пользователей на себя.
При традиционной реализации, с учетом, что надо сделать надежную систему, накладные ресурсы будут расти как на дрожжах.
А потому введем некоторые ограничения.
Система будет работать на основе сессий. Сессия будет генерироваться и записываться в кукис браузера пользователя только после прохождения аутентификации на сайте.
Этот момент уже убирает нагрузку по работе с БД. Ну, точнее расходы, связанные с операциями с БД.
Кукис с сессией должен иметь разумный срок хранения в пределах суток - устанавливая его длительность можем регулировать "расходы".
Кукис должны удаляться принудительно только при выходе из системы самим пользователем или автоматически при истечении срока хранения (скажем - сутки).
Далее..
Допустим, пользователь залогинился, походил и отошел.. кукис еще в браузере.
При заходе на сайт имеем ситуацию - пускать его автоматом в "кабинет" или заставлять логиниться?
Тут мы должны определиться для себя на сервере - незакрытые сессии мы храним, ну или считаем активными в течение допустим суток!
Какие накладные "расходы" в этом случае?
Мы должны обновлять маркер времени активности пользователя. Он находится в БД. Как сэкономить?
Использовать Memcache конечно. Изначально, мы доверяем нашему Memcache, так как никто кроме нас туда "залезть" не может.
То есть и временную метку мы будем хранить тамже, как и сессию и логин.
Тогда, расходы по считыванию из БД у нас возникнут только при сбросе Memcache.
Рабочий момент - обновлять метку времени в самой БД, если она удовлетворяет правилу - не больше суток dt не нужно.
В таком варианте обновление БД и расходы будут только когда дельта времени уже выйдет за дозволенные рамки. И только тогда нам необходимо будет обновлять метку сессии и времени. А это уже черевато либо логином, либо "доверяем" - хотя есть еще варианты.
Имеем гарантированный "расход" на запись только при:
Аутентификации.
Выходе из системы.
Просрочке метки времени в БД более установленного нами интервала.

Регулируется нагрузка на БД в нашем варианте двумя параметрами - времени жизни кукис и разрешенным интервалом активности сессии на сервере.
Регулируя первый - изменяем количество запросов на чтение.
Регулируя второй параметр - количество запросов на запись.

Борьба с ботами и зловредами монтируется отдельно. Варианты есть.

DocPad. Документация по-русски

2013-12-17T10:23:00.003+03:00

Что такое DOCPAD?

Мода на генераторы статических сайтов не пройдет никогда, и вот одним из таких инструментов для управления и создания сайтов является DocPad. Он создан на основе Node.js и Express.js.
Описывать установку, пожалуй не буду, перейду сразу к докам для начинающих.

С чего начинается создание сайта с помощью DocPad?

Ну конечно же с папки в которой все будет хранится! )))
Ну и как предлагает нам официальная документация (для стартового проекта используем рекомендуемое имя), назовем папку my-new-website, что по-ангельски означает "мой-новый-вэбсайт"!
Открываем командную строку Node.JS и топаем в папку с помощью команды:
cd путь_к_папке/my-new-website
Запускаем docpad командной
docpad run
Процесс пошел (в первый раз при запуске вам нужно будет согласится с предлагаемым множеством букав) и вам выпадет список предлагаемых заготовок-скелетонов. Нам нужен пустой (вводим цифирь 20)! Так что выбираем No Skeleton. Ну и ввод!
Побежит кучка строчек и все это дело в конце "зависнет" мигающим курсором.
Сие означает что наш сайт сгенерировался в первый раз и ожидает нас по адресу http://localhost:9778/
Откроем его в браузере.. а там пока пусто.. что и следовало ожидать. Ну не совсем пусто..Тупо - текст "Not Found", что одно и тоже.
Вообщем процесс работает и отслеживает все дела. Чтобы прервать и вывести его из забытия давим CTRL-C и соглашаемся с предложением об амине.

И что дальше?

После того, как мы выбрали No Skeleton, товарищ docpad создал в нашей папке проекта кучу своих подпапок по стандарту
Нас интересует папочка src - там будут храниться закрома Родины. А сейчас там внутри три папки: documents, files и layouts.
Давайте создадим первую страницу сайта!
Для этого в папке documents создаем пустой файл под названием index.html и напхаем в него обычного html-ного содержимого:
Welcome! | My Website
Welcome!
Welcome to My Website!
<html> <head> <title>Welcome! | My Website</title> </head> <body> <h1>Welcome!</h1> <p>Welcome to My Website!</p> </body> </html

Теперь топаем в нашу командную строку и заново запускаем docpad run!
Открываем заветный http://localhost:9778/
Ну и видим:
Welcome!
Welcome to My Website!

И в чем прикол? Может без всей этой пурги можно было такой файлик создать, да открыть в хроме... Технологии однако.. Вот дальше и будет интереснее!

Продолжение банкета. Шаблоны для ленивых.
Для того, чтобы не расслабляться, авторы предлагают создать нам еще одну страницу - About.html
Ну послушаемся и пройдет в папку documents, где и создадим файл about.html
Напихаем в него чего-нить символичного вроде:
<html> <head> <title>About Me | My Website</title> </head> <body> <h1>About Me</h1> <p>I like long walks on the beach. <strong>Plus I rock at DocPad!</strong></p> </body> </html> About Me | My Website
About Me
I like long walks on the beach. Plus I rock at DocPad!

Кто не в теме - там про прогулки по пляжу и крутого перца, рулящего Docpad-ом. ))
Вообщем имеем две страницы - index и about.
Открываем адресок
http://localhost:9778/about.html
А там опять нихрена... Ну так надо docpad остановить и запустить заново )))
И тогда нам явится что-то вроде:
About Me I like long walks on the beach. Plus I rock at DocPad!

Ну.. давайте еще десять страниц создадим? ))) Шучу ))
Дальше товарищи создатели справедливо пишут - крутые перцы черную работу перекладывают на коней! Не будь конем!
И вот тут они предлагают пользоваться шаблонами.
Топаем в папку layouts и создаем файл default.html.eco
И не пугайтесь такого количества точек. Это значит что файл сначала обработается шаблонизатором eco ))
Создатели тупо предлагают наполнить сей файл содержимым следующего рода:
<%= @document.title %> | My Website
<%= @document.title %>
<%- @content %> <html> <head> <title><%= @document.title %> | My Website</title> </head> <body> <h1><%= @document.title %></h1> <%- @content %> </body> </html>

И что это? Пока не знаем.. идем дальше!
Далее, открываем наш старый файлик index.html и стираем всю ботву, что там писали. Взамен берем перо и пишем:
--- title: "Welcome!" layout: "default" isPage: true --- Welcome to My Website!

Каково? А это еще не все. Открываем еще и about.html и пишем вместо старых требухов:
--- title: "About Me" layout: "default" isPage: true --- I like long walks on the beach. Plus I rock at DocPad!

Вот оно чо, Михалыч! А чо это, собственно?
Ну я не знаю, как вы, а я вижу, что зазря копипастил тучу текста )
Теперь можно просто указать в файле title, файл шаблона, дать понять, что это страница (isPage-true), ну и после --- накалякать собственно содержимое, которое в файле шаблона будет выведено вместо <%- @content %>

Ого! Технология, однако! Это ж куча времени теперь сэкономиться )))
Но это только вступление.. Продолжение будет. А теперь срочно в библиотеку и читать что-нить от головы.

Рассылка писем с помощью SendGrid из Google App Engine

2013-07-29T10:44:00.000+03:00

Этот пост от Адама ДюВандера, директора по коммуникациям в SendGrid. SendGrid это облачный почтовый сервис, доставляющий электронную почту от имени компаний для улучшения связей и общения с клиентами. Интеграция новых или существующих систем почты осуществляется через SMTP или через REST API. В этом посте Адам рассказал как интегрировать SendGrid в приложение на Google App Engine.

Если вы разрабатываете приложения для Интернет или мобильной среды, вам необходим эффективный способ общения с клиентами. Создание и поддержание собственной инфраструктуры SMTP может занять много ресурсов и станет дорогим удовольствием. SendGrid исключает затраты и сложности по работе с электронной почтой, так что вы можете сосредоточиться на разработке своего следующего экстраординарного приложения.

Разработчики, использующие Google App Engine могут легко интегрировать SendGrid в собственные приложения. В примере ниже я покажу вам, как использовать нашу библиотеку Python. Java и PHP разработчики также имеют такую возможность. Любой разработчик Google App Engine может зарегистрироваться на SendGrid и рассылать бесплатно 25000 писем ежемесячно, так что ждем Вас!

Сначала, скопируйте библиотеку Python SendGrid в ваш проект в соответствующую папку. Когда вы импортируете эту библиотеку в ваше приложение, вы сможете создавать экземпляры SendGrids и рассылать почту с помощью простых команд.

Итак, вначале:
from sendgrid import Sendgrid
from sendgrid import Message

Теперь, в приложении можно отсылать почту с помощью нескольких строк:
# make a secure connection to SendGrid
s = sendgrid.Sendgrid('', '', secure=True)
# make a message object
message = sendgrid.Message("from@mydomain.com", "message subject", "plaintext message body",
"HTML message body")
# add a recipient
message.add_to("someone@example.com", "John Doe")
# use the Web API to send your message
s.web.send(message)

Также SendGrid предоставляет информацию о ваших письмах, например с помощью EventAPI вы можете узнать когда была доставлена, прочитана почта и множество других событий.

Новости блога Google AppEngine

2012-11-08T22:01:00.002+03:00

6 ноября в блоге появилась статья общего характера, в которой говориться следующее:

С момента появления новой среды Python версии 2.7 в феврале на нее успели перейти более половины всех активных приложений AppEngine.

Что же такого замечательного пришло вместе с Python 2.7? Это не просто обновление версии языка, это множество улучшений и изменений, способных значительно повлиять на эффективность выполнения приложений в среде Google AppEngine.

Увеличение эффективности параллельных запросов. Теперь всего лишь один фронтенд-экземпляр может обрабатывать сразу несколько запросов одновременно в разных потоках. А это значит, что теперь AppEngine требуется значительно меньше экземпляров для обработки того же объема трафика, а это значит значительное уменьшение стоимости работы сервиса.

Небольшая, но энергично-растущая компания мобильных игровых приложений Pocket Gems смогла снизить расходы на запуск фронтенд-экземпляров на 78%, когда они перешли на работу со средой Python 2.7. "Мы сразу же увидели значительную разницу." - заявил технический директор Дэвид Ундерхил. Нам теперь было достаточно лишь одной трети ресурсов, работающих на Python 2.7, чтобы справляться с тем же объемом трафика и задач под Python 2.5.

Более быстрые и более "нативные" С модули. В среду Google AppEngine были добавлены более быстрые "нативные" С-модули. Базовые библиотеки, такие как например cPickle выполняются значительно быстрее, чем их эквиваленты в среде исполнения Python 2.5.

Воспользуйтесь популярными сторонними библиотеками вроде PIL или NumPy. Мы значительно расширили количество библиотек сторонних разработчиков, которые теперь можно использовать в Google AppEngine Python 2.7.

Google Apps Script - язык для удобства )

2012-08-21T22:48:00.002+03:00

В поисках материалов по интернету о Google App Engine попалась информация по интересному проекту Google Apps Script. Очень многообещающе - начал изучать. Очередной сюрприз от Google для меня :) Не устаю удивляться.

Надо будет попереводить, потренироваться.

Google App Engine. Обзор хранилища данных

2012-05-29T19:48:00.000+03:00

Хранение данных https://developers.google.com/appengine/docs/python/datastore/overview

Среда App Engine предоставляет несколько вариантов для хранения данных:

App Engine Datastore предоставляет NoSQL безсхемное хранилище с языком запросов и атомарными транзакциями
Google Cloud SQL предоставляет реляционную SQL базу данных для приложений App Engine, основываясь на знакомой базе MySQL
Google Cloud Storage предоставляет сервис хранения для объектов и файлов размером до терабайтов

Python API хранилища данных

App Engine Datastore это безсхемное объектное хранилище предоставляющее надежное, масштабируемое хранилище для вашего вэб-приложения без плановых простоев, с атомарными транзакциями, высокодоступными чтением и записью, строгой согласованностью при запросах чтения и в конечном итоге всех иных запросов. Интерфейс хранилища включает в себя обширное API моделирования данных и похожий на SQL язык запросов, называемый GQL.

Вступление

Хранилище App Engine содержит объекты с данными, так называемыми сущностями. Сущность имеет одно или множество свойств — именованных значений одного из нескольких поддерживаемых типов данных: например свойство может быть строкой, числом или ссылкой на другую сущность. Каждая сущность идентифицируется по виду (типу), который определяет ее для выполнения запросов, а также уникальный ключ, который идентифицирует ее внутри этого вида.

Хранилище может выполнять множество операций в одной транзакции. По-определению транзакция не может быть успешно закончена, пока каждая из ее операций не выполнена успешно, если любая из операций прервана, следует автоматический откат транзакции. Это особенно полезно при распределенных приложениях где множество пользователей могут одновременно получать доступ или манипулировать одними данными в один момент времени.

Репозитарий данных

Основной репозитарий данных App Engine это High Replication Datastore (HRD), высокореплицируемое хранилище, в котором данные реплицируются во множестве центров данных с помощью системы, основанной на алгоритме Pasox. Это предоставляет высокий уровень доступности для чтения и записи. Большинство запросов в конечном счете согласованы.

Второй вариант хранилища — Master/Slave перестал поддерживаться в апреле 2012 года. Хотя Google продолжает поддержку Master/Slave хранилищ в соответствии с условиями обслуживания, рекомендуется чтобы все новые приложения использовали HRD, а уже существующие приложения использующие Master/Slave хранилища мигрировали на HRD. Только HRD поддерживается в Python 2.7.

Сравнение с традиционными базами данных

В отличие от традиционных реляционных БД, App Engine использует распределенную архитектуру для автоматического управления масштабированием до очень больших наборов данных. И несмотря на то, что интерфейс хранилища имеет множество похожих на традиционные БД возможностей он отличается от них тем, как описываются связи между объектами данных. Сущности одного типа могут иметь различные свойства, а различные сущности могут иметь свойства с теми же именами но другими типами значений.

Эти уникальные характеристики предполагают иные пути для моделирования и управления данными для получения возможности автоматического масштабирования. В частности App Engine отличается от традиционных реляционных БД по следующим важным характеристикам:

- App Engine спроектирована для масштабирования, позволяющего приложениям обеспечивать высокую производительность при большом трафике:

запись в хранилище масштабируется автоматически распределяется по мере необходимости
чтение из хранилища масштабируется так как единственные поддерживаемые запросы те, чья производительность масштабируется согласно результирующему выходному набору данных (в отличие от просто набора данных). Это означает что запрос, выдающий в ответе 100 сущностей выполняется также как если бы поиск происходил по сотням или миллионам записей. Это свойство - ключевая причина, по которой не поддерживаются некоторые типы запросов.

- так как все запросы в App Engine строятся на основе предварительно построенных индексов, типы запросов, которые могут выполняться более ограничены, чем позволенные в реляционных базах данных. В частности не поддерживаются следующие типы запросов:

Join-операции объединения
фильтрация по неравенству по нескольким свойствам
фильтрация или данные, основанные на результатах вложенных запросов

- В отличии от традиционных реляционных баз данных, хранилище App Engine может работать с сущностями одного типа с различными не строго определенными наборами наборами свойств (хотя вы можете сами наложить эти ограничения в приложении). В настоящий момент невозможно выполнить запрос, возвращающий только подмножество результирующих свойств сущностей.

Для получения более детальной информации по архитектуре хранилища читайте нашу серию статей Mastering the Datastore.

Введение в Python Datastore API

В Python сущности хранилища создаются из объектов Python; атрибуты объекта становятся свойствами сущности. Для создания новой сущности вы вызываете базовый класс родительской сущности (если таковая имеется), устанавливает атрибуты объектов, а затем сохраняет объект (вызывая такой метод как put()).
import datetime
from google.appengine.ext import db
from google.appengine.api import users

class Employee(db.Model):
name = db.StringProperty(required=True)
role = db.StringProperty(required=True, choices=set(["executive", "manager", "producer"]))
hire_date = db.DateProperty()
new_hire_training_completed = db.BooleanProperty(indexed=False)
account = db.UserProperty()

e = Employee(name="John",
            role="manager",
            account=users.get_current_user())
e.hire_date = datetime.datetime.now().date()
e.put()

API хранилища предоставляет два интерфейса для запросов: интерфейс объектных запросов и похожий на SQL язык запросов, называемый GQL. Запрос возвращает сущности в форме экземпляра объекта класса модели, который можно изменить и обратно поместить в хранилище:

training_registration_list = [users.User("Alfred.Smith@example.com"),
                             users.User("jharrison@example.com"),
                             users.User("budnelson@example.com")]
employees_trained = db.GqlQuery("SELECT * FROM Employee WHERE account IN :1",
                               training_registration_list)
for e in employees_trained:
e.new_hire_training_completed = True
db.put(e)

Сущности

Объекты в хранилище App Engine известны как сущности. Сущность имеет одно или несколько именованных свойств, каждое из которых может иметь одно или несколько значений. Значения свойств могут быть данными различного типа, включая целые числа, числа с плавающей запятой, строки, даты, бинарные данные и многие другие. Запрос по свойству с множеством значений проверяет, соответствует ли какое-нибудь из значений нужному критерию запроса. Такие свойства очень удобны при проверке совокупности значений.

Примечание: сущности хранилища безсхемные, как в традиционных реляционных БД, хранилище App Engine не требует, чтобы все сущности одного типа имели одинаковый набор свойств или чтобы все значения свойств сущности были одинакового типа данных. Если потребуется формальная схема. то само приложение ответственно за то, чтобы сущности соответствовали ей; Python SDK включает богатую библиотеку возможностей моделирования данных для этого.

Типы, ключи и идентификаторы

Каждая сущность хранилища имеет свой тип или вид, который классифицирует сущность по назначению запроса: например, приложение управления человеческими ресурсами может представлять каждого работника в компании с помощью сущности типа Employee. Также, каждая сущность имеет собственный ключ, который однозначно ее идентифицирует. Ключ состоит из следующих компонентов:

Тип сущности

Опциональный родительский путь определяющий сущность в иерархии хранилища

Идентификатор, который может быть:

ключевой строкой

целым числом ID

Идентификатор ассоциируется с сущностью при ее создании. Так как он является частью ключа сущности, он ассоциируется с сущностью навсегда и не может изменяться. Он может быть присвоен двумя путями:

Ваше приложение может само указать ключевую строку-значение для сущности

Вы можете определить для хранилища автоматическое присвоение идентификатору численное значение ID

Примечание: вместо именованных строковых значений или генерирования числовых значений ID автоматически, сложные приложения могут иногда присваивать собственные числовые значения ID сущностям, которые они создают. Будьте внимательны, если вы выберите этот путь, вам придется предпринять специальные меры, чтобы предотвратить возможные конфликты вручную присвоенных ID с автоматически-сгенерированными хранилищем, смотрите Сущности, свойства и Ключи для подробной информации.

Родительские пути

Сущности в хранилище формируют иерархическую структуру, похожую на структуру директорий файловой системы. При создании сущности вы опционально можете указать другую сущность как родительскую; новая сущность будет потомком родительской сущности. Эта связь между сущностью и ее родителем неразрывна и ее нельзя будет изменить после ее создания. Сущность у которой нет родителя является корневой (root) сущностью. Хранилище никогда не присвоит двум сущностям с одинаковым родителем одинаковый ID, также как и двум корневым сущностям.

Родитель сущности, родитель родителя и так далее по рекурсии являются предками. Ее наследники, потомки потомков называются потомками. Сущность и ее потомки принято называть одной группой потомков. Последовательность сущностей, начиная с корневой и следую от родителя к потомкам до указанной сущности составляю родительский путь или путь предков сущности. Полный ключ, идентифицирующий сущность состоит из последовательности пар идентификатор-тип, указывающих их родительский путь и заканчивающихся на самой сущности:

Person:GreatGrandpa / Person:Grandpa / Person:Dad / Person:Me

У корневой сущности родительский путь пуст и ключ состоит только из собственно типа и идентификатора.

Person:GreatGrandpa

Запросы и индексы

Кроме прямого получения сущностей из хранилища по их ключам, приложение может выполнять запрос для их получения по значениям свойств. Запрос работает с сущностями указанного типа, он может фильтровать сущности по значениям свойств или ключей и может возвращать ноль и более сущностей в результате. (Для экономии памяти и увеличения производительности запросу следует где возможно указывать лимит на количество результирующих данных). Запросу также можно указать порядок сортировки по значениям свойств. Результат включает все сущности, которые имеют хотя бы одно (возможно нулевое) значение для каждого свойства, указанного в фильтре и порядке сортировки и свойства которых соответствуют указанному в фильтре критерию. Запрос может возвращать всю сущность, ее проекцию или только ключи.

Запрос может также включать родительский фильтр, ограничивающий результаты только группой потомков указанного родителя. Такие запросы известны также как родительские запросы. По-умолчанию родительские запросы возвращают строго соответствующие результаты, которые гарантировано синхронизированы с последними изменениями в данных. Неродительские запросы напротив, могут охватывать все хранилище, а не только одну группу сущностей, которые в конечном счете соответствуют реальным, но могут возвращать устаревшие данные. Если приложению важно строгое соответствие, то вам необходимо учесть это при структурировании данных, размещая связанные сущности в той же группе сущностей, так что их можно будет получить с помощью родительского а не обычного запроса; смотрите для подробностей Структурирование данных для точной согласованности.

Примечание: соблюдение согласованности немного отличается в Master/Slave хранилищах; смотрите Использование Master/Slave хранилищ для детального ознакомления.

Помимо фильтров в запросе можно указать порядок сортировки по значениям свойств. Результаты запроса будут включать все сущности, которые имеют по крайней мере одно (возможно нулевое) значение для каждого свойства, указанного в фильтре и порядке сортировки и чьи свойства соответствуют указанным критериям фильтра. Запрос может возвращать целиком сущности, указанное подмножество их свойств или просто их ключи (в ключевых запросах).

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

Каждый запрос использует индекс - таблицу, содержащую потенциальные результаты запроса в необходимом порядке. Хранилище обновляет индексы постепенно для отражения любых изменений, которые приложение делает с сущностями. Таким образом, корректные результаты всех запросов мгновенно доступны напрямую из индексов, без необходимости проведения дополнительных расчетов.

Индексы для некоторых типов запросов предоставляются автоматически; приложение может определить дополнительные индексы для себя в файле индексной конфигурации под названием index.yaml. Вэб сервер разработчика автоматически добавляет предложения в конфигурационный файл, когда находит запросы, у которых еще не сконфигурированы индексы. Вы можете вручную настроить индексы, отредактировав файл перед загрузкой приложения, смотрите статью Выбор индексов и расширенный поиск для дополнительной информации.

Примечание: Этот индексный механизм поддерживает широкий спектр запросов и подходит для большинства приложений. Однако он не поддерживает некоторые типы запросов, общие для других технологий БД, в частности объединение и запросы агрегирования не поддерживаются в это механизме запросов.

Транзакции

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

Вы можете выполнить множество действий с сущностью внутри одной транзакции. Например для увеличения поля счетчика объекта вам необходимо считать значение счетчика, рассчитать новое значение и сохранить его обратно. Без использования транзакции возможна ситуация, когда другой процесс изменит значение поля счетчика в промежуток времени между тем, когда вы его прочитали и моментом обновления счетчика и ваше приложение перезапишет это значение своим.Использование транзакций обеспечит уверенность в том, что никакой другой процесс в это время не повлияет на данные.

Транзакции и группы сущностей

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

Хранилище использует оптимистичный параллелизм для управления транзакциями. Когда два и более экземпляров приложения пытаются изменить одну группу сущностей в один момент времени (как обновляя сущности так и создавая новые), первое приложение пытающееся внести изменение сможет это сделать, а другие нет. Эти другие приложения могут позже попытаться еще раз внести изменения в уже обновленные первым приложением данные. Помните, что это ограничивает количество параллельных записей, которые вы можете сделать в любую сущность в данной группе сущностей.

Кросс-групповые транзакции

Транзакция с сущностями, принадлежащими к разным группам, называется кросс-групповая (XG) транзакция. В пределах одной транзакции можно работать максимум с пятью группами сущностей и будет завершена успешно, если ни одна из групп не будет затронута другими параллельными транзакциями.

В транзакции с одиночной группой вы не можете выполнять неродительские запросы в XG транзакции. Однако вы можете выполнять родительские запросы на отдельных группах сущностей. Нетранзакционные (неродительские) запросы могут видеть все, некоторые или никакие результаты предыдущих выполненных транзакций (подробнее об этом в Запись в хранилище и видимость данных). Однако такие нетранзакционные запросы лучше всего подходят, чтобы увидеть результаты частично выполненной XG транзакции, чем такие же частично выполненные одиночные групповые транзакции.

Примечание: первая попытка чтения группы сущностей при XG запросах может вызвать исключение TransactionFailedError, если есть конфликт с другой транзакцией, работающей с этой группой сущностей в этот момент. Это означает, что даже XG транзакция, пытающаяся просто считать данные потерпит неудачу и вызовет исключение согласованности данных.

XG транзакция, которая затрагивает только одну группу сущностей ведет себя также как транзакция с одиночной группой. Операции в такой транзакции имеют такую же производительность и стоимость как и эквивалентная одиночно-групповая транзакция с экономией ресурсов и биллинга, но с более высокой задержкой.

Запись в хранилище и видимость данных.

Примечание: эта секция описывает работу с High replication datastore (HRD). Устаревшие Master/Slave хранилища ведут себя по-другому; смотрите Использование Master/Slave хранилища. Для дополнения к этому топику смотрите также статьи Жизнь записи в хранилище и Изоляция транзакций в App Engine.

Данные записываются в хранилище в две фазы:

1. В фазе фиксации (Commit) данные сущности записываются в журнал

2. Фаза применения состоит из двух параллельных действий:

Данные сущности записываются

Записывается индексный ряд для сущности (этот процесс может занять больше времени чем простая запись данных)

Операция записи возвращается сразу после фазы Commit а фаза применения происходит асинхронно. Если произошла ошибка при первом шаге Commit, то он автоматически повторяется, однако если ошибки продолжаются, хранилище возвращает сообщение об ошибке, которое ваше приложение принимает как исключение. Если Commit фаза проходит, а фаза применения вызывает ошибку то она переносится вперед до завершения пока не произойдет следующее:

Периодическая зачистка хранилища на предмет незавершенных Commit операций и их применение

Некоторые операции применения (get, put, delete и родительские запросы) которые используют затронутые группы сущностей не будут выполнятся пока не будут завершены предыдущие предыдущие.

Работа с изображениями на canvas с помощью JavaScript

2012-05-24T23:48:00.003+03:00

Начинаем

Настало время что-нибудь нарисовать на нашем экране. Сначала нам понадобится HTML страница на которой собственно и будет отображаться canvas элемент.



     <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN">
     <html lang="en">
        <head>
           <title>JavaScript Platformer 1</title>
           <script type="text/javascript" src="jsplatformer1.js"></script>
           <style type="text/css">
              body { font-family: Arial,Helvetica,sans-serif;}
           </style>
        </head>
       <body>
          <p>
             <a href="http://www.brighthub.com/internet/web-development/articles/38364.aspx">
                Game Development with Javascript and the canvas element
             </a>
          </p>
          <canvas id="canvas" width="600" height="400">
             <p>Your browser does not support the canvas element.</p>
          </canvas>
       </body>
    </html>

В коде страницы все достаточно просто и понятно. Есть два важных элемента:
<script type="text/javascript" src="jsplatformer1.js"></script>
Эта строчка подключает файл с кодом JavaScript, с помощью которого будет изменяться canvas элемент, который будет описан ниже.
<canvas id="canvas" width="600" height="400"> <p>Your browser does not support the canvas element.</p> </canvas>
Так мы создаем элемент canvas. Броузеры, которые не поддерживают элемент canvas, такие как IE (до версии 8), игнорируют его, отображая вместо него дочерний элемент. В нашем случае это простой параграф, предупреждающий пользователя. что их браузер не поддерживает элемент canvas. Все броузеры, которые этот элемент поддерживают - не отображают его дочерний элемент.
Атрибут ID элемента canvas очень важен, так как понадобится нам для получения ссылки на этот элемент с помощью JavaScript. Атрибуты ширины и высоты просто указывают размеры canvas, как и для других html элементов вроде таблицы или изображения.
Содержимое файла jsplatformer1.js:



     // target frames per second
     const FPS = 30;
     var x = 0;
     var y = 0;
     var xDirection = 1;
     var yDirection = 1;
     var image = new Image();
     image.src = "http://javascript-tutorials.googlecode.com/files/jsplatformer1-smiley.jpg";
     var canvas = null;
    var context2D = null;

    window.onload = init;

    function init()
    {
       canvas = document.getElementById('canvas');
       context2D = canvas.getContext('2d');
       setInterval(draw, 1000 / FPS);
    }

    function draw()
    {
       context2D.clearRect(0, 0, canvas.width, canvas.height);
       context2D.drawImage(image, x, y);
       x += 1 * xDirection;
       y += 1 * yDirection;

       if (x >= 450)
       {
          x = 450;
          xDirection = -1;
       }
       else if (x <= 0)
       {
          x = 0;
          xDirection = 1;
       }

       if (y >= 250)
       {
          y = 250;
          yDirection = -1;
      }
       else if (y <= 0)
       {
          y = 0;
          yDirection = 1;
       }
    }

Сам по себе элемент canvas достаточно прост и бесполезен. Необходимо с помощью JavaScript что-нибудь отрисовывать на canvas и в нашем случае этот код находится в файле jsplatformer1.js. В качестве простого примера мы загружаем изображение, отрисовываем его на canvas и двигаем его.
Сначала определим несколько глобальных переменных:
const FPS = 30;
FPS определяет частоту с которой будет перерисовываться canvas.
var x = 0; var y = 0; var xDirection = 1; var yDirection = 1;
Переменные x, y, xDirection и yDirection используются для определения положения изображения (относительно левого верхнего угла canvas) и указывают направление движения изображения.
var image = new Image(); image.src = "http://javascript-tutorials.googlecode.com/files/jsplatformer1-smiley.jpg";

Чтобы отрисовать изображение на canvas нам сначала необходимо загрузить это изображение. Для этого мы создаем объект Image и устанавливаем свойство src на месторасположение этого файла.

var canvas = null;
var context2D=null;

Нам также понадобится ссылка на элемент canvas, также как и на отрисовывамый контекст. Мы присвоим необходимые значения элементу позже, а пока оставим их в null.

windows.onload = init;

В конце нам необходимо дать знать, когда страница будет загружена, чтобы запустить код который отрисует canvas, поэтому мы указываем функцию init, которая будет вызвана при отработке события окна после загрузки.

html 5. Об элементе Canvas

2012-05-24T22:57:00.003+03:00

Элемент canvas появившийся в JavaScript движках наряду с некоторыми другими возможностями дает вэб-разработчикам возможность создавать детализированные и интерактивные 2D вэбстраницы без использования сторонних 3D плагинов. В этом топике обсудим некоторые возможности canvas и его потенциальные возможности.

JavaScript и элемент Canvas

HTML начал жизнь как формат для статичных страниц. Анимированные GIF изображения и мигающий текст - вот и вся динамика, которую он мог предоставить. JavaScript изменил все, позволяя динамическое изменение вэб-страниц и многие вэб-сервисы теперь используют и технологию AJAX для создания сайтов, которые дают пользователю более привычную работу, чем "нажал, обновилась страница, нажал", которая обычно так часто используется в обычных html-страницах.

К сожалению, JavaScript несколько ограничен функциональностью браузеров, в которых он работает. И если вы вполне можете создавать и изменять элемент на странице, то с помощью JavaScript вы не сможете (просто) заставить клиентскую машину отображать новый тип объектов. JavaScript может изменять текст, вставлять изображение или с легкостью изменять таблицу, так как эти элементы уже поддерживаются в HTML. Но что, если вы захотите чего-то больше, как например создать игру? Все, что вы могли использовать это стандартные элементы html таким образом, для которого они вовсе не предназначены. Ну или вам пришлось бы использовать плагины вроде Flash или Silverlight.

Появился элемент canvas. Этот новый HTML элемент предоставляет возможность JavaScript разработчикам рисовать прямо на странице без использования плагинов. Он впервые был представлен компанией Apple в их фреймворке WebKit и используется браузером Safari и виджетами Dashboard. Элемент canvas теперь является частью html 5 и теперь поддерживается большинством браузеров, таких как Chrome, Firefox, Opera и Konqueror. Internet Explorer (по-крайней мере до версии 8) является исключением, хотя проекты вроде ExplorerCanvas предоставляют некоторую функциональность элемента canvas в IE.

Любой кто работал с программированием 2D графики увидит что использование элемента canvas достаточно легкое и простое. Вы можете рисовать линии, фигуры, градиенты и даже изменять отдельные пиксели с помощью функций, которые очень похожи на большинство подобных в других 2D API. И огромное спасибо производительности последних JavaScript движков Chrome V8, Firefox SpiderMonkey и Safari Nitro за то что создание детализированных и интерактивных вэб-приложений теперь вполне доступно.

В этой серии статей мы посмотрим как создать простую игру с помощью JavaScript и элемента canvas. Мы раскроем такие темы как анимация, загрузка ресурсов, рендеринг слоев, прокрутка и взаимодействие.

ExtJS и jQuery

2010-07-30T13:28:00.004+03:00

Ну вот наконец стал использовать в рабочих проектах ExtJS и jQuery
Ext конечно же использую для создания панелей управления сайтами - чудно и практично, а главное люди довольны что сами могут содержимым сайта управлять просто и понятно как в обычных программах, а не в лохматых непонятных самоделках или стандартных монстерских панелях открытых проектов, где сам чорт ногу сломит, не то что новичок.
jQuery также приятно радует, отличная библиотечка для движка, динамика некоторых просто восхищяет, когда сайт "расплывается" и трансформируется или меняется расцветка прямо на их глазах :)
Вообщем связка PHP MySQL jQuery ExtJS для меня теперь становиться стандартом :) Ну очень я не люблю всякий ширпотреб проектов "на любой случай", хотя конечно не спорю - многим нравится. А я люблю проекты с "индивидуальным подходом".
Чего и всем желаю!

jQuery 1.3

2009-01-20T10:22:00.001+02:00

Вышел новый релиз jQuery - 1.3
Отмечается значительное увеличение производительности и скорости работы библиотеки.
Подробнее

Приложения в ExtJS

2009-01-03T09:00:00.000+02:00

До того как начать

Это пособие подразумевает, что вы уже установили ExtJS - JavaScript библиотеку и что она установлена в директории extjs в вышестоящей от текущей директории, где будет создаваться наше приложение. Если вы установили библиотеку в другом месте вам необходимо будет изменять пути которые мы употребляем в примерах.
Что нам понадобится?

Помимо ExtJS нам понадобится создать два файла:

* applayout.html
* applayout.js

Давайте начнем с файлов с минимумом содержимого. Вот они с детальным описанием:

applayout.html

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" 
    "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8">

    <link rel="stylesheet" type="text/css" href="../extjs/resources/css/ext-all.css">
    <script type="text/javascript" src="../extjs/adapter/ext/ext-base.js"></script>

    <script type="text/javascript" src="../extjs/ext-all-debug.js"></script>
    <script type="text/javascript" src="applayout.js"></script>

    <!-- A Localization Script File comes here -->
    <script type="text/javascript">
        Ext.onReady(myNameSpace.app.init, myNameSpace.app);
    </script>
    <title>Application Layout Tutorial</title>

</head>
<body>
 
<div id="btn1-ct"></div>
 
</body>
</html>

Первые две строчки указывают тип документа. Наше приложение будет работать и без указания типа, однако в этом случае броузер перейдет в режим Quirks и приложение не станет совместимым с другими броузерами.
Мы будем использовать HTML 4.0.1 спецификацию, потому что она поддерживается большинством броузеров. Конечно, вы можете использовать другой тип документа если захотите, однако важно помнить, что вы всегда должны указывать тип документа.

ОБНОВЛЕНИЕ: Если вы будете указывать тип документа, то в броузерах IE (всех версиях) есть баги, которые могут вызвать непредсказуемые результаты выполнения. Поэтому больше не рекомундуется указывать тип документа в приложениях.

После начала файла и заголовка head идет указание типа содержимого Content-Type. Ваше приложение будет работать и без него, но лучше указать его.

Затем мы подключаем Ext стили, адаптер и ExtJS. Есть две версии ExtJS:
* ext-all.js - плохо-читаемый, загружается быстрее, используется для готовых приложений
* ext-all-debug.js - легко-читаемый, используется для разработки

Мы собираемся разрабатывать, поэтому включаем вторую версию.
Затем идет наше приложение applayout.js, а после него файлы локализации которые перекрывают английский текст в приложении applayout.js и ExtJS своим переводом, до того как приложение стартует.
Теперь мы готовы установить обработчик событий, который инициализирует (стартует) наше приложение после того, как документ полностью загрузится.
Строка

Ext.onReady(myNameSpace.app.init, myNameSpace.app);

говорит: Когда документ полностью загрузился, запустить init метод myNameSpace.app в области myNameSpace.app
Затем идет текст заголовка, конец head (пустой) и закрывающиеся тэги.
Это все, что сейчас находится в html файле.
applayout.js

/**
  * Application Layout
  * by Jozef Sakalos, aka Saki
  * http://extjs.com/learn/Tutorial:Application_Layout_for_Beginners
  */
 
// reference local blank image
Ext.BLANK_IMAGE_URL = '../extjs/resources/images/default/s.gif';
 
// create namespace
Ext.namespace('myNameSpace');

 
// create application
myNameSpace.app = function() {
    // do NOT access DOM from here; elements don't exist yet
 

    // private variables
 
    // private functions
 
    // public space
    return {
        // public properties, e.g. strings to translate

 
        // public methods
        init: function() {
            alert('Application successfully initialized');
        }

    };
}(); // end of app
 
// end of file

Первые строки этого файла это комментарии, объясняющие содержимое файла, автора и другую связанную информацию. Уверен, ваши приложения будут работать и без комментариев, но запомните: всегда пишите ваше приложение так, как будто пишите для другого человека. Когда вы когда-нибудь снова вернетесь к этому коду через пару месяцев и не сможете понять чтоже такое написано здесь, потому как нет комментариев, вы измените вашу практику кодирования.
Затем идет ссылка на пустое изображение, указывающее на ваш собственный сервер взамен сервера по-умолчанию extjs.com. Вам ведь не надо загружать что-либо с extjs.com при каждой загрузке приложения, не так ли?
Теперь мы создаем собственное пространство имен. Причина этого в инкапсуляции (изолированиии) всех переменных и методов в одном глобальном объекте чтоб избежать конфликтов имен переменных и избежать изменнений их значений извне.
Ядро приложения в конце.. Мы создаем свойство app в myNameSpace как возвращаемое значение функции которая запускается немедленно.
Если мы запустим следующий код

var o = function() {
    return {p1:11, p2:22};

}();

Мы по-сути создаем анонимную функцию (функцию без имени) которая запускается сразу же после обработки (помните () полсе определения функции). Функция возвращает объект который привязывается к переменной о. Наше приложение будет использовать туже логику.
Вы можете разместить инициализацию, частные переменные и\или определения частных функций между началом объявление функции и моментом возврата результата, но помните: Код запускается как часть заголовка и никакие html элементы еще не созданы поэтому любые попытки доступа к ним вызовут ошибку.
С другой стороны, init функция это просто один из методов возвращаемых этой анонимной функцией, запускается только после того, как весь документ полностью загружен и вся структура DOM уже доступна.
Дальше - больше. Если вы не сделали никаких ошибок вы получите сообщение об успехе когда запустите ваше приложение.
Теперь идет самая сложная часть. Это написать что-то работающее внутри этого пустого шаблона.

Public, Private, Privileged?

Давайте добавим некоторую жизнь нашему приложению. Добавьте следующие строки в applayout.html внутрь тэга body:

<div id="btn1-ct"></div>

Это пустой div который послужит как контейнер для кнопки. Затем добавим парочку строк в applayout.js и вот что получится:

/**
  * Application Layout
  * by Jozef Sakalos, aka Saki
  * http://extjs.com/learn/Tutorial:Application_Layout_for_Beginners
  */
 
// reference local blank image
Ext.BLANK_IMAGE_URL = '../extjs/resources/images/default/s.gif';
 
// create namespace
Ext.namespace('myNameSpace');

 
// Just to allow this tutorial to work for 1.1 and 2.
Ext.Ext2 = (Ext.version && (Ext.version.indexOf("2") == 0));

 
// create application
myNameSpace.app = function() {
    // do NOT access DOM from here; elements don't exist yet
 

    // private variables
    var btn1;
    var privVar1 = 11;
 
    // private functions
    var btn1Handler = function(button, event) {

        alert('privVar1=' + privVar1);
        alert('this.btn1Text=' + this.btn1Text);
    };

 
    // public space
    return {
        // public properties, e.g. strings to translate
        btn1Text: 'Button 1',
 

        // public methods
        init: function() {
            if (Ext.Ext2) {

                btn1 = new Ext.Button({
                    renderTo: 'btn1-ct',
                    text: this.btn1Text,
                    handler: btn1Handler
                });
            } else {

                btn1 = new Ext.Button('btn1-ct', {
                    text: this.btn1Text,
                    handler: btn1Handler
                });
            }

        }
    };
}(); // end of app
 
// end of file

Переменные btn1 и privVar1 - закрытые, private. Это значит что к ним можно получить доступ только из приложения а вне его они невидимы. Тоже самое справедливо для частной функции btn1Handler.
С другой стороны, btn1Text это публичная public переменная которая видима и может быть доступна или изменена извне приложения (мы продемонстрируем это позже).
Функция init привелигирована в том что может работать как с public так и с private переменными и функциями. В нашем примере она работает с публичной переменной this.btn1Text, а также с private функцией btn1Handler. Функция init публичная (public) и может быть вызвана откуда угодно.
Ок, давайте запустим его. Видите кнопку в верхнем левом углу? Хорошо. Нажмите ее. Вы получите сообщение privVar1=11, так? Частная private функция может работать с частными private переменными.
Однако что то не так при втором показе сообщения и мы видим что this.btn1Text=undefined; это не то, что мы ожидали. Причина в том, что переменная this внутри обработчика теперь указывает на кнопку а не на наше приложение. Добавьте scope:this в конфигурацию кнопки вот так:

if (Ext.Ext2) {
    btn1 = new Ext.Button({

        renderTo: 'btn1-ct',
        text: this.btn1Text,
        handler: btn1Handler,
        scope:this
    });
} else {

    btn1 = new Ext.Button('btn1-ct', {
        text: this.btn1Text,
        handler: btn1Handler,
        scope:this

    });
}

и перезагрузите страницу. Работает теперь?

Перезагрузка (перекрытие) публичных переменных.
Добавьте следующий код в конце applayout.js чтобы было так:

Ext.apply(myNameSpace.app, {
    btn1Text:'Taste 1'
});
 
// end of file

Что теперь делает весь этот код? Сначала он создает объект нашего приложения и затем изменяет (перезагружает) значение публичной переменной btn1Text. Запустите его, чтобы увидеть что текст на кнопке изменился.
Хорошая практика кодирования это хранить весь текст используемый приложением в публичных переменных, так они могут быть легко переведены на другие языки без изменения оригинального кода приложения.
Конечно, следует хранить также другие значения, такие как размеры по-умолчанию, стили и другие настраиваемые опции в публичных переменных. Тогда вам не понадобится исследовать тысячи строк кода приложения чтобы изменить цвет какого нибудь элемента например.

Перегрузка (перекрытие) публичных функций

Давайте изменим наш код на следующий:

Ext.apply(myNameSpace.app, {
    btn1Text:'Taste 1',
    init: function() {

        try {
            btn1 = new Ext.Button('btn1-ct', {
                text: this.btn1Text,
                handler: btn1Handler,
                scope: this

            });
        }
        catch(e) {
            alert('Error: "' + e.message + '" at line: ' + e.lineNumber);
        }

    }
});
 
// end of file

Что мы здесь сделали? Просто переопределили функцию init тем же кодом что и до того, только заключенным в блок try/catch чтобы мы могли обрабатывать любые ошибки. Должны мы ожидать прежнего результата или другого? Запустите и увидите.
Да, будет ошибка о том что btn1Handler не определен. Это потому, что обновленная функция пытается получить доступ к частной переменной но не может. Вы видите, оригинальный init привелоигирован и имеет доступ к частному пространству но новый не имеет. В этом есть аспект безопасности: Никакой внешний код не должен получать доступ к частному пространству даже если пытается перегрузить привелигированные методы.

Учебник: работа с данными в Ext

2008-12-15T10:19:00.003+02:00

Основная концепция данных
- Stores - Store это хранилище данных для таблиц (Grid). Это кэш объектов Ext.data.Record, который содержит те поля, которые вы указываете. Поля могут быть доступны по имени.
-Proxies - Хранилище Store использует объект Proxy для получения данных из заданного их месторасположения. Если у вас допустим просто javascript массив прямо в коде страницы, то вам понадобиться MemoryProxy, конструктор которого просто работает с этими данными. Если вы получаете данные с сервера, расположенного в том же домене, то вам нужен HttpProxy. Proxy достаточно прозрачен. Он всего лишь обеспечивает доступ к порциям данных. Вы назначаете объект Reader взависимости от того, какие данные ожидаются. Вам лучше использовать ArrayReader если у вас просто MemoryProxy, который рабоает с со значениями массивов.
-Readers - Reader, является конструктором для определения данных, как бы расставляя поля. Он выделяет отдельные поля из порции данных и передает их массиву записей, которые передаются в хранилище с помощью метода loadRecords, который и обновляет кэш хранилища.

Основные классы данных
-Ext.data.Connection - класс обеспечивает подключение к соответствующему домену страницы, позволяя делать запросы как к статическому URL, так и к динамическому, указанному в процессе запроса.
-Ext.data.Record - экземпляры этого класса одновременно и определяют описание информации и описание для использования информации записей в хранилище Ext.data.Store или любом другом коде которому нужно иметь доступ к записям, сохраненным в Ext.data.Store объекте.
-Ext.data.SortTypes - Этот класс является уникальным и не может быть создан напрямую.
-Ext.data.Tree -Представляет структуру дерева данных и все события узлов дерева.
-Ext.data.Node -не указано

Источник: http://extjs.com/learn/Manual:Data

Расширение Ext для новичков

2008-12-10T11:28:00.001+02:00

Источник: http://extjs.com/learn/Tutorial:Extending_Ext_for_Newbies

Обычно вы хотите привнести мощь объектно-ориентированного проектирования с помощью классов. Вы делаете это по нескольким причинам как объяснено в этом учебнике.

Классы, используемые многократно

Иногда вам нужны будут компоненты, конфигурационные опции которых вы хотите использовать многократно. Например, у вас может быть набор панелей с одной и той же шириной и высотой, но с разными заголовками. Это назывется предопределенные (предварительно-сконфигурированные) классы.

Модель Конструктора

Один вариант решения это использование функции конструктора, как например здесь:

// функция - конструктор
var MyPanel = function(config) {
    Ext.apply(this, { 
        // создайте нужные опции здесь

        width: 300,
        height: 300
    });
    MyPanel.superclass.constructor.apply(this, arguments);

};
// MyPanel расширяет возможности Ext.Panel
Ext.extend(MyPanel, Ext.Panel, {});
 
var myfirstpanel = new MyPanel({

    title: 'My First Panel'
});
 
var mysecondpanel = new MyPanel({

    title: 'My Second Panel'
});

Фабрика шаблонов (палитр)
Другой путь для создания предопределенных объектов это использование фабрики шаблонов дизайна. Фабричная функция (предопределенная функция) возвращает новый экземпляр объекта. Этот подход не требует расширения классов (краткий обзор не позволяет обсудить это подробно). Фабрика шаблонов это альтернативный вышеупомянутому метод который особенно полезен когда все, что вы хотите сделать, это задать конфигурирование свойств "по-умолчанию", не расширяя/переопрделяя базовый класс.

function createMyPanel(config) {
    return new Ext.Panel(Ext.apply({//опции по-умолчанию идут здесь

        width: 300,
        height: 300
    }, config));
};
 
var myfirstpanel = createMyPanel({

    title: 'My First Panel'
});
 
var mysecondpanel = createMyPanel({
    title: 'My Second Panel'

});

Расширение функциональности

Другая причина, по которой вы хотите использовать ОО классы это когда вы хотите расширить функциональность другого класса. Допустим вы хотите добавить функцию в вышеупомянутую панель и переопределить существующую функцию. Есть один путь сделать это:

// Конструктор
var MyPanel = function(config) {
    //Повторно-используемые опции идут здесь
    Ext.apply(this,
        {

        width: 300,
        height: 300
        }
    });
    // вызов конструктора суперкласса для сохранения функциональности класса-родителя
    MyPanel.superclass.constructor.apply(this, arguments);
    // Здесь вы можете добавить функциональность, нужную вам, 

    //например обработку событий. 
    this.on('click', function() {alert("You Clicked " + this.title);}, this);

};
// MyPanel расширяет Ext.Panel
Ext.extend(MyPanel, Ext.Panel, {
    // Здесь вы можете добавить статические переменные класса, переменные, которые будут иметь 
    //одинаковое значение для всех объектов класса.

    // Если вы не уверены нужно ли включать его в конструктор выше. Не помещайте никакого объекта
    // созданного с помощью 'new' или 'xtype' здесь. Безопаснее положить его в конфигурационных
    // опциях в конструкторе.
 
    // Новая функция добавлена
    myNewFunction: function() {

    },
    // Переопределить существующую функцию
    onRender: function() {
        MyPanel.superclass.onRender.apply(this, arguments);
        this.myNewFunction();
    }

});
 
var myfirstpanel = new MyPanel({
    title: 'My First Panel'

});
 
var mysecondpanel = new MyPanel({
    title: 'My Second Panel'

});

Другой путь для создания конструктора выше показан @Condor :

var MyPanel = function(config) {
    // вызов конструктора суперкласса для сохранения функциональности класса-родителя
    MyPanel.superclass.constructor.call(this, Ext.apply({

        //опции по-умолчанию идут здесь
        width: 300,
        height: 300
    }, config));
 
    // После конструктора суперкласса добавьте требуемую функциональность

    //для объекта (обработка событий, прослушивание)
    this.on('click', function() {alert("You Clicked " + this.title);}, this);

};

Вышеупомянутый способ расширения Ext класса это модель конструктора. Другой путь расширения Ext класса - использование initComponent, один из шаблонных методов Ext JS созданный специально для этого. Как вы можете догадаться этот метод применяется только для расширения Ext компонентов. Вот пример использования:
var MyPanel = Ext.extend(Ext.Panel, {
// Здесь добавляются статические переменные
//
// If you are not sure put it in the constructor above. Do not put
// any object created with 'new' or 'xtype' here. It is safer to
// put it in the config option of the constructor.

// New function added
initComponent: function() {
//Reusable config options here
Ext.apply(this,
width: 300,
height: 300
});
// And Call the superclass to preserve baseclass functionality
MyPanel.superclass.initComponent.apply(this, arguments);
// Here you can add functionality that requires the object to
// exist, like event handling.
this.on(
'click',
function() {
alert("You Clicked " + this.title);
},
this
);
},
myNewFunction: function() {
},
// Override an existing function
onRender: function() {
MyPanel.superclass.onRender.apply(this, arguments);
this.myNewFunction();
}
});

Первое что вы получите это оповещение, что нет конструктора. Ext создает конструктор сам. Конструктор создается Ext с помощью вызова initComponent. Это широко используемый метод, который вы найдете в продвинутых учебниках и примерах. Но запомните сейчас, что он делает тоже самое, что и модель конструктора.

Предпочитаемый путь для обработки событий (listeners) это добавить их после вызова суперкласса в конструктор или initComponent.

MyPanel.superclass.constructor.apply(this, arguments);
    // Here you can add functionality that requires the object to exist, 
    // like event handling. 
    this.on(

        'click',
        function() {
            alert("You Clicked " + this.title);
        },
        this

    );

В случае фабричного метода можно добавить обработчки событий вне фабричного метода, как здесь:

myFirstPanel.on(
        'click',
        function() {
            alert("You Clicked " + this.title);
        },
        myFirstPanel //scope

    );

Есть и другие пути обработки событий. Но они более для продвинутых пользователей

Проектирование больших приложений в Ext

2008-12-09T10:26:00.002+02:00

Вступление

Я решил написать эту статью для тех пользователей Ext2.x которые уже выросли из детских потребностей, создавая одну HTML страницу c простыми скриптами которые создают одно простое окно или форму, для тех кто уже решил что Ext - это путь, и для тех кто борется со слишком большими файлами, трудными для поиска и чувствующих, что их приложениям нужна структура.

Количество проблем и путей их решения равно количеству людей, работающих над этим. Способ, который я опишу в тексте, не единственный, и я не хочу сказать что приложение можно написать только моим способом, иначе будет неверно. Ничего подобного.

Все что я хочу сказать, то что этот вариант рабочий, достаточно структурированный, легко разрабатываемый - просто сказать - Он работает!

Что такое Большое приложение?

Если вы сделали Viewport с BorderLayout, таблицой и формой и все это находится в одном файле - это большое приложение, не так ли? Если вы создали десяток окон с таблицами, формами или границами - это большое приложение, да?

У немцев есть отличные слова: Jein - комбинация слов Да и Нет.
Ответ для обоих вариантов - Jein (и да и нет). Когда приложение становится большим? Ответ простой: оно становится большим когда вы чувствуете, что оно большое. Это начинается тогда, когда у вас у самих начинаются проблемы в ориентировании в множестве файлов или вы не можете найти нужный код в одном файле., когда вы уже не понимаете взаимосвязь компонентов и так далее. Я это пишу, но представьте когда у программиста с в 2-3 раза большим опытом появляется это чувство?
Мы может просто установить, что каждое приложение становится большим, когда оно хорошо написано и у нас не вызовет проблем добавиьт в него дополнительные возможности, дописать новый код, новые CSS правила и так далее.
Лучший и безопасный вариант старта нового приложения это чувство : я начинаю большое приложение!

Файлы и директории
Это первое что нам нужно организовать. Всегда существует корневая директория DocumentRoot на Apache или другом HTTP сервере, так что все поддиректории которые я опишу позже расположены относительно нее.
Рекомендуемая структура директорий такова:

./css (optionally link)
./ext (ссылка)
./img (ссылка)
./js
index.html

Ссылка в вышеупомянутой структуре означает мягкую ссылку, указывающую на реальное месторасположение файлов. Это нужно для того, когда вы например, скачаете новую версию Ext в директорию, то просто измените ссылку на нее, без изменений кода, ссылающегося на нее и можете испытать что все работает правильно в новой версии. Если да, можно оставить все как есть, если нет, просто изменить ссылку на прежнюю.

* css содержит все таблицы стилей. Если у вас есть глобальные стили с цветами компании или шрифтами вы можете создать и эту директорию как ссылку.
* ext ссылается на библиотеку Ext JS как было описано выше
* img ссылается на ваши изображения. Также она может иметь поддиректорию с иконками.
* js будет содержать все JavaScript файлы приложения.
* index.html HTML файл, который является стартовой точкой приложения. Вы можете назвать его как захотите и можете добавить другие файлы, например файлы для процесса аутентификации. В любом случает должна быть одна стартовая точка - файл.
* опционально вы можете создать директорию или ссылку на серверную часть приложения (у меня например ./classes). Вы можете называть их как пожелаете, но придерживаться целостности для приложений, которые пишите (./server, ./php хорошие примеры)

index.html

Самое минимальное содержание файла index.html такое

<html>
<head>
  <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
  <link rel="stylesheet" type="text/css" href="./ext/resources/css/ext-all.css">

  <link rel="stylesheet" type="text/css" href="./css/application.css">
  <script type="text/javascript" src="./ext/adapter/ext/ext-base.js"></script>

  <script type="text/javascript" src="./ext/ext-all-debug.js"></script>
  <script type="text/javascript" src="./js/application.js"></script>

  <title>A Big Application</title>
</head>
<body></body>
</html>

Чтобы я рекомендовал сделать в файле выше, добавить описательный заголовок не только в этот файл но и во все создаваемые файлы. Также маркер End of file имеет значение. Смотрите File Patterns как пример таких заголовков.

js/application.js

Нам нужен файл, где будет располагаться функция onReady, давайте назовем его application.js. Его минимальное содержимое такое:

// vim: sw=4:ts=4:nu:nospell:fdc=4
/**
 * An Application
 *
 * @author    Ing. Jozef Sakáloš
 * @copyright (c) 2008, by Ing. Jozef Sakáloš
 * @date      2. April 2008
 * @version   $Id$
 *
 * @license application.js is licensed under the terms of the Open Source
 * LGPL 3.0 license. Commercial use is permitted to the extent that the 
 * code/component(s) do NOT become part of another Open Source or Commercially
 * licensed development library or toolkit without explicit permission.
 * 
 * License details: http://www.gnu.org/licenses/lgpl.html
 */
 
/*global Ext, Application */
 
Ext.BLANK_IMAGE_URL = './ext/resources/images/default/s.gif';
Ext.ns('Application');

 
// application main entry point
Ext.onReady(function() {
 
    Ext.QuickTips.init();

 
    // code here
 
}); // eo function onReady
 
// eof

Ваш заголовок и подвал может изменяться но удостоверьтесь что установили Ext.BLANK_IMAGE_URL на ваш сервер. Это путь на прозрачное изображение 1х1 пикселей которое используется Ext как указатель расположения ихображения, и если он указывает на неверное месторасположение вы можете получить проблемы при отрисовке, такие как потеря изображений в элементах, отсутствие иконок или что-то подобное.
Вам может также понадобится новой глобальной переменной объекта для приложения ( здесь это Application).
В чем вы должны быть уверены то что Ext.onReady это главная начальная точка приложения.

css/application.css

Здесь будут храниться ваши таблицы стилей, в этом файле. Если вам нужно всего лишь пару правил, то создавать отдельный файл нет необходимости, и будет лучше просто включить его в заголовок страницы.
Обратное тоже истина, помните, вы пишите большое приложение, поэтому все должно быть на своем месте. Если вы напишите таблицу стилей прямо в заголовке файла, то рано или поздно у вас могут возникнуть проблемы при отображении и вы забудете где вы сохранили эти стили.

Ошибочный путь

Что обычно следует когда мы начинаем создавать что то? Давайте напишем. Итак, мы сидим и начинаем писать:

var vp = new Ext.Viewport({
     layout:'border'
    ,items:[

        new Ext.grid.GridPanel({
            store:new Ext.data.Store({

                 proxy:new Ext.data.HttpProxy({ ...

Подождите минутку. С таким подходом у нас будет 10000 строк в нашем application.js очень скоро и это то, чего мы хотим в последнюю очередь. Очевидно, мы пропустили какой-то шаг, как будто мы не могли написать это все сразу в index.html?

Правильный путь: Разбиваем все на части

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

Итак, сядьте, обдумайте все, набросайте схему, сделайте список, но в результате вы должны знать компоненты - хотя бы самые основные, из которых состоит ваше приложение.

Предопределенные классы

Теперь, когда вы проанализировали приложение и определили его компоненты вы можете начать писать. Но как? Самый лучший подход - написать расширение для классов Ext компонент, у которых есть все конфигурационные опции, или они передаются встроенными в конфигурационный объект. Я использую такие предопределенные классы расширения так как они удобнее и более функциональны чем базовые Ext классы, но их главное назначение - это их настройка для своих нужд. Например, чтобы создать таблицу Персонал со специфичной моделью колонок, хранилищем, опциями сортировки, редакторами и тд.
Если у нас такой подход, наше конфигурационное Окно могло мы выглядеть так:

var win = new Ext.Window({
     title:'Personnel'
    ,width:600

    ,height:400
    ,items:{xtype:'personnelgrid'}
});
win.show();

Создание предопределенных классов.

(Запомните: Следующая структура может работать не во всех ситуациях, есть исключения)

Давайте обсудим один пример:

Application.PersonnelGrid = Ext.extend(Ext.grid.GridPanel, {
     border:false

    ,initComponent:function() {
        Ext.apply(this, {
             store:new Ext.data.Store({...})

            ,columns:[{...}, {...}]
            ,plugins:[...]

            ,viewConfig:{forceFit:true}
            ,tbar:[...]
            ,bbar:[...]

        });
 
        Application.PersonnelGrid.superclass.initComponent.apply(this, arguments);
    } // eo function initComponent

 
    ,onRender:function() {
        this.store.load();

 
        Application.PersonnelGrid.superclass.onRender.apply(this, arguments);
    } // eo function onRender

});
 
Ext.reg('personnelgrid', Application.PersonnelGrid);

Что мы здесь делаем? Мы расширяем класс Ext.grid.GridPanel создавая новый класс (расширение) Application.PersonelGrid и мы регистрируем его как новый xtype с именем personnelgrid.
Мы передаем главноей табличной панели все конфигурационные опции необходимые для специфичной таблицы персонала. С этой точки у нас есть новый компонент, строительный блок для нашего приложения, который мы сможем использовать где-либо (окна, регион, отдельно-стоящий) где нам понадобится список персонала. Мы можем создать его так:

var pg = new Application.PersonnelGrid();

или с помощью xtype (для ленивых)

var win = new Ext.Window({
     items:{xtype:'personnelgrid'}

    ,....
});

Организация предопределенных классов

Код выше не должен и не нужно запускать его внутри функции onReady, потому что он ничего не делает с DOM структурой документа; он только создает JavaScript объект. Вот почему он может и должен быть написан в отдельном файле (js/Application.PersonnelGrid.js) и он может и должен быть включен в заголовок index.html файла как:

<script type="text/javascript" src="./js/Application.PersonnelGrid.js></script>

Шаг за шагом мы продолжаем создавать наши предопределенные классы, складывать их в /js директорию, включать их в index.html и строить наше приложение из них, как пазл, собирая из кусочков.
Выглядит хорошо, так?

В любом случае, есть еще что добавить.

Межкомпонентное взаимодействие

Представьте что нам нужен экран с каймой со списком ссылок на западе и таб-панелью в центре. Нажатие ссылки в списке должно создавать новую закладку в центре. Теперь, куда мы должны положить логику этого события и процедуру обработки? На запад или в центр?
Ни в одно из них. Почему? Если у нас есть предопределенные классы которые создают и показывают ссылки на западе (слева) и мы положили всю логику в них, то они больше не могут существовать без центрального региона. Мы можем просто не сможем их использовать без центра, так как не сможем создавать закладки в центре.
Если положить логику в центр - результат будет тот же: центр не сможет существовать без запада.
Единственный компонент, который будет независим в этом случае это их контейнер - border layout, и это единственно правильное место куда следует поместить межкомпонентную связь.
Что мы затем должны сделать? Контейнер (с border layout) должен прослушивать все события с запада и должен создавать закладки в центре как ответ на эти клики. Пример такого межкомпонентного взаимодействия можно найти по ссылке http://examples.extjs.eu/?ex=compcomm

Система представлений

По мере создания приложения число файлов растет, число включений JavaScript файлов тоже (у меня в одном приложении включается около 80 файлов и их количество каждый день растет). Это може уменьшить производительность и продуктивность системы.
Лучший путь решения - это слияние всех javascript файлов и создание одного большого файла, и минимизирование его с помощью JavaScript или других инструментов сжатия. Также вам не понадобится отладка библиотеки Ext для готовой системы.

На продуктивной системе нам надо включить:

ext-all.js

app-all.js and

application.js

Для дополнительной информации о минимизации исходных кодов и создания комбинированных файлов у нас есть другой учебник, который раскрывает эту тему более подробно (http://extjs.com/learn/Tutorial:Building_Ext_From_Source).

Заключение
Вот и все почти... Есть специфичные техники для специальных Ext классов, есть множество других ноу-хау сервер-клиентских приложений, но выше изложена практически основная концепция.
Удачного кодинга!

Источник: http://extjs.com/learn/Tutorial:Writing_a_Big_Application_in_Ext

Учебник: Grid PHP SQL Часть 12

2008-12-08T11:10:00.002+02:00

Создание контекстного меню (правой кнопки)

Это будет последняя часть учебника!!! Знаю, знаю... было очень весело читать! Ок, достаточно! Теперь мы поговорим о контекстных меню или как их обычно называют меню открывающиеся по правому клику мышки.

Во-первых мы записываем номер ряда, на котором мы нажали:

var PresidentListingSelectedRow;

У нас будет простое меню с тремя пунктами: изменение текущей записи, удаление и печать таблицы.
Ок, давайте определим четыре функции. Первая будет вызываться каждый раз при нажатии правой кнопки мыши на таблице:

  function onPresidentListingEditorGridContextMenu(grid, rowIndex, e) {
    e.stopEvent();
    var coords = e.getXY();
    PresidentListingContextMenu.rowRecord = grid.store.getAt(rowIndex);
    grid.selModel.selectRow(rowIndex);
    PresidentListingSelectedRow=rowIndex;
    PresidentListingContextMenu.showAt([coords[0], coords[1]]);
  }

Ок, как вы видите мы показываем переменную названную PresidentListingContextMenu. Мы ее еще не создали, мы сделаем это сразу после этого. Давайте определим три функции которые будут вызываться для каждого пункта меню:

  function modifyPresidentContextMenu(){
      PresidentListingEditorGrid.startEditing(PresidentListingSelectedRow,1);
  }

  function deletePresidentContextMenu(){
      confirmDeletePresidents();
  }

  function printListingContextMenu(){
      printListing();
  }

Как видите, это те функции, которые мы уже определили. Ок, давайте определим ContextMenu:

  PresidentListingContextMenu = new Ext.menu.Menu({
      id: 'PresidentListingEditorGridContextMenu',
      items: [
      { text: 'Modify this President', handler: modifyPresidentContextMenu },
      { text: 'Delete this President', handler: deletePresidentContextMenu },
      '-',
      { text: 'Print this grid', handler: printListingContextMenu }
      ]
   });

Последнее, что нам понадобится это перехватчик событий (actionlistener) который будет вызывать функцию onPresidentListingEditorGridContextMenu при нажатии правой кнопки (я пытался найти еще более длинное имя для этой функции, но... :))

  PresidentListingEditorGrid.addListener('rowcontextmenu', onPresidentListingEditorGridContextMenu);

Это конец учебника. Надеюсь он помог вам понять как работать с таблицами в ext. Теперь вы понимаете ее код. Не забывайте проверять наши материалы и играйте с различными методами, свойствами и событиями.

Вы можете оставить отзыв на форуме http://extjs.com/forum/showthread.php?p=144865#post144865
For more advanced features and usage of grids, I want to once again refer you to Michael Lecomte's tutorial.
Для более продвинутых функций таблиц посмотрите учебник Michael Lecomte's
Happy Griding!http://extjs.com/learn/Tutorial:Ext20_Grid_Editor_PHP_MySQL

Nicolas Bize.

Что запомнить из этой части

* Перехватчик событий необходимо прикреплять к таблице
* Вам не надо пересоздавать контекстное меню каждый раз заново, так как это глобальная переменная :)

Материалы этой части можно скачать по ссылке http://nicolas.bize.free.fr/ext/tutorial/Tutorial%20Part%2012.zip

Учебник: Grid PHP SQL Часть 11

2008-12-08T11:09:00.000+02:00

Печать вашей таблицы.

Отлично... Я собираюсь сказать одну вещь до того, как буду заспамлен тоннами писем с критикой... Метод, описанный здесь для печати вашей таблицы не единственно возможный и не самый оригинальный. Это просто быстрый пример того, как можно распечатать таблицу.

Наш метод - это просто создание HTML файла и заполнение его массивом, содержащим отображаемые в таблице данные (все данные, не только 15 выведенных в данный момент)

Во-первых, мы добавим кнопку Print на нашу панель инструментов:

         ,'-', {
            text: 'Print',
     tooltip: 'Print me!',
            handler: printListing, 
            iconCls:'print'        // defined in our css
          }

Давайте теперь определим функцию printListing(). Эта функция вызовет php функцию которая создаст HTML файл таблицы:

    function printListing(){
      var searchquery = "";
      var searchfirstname = "";
      var searchlastname = "";
      var searchparty = "";
      var searchenteringoffice = "";
      var searchleavingoffice = "";
      var win;               // our popup window
      // check if we do have some search data...
      if(PresidentsDataStore.baseParams.query!==null){searchquery = PresidentsDataStore.baseParams.query;}
      if(PresidentsDataStore.baseParams.firstname!==null){searchfirstname = PresidentsDataStore.baseParams.firstname;}
      if(PresidentsDataStore.baseParams.lastname!==null){searchlastname = PresidentsDataStore.baseParams.lastname;}
      if(PresidentsDataStore.baseParams.party!==null){searchparty = PresidentsDataStore.baseParams.party;}
      if(PresidentsDataStore.baseParams.enteringoffice!==null){searchenteringoffice = PresidentsDataStore.baseParams.enteringoffice;}
      if(PresidentsDataStore.baseParams.leavingoffice!==null){searchleavingoffice = PresidentsDataStore.baseParams.leavingoffice;}
         
      Ext.Ajax.request({   
        waitMsg: 'Please Wait...',
        url: 'database.php',
        params: {
          task: "PRINT",
               // we have to send all of the search

          query: searchquery,                                 // if we are doing a quicksearch, use this
          firstname : searchfirstname,                        // if we are doing advanced search, use this
          lastname : searchlastname,
          party : searchparty,
          enteringoffice : searchenteringoffice,
          leavingoffice : searchleavingoffice,
          currentlisting: PresidentsDataStore.baseParams.task // this tells us if we are searching or not
        }, 
        success: function(response){              
          var result=eval(response.responseText);
          switch(result){
          case 1:
            win = window.open('./presidentslist.html','presidentslist','height=400,width=600,resizable=1,scrollbars=1, menubar=1');
            win.print();
            break;
          default:
            Ext.MessageBox.alert('Uh hu...','Unable to print the grid!');
            break;
          }  
        },
        failure: function(response){
          var result=response.responseText;
          Ext.MessageBox.alert('error','could not connect to the database. retry later');      
        }                      
      });
  }

Ок, вы можете удивится почему мы должны передавать так много параметров... Дело в том что... мы хотим распечатать всю нашу таблицу а наш DataStore содержит лишь 15 записей. Поэтому наш PHP файл собирается сделать запросы заново еще раз. не ограничивая поиск частичными запросами. Затем наш database.php сложит все это в файл listpresidents.html.

Вот наш database.php файл (сначала выбор)

    case "PRINT":
        printPresidents();
        break;

А затем функция печати:

function printPresidents()
{
   // Ok since we limited our queries to 15 entries, we need to do a query again and get everything.
   if($_POST['currentlisting']=='LISTING'){  // we are doing a basic listing or using the quicksearch
        $query = "SELECT * FROM presidents pr, parties pa WHERE pr.IDparty = pa.IDparty";
        // Here we check if we have a query parameter :
        if (isset($_POST['query']) && ($_POST['query'] != "")){
          $query .= " AND (pr.firstname LIKE '%".$_POST['query']."%' OR pr.lastname LIKE '%".$_POST['query']."%')";
        }
        $query .= " ORDER BY tookoffice";
        $result = mysql_query($query);
        $nbrows = mysql_num_rows($result);
   } else if($_POST['currentlisting']=='SEARCH'){
         $query = "SELECT * FROM presidents pr, parties pa WHERE pr.IDparty = pa.IDparty";
         $firstname = $_POST['firstname'];
         $lastname = $_POST['lastname'];
         $enteringoffice = $_POST['enteringoffice'];
         $leavingoffice = $_POST['leavingoffice'];
         $party  = $_POST['party'];

         if($firstname != ''){
            $query .= " AND firstname LIKE '%".$firstname."%'";
         };
         if($lastname != ''){
            $query .= " AND lastname LIKE '%".$lastname."%'";
         };
         if($party != ''){
            $query .= " AND pr.IDparty = '".$party."'";
         };
         if ($enteringoffice) {
            $query .= " AND tookoffice >= '".$enteringoffice."'";
         };
         if ($leavingoffice) {
            $query .= " AND leftoffice <= '".$leavingoffice."'";
         };
         $result = mysql_query($query);
         $nbrows = mysql_num_rows($result);
   }

   // We now have our array, let's build our HTML file :
   $file = fopen("presidentslist.html",'w');
   fwrite($file, "<!DOCTYPE html PUBLIC '-//W3C//DTD XHTML 1.0 Transitional//EN' 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd'><html xmlns='http://www.w3.org/1999/xhtml'><head><meta http-equiv='Content-Type' content='text/html; charset=iso-8859-1' /><title>Printing the Grid</title><link rel='stylesheet' type='text/css' href='printstyle.css'/></head>");
   fwrite($file, "<body><table summary='Presidents List'><caption>The Presidents of the United States</caption><thead><tr><th scope='col'>First Name</th><th scope='col'>Last Name</th><th scope='col'>Party</th><th scope='col'>Entering Office</th><th scope='col'>Leaving Office</th><th scope='col'>Income</th></tr></thead><tfoot><tr><th scope='row'>Total</th><td colspan='4'>");
   fwrite($file, $nbrows);
   fwrite($file, " presidents</td></tr></tfoot><tbody>");
   for($i = 0; $i< $nbrows; $i++){
    $data = mysql_fetch_array($result);
    fwrite($file,'<tr');
    if($i%1==0){
      fwrite($file," class='odd'");
    }
    fwrite($file, "><th scope='row' id='r97'>");
    fwrite($file, $data['firstname']);
    fwrite($file,"</th><td>");
    fwrite($file, $data['lastname']);
    fwrite($file, "</td><td>");
    fwrite($file, $data['name']);
    fwrite($file, "</td><td>");
    fwrite($file, codeDate($data['tookoffice']));
    fwrite($file, "</td><td>");
    fwrite($file, codeDate($data['leftoffice']));
    fwrite($file, "</td><td> $");
    fwrite($file, $data['income']);
    fwrite($file, "</td></tr>");
  }
  fwrite($file, "</tbody></table></body></html>");  
  fclose($file);
  echo '1';        // we are done. 

}

На самом деле это очень просто. Мы просто вставляем запросы без ограничения количества записей и сохраняет полученный массив в HTML файл. Затем мы возвращаем 1.
Как будут выглядеть результаты на самом деле зависит от вас!
Некоторые предпочитают решения на основе экспорта в PDF формат. Вы можете найти эту информацию в топиках форумов.

Что запомнить:
Этот способ нельзя применить везде
Он не показывает колонки в нужном выбранном порядке и видимости
Это не самое лучшее решение.

Файлы этой части можно скачать здесь http://nicolas.bize.free.fr/ext/tutorial/Tutorial%20Part%2011.zip

Учебник: Grid PHP SQL Часть 10

2008-12-08T11:08:00.000+02:00

Компонент быстрого поиска.

Отлично... Мы почти прошли этот учебник!!! Скоро вы сможете создавать свои собственные впечатляющие таблицы. Давайте изучим компонет QuickSearch.
Мы уже прошли тему как осуществлять обычный поиск по таблице. Для этого нужно чтобы пользователь нажал кнопку Search и ввел поля поиска... Ок, чтож, вы поймете что это может оказаться очень сложной задачей для большинства пользователей. И тут появляется мистер быстрый поиск QuickSearch. Компонент QuickSearch это просто текстовое поле в котором пользователь вводит текст для поиска, нажимает Ввод и тогда... А дальнейшее зависит от того как мы это сделаем..

Давайте продолжим и сделаем так ,чтобы текст искался всей таблице.
Отлично, до того как мы начнем нам нужно добавить еще один .js файл в заголовок HTML файла:

<script type="text/javascript" src="searchfield.js"></script>

Вы можете найти файл в папке examples/form архива extjs или скачайте его по ссылке http://extjs.com/deploy/dev/examples/form/SearchField.js
Во-первых мы просто добавим его на нашу панель инструментов. Нам просто надо установить некоторые основные параметры, которые передаем в datastore.

, '-', new Ext.app.SearchField({
  store: PresidentsDataStore,
  params: {start: 0, limit: 15},
  width: 120
})

Ок, если вы достаточно опытны, мы можем просто открыть файл searchfield.js в любимом Блокноте и посмотреть что там внутри... И там вы увидите параметр называемый query который посылается при перезагрузке datastore. Да... Мы знаем что есть что! Теперь.. DataStore президентов может быть как в LISTING режиме так и в режиме SEARCHING (зависит от параметров). Итак, кнопка QuickSearch будет просто добавлять строку введенную в текстовое поле как дополнительный параметр.
Я просто собираюсь реализовать это при простом получении списка президентов. Я вам покажу как это сделать при поиске (быстрый поиск на существующем поиске)
Давайте откроем наш файл database.php.Теперь, когда мы обращаемся к функции getList() мы должны проверить нет ли у нас параметра query. И если есть мы должны найти похожие данные в нашей таблице. Теперь наша новая функци getList выглядит так:

  $query = "SELECT * FROM presidents pr, parties pa WHERE pr.IDparty = pa.IDparty";
  // Here we check if we have a query parameter :
  if (isset($_POST['query'])){
    $query .= " AND (pr.firstname LIKE '%".addslashes($_POST['query'])."%' OR pr.lastname LIKE '%".addslashes($_POST['query'])."%')";
  }
  $result = mysql_query($query);
  $nbrows = mysql_num_rows($result);
  $start = (integer) (isset($_POST['start']) ? $_POST['start'] : $_GET['start']);
  $end = (integer) (isset($_POST['limit']) ? $_POST['limit'] : $_GET['limit']);
  $limit = $query." LIMIT ".$start.",".$end;  
  $result = mysql_query($limit);  
  [...]

Это так просто! :) Ну теперь вы можете брать параметр query, убрать все пробелы, разбить по словам для лучшего поиска. Вы даже можете делать поиск по годам и так далее... Реализация поиска, который мыуже сделали достаточно проста. Просто проверяйте переменную query до того, как сделаете запрос. Вот и все!

Скачать файлы проекта можно по ссылке http://nicolas.bize.free.fr/ext/tutorial/Tutorial%20Part%2010.zip

Учебник: Grid PHP SQL Часть 9

2008-12-08T11:07:00.001+02:00

Панель страниц

Ну что, это снова вы... Да... Ок, давайте поговорим о панели страниц, которую вы можете увидеть внизу таблицы. Она мне всегда очень нравилась. Самое хорошее, что реализовать ее очень просто. Так давайте быстро сделаем ее!

Элемент PagingToolbar должен знать в основном две вещи: как много записей вы хотите отображать на странице и куда отсылать информацию о текущей странице.(мы будем посылать эту информацию в DataStore)
Итак... Сразу после панели инструментов в EditorGrid, давайте добавим нижнюю панель:

      bbar: new Ext.PagingToolbar({
                pageSize: 15,
                store: PresidentsDataStore,
                displayInfo: true
            })

Мы будем показывать по 15 президентов на странице. Мы уже почти все сделали! Единственная вещь теперь - как сообщить нашему PHP скрипту как мы будем делать наш постраничный просмотр. Элемент PagingToolbar использует два параметра - start (стартовая запись) и limit (количество записей). Они будут доступны в серверном скрипте и мы должны лишь только учесть их в нашем SQL запросе.
Давайте убедимся что посылаем эти параметры каждый раз, когда нам нужен список президентов: Каждую PresidentsDataStore.reload() или PresidentsDataStore.load() мы трансформируем в:

  PresidentsDataStore.reload({params: {start: 0, limit: 15}});

Сделайте изменения сами (они встречаются в mainscript.js) только в 3 местах)

Серверная часть
Это очень просто. Теперь, когда мы имеем переменные start и limit, нам нужно получить их значения и изменить конец нашего SQL запроса.
Вот изменения в фукции getList():

  $query = "SELECT * FROM presidents pr, parties pa WHERE pr.IDparty = pa.IDparty";
  $result = mysql_query($query);
  $nbrows = mysql_num_rows($result);
  // Add this for the paging bar:
  $start = (integer) (isset($_POST['start']) ? $_POST['start'] : $_GET['start']);
  $end = (integer) (isset($_POST['limit']) ? $_POST['limit'] : $_GET['limit']);
  $limit = $query." LIMIT ".$start.",".$end;  
  $result = mysql_query($limit);

Мы все еще хотим делать первый запрос так, чтбы получить общее количество записей (nbrows), но обратно в Ext будем отсылать массим содержащий 15 или менее записей, которые были запрошены.
Давайте не забудем сделать эти же изменения в функции поиска searchPresidents().

Файл с материалами этой части учебника здесь http://nicolas.bize.free.fr/ext/tutorial/Tutorial%20Part%209.zip

Учебник: Grid PHP SQL Часть 8

2008-12-05T13:14:00.007+02:00

Поиск по таблице

Отлично.. Как вы можете видеть мы может форматировать нашу таблицу так как захотим. Сегодня мы собираемся научиться как что-нибудь искать в таблице. Легко найти Джона Кеннеди, не потому конечно, что знаешь дату его избрания, но так же потому, что в нашей таблице всего 40 записей. Другое дело, если мы включили всех политиков США... Следовательно мы должны дать пользователю возможность сужать поиск.

Создание формы поиска

Когда мы создали форму мы объявили некоторые поля как глобальные переменные и работали с ними через методы name.setValue() или getValue(). Помните, что из-за этого мы можем иметь только одну форму для добавления записей. В нашем случае это не ограничивает ничего, а целью было сосредоточиться на табличной системе ext. Однако, чтобы показать как подобные вещи следует делать мы создадим следующую форму без глобальных переменных. Следовательно мы сможем открывать несколько форм поиска одновременно. Это очень полезно в наши дни.
Вот как мы сделаем. Когда мы наживаем на кнопку Advanced Search (Расширенный поиск) мы хотим, чтобы открылось новое окно для поиска с пустыми полями и готовое для поиска. Мы бы хотели сделать окно с расширенным поиском по нескольким полям.

Сначала, довайте добавим кнопку поиска Search в панель инструментов (в PresidentListingEditorGrid):

          }, '-', {
            text: 'Search',
            tooltip: 'Advanced Search',
            handler: startAdvancedSearch,  // search function
            iconCls:'search'               // we'll need to add this to our css
          }

Давайте определим нашу функцию startAdvancedSearch. Вот немного для начала:

  function startAdvancedSearch(){
      // local vars
      var PresidentSearchForm;
      var PresidentSearchWindow;
      var SearchFirstNameItem;
      var SearchLastNameItem;
      var SearchPartyItem;
      var SearchEnteringItem;
      var SearchLeavingItem;
      
      SearchFirstNameItem = new Ext.form.TextField({
          fieldLabel: 'First Name',
          maxLength: 20,
          anchor : '95%',
          maskRe: /([a-zA-Z0-9\s]+)$/
            });

      SearchLastNameItem = new Ext.form.TextField({
          fieldLabel: 'Last Name',
          maxLength: 20,
          anchor : '95%',    
          maskRe: /([a-zA-Z0-9\s]+)$/  
            });
      
      SearchPartyItem = new Ext.form.ComboBox({
         fieldLabel: 'Party',
         store:new Ext.data.SimpleStore({
          fields:['partyValue', 'partyName'],
          data: [['1','No Party'],['2','Federalist'],['3','Democratic-Republican'],['4','Democratic'],['5','Whig'],['6','Republican']]
          }),
         mode: 'local',
         displayField: 'partyName',
         valueField: 'partyValue',
         anchor:'95%',
         triggerAction: 'all'
            });
            
      SearchEnteringItem = new Ext.form.DateField({
          fieldLabel: 'Entered Office after',
          format : 'm/d/Y',
          anchor:'95%'
          });
          
      SearchLeavingItem = new Ext.form.DateField({
          fieldLabel: 'Left Office before',
          format : 'm/d/Y',
          anchor:'95%'
          });
        }

Знакомо выглядит? Так и должно быть!!! Это почти тоже самое что мы делали при создании формы.. За исключеним того, что мы не указываем никакие идентификаторы (запомните, что они должны быть уникальны, мы не можем иметь несколько элементов с одинаковыми id) Другое огромное отличие в том, что каждое поле, форма или окно определено прямо в функции. Нам не нужно беспокоится о скрытии окна, мы просто можем открыть другое окно как только это закроется.
Продолжим:

     PresidentSearchForm = new Ext.FormPanel({
       labelAlign: 'top',
       bodyStyle: 'padding: 5px',
       width: 300,
       items: [{
         layout: 'form',
         border: false,
         items: [ SearchFirstNameItem,SearchLastNameItem,SearchPartyItem,SearchEnteringItem, SearchLeavingItem ],
         buttons: [{
               text: 'Search',
               handler: listSearch
             },{
               text: 'Close',
               handler: resetSearch
             }]
         }]
     });
      
     PresidentSearchWindow = new Ext.Window({
         title: 'President Search',
         closable:true,
         width: 200,
         height: 400,
         plain:true,
         layout: 'fit',
         items: PresidentSearchForm
     });

Важный момент в этом коде - просто вызовы двух функций, listSearch и resetSearch, которые должны быть определены здесь же локально (смотри следующий параграф) чтобы позволить им получить доступ к локальным значениям полей. У нас есть кнопки Search (искать) и Close (закрыть). Кнопка Search будет запускать поиск а кнопка Close, то очень интересно, также будет выполнять поиск. Вот почему...

    function listSearch(){
         // render according to a SQL date format.
         var startDate = "";
         var endDate = "";
         if(SearchEnteringItem.getValue() != "") {
            startDate = SearchEnteringItem.getValue().format('Y-m-d');
         }
         if(SearchLeavingItem.getValue() != "") {
            endDate = SearchLeavingItem.getValue().format('Y-m-d');
         }
         
         // change the store parameters
         PresidentsDataStore.baseParams = {
      task: 'SEARCH',
      firstname: SearchFirstNameItem.getValue(),
            lastname : SearchLastNameItem.getValue(),
            party : SearchPartyItem.getValue(),
            enteringoffice : startDate,
            leavingoffice : endDate
     };
         // Cause the datastore to do another query : 
     PresidentsDataStore.reload();
     }
     
     function resetSearch(){
         // reset the store parameters
      PresidentsDataStore.baseParams = {
      task: 'LISTING'
     };
         // Cause the datastore to do another query : 
     PresidentsDataStore.reload();
         PresidentSearchWindow.close();
     }
     
     // once all is done, show the search window
     PresidentSearchWindow.show();

Видите почему? Все что мы делаем это берем оригинальный datastore и изменяем его параметры. Мы затем просим его перезагрузится. А это выполняет новый запрос. Результаты затем отображаются так же как и в начале учебника.
Это объясняет функцию resetSearch. Чтобы сбросить поиск, мы должны установить оригинальные параметры DataStore (а это просто задача listing). Затем мы перезагружаем наш DataStore.

Маленькое упражнение с запросами
Вы уже использовали эти Ajax запросы? Серверный скрипт просто обрабатывает это вызов как любой другой... Давайте запишем ( в database.php)

Сначала в выборе :

    case "SEARCH":
        searchPresidents();
        break;

а затем идет наша функция searchPresidents()

function searchPresidents()
{
   $query = "SELECT * FROM presidents pr, parties pa WHERE pr.IDparty = pa.IDparty";

   $firstname = $_POST['firstname'];
   $lastname = $_POST['lastname'];
   $enteringoffice = $_POST['enteringoffice'];
   $leavingoffice = $_POST['leavingoffice'];
   $party  = $_POST['party'];
  
   if($firstname != ''){
      $query .= " AND firstname LIKE '%".$firstname."%'";
   };
   if($lastname != ''){
      $query .= " AND lastname LIKE '%".$lastname."%'";
   };
   if($party != ''){
      $query .= " AND pr.IDparty = '".$party."'";
   };
   if ($enteringoffice) {
        $query .= " AND tookoffice >= '".$enteringoffice."'";
     };
   if ($leavingoffice) {
        $query .= " AND leftoffice <= '".$leavingoffice."'";
     };
    
   $result = mysql_query($query);
   $nbrows = mysql_num_rows($result);  
   if($nbrows>0){
    while($rec = mysql_fetch_array($result)){
            // render the right date format
      $rec['tookoffice']=codeDate($rec['tookoffice']);
      $rec['leftoffice']=codeDate($rec['leftoffice']);      
      $arr[] = $rec;
    }
    $jsonresult = JEncode($arr);
    echo '({"total":"'.$nbrows.'","results":'.$jsonresult.'})';
   } else {
    echo '({"total":"0", "results":""})';
   }
}

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

Что запомнить из этой части:
id обьектов должны быть уникальны
Работа с параметрами DataStore

Файлы этой части можно скачать здесь

Источник: http://extjs.com/learn/w/index.php?title=Tutorial:Grid_PHP_SQL_Part8

Учебник: Grid PHP SQL Часть 7

2008-12-05T12:44:00.006+02:00

Настраиваемые CSS стили

Отлично, рад видеть, что вы все еще со мной! Если вы зашли так далеко, то вы уже наверное обладаете знаниями о редактировании, добавлении и удалении записей в таблице. Вы наверное провели часы, играясь с таблицей и потратили много времени, показывая свои достижения детям, супруге, родителям а может даже своей собаке. Наиболее вероятно, они ответили: "Отлично! Но есть ли вариант изменить css стиль вот тех ячеек??" Чтож, звучит загадочно.. ЭТО ВОЗМОЖНО! И... это на самом деле не очень сложно...

Давайте начнем сначала
В каждую колонку, добавленную в ColumnModel, мы можем добавить параметр, называемый renderer (построитель). Этот параметр просто функция, которая позволяет нам сказать Ext как отображать ячейки в этой колонке.
Функция постройки имеет 6 параметров: (data (данные), cell (ячейка), rowIndex (индекс ряда), columnIndex (индекс колонки), store). Играя с этими значениями мы можем установить любой стиль в нужном месте. На самом деле, это почти то же самое, что мы уже сделали в нашем NumberField... (мы написали '$' прямо за значением)

Играем с цветами

Мы найдем президентов, которые имели больше всего голосов. Для этого мы изменим цвет ячейки голосов в соответствии с её значением. Нам надо изменить функцию постройки колонки Income:

        renderer: function(value, cell){ 
         var str = '';
         if(value > 1000000){
            str = "<span style='color:#336600;'>$ " + value + "</span>";
         } else if (value > 100000 && value < 1000000){
            str = "<span style='color:#FF9900;'>$ " + value + "</span>";
         } else {
            str = "<span style='color:#CC0000;'>$ " + value + "</span>";
         }
         return str; 
        },

Играем с css стилями

Вы наверное показывали вашу таблицу друзьям а те очень сердились, что не могут изменить идентификаторы ID президентов (эта колонка доступна для редактирования) и должно быть убили вашу мышку так, как будто играли в Diablo очень много времени. Давайте убережемся от таких друзей и изменим css стили ячеек. Это просто делается через cell.css поле.
Давайте добавим следующий код в style.css :

.readonlycell { 
  background-color:#CCCCCC !important;
}

Теперь для IDPresident и IDParty давайте добавить построитель, который установит css стили для ячеек:

        renderer: function(value, cell){ 
         cell.css = "readonlycell";
         return value;
        }

Запомните, функция построителя должна возвращать какие-то данные. Иначе вы не увидите ничего...

Любой стиль для любой ячейки
Как вы можете видеть, вы можете изменять ячейки так как захотите. В данном примере, мы изменили фоновое изображение для имени и фамилии президента. Просто так, без причины.. Я бы не советовар перегружать вашу таблицу большим количеством css стилей, так как иначе ваши глаза просто заболят, когда таблица появится на экране.

Что запомнить из этой части:
Используйте css стили лишь для того, чтобы было понятно и удобно работать с таблицой.

Файлы этой части можно скачать здесь

Источник: http://extjs.com/learn/w/index.php?title=Tutorial:Grid_PHP_SQL_Part7

Учебник: Grid PHP SQL Часть 6

2008-12-05T11:36:00.006+02:00

Удаление записи

В предыдущих частях мы создали редактируемую таблицу с функцией добавления записей в нее. Давайте подумаем. Мы еще многое не реализовали, но уже написали пару сотен строк кода...
Это показывает насколько важно структурировать код. Есть множество топиков на форумах и учебников как правильно писать Ext код. Убедитесь, что используете Firefox и отладчик (Firebug) и проверяйте результаты в IE. Вы можете проверять ваши .js файлы с помощью JSLint чтобы убедится в их корректности. Очень легко потеряться в Ext коде, так как большинство структур построено в Json формате. Правильно расставляйте отступы. Если вам еще не понятно, посмотрите ЧАВО от Mickael's по таблицам.

Эта часть учебника научит нас удалять записи из таблицы. Это будет очень просто. Мы просто выбираем ряд таблицы и нажимаем кнопку Delete (Удалить), Ajax запрос посылается и трансформируется в SQL запрос, как мы делали в других случаях. Вы просто можете попробовать сделать это и посмотреть как это легко.

А что делать если мы хотим удалить несколько рядов. Как это сделать?? Вы можете выбирать носколько рядов с помощью CTRL или SHIFT.. Видите? Чтобы удалить все эти ряды мы должны их все обработать и мы это сделаем с помощью цикла и создадим массив который будет содержать все идентификаторы IDPresidents для каждого ряда. Затем мы просто перекодируем массив и отошлем его на сервер как параметр.

Давайте посмотрим, как это сделать:

  var selections = PresidentListingEditorGrid.selModel.getSelections();
  var prez = [];
  for(i = 0; i< PresidentListingEditorGrid.selModel.getCount(); i++){
    prez.push(selections[i].json.IDpresident);
  }
  var encoded_array = Ext.encode(prez);

Как вы можете видеть этот код достаточно прямолинейный. Давайте внедрим его в наш скрипт.
Во-первых давайте добавим кнопку удаления на панель инструментов (мы также добавили CSS код), вот так:

  tbar: [
    {
      text: 'Add a President',
      tooltip: 'Great tooltips...',
      iconCls:'add',                      // reference to our css
      handler: displayFormWindow
    }, '-', {
      text: 'Delete selection',
      tooltip: 'Jose, can you seeeee??',
      handler: confirmDeletePresidents,   // Confirm before deleting
      iconCls:'remove'
  }]

Так как люди, которые будут использовать ваши приложения не всегда сообразительны (я не исключение) и могут просто нажать кнопку удаления случайно, нам нужно спросить подтверждение для удаления с помощью функции:

  function confirmDeletePresidents(){
    if(PresidentListingEditorGrid.selModel.getCount() == 1) // only one president is selected here
    {
      Ext.MessageBox.confirm('Confirmation','Do you not like that president at all?', deletePresidents);
    } else if(PresidentListingEditorGrid.selModel.getCount() > 1){
      Ext.MessageBox.confirm('Confirmation','Delete those presidents?', deletePresidents);
    } else {
      Ext.MessageBox.alert('Uh oh...','You can\'t really delete something you haven\'t selected huh?');
    }
  }

Полная функция удаления

Итак, что мы имеем:

  function deletePresidents(btn){
    if(btn=='yes'){
         var selections = PresidentListingEditorGrid.selModel.getSelections();
         var prez = [];
         for(i = 0; i< PresidentListingEditorGrid.selModel.getCount(); i++){
          prez.push(selections[i].json.IDpresident);
         }
         var encoded_array = Ext.encode(prez);
         Ext.Ajax.request({  
            waitMsg: 'Please Wait',
            url: 'database.php', 
            params: { 
               task: "DELETEPRES", 
               ids:  encoded_array
              }, 
            success: function(response){
              var result=eval(response.responseText);
              switch(result){
              case 1:  // Success : simply reload
                PresidentsDataStore.reload();
                break;
              default:
                Ext.MessageBox.alert('Warning','Could not delete the entire selection.');
                break;
              }
            },
            failure: function(response){
              var result=response.responseText;
              Ext.MessageBox.alert('error','could not connect to the database. retry later');      
              }
         });
      }  
  }

Теперь подкорректируем серверный скрипт database.php:

Наши варианты выбора пополнятся:

    case "DELETEPRES":
        deletePresidents();
        break;

А теперь нам нужно реализовать функцию deletePresidents(). Эта небольшая часть, которая строит запрос взависимости от выбора. На не нужно делать столько же запросов, сколько нам нужно удалить записей. Мы должны сделать все удаления в одном запросе. (Firebug очень здесь поможет) В любом случаем запрос создается следующей функцией:

function deletePresidents(){
   $ids = $_POST['ids']; // Get our array back and translate it :
   if (version_compare(PHP_VERSION,"5.2","<"))  {    
     require_once("./JSON.php"); 
     $json = new Services_JSON();
     $idpres = $json->decode(stripslashes($ids));
   } else {
     $idpres = json_decode(stripslashes($ids));
   }
   
    // You could do some checkups here and return '0' or other error consts.
    
    // Make a single query to delete all of the presidents at the same time :
    if(sizeof($idpres)<1){
      echo '0';
    } else if (sizeof($idpres) == 1){
      $query = "DELETE FROM presidents WHERE IDpresident = ".$idpres[0];
      mysql_query($query);
    } else {
      $query = "DELETE FROM presidents WHERE ";
      for($i = 0; $i < sizeof($idpres); $i++){
         $query = $query . "IDpresident = ".$idpres[$i];
         if($i<sizeof($idpres)-1){
            $query = $query . " OR ";
         }     
      }
      mysql_query($query);
    }
    // echo $query;  This helps me find out what the heck is going on in Firebug...
    echo '1';
}

Что надо запомнить из этой части:
SelectionModels
Firebug сохранит много вашего времени

Файлы этой части вы найдете здесь

Источник: http://extjs.com/learn/w/index.php?title=Tutorial:Grid_PHP_SQL_Part6

Учебник: Grid PHP SQL Часть 5

2008-12-05T10:44:00.010+02:00

Добавление новой записи

Отлично, мы создали нашу таблицу и теперь даже можем вносить в нее изменения. Они записываются прямо в нашу SQL таблицу. Эта часть учебника научит вас добавлять новые записи в таблицу.

Есть много путей сделать это. Один из вариантов - это вставка пустой новой записи и ее редактирование. Это вариант, предпочитаемый M. LeCompte. Мы собираемся сделать это несколько другим способом. Мы создадим новое окно, которое будет содержать форму для заполнения данных президента.

Создание формы
Отлично, давайте посмотрим, какие поля формы нам понадобятся:
* Текстовое поле имени президента
* Текстовое поле фамилии
* Два поля даты - для ввода дат президентсва.
* Числовое поле для ввода поступлений
* Выпадающий список для партии

Все это надо поместить в форму и отобразить в окне. Давайте сделаем это вначале скрипта:

  var PresidentCreateForm;
  var PresidentCreateWindow;

Чтобы каджому все было ясно и понятно мы будем создавать каждое поле до того, как добавлять его в форму. Каждое поле будет глобальной переменной (это не лучший вариант, позже вы сможете создавать различные идентификаторы для каждого поля и ссылаться на них) Просто запомните, вам бы не захотелось иметь 35078 глобальных переменных в программе... Также, почему мы делаем сейчас все таким способом - это защита от запуска двух форм одновременно.
Запомните: Если вы еще не ознакомились с нашей "подложкой" для кода приложения, позже вам лучше посмотреть учебник по Подложке (Структуре) Приложений сделаный Jozef Sakalos.
Давайте определим наши поля вначале скрипта:

  var FirstNameField;
  var LastNameField;
  var EnteringOfficeField;
  var LeavingOfficeField;
  var IncomeField;
  var PartyField;

Нам нужно написать код который описывает назначения каждого поля: (внутри функции onReady):

  FirstNameField = new Ext.form.TextField({
    id: 'FirstNameField',
    fieldLabel: 'First Name',
    maxLength: 20,
    allowBlank: false,
    anchor : '95%',
    maskRe: /([a-zA-Z0-9\s]+)$/
      });
      
  LastNameField = new Ext.form.TextField({
    id: 'LastNameField',
    fieldLabel: 'Last Name',
    maxLength: 20,
    allowBlank: false,
    anchor : '95%',    
    maskRe: /([a-zA-Z0-9\s]+)$/  
      });
  
  EnteringOfficeField = new Ext.form.DateField({
    id:'EnteringOfficeField',
    fieldLabel: 'Entering Office',
    format : 'm/d/Y',
    allowBlank: false,
    anchor:'95%'
    });
    
  LeavingOfficeField = new Ext.form.DateField({
    id:'LeavingOfficeField',
    fieldLabel: 'Leaving Office',
    allowBlank: false,
    format : 'm/d/Y',
    anchor:'95%'
    });
  
  IncomeField = new Ext.form.NumberField({
    id:'IncomeField',
    fieldLabel: 'Income',
    allowNegative: false,
    allowBlank: false,
    anchor:'95%'
    });

Все очень просто и понятно. Теперь у нас есть поля... Вам нравится? Запомните, что поле должно быть связано с данными в SQL таблице. В 3 Части мы говорили об этом при использовании DataStore. В 4 части мы видим три различных варианта заполнения нашего выпадающего списка.
В этой части учебника мы продолжим использование SimpleStore. Вам следует держать в памяти, что заполнение нашего списка из предопределенного HTML списка может создать некоторые проблемы совместимости броузера (я подумал о бедных пользователях IE немножко...)

  PartyField = new Ext.form.ComboBox({
     id:'PartyField',
     fieldLabel: 'Party',
     store:new Ext.data.SimpleStore({
       fields:['partyValue', 'partyName'],
       data: [['1','No Party'],['2','Federalist'],['3','Democratic-Republican'],['4','Democratic'],['5','Whig'],['6','Republican']]
       }),
     mode: 'local',
     displayField: 'partyName',
     allowBlank: false,
     valueField: 'partyValue',
     anchor:'95%',
     triggerAction: 'all'
      });

Создание формы

Теперь все поля созданы и готовы, надо создать форму для них:

  PresidentCreateForm = new Ext.FormPanel({
        labelAlign: 'top',
        bodyStyle:'padding:5px',
        width: 600,        
        items: [{
            layout:'column',
            border:false,
            items:[{
                columnWidth:0.5,
                layout: 'form',
                border:false,
                items: [FirstNameField, LastNameField, PartyField]
            },{
                columnWidth:0.5,
                layout: 'form',
                border:false,
                items: [EnteringOfficeField, LeavingOfficeField, IncomeField]
            }]
        }],
    buttons: [{
      text: 'Save and Close',
      handler: createThePresident
    },{
      text: 'Cancel',
      handler: function(){
        // because of the global vars, we can only instantiate one window... so let's just hide it.
        PresidentCreateWindow.hide();
      }
    }]
    });
  
  PresidentCreateWindow= new Ext.Window({
      id: 'PresidentCreateWindow',
      title: 'Creating a New President',
      closable:true,
      width: 610,
      height: 250,
      plain:true,
      layout: 'fit',
      items: PresidentCreateForm
    });

Ок... неплохо да? Недо запомнить одну важную вещь, то что каждый вложенный элемент имеет поле layout (подложка). Не забудьте его, так как это тема множества топиков на форумах... Ну хорошо, теперь у нас есть отличная форма. До того, как мы ее покажем, нам нужно перехватывать события кнопок и создать функции для каждого из них для сохранения данных. Хорошая штука в том, что мы так создали форму в том мы можем напрямую получать значения полей с помощью методов setValue() или getValue().

Давайте сначала создадим небольшие функции для работы с формой.

  // reset the Form before opening it
  function resetPresidentForm(){
    FirstNameField.setValue('');
    LastNameField.setValue('');
    EnteringOfficeField.setValue('');
    LeavingOfficeField.setValue('');
    IncomeField.setValue('');
    PartyField.setValue('');    
  }
  
  // check if the form is valid
  function isPresidentFormValid(){
  return(FirstNameField.isValid() && LastNameField.isValid() && EnteringOfficeField.isValid() && LeavingOfficeField.isValid() && IncomeField.isValid() && PartyField.isValid());
  }
  
  // display or bring forth the form
  function displayFormWindow(){
  if(!PresidentCreateWindow.isVisible()){
    resetPresidentForm();
    PresidentCreateWindow.show();
  } else {
    PresidentCreateWindow.toFront();
  }
  }

Создание президента
Теперь нам нужно реализовать метод сохранения. Вы найдете его достаточно простым по сравнению с тем, что мы делали при редактировании ячеек:

  function createThePresident(){
     if(isPresidentFormValid()){
      Ext.Ajax.request({   
        waitMsg: 'Please wait...',
        url: 'database.php',
        params: {
          task: "CREATEPRES",
          firstname:      FirstNameField.getValue(),
          lastname:       LastNameField.getValue(),
          enteringoffice: EnteringOfficeField.getValue().format('Y-m-d'),
          leavingoffice:  LeavingOfficeField.getValue().format('Y-m-d'),
          income:         IncomeField.getValue(),
          party:          PartyField.getValue()
        }, 
        success: function(response){              
          var result=eval(response.responseText);
          switch(result){
          case 1:
            Ext.MessageBox.alert('Creation OK','The president was created successfully.');
            PresidentsDataStore.reload();
            PresidentCreateWindow.hide();
            break;
          default:
            Ext.MessageBox.alert('Warning','Could not create the president.');
            break;
          }        
        },
        failure: function(response){
          var result=response.responseText;
          Ext.MessageBox.alert('error','could not connect to the database. retry later');          
        }                      
      });
    } else {
      Ext.MessageBox.alert('Warning', 'Your Form is not valid!');
    }
  }

Отлично... Это было неплохо, да? Теперь все что нам нужно это каким-нибудь образом вызывать displayFormWindow(). Мы можем делать это через контекстное меню (правый клик) который опишем позже, или мы можем сделать это с помощью панели инструментов. Давайте сделаем эту панель:
Нам просто нужно добавить следующее в наш конструктор EditorGrid:

      tbar: [{
         text: 'Add a president',
  tooltip: 'Great Tooltip',
         iconCls:'add',    // this is defined in our styles.css
         handler: displayFormWindow
      }]

Последние штрихи

Отлично. Мы еще не все сделали. Нам нужна серверная обработка запроса CREATEPRES.
Идем в файл database.php и вставим ее:
В выборе:

    case "CREATEPRES":
        createPresident();
        break;

И напишем саму функцию:

function createPresident(){

 $firstname = addslashes($_POST['firstname']);
 $lastname = addslashes($_POST['lastname']);
 $enteringoffice = $_POST['enteringoffice'];
 $leavingoffice = $_POST['leavingoffice'];
 $income = $_POST['income'];
 $party  = $_POST['party'];

 // Here we should probably do some database checking, to make sure that we do not have the same entry twice for ex... And we would return a different error code (ECHO '0' or whatever you want...) For now we'll pretend like the entry is valid. 
 $query = "INSERT INTO presidents (`IDpresident` ,`IDparty` ,`firstname` ,`lastname` ,`tookoffice` ,`leftoffice` ,`income` ) VALUES (NULL , '$party', '$firstname', '$lastname', '$enteringoffice', '$leavingoffice', '$income')";
 $result = mysql_query($query);
 echo '1';
}

Вот теперь вы можете добавлять президентов в вашу таблицу.

Что надо запомнить из этой части:
-Обязательно про SimpleStore

Файлы этой части учебника доступны здесь

Иточник: http://extjs.com/learn/Tutorial:Grid_PHP_SQL_Part5