Базовые объекты для всех приложений какао

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

Рисунок 2-4 показывает отношения среди базовых объектов для стилей приложения единственного окна. Объекты в этом числе разделяются согласно тому, являются ли они частью модели, представления или частей контроллера приложения. Как Вы видите от фигуры, Предоставленные какао объекты обеспечивают большую часть контроллера и просматривают уровень для Вашего приложения.

Таблица 2-2 описывает роли, которые играют объекты в схеме.

Дополнительные базовые объекты для приложений мультиокна

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

Рисунок 2-5 показывает отношения среди базовых объектов мультиокна основанное на документе приложение. Многие из тех же объектов в этом числе идентичны используемым приложением единственного окна. Основным различием является вставка NSDocumentController и NSDocument объекты между объектами приложения и объекты для управления пользовательским интерфейсом.

Таблица 2-3 описывает роль вставленного NSDocumentController и NSDocument объекты. (Для получения информации о ролях других объектов в схеме посмотрите Таблицу 2-2.)

Интеграция Поддержки iCloud В Приложение

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

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

• Основанные на документе приложения передают поддержку iCloud NSDocument класс, обрабатывающий большинство взаимодействий, требуемых управлять дисковыми пакетами файла, представляющими документы.

• Если Вы реализуете пользовательскую модель данных и управляете файлами сами, необходимо явно использовать координацию файла, чтобы гарантировать, что изменения, которые Вы вносите, сделаны безопасно и совместно с изменениями, внесенными на других устройствах пользователя. Для получения дополнительной информации посмотрите Роль Координаторов Файла и Предъявителей в Руководстве по программированию Файловой системы.

• Для хранения мелких сумм данных в iCloud Вы используете хранение значения ключа. Используйте хранение значения ключа для таких вещей как акции или информация о погоде, расположения, закладки, список недавних документов, настройки и предпочтения и простое игровое состояние. Каждое приложение iCloud должно использовать в своих интересах хранение значения ключа. Для взаимодействия с хранением значения ключа Вы используете совместно используемое NSUbiquitousKeyValueStore объект.

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

Приложения стиля обувной коробки не должны использовать NSDocument

При реализации единственного окна, стиль обувной коробки (иногда называемый стилем «библиотеки») приложение, иногда лучше не использовать NSDocument объекты управлять Вашим содержанием. NSDocument класс был специально разработан для использования в приложениях документа мультиокна. Вместо этого используйте пользовательские объекты контроллера управлять Вашими данными. Те пользовательские контроллеры тогда работали бы с целью контроллер или контроллер главного окна Вашего приложения для координирования представления данных.

Несмотря на то, что Вы обычно используете NSDocumentController возразите только в приложениях мультиокна, можно разделить его на подклассы и использовать его в приложении единственного окна для координирования Открыть Recent and similar behaviors. Когда разделение на подклассы, тем не менее, Вас должно переопределить любые методы, связанные с созданием NSDocument объекты.

Документы в OS X

Существует несколько способов думать о документе. Концептуально, документ является контейнером для объема информации, который можно назвать и сохранены в дисковом файле и в iCloud. В этом смысле документ не является тем же как файлом, но является объектом в памяти, владеющей и управляющей данными документа. Пользователям документ является их информацией — такой как текст и графика, отформатированная на странице. Программно, документ является экземпляром пользовательского NSDocument подкласс, знающий, как представлять внутренне персистентные данные, которые он может вывести на экран в окнах. Этот объект документа знает, как считать данные документа из файла и создать граф объектов в памяти для модели данных документа. Это также знает, как обработать команды редактирования пользователя, чтобы изменить модель данных и записать данные документа обратно к диску. Так, объект документа посредничает между различными представлениями данных документа, как показано на рисунке 2-6.

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

Архитектура документа обеспечивает много возможностей бесплатно

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

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

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

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

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

• Асинхронно считайте и запишите данные документа. Чтение и запись сделаны асинхронно на фоновом потоке, так, чтобы длинные операции не делали пользовательский интерфейс приложения безразличным. Кроме того, чтения и записи координируются с помощью NSFilePresenter протокол и NSFileCoordinator класс для сокращения конфликтов версий. Скоординированные чтения и записи сокращают конфликты версий и среди различных приложений, совместно использующих данные документа в локальном хранении и среди различных экземпляров приложения на различных устройствах, совместно использующих данные документа через iCloud.

• Управляйте многократными версиями документов. Автосохранение создает версии равномерно, и пользователи могут вручную сохранить версию каждый раз, когда они желают. Пользователи могут просмотреть версии и вернуться содержание документа к выбранной версии с помощью подобного машине времени интерфейса. Браузер версии также используется для разрешения конфликтов версий от одновременных обновлений iCloud.

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

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

• Изменения дорожки. Документ управляет своим отредактированным состоянием и реализует многоуровневую отмену и восстановление.

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

См. Основанное на документе Руководство по программированию Приложения для Mac для более подробной информации о том, как реализовать основанное на документе приложение.

Основная Функция является Точкой входа Приложения

Как любое приложение на базе С, основная точка входа для приложения Mac во время запуска main функция. В приложении Mac, main функция используется только минимально. Его основное задание должно дать контроль к платформе AppKit. Любой новый проект, который Вы создаете в XCode, идет со значением по умолчанию main функционируйте как один показанный в Перечислении 2-1. Вы не должны обычно должны быть изменять реализацию этой функции.

Перечисление 2-1  main функция приложения Mac

#import <Cocoa/Cocoa.h>

int main(int argc, char *argv[])

{

    return NSApplicationMain(argc,  (const char **) argv);

}

NSApplicationMain функция инициализирует Ваше приложение и подготавливает его для выполнения. Как часть процесса инициализации, эта функция делает несколько вещей:

• Создает экземпляр NSApplication класс. Можно получить доступ к этому объекту отовсюду в приложении с помощью sharedApplication метод класса.

• Загружает файл пера, указанный NSMainNibFile ключ Info.plist файл и инстанцирует всех объектов в том файле. Это - основной файл пера Вашего приложения и должно содержать Вашего делегата приложения и любые другие критические объекты, которые должны быть загружены рано в цикле запуска. Любые объекты, которые не необходимы во время запуска, должны быть помещены в отдельные файлы пера и загружены позже.

• Вызовы run метод Вашего объекта приложения, чтобы закончить цикл запуска и начать обрабатывать события.

К этому времени run метод вызывают, основные объекты Вашего приложения загружаются в память, но полностью все еще не запускается приложение. run метод уведомляет делегата приложения, что приложение собирается запуститься, показывает панель меню приложения, открывает любые файлы, переданные приложению, делает некоторое обслуживание платформы и запускает цикл обработки событий. Вся эта работа происходит на основном потоке приложения за одним исключением. Файлы могут быть открыты во вторичных потоках если canConcurrentlyReadDocumentsOfType: метод класса из соответствия NSDocument объектные возвраты YES.

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

Основной цикл событий приложения управляет взаимодействиями

Поскольку пользователь взаимодействует с Вашим приложением, основные процессы цикла событий приложения входящие события и диспетчеризирует их надлежащим объектам для обработки. Когда NSApplication объект сначала создается, он устанавливает соединение с системным сервером окна, получающим события от используемого оборудования и передающим их приложению. Приложение также устанавливает очередь событий FIFO для хранения событий, отправленных в него сервером окна. Основной цикл событий тогда ответственен за события исключения из очереди и обработки, ожидающие в очереди, как показано на рисунке 2-7.

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

1. Уведомления обновления окна служб, который приводит к перерисовке любых окон, отмеченных как «грязные».

2. Исключает событие из очереди от его очереди внутреннего события, использующей nextEventMatchingMask:untilDate:inMode:dequeue: метод и преобразовывает данные о событии в NSEvent объект.

3. Диспетчеризирует событие надлежащему целевому объекту с помощью sendEvent: метод NSApplication.

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

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

Полный процесс для обработки событий описан подробно в Руководстве по Обработке событий Какао.

Автоматическое и внезапное завершение приложений улучшает пользовательский опыт

В OS X v10.7 и позже, использование команды Quit для завершения приложения уменьшено в пользу большего количества ориентированных на пользоователя методов. В частности Какао поддерживает два метода, делающие завершение приложения прозрачным и быстрым:

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

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

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

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

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

Для получения информации о том, как поддерживать для автоматического завершения в Вашем приложении, посмотрите Автоматическое Завершение. Для получения информации о том, как поддерживать внезапное завершение, посмотрите Внезапное Завершение.

Автоматическое завершение

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

Для поддержки автоматического завершения необходимо сделать следующее:

• Объявите поддержку своего приложения автоматического завершения, или программно или использование Info.plist ключ.

• Сохранение поддержки и восстановление Ваших конфигураций окна.

• Сохраните данные пользователя в подходящее время.

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

  • Мультиокно, основанные на документе приложения могут использовать автоматическое сохранение и saveless возможности документов в NSDocument.

• Каждый раз, когда возможно, поддерживайте внезапное завершение для своего приложения также.

Внезапное завершение

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

Приложение имеет два способа объявить его поддержку внезапного завершения:

• Включайте NSSupportsSuddenTermination ключ (со значением YES) в приложении Info.plist файл.

• Используйте NSProcessInfo класс для объявления поддержки внезапного завершения динамично. Можно также использовать этот класс для изменения поддержки по умолчанию приложения, включающего NSSupportsSuddenTermination ключ в Info.plist файл.

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

Вы отключаете и включаете внезапное завершение программно с помощью disableSuddenTermination и enableSuddenTermination методы NSProcessInfo класс. Эти методы постепенно увеличивают и постепенно уменьшают счетчик, соответственно, сохраняемый процессом. Когда значение этого счетчика 0, процесс приемлем на внезапное завершение. Когда значение больше, чем 0, внезапное завершение отключено.

Включение и отключение внезапного завершения динамично также означают, что Ваше приложение должно прогрессивно сохранять данные и не полагаться исключительно на пользовательские действия для сохранения важной информации. Лучший способ гарантировать, что информация Вашего приложения сохранена в подходящее время, состоит в том, чтобы поддерживать интерфейсы в OS X v10.7 для того, чтобы сохранить Ваш документ и статус окна. Те интерфейсы упрощают автоматическое сохранение данных приложения и соответствующего пользователя. Для получения дополнительной информации о сохранении Вашего состояния пользовательского интерфейса, посмотрите Сохранение Пользовательского интерфейса. Для получения дополнительной информации о сохранении Ваших документов, посмотрите, что Основанные на документе Приложения Основываются на Подклассе NSDocument.

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

Сохранение пользовательского интерфейса

Функция Resume, в OS X v10.7 и позже, сохраняет состояние окон Вашего приложения и восстанавливает их во время последующих запусков Вашего приложения. Сохранение состояния Ваших окон позволяет Вам возвратить свое приложение состоянию, это было в том, когда пользователь в последний раз использовал его. Используйте функцию Resume особенно, если Ваши поддержки приложений автоматическое завершение, которое может заставить Ваше приложение быть завершенным, в то время как это работает, но скрытое от пользователя. Если Ваши поддержки приложений его состояние по умолчанию, автоматическое завершение, но не сохраняет свой интерфейс, приложение начинают, пользователи, только переключившиеся далеко от Вашего приложения, могли бы думать, что приложение отказало, в то время как это не использовалось.

Выписывание состояния Windows и пользовательских объектов

Необходимо сделать следующий для сохранения состояния пользовательского интерфейса:

• Для каждого окна необходимо установить, должно ли окно быть сохранено с помощью setRestorable: метод.

• Для каждого сохраненного окна необходимо указать объект, задание которого должно воссоздать то окно во время запуска.

• Любые объекты, вовлеченные в Ваш пользовательский интерфейс, должны выписать данные, которых они требуют для восстановления их состояния позже.

• Во время запуска необходимо использовать предоставленные данные для восстановления объектов к их предыдущему состоянию.

Фактический процесс выписывания Вашего состояния приложения к диску и восстановлению его позже обрабатывается Какао, но необходимо сказать Какао, что сохранить. Окна Вашего приложения являются начальной точкой для всех, сохраняют операции. Какао выполняет итерации по всем окнам Вашего приложения и сохраняет данные для тех чей isRestorable возвраты метода YES. Большинство окон сохраняется по умолчанию, но можно изменить состояние сохранения окна с помощью setRestorable: метод.

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

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

• Если Вы разделяете на подклассы NSWindow или NSView, реализуйте encodeRestorableStateWithCoder: метод в Вашем подклассе и использовании это для выписывания любых соответствующих данных.

  Также Ваши пользовательские объекты респондента могут переопределить restorableStateKeyPaths метод и использование это для указания ключа соединяет каналом для любых атрибутов, которые будут сохранены. Какао использует ключевые пути, чтобы определить местоположение и сохранить данные для соответствующего атрибута. Атрибуты должны быть совместимыми с кодированием значения ключа и наблюдением Значения ключа.

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

• В Вашем контроллере окна используйте encodeRestorableStateWithCoder: метод для сохранения любых соответствующих данных или конфигурационной информации.

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

Для получения информации о том, как использовать объекты кодера заархивировать информацию состояния, видеть Ссылку класса NSCoder. Для получения дополнительной информации о том, что необходимо сделать для сохранения состояния в мультиокне основанное на документе приложение, см. Основанное на документе Руководство по программированию Приложения для Mac.

+ (void)restoreWindowWithIdentifier:(NSString *)identifier

        state:(NSCoder *)state

        completionHandler:(void (^)(NSWindow *, NSError *))completionHandler

{

   // Get the window from the window controller,

   // which is stored as an outlet by the delegate.

   // Both the app delegate and window controller are

   // created when the main nib file is loaded.

   MyAppDelegate* appDelegate = (MyAppDelegate*)[[NSApplication sharedApplication] delegate];

   NSWindow* mainWindow = [appDelegate.windowController window];

   // Pass the window to the provided completion handler.

   completionHandler(mainWindow, nil);

}

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

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

Вы используете окна и представления, чтобы представить визуальное содержание Вашего приложения на экране и управлять непосредственными взаимодействиями с тем содержанием. Окно является экземпляром NSWindow класс. Панель является экземпляром NSPanel класс (который является потомком NSWindow) то, что Вы используете для представления вторичного содержания. Приложения единственного окна имеют одно главное окно и могут иметь один или несколько вторичные окна или панели. Приложения мультиокна имеют многократные окна для отображения их основного содержания и могут иметь один или несколько вторичные окна или панели также. Стиль окна определяет свое появление на экране. Рисунок 2-9 показывает строку меню, вместе с некоторыми стандартными окнами и панелями.

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

• Рисование и поддержка анимации. Представления рисуют содержание в своей прямоугольной области. Представления, что Слои анимации Ядра поддержки могут использовать те уровни для анимации их содержания.

• Расположение и управление подпредставлением. Каждое представление управляет списком подпредставлений, позволяя Вам создать произвольные иерархии представления. Каждое представление определяет способы поведения расположения и изменения размеров разместить изменения в размере окна.

• Обработка событий. Представления получают события. Представления передают события к другим объектам в надлежащих случаях.

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

Обработка событий

Системный сервер окна ответственен за отслеживание мыши, клавиатуры, и других событий и поставки их к Вашему приложению. Когда система запускает приложение, она создает и процесс и единственный поток для приложения. Этот начальный поток становится основным потоком приложения. В нем, NSApplication объект устанавливает основной цикл выполнения и конфигурирует его код обработки событий, как показано на рисунке 2-10. Поскольку сервер окна поставляет события, приложение ставит те события в очередь и затем обрабатывает их последовательно в основном цикле выполнения приложения. Обработка события включает диспетчеризацию события к объекту, подходящему лучше всего для обработки его. Например, события от нажатия мыши обычно диспетчеризируются представлению, в котором событие имело место.

Распределение и обработка событий являются заданием объектов респондента, которые являются экземплярами NSResponder класс. NSApplication, NSWindow, NSDrawer, NSView, NSWindowController, и NSViewController классы являются всеми потомками NSResponder. После получения по запросу события от очереди событий приложение диспетчеризирует то событие объекту окна, где это произошло. Объект окна, в свою очередь, передает событие его первому респонденту. В случае событий от нажатия мыши первый респондент обычно является объектом представления (NSView) в котором имело место касание. Например, событие от нажатия мыши, происходящее в кнопке, поставлено соответствующему объекту кнопки.

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

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

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

Графика, получение и печать

Существует два основных пути, которыми приложение Mac может нарисовать свое содержание:

• Собственные технологии получения (такие как Базовая Графика и AppKit)

• OpenGL

Собственные технологии рисования OS X обычно используют инфраструктуру, предоставленную представлениями Какао и окнами, чтобы представить и представить пользовательское содержание. Когда представление сначала показано, система просит, чтобы он нарисовал свое содержание. Системные представления рисуют свое содержание автоматически, но пользовательские представления должны реализовать a drawRect: метод. В этом методе Вы используете собственные технологии получения для рисования форм, текста, изображений, градиентов или любого другого визуального содержания, которое Вы хотите. Когда Вы хотите обновить визуальное содержание своего представления, Вы отмечаете все или часть представления, недопустимого путем вызова setNeedsDisplay: или setNeedsDisplayInRect: метод. Система тогда вызывает Ваше представление drawRect: метод (в подходящее время) для размещения обновления. Этот цикл тогда повторяется и продолжается всюду по времени жизни Вашего приложения.

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

Для получения информации о том, как нарисовать пользовательское содержание в Ваших представлениях, посмотрите, что Какао Рисует Руководство.

Текстовая обработка

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

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

Лежание в основе текстовой системы Какао является Базовым текстом, обеспечивающим низкий уровень, основное текстовое расположение и обрабатывающие шрифт возможности к высокоуровневым механизмам, таким как Какао и WebKit. Базовый текст обеспечивает реализацию для многих текстовых технологий Какао. У разработчиков приложений обычно нет потребности использовать Базовый текст непосредственно. Однако Базовый текстовый API доступен для разработчиков, которые должны использовать его непосредственно, такие как те, которые пишут приложения с их собственным механизмом расположения и теми, которые портируют более старый ATSUI-или находящиеся в QuickDraw кодовые базы к современному миру.

Для получения дополнительной информации о текстовой системе Какао, посмотрите текстовое Руководство по архитектуре Какао.

Шаблоны XCode обеспечивают строку меню

Шаблоны приложений Какао XCode обеспечивают это NSMenu экземпляр в файле пера вызывают MainMenu.xib. Этот файл пера содержит меню приложения (названный с именем приложения), меню File (со всеми его связанными командами), меню Edit (с командами редактирования текста и пунктами меню Undo и Redo), и Формат, Представление, Окно и Меню справки (с их собственными командами представления пунктов меню). Эти пункты меню, а также все пункты меню меню File, подключены к надлежащим методам действия первого респондента. Например, пункт меню About подключен с orderFrontStandardAboutPanel: метод действия во Владельце Файла, выводящем на экран стандартное окно About.

Шаблон имеет подобные готовые соединения для Редактирования, Формата, Представления, Окна и Меню справки. Если Ваше приложение не поддерживает ни одного из предоставленных действий (например, распечатывая), необходимо удалить связанные пункты меню (или меню) от пера. Также можно хотеть повторно иметь целью и переименовать команды меню и методы действия удовлетворить собственному приложению, используя в своих интересах механизм меню в шаблоне, чтобы гарантировать, что все находится в правильном месте.

Подключите пункты меню к своему коду или своему первому респонденту

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

• Подключите соответствующий пункт меню к первому методу респондента.

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

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

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