Название книги в оригинале: Нахавандипур Вандад. iOS. Приемы программирования

A- A A+ White background Book background Black background

На главную » Нахавандипур Вандад » iOS. Приемы программирования.





Читать онлайн iOS. Приемы программирования. Нахавандипур Вандад.

Вандад Нахавандипур

iOS. Приемы программирования

 Сделать закладку на этом месте книги

Предисловие

 Сделать закладку на этом месте книги

Это издание книги является не просто дополненной, а полностью переработанной версией предыдущего. В iOS 7 изменилось все: внешний вид и функциональная сторона операционной системы, способы использования наших устройств с iOS и, самое главное, принципы программирования для таких устройств. Действительно, без серьезной переработки всей книги было не обойтись. Я добавил в нее примерно 50 новых разделов-рецептов, затронув в них такие вопросы, как динамика UIKit, работа с видами-коллекциями, связкой ключей, удаленными уведомлениями и пр. Кроме того, я проработал все примеры кода и иллюстрации и обновил их с учетом iOS 7.

iOS 7 — огромный шаг вперед в развитии той операционной системы, которую любим все мы, пользователи и разработчики. Нам нравится как работать с нею, так и программировать для нее. Возможно, вы заметили, какое внимание в iOS 7 уделяется динамичности  системы: ваш пользовательский интерфейс должен реагировать на различные движения и перемещения, которые могут происходить с устройством. Я имею в виду следующее: Apple стремится, чтобы разработчики по-настоящему внимательно относились к деталям создаваемых приложений, обогащали их реалистичной физикой и динамикой. Именно поэтому Apple дополнила iOS SDK новым элементом — UIKit Dynamics, а в этой книге данной концепции посвящена целая глава. iPhone становится все более высокотехнологичным устройством, оставаясь при этом довольно дорогим. Соответственно, запросы его пользователей также растут. И это понятно. Пользователь только что приобрел совершенно фантастический новейший iPhone или iPad и хочет найти на нем замечательные приложения, максимально полно и эффективно задействующие все возможности этих устройств.

Именно поэтому сейчас разработчик как никогда нуждается в глубоких знаниях SDK, чтобы понимать, что этот SDK может предложить программисту для создания более классных и быстрых приложений. Apple реализовала в SDK для iOS 7 множество классных новых API, и в этой книге мы подробно с ними познакомимся.

Главной особенностью iOS 7 является динамика!

Прежде чем вы приступите к изучению этой книги, я хотел бы немного рассказать о своем профессиональном опыте и о том, чем смогу помочь вам в путешествии по ее страницам. Поведаю, что я за человек и как началась моя большая любовь к iOS. Еще ребенком я впервые попробовал писать код на Basic, тогда у меня был компьютер Commodore 64. Потом я купил себе ПК и принялся экспериментировать с кодом на ассемблере. Сначала это был 8-битный ассемблер для DOS. Затем я попробовал в домашних условиях написать собственную операционную систему, которая так и не была выпущена в качестве коммерческой программы. Она предназначалась для работы на 32-битной архитектуре на процессоре Intel x86.

Среди языков программирования, в которых я пробовал свои силы, особое место занимают ассемблер и Objective-C. Они мне по-настоящему нравились и очень отличались от всех остальных. В ассемблере меня привлекала его чистота: каждая команда делает всего одну вещь, и делает ее хорошо. Думаю, Objective-C приглянулся мне по схожей причине. На самом деле этот признак ассемблера и Objective-C прослеживается во всей операционной системе iOS. Конечно, iOS — это именно операционная система, а ни в коем случае не язык программирования, но во всем, что она делает, iOS обходит своих конкурентов. Это касается как ее простоты, так и того чистого потенциала, которым она наделяет вас, комбинируя аппаратные и программные возможности. В iOS используются замечательные собственные технологии, в частности GCD. Эта операционная система задает такую высокую планку в области удобства и простоты использования, которая до сих пор остается беспрецедентной.

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

Для кого предназначена книга

 Сделать закладку на этом месте книги

Предполагается, что читатель хорошо знаком со средой для разработки в iOS и знает, как создать приложение для iPhone или iPad. Эта книга не подойдет программисту-новичку в качестве вводного пособия, но в ней описаны удобные способы решения конкретных задач, с которыми могут столкнуться программисты разного уровня — и новички, и эксперты.

Как построено издание

 Сделать закладку на этом месте книги

В этой книге мы рассмотрим фреймворки и классы, доступные в SDK для iOS 7. Я приложил все возможные усилия, чтобы на ее страницах научить вас работе с новейшими и самыми классными API iOS. Разумеется, некоторые пользователи ваших приложений могут работать и с более старыми версиями iOS. Пожалуйста, не забывайте об этих пользователях и выбирайте API рационально, с учетом минимальной версии iOS, на работу с которой рассчитано ваше приложение.

Apple рекомендует писать приложения таким образом, чтобы они поддерживались и работали в версиях iOS 6 и 7. Таким образом, в качестве базового SDK вы должны применять последнюю версию этого инструментария (имеется в виду SDK, на базе которого будет компилироваться ваше приложение) и выбирать в качестве целевой платформы iOS 6 (если это не противоречит поставленным перед вами бизнес-требованиям). Если от вас требуется написать такое приложение, которое должно поддерживаться только в iOS 7, вас ждет масса интересного. Ведь вы будете работать с превосходными API, появившимися только в iOS 7 и рассмотренными в этой книге.

Рассмотрим краткое содержание материала.

 Глава 1. Реализация контроллеров и видов. В этой главе объясняется структура классов в Objective-C и рассматриваются способы реализации объектов. Здесь мы поговорим о свойствах и делегатах, а также о подписке по ключам и индексам. Даже если вы хорошо разбираетесь в Objective-C, настоятельно рекомендую вам изучить данную главу, пусть даже бегло. Это нужно, чтобы понять базовый материал, на котором построены остальные главы. В этой главе мы также рассмотрим типичные способы обращения с различными элементами пользовательского интерфейса — видами-предупреждениями, сегментированными элементами управления, переключателями и надписями. Также поговорим о настройке этих компонентов с применением новейших API, имеющихся в SDK.

 Глава 2. Создание динамических и интерактивных пользовательских интерфейсов. Глава рассказывает о UIKit Dynamics — новейшем дополнении, появившемся во фреймворке UIKit. Эти динамические компоненты позволяют обогащать компоненты вашего пользовательского интерфейса реалистичной физикой и динамикой. Интерфейсы получатся еще более живыми, причем с меньшими усилиями с вашей стороны.

 Глава 3. Автоматическая компоновка и язык визуального форматирования. В этой главе вы узнаете, как пользоваться возможностью автоматической компоновки в iOS SDK и создавать пользовательские интерфейсы таким образом, чтобы их можно было гибко масштабировать (сжимать и растягивать) на экране практически в любом направлении.

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

 Глава 5. Выстраивание сложных макетов с помощью сборных видов. Виды-коллекции уже довольно давно вошли в арсенал программистов, работающих с OS X. Теперь Apple решила включить те же самые API в iOS SDK, предоставив их, таким образом, iOS-программистам. Виды-коллекции во многом напоминают табличные виды, но отличаются значительно более широкими возможностями конфигурирования и динамичностью. Если в табличных видах мы имеем дело с концепцией разделов, каждый из которых делится на строки, в видах-коллекциях появляются также столбцы. Поэтому в виде-коллекции вы при желании можете отображать много элементов в одной строке. В этой главе мы рассмотрим все великолепные пользовательские интерфейсы, которые можно создавать с применением видов-коллекций.

 Глава 6. Раскадровки. Здесь мы поговорим о процессе раскадровки. Это новый способ определения связей между различными экранами (видами), задействованными в приложении. Самая приятная особенность раскадровки заключается в том, что вам совсем не обязательно вообще что-то знать о программировании для iOS, чтобы написать и запустить простое приложение. Это свойство очень помогает специалистам, работающим вне команды, — аналитикам, владельцам продукта или дизайнерам, — а также команде разработчиков познакомиться со свойствами, которыми обладают компоненты пользовательского интерфейса в iOS, и, имея такие знания, создавать более надежные продукты. Кроме того, преимущества, которые дает раскадровка, облегчают работу программиста на этапе прототипирования. Раскадровка — это просто интересное дело, независимо от того, занимаетесь ли вы ею на бумаге или с помощью Xcode.

 Глава 7. Параллелизм. Человек умеет делать одновременно несколько вещей, причем особенно не задумываясь о том, как это происходит. С развитием информационных технологий мобильные устройства также становятся многозадачными. Разработчику, пишущему программы для таких устройств, предоставляются инструменты и механизмы, которые позволяют выполнять несколько задач в определенный момент времени. Этот феномен называется параллелизмом или конкурентным программированием. В главе 5 вы узнаете о технологии Grand Central Dispatch, с помощью которой Apple в основном обеспечивает параллелизм в iOS. В этой главе мы поговорим также о таймерах, потоках и операциях.

 Глава 8.Безопасность. iOS 7 — весьма безопасная операционная система. Приложения, которые мы для нее пишем, также должны соответствовать определенным стандартам и практикам обеспечения безопасности. В этой главе будет рассмотрено, как пользоваться преимуществами различных API связки ключей и повысить безопасность ваших приложений. Мы обсудим также различные меры, помогающие повысить безопасность вашего пользовательского интерфейса.

 Глава 9. Core Location и карты. В этой главе обсуждается работа с комплектом для программирования карт (Map Kit) и основных геолокационных API — то есть речь пойдет о написании приложений для iOS, располагающих информацией о местоположении устройства. Сначала поговорим о картах, потом обсудим, как определяется местоположение устройства, и снабдим ваши карты пользовательскими аннотациями. Потом изучим геокодирование и обратное геокодирование, а также методы, входящие в состав фреймворка Core Location, доступные лишь в версии iOS 7 SDK.

 Глава 10. Реализация распознавания жестов. Здесь демонстрируется использование механизмов, распознающих жесты пользователя на сенсорном экране. Они позволяют пользователю легко обращаться с графическим интерфейсом ваших приложений для iOS. В этой главе вы научитесь применять соответствующие механизмы, доступные в SDK для iOS, а также изучите рабочие примеры, которые протестированы в операционной системе iOS 7.

 Глава 11. Сетевые функции, JSON, XML и Twitter. Глава рассказывает о встроенных синтаксических анализаторах для JSON и XML. На базе этой информации в главе рассматриваются различные API для сетевых взаимодействий, а также обсуждается, как вы можете реализовать в ваших приложениях функции для общения в социальных сетях. С помощью таких возможностей пользователи смогут обмениваться своими данными и творчеством на подобных ресурсах, например в Facebook.

 Глава 12. Управление файлами и каталогами. Одна из самых важных задач, которые нам как разработчикам приходится решать при программировании для iOS, — это управление файлами и каталогами. В этой главе речь пойдет о создании, считывании, записи и удалении файлов. Здесь вы найдете информацию, достаточно подробную для того, чтобы наладить управление файлами и каталогами с помощью средств iOS SDK.

 Глава 13. Камера и библиотека фотографий. В данной главе показано, как обнаружить доступность камеры на передней и задней поверхностях устройства с системой iOS. Кроме того, вы научитесь обращаться к библиотеке фотографий посредством фреймворка ресурсов (Assets Framework). В конце главы рассказано о том, как редактировать видео прямо на устройстве с iOS с помощью встроенного контроллера видов.

 Глава 14. Многозадачность. В этой главе показано, как создавать приложения, ориентированные на многозадачность и хорошо функционирующие на устройствах с iOS. Вы узнаете об организации фоновых процессов, о воспроизведении аудио и определении местонахождения пользователя в фоновом режиме. Кроме того, мы поговорим о загрузке содержимого по URL, пока ваше приложение находится в фоновом режиме. Опираясь на эту информацию, мы также исследуем некоторые новые API для многозадачности, появившиеся в iOS 7. Они позволяют нам скачивать контент периодически, пока приложение работает в фоновом режиме и даже когда оно не запущено.

 Глава 15. Уведомления. Уведомления — это объекты, несущие определенную информацию, которая может передаваться множеству получателей методом широковещания. В этой главе мы обсудим уведомления, в том числе локальные и пуш-уведомления. Вы узнаете, как использовать новейшие возможности, встроенные в Xcode, и легко включать эти функции в свои приложения.

 Глава 16. Фреймворк Core Data. Глава описывает детали стеков Core Data и демонстрирует, из чего состоят эти стеки. Изучив ее, вы сможете проектировать собственные объектно-ориентированные модели данных прямо в Xcode с помощью редактора моделей Core Data, а также создавать и получать объекты в Core Data. Опираясь на эту информацию, вы научитесь добавлять в Core Data собственные данные и искать данные с помощью фонового потока. В таком случае ваш поток пользовательского интерфейса останется свободен и сможет своевременно обрабатывать пользовательские события.

 Глава 17. Графика и анимация. В этой главе дается введение во фреймворк Core Graphics. Вы узнаете, как отрисовывать изображения и текст в графическом контексте, рисовать линии, прямоугольники и пути, а также многое другое. Также вы познакомитесь с новыми API из iOS SDK, позволяющими фиксировать содержимое ваших видов в форме скриншотов.

 Глава 18. Фреймворк Core Motion. Как следует из названия, глава посвящена рассмотрению фреймворка Core Motion. С помощью Core Motion вы получаете доступ к акселерометру и гироскопу, установленным на устройстве с iOS. Кроме того, вы сможете регистрировать встряхивание устройства. Разумеется, не на всех устройствах с iOS имеются акселерометр и гироскоп, поэтому вы также узнаете, как определять доступность этого оборудования.

 Глава 19. Фреймворк Pass Kit. В этой главе описан Passbook — виртуальный кошелек, который позволяет управлять вашими купонами, посадочными талонами, железнодорожными и автобусными билетами, а также другими подобными документами. Здесь вы узнаете все необходимое для создания ваших собственных путевых документов с цифровой подписью и научитесь с легкостью раздавать их пользователям.

Дополнительные ресурсы

 Сделать закладку на этом месте книги

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

Для начала предлагаю ознакомиться с iOS Human Interface Guidelines (Руководством по созданию пользовательских интерфейсов для всех устройств iOS) (https://developer.apple.com/library/ios/documentation/UserExperience/Conceptual/MobileHIG/Introduction/Introduction.html). Этот документ необходимо прочитать любому программисту, работающему с iOS. На самом деле я считаю, что эти документы обязательно должны прочитать также сотрудники отделов разработки и дизайна продукции в любой компании, занимающейся iOS.

Рекомендую также просмотреть документ iOS Application Programming Guide (Руководство по программированию приложений для iOS), имеющийся в iOS Reference Library (Справочной библиотеке iOS), где даются полезные советы по созданию отличных приложений для iOS: https://developer.apple.com/library/ios/#documentation/iPhone/Conceptual/iPhoneOSProgrammingGuide/Introduction/Introduction.html.

В iOS 7 значительно изменились принципы представления компонентов пользовательского интерфейса на экране. Мы подробно обсудим все эти изменения и поговорим о том, как программист может применять эти новейшие API для создания замечательных приложений для iOS 7. Кроме того, я рекомендую вам ознакомиться с документом iOS 7 UI Transition Guide (Руководство по переходу на пользовательский интерфейс iOS 7) от Apple (https://developer.apple.com/library/ios/documentation/UserExperience/Conceptual/TransitionGuide/index.html#//apple_ref/doc/uid/TP400 13174). В нем описаны все изменения, связанные с пользовательским интерфейсом, появившиеся в последней версии SDK.

Читая главу 12, вы обратите внимание на то, что в ней одной из наиболее важных тем являются блоковые объекты. Блоковые объекты рассматриваются в книге вкратце, но чтобы подробнее разобраться с этой темой, рекомендую познакомиться с руководством A Short Practical Guide to Blocks (Краткое практическое руководство по блоковым объектам), доступным по следующей ссылке: https://developer.apple.com/library/ios/#featuredarticles/Short_Practical_Guide_Blocks/index.html%23/apple_ref/doc/uid/TP400 09758.

В книге я буду часто упоминать пакеты (bundles) и говорить о том, как загружать из пакетов изображения и данные. В издании будет кратко рассказано о пакетах, но если хотите разобраться с ними подробнее, прочтите Bundle Programming Guide (Руководство по программированию пакетов) по адресу: https://developer.apple.com/library/ios/#documentation/CoreFoundation/Conceptual/CFBundles/Introduction/Introduction.html.

Условные сокращения, используемые в данной книге

 Сделать закладку на этом месте книги

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

Шрифт для названий

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

Шрифт для команд

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

Шрифт для листингов

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

Данный символ означает совет, замечание практического характера или общее замечание.

Данный символ означает предостережение.

Работа с примерами кода

 Сделать закладку на этом месте книги

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

Нам интересны ваши отзывы

 Сделать закладку на этом месте книги

Все примеры кода из этой книги были протестированы на iPhone 4, iPhone 3GS и эмуляторе iPhone/iPad, но не исключено, что у вас все же возникнут какие-то сложности. Например, у вас будет иная версия SDK, нежели та, в которой компилировался и тестировался код из примера. Информация, изложенная в этой книге, проверялась на каждом этапе подготовки издания. Тем не менее мы могли допустить какие-то ошибки или чего-то недосмотреть, поэтому с благодарностью примем от вас информацию о любых подобных недочетах, которые могут вам встретиться, а также все ваши предложения о том, как можно было бы улучшить будущие издания книги. С автором и редакторами можно связаться по следующему адресу:

O’Reilly Media, Inc.

1005 Gravenstein Highway North

Sebastopol, CA 95472

(800) 998-9938 (в США или Канаде)

(707) 829-0515 (международный или местный телефон)

(707) 829-0104 (факс)

Благодарности

 Сделать закладку на этом месте книги

Энди Орам, мой любезный редактор, вновь потрудился на славу и внимательно проработал все изменения, появившиеся в новом издании книги. Фактически эта книга переработана полностью, это касается и содержащихся в ней скриншотов и примеров кода. Я хотел бы поблагодарить также Кшиштофа Гробельного и Кшиштофа Гутовского — моих хороших друзей и коллег, выполнивших техническое рецензирование книги. Без их участия она ни за что не оказалась бы в ваших руках.

Особой благодарности заслуживает Рэйчел Румелиотис, поддерживавшая меня и Энди. В первую очередь спасибо ей за ту административную работу, которая на первый взгляд как будто не видна. Кроме того, с наилучшей стороны себя показала Меган Конноли из издательства O’Reilly. Она терпеливо сносила мои причитания о бумажной работе, сотрудничество с ней доставило одно удовольствие. Благодарю Джессику Хозман за то, что помогла нам справиться с проблемами, которые возникали с Git. Я и поверить не мог, что те простые решения, которые она мне подсказывала, действительно сработают. Но они работали, а я порой чувствовал себя идиотом.

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

От издательства

 Сделать закладку на этом месте книги

Ваши замечания, предложения и вопросы отправляйте по адресу электронной почты [email protected] (издательство «Питер», компьютерная редакция).

Мы будем рады узнать ваше мнение!

На сайте издательства https://www.piter.com вы найдете подробную информацию о наших книгах.

Глава 1. Реализация контроллеров и видов

 Сделать закладку на этом месте книги

1.0. Введение

 Сделать закладку на этом месте книги

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

Чтобы программировать приложения для iOS 7, вы должны знать основы языка Objective-C, с которым мы будем работать на протяжении всей этой книги. Как понятно из названия, язык Objective-C основан на С, но имеет определенные расширения, которые облегчают оперирование объектами. Объекты и классы имеют фундаментальное значение в объектно-ориентированном программировании (ООП). К числу объектно-ориентированных языков относятся Objective-C, Java, C++ и многие другие. В Objective-C, как и в любом объектно-ориентированном языке, вы имеете доступ не только к объектам, но и к примитивам. Например, число –20 (минус двадцать) можно выразить в виде примитива следующим образом:

NSInteger myNumber = -20;

В этой простой строке кода определяется переменная myNumber, относящаяся к типу данных NSInteger. Ее значение устанавливается в 20. Так определяются переменные в языке Objective-C. Переменная — это простое присваивание имени местоположению в памяти. В таком случае если мы задаем 20 в качестве значения переменной myNumber, то сообщаем машине, что собираемся выполнить фрагмент кода, который поместит указанное значение в область памяти, соответствующую переменной myNumber.

В сущности, все приложения iOS используют архитектуру «модель — вид — контроллер» (MVC). C архитектурной точки зрения модель, вид и контроллер — это три основные составляющие приложения iOS.

Модель  — это мозг приложения. Она выполняет все вычисления и создает для себя виртуальный мир, в котором может существовать сама, без видов и контроллеров. Иными словами, вы можете считать модель виртуальной копией вашего приложения, без интерфейса.

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

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

В этой главе вы узн


убрать рекламу






аете, как выстраивать структуру приложения iOS и использовать виды и контроллеры видов для создания интуитивно понятных приложений.

В этой главе мы будем создавать большинство компонентов пользовательского интерфейса на базе шаблона Single View Application из Xcode. Чтобы воспроизвести приведенные инструкции, следуйте рекомендациям, приведенным в подразделе «Создание и запуск вашего первого приложения для iOS» данного раздела. Убедитесь в том, что ваше приложение является универсальным, а не ориентировано только на iPhone или на iPad. Универсальное приложение может работать как на iPhone, так и на iPad.

Создание и запуск вашего первого приложения для iOS

 Сделать закладку на этом месте книги

Прежде чем подробнее познакомиться с возможностями Objective-C, вкратце рассмотрим, как создать простое приложение для iOS в среде Xcode. Xcode — это интегрированная среда разработки (IDE) для работы с Apple, позволяющая создавать, строить и запускать ваше приложение в эмуляторе iOS и даже на реальных устройствах с iOS. По ходу книги мы подробнее обсудим Xcode и ее возможности, а пока научимся создавать и запускать самое простое приложение. Я полагаю, что вы уже скачали Xcode из Mac App Store и установили ее на своем компьютере. В таком случае выполните следующие шаги.

1. Откройте Xcode, если еще не сделали этого.

2. Выберите в меню пункт File (Файл), далее — New Project (Новый проект).

3. Слева в диалоговом окне создания нового проекта выберите подкатегорию Application (Приложение) в основной категории iOS. Затем справа щелкните на варианте Single View Application (Приложение с единственным видом) и нажмите кнопку Next (Далее).

4. На следующем экране вы увидите поле Product Name (Название продукта). Здесь укажите название, которое будет понятно вам, например My First iOS App. В разделе Organization name (Название организации) введите название вашей компании или, если работаете самостоятельно, любое другое осмысленное название. Название организации — довольно важная информация, которую, как правило, придется здесь указывать, но пока она нас не особенно волнует. В поле Company Identifier (Идентификатор компании) запишите com.mycompany. Если вы действительно владеете собственной компанией или пишете приложение для фирмы, являющейся вашим работодателем, то замените mycompany настоящим названием. Если просто экспериментируете, придумайте какое-нибудь название. В разделе Devices (Устройства) выберите вариант Universal (Универсальное).

5. Как только зададите все эти значения, просто нажмите кнопку Next (Далее).

6. Система предложит сохранить новый проект на диске. Выберите желаемое местоположение проекта и нажмите кнопку Create (Создать).

7. Перед запуском проекта убедитесь, что к компьютеру не подключено ни одного устройства iPhone или iPad/iPod. Это необходимо, поскольку, если к вашему Mac подключено такое устройство, то Xcode попытается запускать приложения именно на устройстве, а не на эмуляторе. В таком случае могут возникнуть некоторые проблемы с профилями инициализации (о них мы поговорим позже). Итак, отключите от компьютера все устройства с системой iOS, а затем нажмите большую кнопку Run (Запуск) в левом верхнем углу Xcode. Если не можете найти кнопку Run, перейдите в меню Product (Продукт) и выберите в меню элемент Run (Запуск).

Ура! Вот и готово простое приложение, работающее в эмуляторе iOS. Может быть, оно и не кажется особенно впечатляющим: в эмуляторе мы видим просто белый экран. Но это лишь первый шаг к освоению огромного iOS SDK. Давайте же отправимся в это непростое путешествие!

Определение переменных и понятие о них

 Сделать закладку на этом месте книги

Во всех современных языках программирования, в том числе в Objective-C, существуют переменные. Переменные — это просто псевдонимы, обозначающие участки (местоположения) в памяти. Каждая переменная может иметь следующие свойства:

тип данных, представляющий собой либо примитив (например, целое число), либо объект;

• имя;

• значение.

Задавать значение для переменной приходится не всегда, но вы обязаны указывать ее имя и тип. Вот несколько типов данных, которые необходимо знать для написания типичного приложения iOS.

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

• NSInteger и NSUInteger. Переменные этого типа могут содержать целочисленные значения, например 10, 20 и т. д. Тип NSInteger может содержать как положительные, так и отрицательные значения, но тип NSUInteger является беззнаковым, на что указывает буква U в его названии. Не забывайте, что слово «беззнаковый» в терминологии языков программирования означает, что число ни при каких условиях не может быть отрицательным. Отрицательные значения могут содержаться только в числовом типе со знаком.

• CGFloat. Содержит числа с плавающей точкой, имеющие десятичные знаки, например 1.31 или 2.40.

• NSString. Позволяет сохранять символьные строки. Такие примеры мы рассмотрим далее.

• NSNumber. Позволяет сохранять числа как объекты.

• id. Переменные типа id могут указывать на объект любого типа. Такие объекты называются нетипизированными . Если вы хотите передать объект из одного места в другое, но по какой-то причине не хотите при этом указывать их тип, то вам подойдет именно такой тип данных.

• NSDictionary и NSMutableDictionary. Это соответственно неизменяемый и изменяемый варианты хеш-таблиц. В хеш-таблице вы можете хранить ключ и ассоциировать этот ключ со значением. Например, ключ phone_num может иметь значение 0 55524 87700. Для считывания значений достаточно ссылаться на ассоциированные с ними ключи.

• NSArray и NSMutableArray. Неизменяемые и изменяемые массивы объектов. Массив — это упорядоченная коллекция элементов. Например, у вас может быть 10 строковых объектов, которые вы хотите сохранить в памяти. Для этого хорошо подойдет массив.

• NSSet, NSMutableSet, NSOrderedSet, NSMutableOrderedSet. Это типы множеств. Множества напоминают массивы тем, что могут содержать в себе наборы объектов, но в отличие от массива множество может включать в себя только уникальные объекты. Массив может содержать несколько экземпляров одного и того же объекта, а в множестве каждый объект может присутствовать только в одном экземпляре. Рекомендую вам четко усвоить разницу между массивами и множествами и использовать их правильно.

• NSData и NSMutableData. Неизменяемые и изменяемые контейнеры для любых данных. Такие типы данных очень вам пригодятся, если вы, например, хотите выполнить считывание содержимого файла в память.


Одни из рассмотренных нами типов данных являются примитивами, другие — классами. Вам придется просто запомнить, какие из них относятся к каждой из категорий. Например, тип данных NSInteger является примитивом, а NSString — классом. Поэтому из NSString можно создавать объекты. В языке Objective-C, как и в C и C++, существуют указатели. Указатель — это тип данных, в котором сохраняется адрес в памяти. По этому адресу уже хранятся фактические данные. Вы уже, наверное, знаете, что указатели на классы обозначаются символом астериска (*):


NSString *myString = @"Objective-C is great!";


Следовательно, если вы хотите присвоить строку переменной типа NSString на языке Objective-C, то вам понадобится просто сохранить данные в указатель типа NSString *. Но если вы собираетесь сохранить в переменной значение, представляющее собой число с плавающей точкой, то не сможете использовать указатель, так как тип данных, к которому относится эта переменная, не является классом:


/* Присваиваем переменной myFloat значение PI */

CGFloat myFloat = M_PI;


Если вам нужен указатель на эту переменную, соответствующую числу с плавающей точкой, то вы можете поступить так:


/* Присваиваем переменной myFloat значение PI */

CGFloat myFloat = M_PI;


/* Создаем переменную указателя, которая направлена на переменную myFloat */

CGFloat *pointerFloat = &myFloat;


Мы получаем данные от исходного числа с плавающей точкой путем простого разыменования (myFloat). Если получение значения происходит с применением указателя, то требуется использовать астериск (*pointerFloat). В некоторых ситуациях указатели могут быть полезны — например, при вызове функции, которая задает в качестве аргумента значение с плавающей точкой, а вы хотите получить новое значение после возврата функции.

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

Как создавать классы и правильно пользоваться ими

 Сделать закладку на этом месте книги

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

Класс должен наследовать от суперкласса. Из этого правила есть немногочисленные исключения. В частности, классы NSObject и NSProxy являются корневыми. У корневых классов не бывает суперкласса.

• Класс должен иметь имя, соответствующее Соглашению об именованиях методов в Cocoa.

• У класса должен быть файл интерфейса, в котором определяется интерфейс этого класса.

• У класса должна быть реализация, в которой вы прописываете все возможности, которые вы «обещали» предоставить согласно интерфейсу класса.

NSObject — это корневой класс, от которого наследуют практически все другие классы. В этом примере мы собираемся добавить класс под названием Person в проект, который был создан в подразделе «Создание и запуск вашего первого приложения для iOS» данного раздела. Далее мы добавим к этому классу два свойства, firstName и lastName, которые относятся к типу NSString. Выполните следующие шаги, чтобы создать класс Person и добавить его в ваш проект.

1. Откройте проект в Xcode и в меню File (Файл) выберите New-File (Новый— Файл).

2. Убедитесь, что слева, в разделе iOS, вы выбрали категорию Cocoa Touch. После этого выберите элемент Objective-C Class (Класс для Objective-C) и нажмите Next (Далее).

3. В разделе Class (Класс) введите имя Person.

4. В разделе Subclass of (Подкласс от) введите NSObject.

Когда справитесь с этим, нажмите кнопку Next (Далее). На данном этапе Xcode предложит вам сохранить этот файл. Просто сохраните новый класс в том каталоге, где находятся ваш проект и все его файлы. Это место выбирается по умолчанию. Затем нажмите кнопку Create (Создать) — и дело сделано.

После этого в ваш проект будут добавлены два новых файла: Person.h и Person.m. Первый файл — это интерфейс вашего класса Person, а второй — файл реализации этого класса. В Objective-C.h-файлы являются заголовочными. В таких файлах вы определяете интерфейс каждого файла. В.m-файле пишется сама реализация класса.

Теперь рассмотрим заголовочный файл нашего класса Person и определим для этого класса два свойства, имеющие тип NSString:


@interface Person: NSObject


@property (nonatomic, copy) NSString *firstName;

@property (nonatomic, copy) NSString *lastName;


@end


Как и переменные, свойства определяются в особом формате в следующем порядке.

1. Определение свойства должно начинаться с ключевого слова @property.

2. Затем следует указать квалификаторы свойства. Неатомарные (nonatomic) свойства не являются потокобезопасными. О безопасности потоков мы поговорим в главе 14. Вы можете указать и другие квалификаторы свойств: assign, copy, weak, strong или unsafe_unretained. Чуть позже мы подробнее поговорим и о них.

3. Затем укажите тип данных для свойства, например NSInteger или NSString.

4. Наконец, не забудьте задать имя для свойства. Имена свойств должны соответствовать рекомендациям Apple.

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

strong — свойства этого типа будут сохраняться во время исполнения. Они могут быть только экземплярами классов. Иными словами, вы не можете сохранить значение в свойстве типа strong, если значение является примитивом. Можно сохранять объекты, но не примитивы.

• copy — аналогичен strong, но при выполнении присваивания к свойствам этого типа среда времени исполнения будет делать копию объекта в правой части операции присваивания. Объект, находящийся в правой части этой операции, должен соответствовать протоколу NSCopying или NSMutableCopying.

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

• unsafe_unretained — аналогичен квалификатору assign.

• weak — практически аналогичен квалификатору assign, но с одним большим отличием. При работе с объектами, когда объект, присвоенный свойству такого типа, высвобождается из памяти, среда времени исполнения будет автоматически устанавливать значение этого свойства в nil.

Итак, у нас есть класс Person с двумя свойствами, firstName и lastName. Вернемся к файлу реализации делегата нашего приложения (AppDelegate.m) и создадим объект типа Person:


#import «AppDelegate.h»

#import «Person.h»

@implementation AppDelegate


— (BOOL) application:(UIApplication *)application

didFinishLaunchingWithOptions:(NSDictionary *)launchOptions{


Person *person = [[Person alloc] init];


person.firstName = @"Steve";

person.lastName = @"Jobs";


self.window = [[UIWindow alloc]

initWithFrame: [[UIScreen mainScreen] bounds]];

self.window.backgroundColor = [UIColor whiteColor];

[self.window makeKeyAndVisible];

return YES;

}


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

Добавление нового функционала к классам с помощью методов

 Сделать закладку на этом месте книги

Методы — это строительные блоки, из которых состоят классы. Например, класс Person может иметь логические возможности — обозначим их как «ходить», «дышать», «есть» и «пить». Обычно такие функции инкапсулируются в методах.

Метод может принимать параметры. Параметры — это переменные, передаваемые вызывающей стороной при вызове метода и видимые только этому методу. Например, в упрощенном мире у нашего класса Person был бы метод walk. Но вы могли бы добавить к этому методу параметр или аргумент и назвать его walkingSpeed. Этому параметру вы бы присвоили тип CGFloat. Теперь, если другой программист вызовет этот метод в вашем классе, он может указать, с какой скоростью будет идти Person. Вы как автор класса напишете соответствующий код, который будет обрабатывать различные скорости ходьбы Person. Не переживайте, если у вас возникает ощущение «как-то много работы получается». Рассмотрим следующий пример. В нем я добавил метод в файл реализации того класса Person, который мы создали в подразделе «Как создавать классы и правильно пользоваться ими» данного раздела.


#import «Person.h»


@implementation Person


— (void) walkAtKilometersPerHour:(CGFloat)paramSpeedKilometersPerHour{

/* здесь пишем код для этого метода */

}


— (void) runAt10KilometersPerHour{

/* Вызываем метод walk в нашем собственном классе и передаем значение 10 */

[self walkAtKilometersPerHour:10.0f];

}

@end


Типичный метод в языке Objective-C имеет следующие качества.

1. Префикс указывает компилятору, является ли данный код методом экземпляра (—) или методом класса (+). К методу экземпляра можно обратиться лишь после того, как программист выделит и инициализирует экземпляр вашего класса. Получить доступ к методу класса можно, вызвав его непосредственно из этого класса. Не волнуйтесь, если на первый взгляд это кажется сложным. В этой книге мы рассмотрим многочисленные примеры методов, пока просто следите за ходом рассказа.

2. Тип данных для метода, если метод возвращает какое-либо значение. В примере мы указали тип данных void. Так мы сообщаем компилятору, что не собираемся возвращать от метода какое-либо значение.

3. Первая часть имени метода, за которой идет первый параметр. Метод может и не иметь параметров. Методы, не принимающие параметров, довольно широко распространены.

4. Список последующих параметров, идущих за первым.

Рассмотрим пример метода с двумя параметрами:


— (void) singSong:(NSData *)paramSongData loudly:(BOOL)paramLoudly{

/* Параметры, к которым мы можем обратиться здесь, в этом методе, таковы:


paramSongData (для доступа к информации о песне)

paramLoudly сообщает нам, должны мы петь песню громко или нет

*/

}


Важно учитывать, что каждый параметр каждого метода обладает внешним  и внутренним  именем. Внешнее имя входит в состав метода, а внутреннее имя — это фактическое название (или псевдоним) параметра, которое может использоваться в пределах реализации метода. В предыдущем примере внешнее имя первого параметра — singSong, а внутреннее — paramSongData. Внешнее имя второго параметра — loudly, а внутреннее — paramLoudly. Имя метода и внешние имена его параметров вместе образуют сущность, которая называется селектором  метода. В данном случае селектор упомянутого метода будет иметь вид singSong: loudly:. Как будет объяснено далее в этой книге, селектор является идентификатором каждого метода в среде времени исполнения. Никакие два метода в рамках одного и того же класса не могут иметь одинаковые селекторы.

В нашем примере мы определили в файле реализации класса Person (Person.m) три метода:

walkAtKilometersPerHour:;

• runAt10KilometersPerHour;

• singSong: loudly:.

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


#import <Foundation/Foundation.h>


@interface Person: NSObject


@property (nonatomic, copy) NSString *firstName;

@property (nonatomic, copy) NSString *lastName;


— (void) walkAtKilometersPerHour:(CGFloat)paramSpeedKilometersPerHour;

— (void) runAt10KilometersPerHour;


/* Не предоставляем метод singSong: loudly: для доступа извне.

Этот метод является внутренним для нашего класса. Зачем же нам открывать к нему доступ? */


@end


Имея такой файл интерфейса, программист может вызывать методы walkAtKilometersPerHour: и runAt10KilometersPerHour извне класса Person. А метод singSong: loudly: так вызывать нельзя, поскольку он не предоставлен в файле интерфейса. Итак, продолжим: попробуем вызвать все три этих метода из делегата нашего приложения и посмотрим, что получится:


— (BOOL) application:(UIApplication *)application

didFinishLaunchingWithOptions:(NSDictionary *)launchOptions{


Person *person = [[Person alloc] init];


[person walkAtKilometersPerHour:3.0f];

[person runAt10KilometersPerHour];


/* Если раскомментировать следующую строку кода, то компилятор выдаст

вам ошибку и сообщит, что такого метода в классе Person не существует */

//[person singSong: nil loudly: YES];


self.window = [[UIWindow alloc]

initWithFrame: [[UIScreen mainScreen] bounds]];

self.window.backgroundColor = [UIColor whiteColor];

[self.window makeKeyAndVisible];

return YES;

}


Итак, теперь мы умеем определять и вызывать методы экземпляров. А что насчет методов классов? Сначала разберемся, что такое методы классов и чем они отличаются от методов экземпляров.

Метод экземпляра — это метод, относящийся к экземпляру класса. Например, в нашем случае вы можете создать экземпляр класса Person дважды и получить в гипотетической игре, которую разрабатываете, двух разных персонажей. Один персонаж будет ходить со скоростью 3 км/ч, другой — 2 км/ч.

Пусть вы и написали код для метода экземпляра walk всего один раз, но когда во время исполнения создаются два экземпляра класса Person, поступающие от них вызовы методов экземпляра маршрутизируются к соответствующему экземпляру класса (тому, который выполнил вызов).

Напротив, методы класса работают только с самим классом. Например, в вашей игре есть экземпляры класса Light, отвечающего за подсвечивание сцен в вашей игре. У этого класса может быть метод dimAllLights. Вызвав этот метод, программист погасит в игре все источники света независимо от того, где они находятся. Рассмотрим пример метода класса, применяемого с нашим классом Person:


#import «Person.h»


@implementation Person


+ (CGFloat) maximumHeightInCentimeters{

return 250.0f;

}


+ (CGFloat) minimumHeightInCentimeters{

return 40.0f;

}


@end


Метод maximumHeightInCentimeters — это метод класса, возвращающий гипотетический максимальный рост любого персонажа в сантиметрах. Метод класса minimumHeightInCentimeters возвращает минимальный рост любого  персонажа. Вот как мы предоставим оба этих метода в файле интерфейса нашего класса:


#import <Foundation/Foundation.h>


@interface Person: NSObject


@property (nonatomic, copy) NSString *firstName;

@property (nonatomic, copy) NSString *lastName;

@property (nonatomic, assign) CGFloat currentHeight;


+ (CGFloat) maximumHeightInCentimeters;

+ (CGFloat) minimumHeightInCentimeters;


@end

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

А в делегате нашего приложения мы продолжим работать с методами вот так:

— (BOOL) application:(UIApplication *)application

didFinishLaunchingWithOptions:(NSDictionary *)launchOptions{


Person *steveJobs = [[Person alloc] init];

steveJobs.firstName = @"Steve";

steveJobs.lastName = @"Jobs";

steveJobs.currentHeight = 175.0f; /* Сантиметры */


if (steveJobs.currentHeight >= [Person minimumHeightInCentimeters] &&

steveJobs.currentHeight <= [Person maximumHeightInCentimeters]){

/* Высота этого персонажа находится в пределах допустимого */

} else {

/* Высота этого персонажа находится вне пределов допустимого */

}


self.window = [[UIWindow alloc]

initWithFrame: [[UIScreen mainScreen] bounds]];

self.window.backgroundColor = [UIColor whiteColor];

[self.window makeKeyAndVisible];

return YES;

}

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

 Сделать закладку на этом месте книги

В языке Objective-C существует концепция под названием «протокол» . Протоколы встречаются и во многих других языках, но называются везде по-разному; например, в Java аналогичная сущность называется «интерфейс». Как понятно из названия, протокол — это набор правил, которым класс должен соответствовать, чтобы его можно было использовать тем или иным образом. Если класс выполняет правила определенного протокола, то принято говорить, что он соответствует  этому протоколу. Протоколы отличаются от самих классов тем, что не имеют реализации. Это просто правила. Например, у любой машины есть колеса, дверцы и цвет кузова, а также многие другие свойства. Определим эти свойства в протоколе Car. Просто выполните следующие шаги, чтобы создать заголовочный файл, который может содержать наш протокол Car.

1. Откройте ваш проект в Xcode и в меню File (Файл) выберите New-File (Новый — Файл).

2. Убедитесь, что слева, в разделе iOS, вы выбрали категорию Cocoa Touch. После этого выберите элемент Objective-C Protocol (Протокол для Objective-C) и нажмите Next (Далее).

3. В разделе Class (Класс) введите имя Car, затем нажмите кнопку Next (Далее).

4. Далее система предложит вам сохранить ваш протокол на диске. Просто выберите для этого место (как правило, в каталоге с вашим проектом) и нажмите кнопку Create (Создать).

После этого Xcode создаст для вас файл Car.h с таким содержимым:


#import <Foundation/Foundation.h>


@protocol Car <NSObject>

@end


Продолжим и определим свойства для протокола Car, как мы обсуждали ранее в этом разделе:


#import <Foundation/Foundation.h>


@protocol Car <NSObject>


@property (nonatomic, copy) NSArray *wheels;

@property (nonatomic, strong) UIColor *bodyColor;

@property (nonatomic, copy) NSArray *doors;


@end


Теперь, когда наш протокол определен, создадим класс, обозначающий автомобиль, — например, Jaguar, — а потом обеспечим соответствие этого класса протоколу. Просто выполните все шаги, перечисленные в подразделе «Как создавать классы и правильно пользоваться ими» данного раздела, после чего обеспечьте его соответствие протоколу Car следующим образом:


#import <Foundation/Foundation.h>

#import «Car.h»


@interface Jaguar: NSObject <Car>

@

end


Если вы попробуете собрать ваш проект на данном этапе, то компилятор выдаст вам несколько предупреждений, например такое:

Auto property synthesis will not synthesize property declared in a protocol

Это означает, что ваш класс Jaguar пытается соответствовать протоколу Car, но на самом деле не реализует всех требуемых свойств и/или методов, описанных в этом протоколе. Теперь вы уже знаете, что в протоколе могут содержаться необходимые и факультативные (опциональные) элементы, которые вы помечаете ключевыми словами @optional или @required. По умолчанию действует квалификатор @required, и поскольку мы явно не указываем квалификатор для этого протокола, компилятор неявно выбирает @required за нас. Следовательно, класс Jaguar теперь обязан  реализовывать все аспекты, требуемые протоколом Car, вот так:


#import <Foundation/Foundation.h>

убрать рекламу






>

#import «Car.h»


@interface Jaguar: NSObject <Car>


@property (nonatomic, copy) NSArray *wheels;

@property (nonatomic, strong) UIColor *bodyColor;

@property (nonatomic, copy) NSArray *doors;


@end


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

Хранение элементов в коллекциях и получение элементов из коллекций

 Сделать закладку на этом месте книги

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


NSArray *stringsArray = @[

@"String 1",

@"String 2",

@"String 3"

];


__unused NSString *firstString = stringsArray[0];

__unused NSString *secondString = stringsArray[1];

__unused NSString *thirdString = stringsArray[2];

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

Изменяемый массив — это такой массив, в который можно вносить изменения уже после того, как он был создан. Как мы видели ранее, неизменяемый массив не может быть дополнен новой информацией уже после создания. Вот пример неизменяемого массива:


NSString *string1 = @"String 1";

NSString *string2 = @"String 2";

NSString *string3 = @"String 3";


NSArray *immutableArray = @[string1, string2, string3];


NSMutableArray *mutableArray = [[NSMutableArray alloc]

initWithArray: immutableArray];


[mutableArray exchangeObjectAtIndex:0 withObjectAtIndex:1];

[mutableArray removeObjectAtIndex:1];

[mutableArray setObject: string1 atIndexedSubscript:0];

NSLog(@"Immutable array = %@", immutableArray);

NSLog(@"Mutable Array = %@", mutableArray);

Вывод этой программы таков:

Immutable array = (

«String 1»,

«String 2»,

«String 3»

)

Mutable Array = (

«String 1»,

«String 3»

)


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


NSDictionary *personInformation =

@{

@"firstName": @"Mark",

@"lastName": @"Tremonti",

@"age": @30,

@"sex": @"Male"

};


NSString *firstName = personInformation[@"firstName"];

NSString *lastName = personInformation[@"lastName"];

NSNumber *age = personInformation[@"age"];

NSString *sex = personInformation[@"sex"];


NSLog(@"Full name = %@ %@", firstName, lastName);

NSLog(@"Age = %@, Sex = %@", age, sex);

А вот и вывод этой программы:

Full name = Mark Tremonti

Age = 30, Sex = Male


Можно также использовать изменяемые словари, которые довольно сильно похожи на изменяемые массивы. Содержимое изменяемого словаря можно изменить после того, как словарь инстанцирован. Пример:


NSDictionary *personInformation =

@{

@"firstName": @"Mark",

@"lastName": @"Tremonti",

@"age": @30,

@"sex": @"Male"

};


NSMutableDictionary *mutablePersonInformation =

[[NSMutableDictionary alloc] initWithDictionary: personInformation];

mutablePersonInformation[@"age"] = @32;


NSLog(@"Information = %@", mutablePersonInformation);

Вывод этой программы таков:

Information = {

age = 32;

firstName = Mark;

lastName = Tremonti;

sex = Male;

}


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


NSSet *shoppingList = [[NSSet alloc] initWithObjects:

@"Milk",

@"Bananas",

@"Bread",

@"Milk", nil];


NSLog(@"Shopping list = %@", shoppingList);

Запустив эту программу, вы получите следующий вывод:

Shopping list = {(

Milk,

Bananas,

Bread

)}


Обратите внимание: элемент Milk упомянут в программе дважды, а в множество добавлен всего один раз. Эта черта множеств — настоящее волшебство. Изменяемые множества можно использовать и вот так:


NSSet *shoppingList = [[NSSet alloc] initWithObjects:

@"Milk",

@"Bananas",

@"Bread",

@"Milk", nil];


NSMutableSet *mutableList = [NSMutableSet setWithSet: shoppingList];


[mutableList addObject:@"Yogurt"];

[mutableList removeObject:@"Bread"];

NSLog(@"Original list = %@", shoppingList);

NSLog(@"Mutable list = %@", mutableList);

А вывод будет таким:

Original list = {(

Milk,

Bananas,

Bread

)}

Mutable list = {(

Milk,

Bananas,

Yogurt

)}


Обсуждая множества и коллекции, следует упомянуть еще два важных класса, о которых вам необходимо знать:

NSOrderedSet — неизменяемое множество, учитывающее, в каком порядке в него добавлялись объекты;

• NSMutableOrderedSet — изменяемый вариант вышеупомянутого изменяемого множества.

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


NSSet *setOfNumbers = [NSSet setWithArray:@[@3, @4, @1, @5, @10]];

NSLog(@"Set of numbers = %@", setOfNumbers);

Запустив эту программу, получим на экране следующий вывод:

Set of numbers = {(

5,

10,

3,

4,

1

)}


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


NSOrderedSet *setOfNumbers = [NSOrderedSet orderedSetWithArray

:@[@3, @4, @1, @5, @10]];


NSLog(@"Ordered set of numbers = %@", setOfNumbers);

Разумеется, вы можете воспользоваться и изменяемой версией упорядоченного множества:

NSMutableOrderedSet *setOfNumbers =

[NSMutableOrderedSet orderedSetWithArray:@[@3, @4, @1, @5, @10]];


[setOfNumbers removeObject:@5];

[setOfNumbers addObject:@0];

[setOfNumbers exchangeObjectAtIndex:1 withObjectAtIndex:2];


NSLog(@"Set of numbers = %@", setOfNumbers);

А вот и результаты:

Set of numbers = {(

3,

1,

4,

10,

0

)}


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


NSCountedSet *setOfNumbers = [NSCountedSet setWithObjects:

@10, @20, @10, @10, @30, nil];


[setOfNumbers addObject:@20];

[setOfNumbers removeObject:@10];


NSLog(@"Count for object @10 = %lu",

(unsigned long)[setOfNumbers countForObject:@10]);


NSLog(@"Count for object @20 = %lu",

(unsigned long)[setOfNumbers countForObject:@20]);

Вывод программы:

Count for object @10 = 2

Count for object @20 = 2

Класс NSCountedSet является изменяемым, хотя из его названия это и не следует.

Обеспечение поддержки подписывания объектов в ваших классах

 Сделать закладку на этом месте книги

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


NSString *const kFirstNameKey = @"firstName";

NSString *const kLastNameKey = @"lastName";


NSMutableDictionary *dictionary = [[NSMutableDictionary alloc] init];

[dictionary setValue:@"Tim" forKey: kFirstNameKey];

[dictionary setValue:@"Cook" forKey: kLastNameKey];


__unused NSString *firstName = [dictionary valueForKey: kFirstNameKey];

__unused NSString *lastName = [dictionary valueForKey: kLastNameKey];

Но с развитием компилятора LLVM этот код можно сократить, придав ему следующий вид:

NSString *const kFirstNameKey = @"firstName";

NSString *const kLastNameKey = @"lastName";


NSDictionary *dictionary = @{

kFirstNameKey: @"Tim",

kLastNameKey: @"Cook",

};


__unused NSString *firstName = dictionary[kFirstNameKey];

__unused NSString *lastName = dictionary[kLastNameKey];

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

NSArray *array = [[NSArray alloc] initWithObjects:@"Tim", @"Cook", nil];

__unused NSString *firstItem = [array objectAtIndex:0];

__unused NSString *secondObject = [array objectAtIndex:1];

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

NSArray *array = @[@"Tim", @"Cook"];

__unused NSString *firstItem = array[0];

__unused NSString *secondObject = array[0];


Компилятор LLVM не останавливается и на этом. Вы можете также добавлять подписывание и к собственным классам. Существует два типа подписывания:

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

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

Сначала рассмотрим пример подписывания по ключу. Для этого создадим класс под названием Person, имеющий свойства firstName и lastName. Далее мы позволим программисту менять значения этих свойств (имя и фамилию), просто предоставив ключи для этих свойств.

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

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


#import <Foundation/Foundation.h>


/* Мы будем использовать их как ключи для наших свойств firstName

и lastName, так что если имена наших свойств firstName и lastName

в будущем изменятся в реализации, нам не придется ничего переделывать

и наш класс останется работоспособным, поскольку мы сможем просто

изменить значения этих констант в нашем файле реализации */

extern NSString *const kFirstNameKey;

extern NSString *const kLastNameKey;


@interface Person: NSObject


@property (nonatomic, copy) NSString *firstName;

@property (nonatomic, copy) NSString *lastName;


— (id) objectForKeyedSubscript:(id<NSCopying>)paramKey;

— (void) setObject:(id)paramObject forKeyedSubscript:(id<NSCopying>)paramKey;


@end


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


#import «Person.h»


NSString *const kFirstNameKey = @"firstName";

NSString *const kLastNameKey = @"lastName";


@implementation Person


— (id) objectForKeyedSubscript:(id<NSCopying>)paramKey{


NSObject<NSCopying> *keyAsObject = (NSObject<NSCopying> *)paramKey;

if ([keyAsObject isKindOfClass: [NSString class]]){

NSString *keyAsString = (NSString *)keyAsObject;

if ([keyAsString isEqualToString: kFirstNameKey] ||

[keyAsString isEqualToString: kLastNameKey]){

return [self valueForKey: keyAsString];

}

}


return nil;

}


— (void) setObject:(id)paramObject forKeyedSubscript:(id<NSCopying>)paramKey{

NSObject<NSCopying> *keyAsObject = (NSObject<NSCopying> *)paramKey;

if ([keyAsObject isKindOfClass: [NSString class]]){

NSString *keyAsString = (NSString *)keyAsObject;

if ([keyAsString isEqualToString: kFirstNameKey] ||

[keyAsString isEqualToString: kLastNameKey]){

[self setValue: paramObject forKey: keyAsString];

}

}

}


@end


Итак, в этом коде мы получаем ключ в методе objectForKeyedSubscript:, а в ответ должны вернуть объект, который ассоциирован в нашем экземпляре с этим ключом. Ключ, который получаем, — это объект, соответствующий протоколу NSCopying. Это означает, что при желании мы можем сделать копию такого объекта. Рассчитываем на то, что ключ будет представлять собой строку, чтобы мы могли сравнить его с готовыми ключами, которые были заранее объявлены в начале класса. В случае совпадения зададим значение данного свойства в этом классе. После этого воспользуемся методом valueForKey:, относящимся к объекту NSObject, чтобы вернуть значение, ассоциированное с заданным ключом. Но, разумеется, прежде, чем так поступить, мы должны гарантировать, что данный ключ — один из тех, которые мы ожидаем. В методе setObject: forKeyedSubscript: мы делаем совершенно противоположное — устанавливаем значения для заданного ключа, а не возвращаем их.

Теперь в любой части вашего приложения вы можете инстанцировать объект типа Person и использовать заранее определенные ключи kFirstNameKey и kLastNameKey, чтобы изменить значения свойств firstName и lastName, вот так:


Person *person = [Person new];

person[kFirstNameKey] = @"Tim";

person[kLastNameKey] = @"Cook";

__unused NSString *firstName = person[kFirstNameKey];

__unused NSString *lastName = person[kLastNameKey];

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

Person *person = [Person new];

person.firstName = @"Tim";

person.lastName = @"Cook";

__unused NSString *firstName = person.firstName;

__unused NSString *lastName = person.lastName;


Вы также можете поддерживать и подписывание по индексу — точно как при работе с массивами. Как было указано ранее, это полезно делать, чтобы обеспечивать программисту доступ к объектам, выстраиваемым в классе в некоем естественном порядке. Но, кроме массивов, существует не так уж много структур данных, где целесообразно упорядочивать и нумеровать элементы, чего не скажешь о подписывании по ключу, которое применяется в самых разных структурах данных. Поэтому пример, которым иллюстрируется подписывание по индексу, немного надуман. В предыдущем примере у нас существовал класс Person с именем и фамилией. Теперь мы хотим предоставить программистам возможность считывать имя, указывая индекс 0, а фамилию — указывая индекс 1. Все, что требуется сделать для этого, — объявить методы objectAtIndexedSubscript: и setObject: atIndexedSubscript: в заголовочном файле класса, а затем написать реализацию. Вот как мы объявляем два этих метода в заголовочном файле класса Person:

— (id) objectAtIndexedSubscript:(NSUInteger)paramIndex;

— (void) setObject:(id)paramObject atIndexedSubscript:(NSUInteger)paramIndex;

Реализация также довольно проста. Мы берем индекс и оперируем им так, как это требуется в нашем классе. Ранее мы решили, что у имени должен быть индекс 0, а у фамилии — индекс 1. Итак, получаем индекс 0 для задания значения, присваиваем значение имени первому входящему объекту и т. д.:


— (id) objectAtIndexedSubscript:(NSUInteger)paramIndex{


switch (paramIndex){

case 0:{

return self.firstName;

break;

}

case 1:{

return self.lastName;

break;

}

default:{

[NSException raise:@"Invalid index" format: nil];

}

}


return nil;

}


— (void) setObject:(id)paramObject atIndexedSubscript:(NSUInteger)paramIndex{

switch (paramIndex){

case 0:{

self.firstName = paramObject;

break;

}

case 1:{

self.lastName = paramObject;

break;

}

default:{

[NSException raise:@"Invalid index" format: nil];

}

}

}

Теперь можно протестировать весь написанный ранее код вот так:

Person *person = [Person new];

person[kFirstNameKey] = @"Tim";

person[kLastNameKey] = @"Cook";

NSString *firstNameByKey = person[kFirstNameKey];

NSString *lastNameByKey = person[kLastNameKey];


NSString *firstNameByIndex = person[0];

NSString *lastNameByIndex = person[1];


if ([firstNameByKey isEqualToString: firstNameByIndex] &&

[lastNameByKey isEqualToString: lastNameByIndex]){

NSLog(@"Success");

} else {

NSLog(@"Something is not right");

}


Если вы правильно выполнили все шаги, описанные в этом разделе, то на консоли должно появиться значение Success.

1.1. Отображение предупреждений с помощью UIAlertView

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

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

Решение

 Сделать закладку на этом месте книги

Воспользуйтесь UIAlertView.

Обсуждение

 Сделать закладку на этом месте книги

Если вы сами пользуетесь iOS, то вам определенно попадались виды-предупреждения. Пример такого вида показан на рис. 1.1.




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


Наилучший способ инициализации вида-предупреждения заключается, разумеется, в использовании его базового конструктора-инициализатора:


— (void) viewDidAppear:(BOOL)paramAnimated{


[super viewDidAppear: paramAnimated];


UIAlertView *alertView = [[UIAlertView alloc]

initWithTitle:@"Alert"

message:@"You've been delivered an alert"

delegate: nil

cancelButtonTitle:@"Cancel"

otherButtonTitles:@"OK", nil];

[alertView show];

}


Когда этот вид-предупреждение отобразится у пользователя, он увидит экран, подобный показанному на рис. 1.2.




Рис. 1.2. Простой вид-предупреждение, отображаемый у пользователя


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

• title — строка, которую пользователь увидит в верхней части вида-предупрежения. На рис. 1.2 эта строка — Title;

• message — сообщение, которое отображается у пользователя. На рис. 1.2 для этого сообщения задано значение Message;

• delegate — опциональный объект-делегат, который мы передаем виду-предупреждению. Затем этот объект будет получать уведомление при каждом изменении состояния предупреждения, например, когда пользователь нажмет на экранную кнопку, изображенную в этом виде. Объект, передаваемый данному параметру, должен соответствовать протоколу UIAlertViewDelegate;

• cancelButtonTitle — строка, которая будет присваиваться кнопке отмены (Cancel Button) в виде-предупреждении. Если в виде-предупреждении есть кнопка отмены, то такой вид обычно побуждает пользователя к действию. Если пользователь не хочет совершать предложенное действие, то он нажимает кнопку отмены. Причем на этой кнопке не обязательно должна быть строка-надпись Cancel (Отменить). Надпись для этой кнопки определяете вы сами, и этот параметр опциональный — можно сделать диалоговое окно и без кнопки Отмена;

• otherButtonTitles — надписи на других кнопках, тех, которые вы хотите отобразить в виде-предупреждении. Разделяйте такие надписи запятыми. Нужно убедиться, что в конце списка названий стоит значение nil, называемое сигнальной меткой . Этот параметр не является обязательным.

Можно создать предупреждение вообще без кнопок. Но такое окно пользователь никак не сможет убрать с экрана. Создавая такой вид, вы как программист должны позаботиться о том, чтобы он убирался автоматически, например, через 3 секунды после того, как появится. Вид-предупреждение без кнопок, который не убирается автоматически, — это настоящее бедствие, с точки зрения пользователя. Ваше приложение не только получит низкие оценки на App Store за то, что вид-предупреждение блокирует пользовательский интерфейс. Велика вероятность, что вашу программу вообще удалят с рынка.

Виды-предупреждения можно оформлять с применением различных стилей. В классе UIAlertView есть свойство alertViewStyle типа UIAlertViewStyle:


typedef NS_ENUM(NSInteger, UIAlertViewStyle) {

UIAlertViewStyleDefault = 0,

UIAlertViewStyleSecureTextInput,

UIAlertViewStylePlainTextInput,

UIAlertViewStyleLoginAndPasswordInput

};


Вот что делает каждый из этих стилей:

• UIAlertViewStyleDefault — стандартный стиль вида-предупреждения, подобное оформление мы видели на рис. 1.2;

• UIAlertViewStyleSecureTextInput — при таком стиле в виде-предупреждении будет содержаться защищенное текстовое поле, которое станет скрывать от зрителя символы, вводимые пользователем. Такой вариант предупреждения вам подойдет, например, если вы запрашиваете у пользователя его учетные данные для дистанционного банковского обслуживания;

• UIAlertViewStylePlainTextInput — при таком стиле у пользователя будет отображаться незащищенное текстовое поле. Этот стиль отлично подходит для случаев, когда вы просите пользователя ввести несекретную последовательность символов, например номер его телефона;

• UIAlertViewStyleLoginAndPasswordInput — при таком стиле в виде-предупреждении будет два текстовых поля: незащищенное — для имени пользователя и защищенное — для пароля.

Если вам необходимо получ


убрать рекламу






ать уведомление, когда пользователь начинает работать с видом-предупреждением, укажите объект-делегат для вашего предупреждения. Этот делегат должен подчиняться протоколу UIAlertViewDelegate. Самый важный метод, определяемый в этом протоколе, — alertView: clickedButtonAtIndex:, который вызывается сразу же, как только пользователь нажимает на одну из кнопок в виде-предупреждении. Индекс нажатой кнопки передается вам через параметр clickedButtonAtIndex.

В качестве примера отобразим предупреждение пользователю и спросим, хочет ли он перейти на сайт в браузере Safari после того, как нажмет ссылку на этот сайт, присутствующую в нашем пользовательском интерфейсе. В предупреждении будут отображаться две кнопки: Yes (Да) и No (Нет). В делегате вида-предупреждения мы увидим, какая кнопка была нажата, и предпримем соответствующие действия.

Сначала реализуем два очень простых метода, которые возвращают надпись на той или иной из двух кнопок:


— (NSString *) yesButtonTitle{

return @"Yes";

}


— (NSString *) noButtonTitle{

return @"No";

}

Теперь нужно убедиться, что контроллер нашего вида подчиняется протоколу UIAlertViewDelegate:

#import <UIKit/UIKit.h>


#import «ViewController.h»


@interface ViewController () <UIAlertViewDelegate>


@end


@implementation ViewController



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


— (void)viewDidAppear:(BOOL)animated{

[super viewDidAppear: animated];


self.view.backgroundColor = [UIColor whiteColor];


NSString *message = @"Are you sure you want to open this link in Safari?";

UIAlertView *alertView = [[UIAlertView alloc]

initWithTitle:@"Open Link"

message: message

delegate: self

cancelButtonTitle: [self noButtonTitle]

otherButtonTitles: [self yesButtonTitle], nil];

[alertView show];


}


Вид-предупреждение будет выглядеть примерно как на рис. 1.3.




Рис. 1.3. Вид-предупреждение с кнопками No (Нет) и Yes (Да)


Далее нужно узнать, какой вариант пользователь выбрал в нашем окне — No (Нет) или Yes (Да). Для этого потребуется реализовать метод alertView: clickedButtonAtIndex:, относящийся к делегату нашего вида-предупреждения:


— (void) alertView:(UIAlertView *)alertView

clickedButtonAtIndex:(NSInteger)buttonIndex{


NSString *buttonTitle = [alertView buttonTitleAtIndex: buttonIndex];


if ([buttonTitle isEqualToString: [self yesButtonTitle]]){

NSLog(@"User pressed the Yes button.");

}

else if ([buttonTitle isEqualToString: [self noButtonTitle]]){

NSLog(@"User pressed the No button.");

}


}

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

Как видите, мы пользуемся методом buttonTitleAtIndex: класса UIAlertView. Мы передаем этому методу индекс кнопки, отсчитываемый с нуля (кнопка находится в нашем виде), и получаем строку, которая представляет собой надпись на этой кнопке — если такая надпись вообще имеется. С помощью этого метода можно определить, какую кнопку нажал пользователь. Индекс этой кнопки будет передан нам как параметр buttonIndex метода alertView: clickedButtonAtIndex:. Если вас интересует надпись на этой кнопке, то нужно будет использовать метод buttonTitleAtIndex: класса UIAlertView. Все готово!

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


— (void) viewDidAppear:(BOOL)animated{

[super viewDidAppear: animated];


UIAlertView *alertView = [[UIAlertView alloc]

initWithTitle:@"Credit Card Number"

message:@"Please enter your credit card number: "

delegate: self

cancelButtonTitle:@"Cancel"

otherButtonTitles:@"OK", nil];

[alertView setAlertViewStyle: UIAlertViewStylePlainTextInput];

/* Отобразить для этого текстового поля числовую клавиатуру. */

UITextField *textField = [alertView textFieldAtIndex:0];

textField.keyboardType = UIKeyboardTypeNumberPad;

[alertView show];


}

Если сейчас запустить приложение в эмуляторе, то мы увидим такое изображение, как на рис. 1.4.




Рис. 1.4. Вид-предупреждение для ввода обычным текстом


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

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


— (void) viewDidAppear:(BOOL)animated{

[super viewDidAppear: animated];


UIAlertView *alertView = [[UIAlertView alloc]

initWithTitle:@"Password"

message:@"Please enter your password: "

delegate: self

cancelButtonTitle:@"Cancel"

otherButtonTitles:@"OK", nil];


[alertView setAlertViewStyle: UIAlertViewStyleSecureTextInput];

[alertView show];


}




Рис. 1.5. Ввод защищенного текста в окно с предупреждением


Стиль UIAlertViewStyleSecureTextInput очень напоминает UIAlertViewStylePlainTextInput, за исключением того, что вместо символов текста мы подставляем какие-то нейтральные символы.

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


— (void) viewDidAppear:(BOOL)animated{

[super viewDidAppear: animated];


UIAlertView *alertView = [[UIAlertView alloc]

initWithTitle:@"Password"

message:@"Please enter your credentials: "

delegate: self

cancelButtonTitle:@"Cancel"

otherButtonTitles:@"OK", nil];


[alertView setAlertViewStyle: UIAlertViewStyleLoginAndPasswordInput];

[alertView show];


}


В результате увидим такое изображение, как на рис. 1.6.




Рис. 1.6. Стиль, позволяющий вводить в вид-предупреждение имя пользователя и пароль

См. также

 Сделать закладку на этом месте книги

Раздел 1.19.

1.2. Создание и использование переключателей с помощью UISwitch

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

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

Решение

 Сделать закладку на этом месте книги

Воспользуйтесь классом UISwitch.

Обсуждение

 Сделать закладку на этом месте книги

Класс UISwitch предоставляет инструмент управления ON/OFF (Вкл./Выкл.), как на рис. 1.7. Этот инструмент используется для работы с автоматической капитализацией, автоматическим исправлением орфографических ошибок и т. д.




Рис. 1.7. Переключатель UISwitch, применяемый в приложении Settings (Настройки) в iPhone


Создать переключатель можно либо с помощью конструктора интерфейса, либо сделав экземпляр такого переключателя в коде. Решим эту задачу вторым способом. Итак, следующая проблема — определить, в каком классе разместить соответствующий код. Это должен быть класс View Controller (Контроллер вида), который мы еще не изучали, но, поскольку в этой главе мы создаем программу типа Single View Application (Приложение с единственным видом), файл реализации (.m) контроллера вида будет называться ViewController.m. Откроем этот файл.

Создадим свойство типа UISwitch и назовем его mainSwitch:


#import «ViewController.h»


@interface ViewController ()

@property (nonatomic, strong) UISwitch *mainSwitch;

@end


@implementation ViewController

Теперь перейдем к файлу реализации контроллера вида (файлу. m) и синтезируем свойство mySwitch:

#import «Creating_and_Using_Switches_with_UISwitchViewController.h»


@implementation Creating_and_Using_Switches_with_UISwitchViewController


@synthesize mySwitch;



Можно продолжить и перейти к созданию переключателя. Найдем метод viewDidLoad в файле реализации нашего контроллера вида:


— (void)viewDidLoad{

[super viewDidLoad];

}

Создадим переключатель и поместим его в виде, в котором находится контроллер нашего вида:

— (void)viewDidLoad{

[super viewDidLoad];


/* Создаем переключатель */

self.mainSwitch = [[UISwitch alloc] initWithFrame:

CGRectMake(100, 100, 0, 0)];


[self.view addSubview: self.mainSwitch];

}


Итак, мы выделили объект типа UISwitch и применили метод initWithFrame: для инициализации переключателя. Обратите внимание: параметр, который мы должны передать этому методу, относится к типу CGRect. CGRect определяет границы прямоугольника, отсчитывая их от точки с координатами (x; y ), находящейся в левом верхнем углу прямоугольника, и также используя данные о его ширине и высоте. Можно создать CGRect, воспользовавшись встраиваемым методом CGRectMake, где первые два параметра, передаваемые методу, — это координаты (x; y ), а следующие два — высота и ширина прямоугольника.

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

Теперь запустим приложение на эмуляторе iPhone. На рис. 1.8 показано, что происходит.




Рис. 1.8. Переключатель, размещенный в виде


Как видите, по умолчанию переключатель находится в состоянии Off (Выкл.). Чтобы задать в качестве стандартного противоположное состояние, можно изменить значение свойства on экземпляра UISwitch. Или можно вызвать метод setOn:, относящийся к переключателю:

[self.mySwitch setOn: YES];

Мы можем немного облегчить работу пользователю, применив метод переключателя setOn: animated:. Параметр animated принимает логическое значение. Если логическое значение равно YES, то при переходе переключателя из состояния on в состояние off этот процесс будет анимироваться, а также будут анимироваться любые взаимодействия пользователя с переключателем.

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


if ([self.mySwitch isOn]){

NSLog(@"The switch is on.");

} else {

NSLog(@"The switch is off.");

}


Если вы хотите получать уведомления о том, когда  переключатель переходит в состояние «включено» или «выключено», необходимо указать ваш класс как цель  (Target) переключателя, воспользовавшись методом addTarget: action: forControlEvents: класса UISwitch:


[self.mySwitch addTarget: self

action:@selector(switchIsChanged:)

forControlEvents: UIControlEventValueChanged];


Затем реализуем метод switchIsChanged:. Когда среда времени исполнения вызовет этот метод в ответ на событие переключателя UIControlEventValueChanged, она передаст переключатель как параметр данного метода и вы сможете узнать, какой именно переключатель инициировал данное событие:


— (void) switchIsChanged:(UISwitch *)paramSender{


NSLog(@"Sender is = %@", paramSender);


if ([paramSender isOn]){

NSLog(@"The switch is turned on.");

} else {

NSLog(@"The switch is turned off.");

}


}


Теперь попробуем запустить наше приложение в эмуляторе iOS. В окне консоли вы увидите примерно такие сообщения:


Sender is = <UISwitch: 0x6e13500;

frame = (100 100; 79 27);

layer = <CALayer: 0x6e13700>>

The switch is turned off.

Sender is = <UISwitch: 0x6e13500;

frame = (100 100; 79 27);

layer = <CALayer: 0x6e13700>>

Переключатель включен.

1.3. Оформление UISwitch

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

Вы вставили в ваш пользовательский интерфейс несколько экземпляров UISwitch и теперь хотите оформить их так, чтобы они вписывались в этот графический интерфейс.

Решение

 Сделать закладку на этом месте книги

Используйте одно из свойств настройки тонов/изображений класса UISwitch, например tintColor или onTintColor.

Обсуждение

 Сделать закладку на этом месте книги

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

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

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

 Изображения . Переключателю соответствуют:

 изображение включенного состояния . Находится на переключателе, когда он включен. Ширина изображения составляет 77 точек, высота — 22 точки;

 изображение выключенного состояния . Находится на переключателе, когда он выключен. Ширина изображения составляет 77 точек, высота — 22 точки.

На рис. 1.9 показаны примеры изображений, используемых при включенном и выключенном переключателе.




Рис. 1.9. Переключатель UISwitch и изображения, соответствующие его включенному и выключенному состояниям


Итак, переключатель может находиться в одном из двух состояний — он либо включен, либо выключен. Теперь рассмотрим, как изменить оттенок переключателя, находящегося в пользовательском интерфейсе. Это можно сделать с помощью трех важных свойств класса UISwitch (все эти свойства относятся к типу UIColor):

tintColor — оттенок, применяемый к переключателю в выключенном состоянии. К сожалению, Apple подобрала для него не совсем точное название (правильнее было бы, конечно, назвать это свойство offTintColor);

• thumbTintColor — оттенок, который будет применяться к рычажку переключателя;

• onTintColor — оттенок, применяемый к переключателю во включенном состоянии.

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


— (void)viewDidLoad

{

[super viewDidLoad];


/* Создаем переключатель */

self.mainSwitch = [[UISwitch alloc] initWithFrame: CGRectZero];

self.mainSwitch.center = self.view.center;

[self.view addSubview: self.mainSwitch];


/* Оформляем переключатель */


/* Изменяем оттенок, который будет у переключателя в выключенном виде */

self.mainSwitch.tintColor = [UIColor redColor];

/* Изменяем оттенок, который будет у переключателя во включенном виде */

self.mainSwitch.onTintColor = [UIColor brownColor];

/* Изменяем также оттенок рычажка на переключателе */

self.mainSwitch.thumbTintColor = [UIColor greenColor];

}


Теперь, когда мы закончили работу с оттенками переключателя, перейдем к оформлению внешнего вида переключателя, связанному с использованием изображений «включено» и «выключено». При этом не забываем, что заказные изображения «включено» и «выключено» поддерживаются только в iOS 6 и старше. iOS 7 игнорирует такие изображения и при оформлении внешнего вида работает только с оттенками. Как было указано ранее, оба варианта изображения на переключателе — как для включенного, так и для выключенного состояния — должны иметь ширину 77 точек и высоту 22 точки. Поэтому я подготовил новый комплект таких изображений (для работы с обычным и сетчатым дисплеем). Я добавил их в мой проект в Xcode под названиями [email protected] и [email protected] (для сетчатого дисплея), а также поместил здесь разновидности изображений для обычного дисплея. Теперь нам предстоит создать переключатель, но присвоить ему заказные изображения «включено» и «выключено». Для этого воспользуемся следующими свойствами UISwitch:

onImage — как указано ранее, это изображение будет использоваться, когда переключатель включен;

• offImage — это изображение соответствует переключателю в состоянии «выключено».

А вот код, позволяющий добиться такого эффекта:


— (void)viewDidLoad

{

[super viewDidLoad];


/* Создаем переключатель */

self.mainSwitch = [[UISwitch alloc] initWithFrame: CGRectZero];

self.mainSwitch.center = self.view.center;

/* Убеждаемся, что переключатель не выглядит размытым в iOS-эмуляторе */

self.mainSwitch.frame = [self roundedValuesInRect: self.mainSwitch.frame];

[self.view addSubview: self.mainSwitch];


/* Оформляем переключатель */

self.mainSwitch.onImage = [UIImage imageNamed:@"On"];

self.mainSwitch.offImage = [UIImage imageNamed:@"Off"];

}

См. также

 Сделать закладку на этом месте книги

Раздел 1.2.

1.4. Выбор значений с помощью UIPickerView

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

Необходимо предоставить пользователю приложения возможность выбирать значения из списка.

Решение

 Сделать закладку на этом месте книги

Воспользуйтесь классом UIPickerView.

Обсуждение

 Сделать закладку на этом месте книги

Вид выбора (Picker View) — это элемент графического интерфейса, позволяющий отображать для пользователей списки значений, из которых пользователь затем может выбрать одно. В разделе Timer (Таймер) приложения Clock (Часы) в iPhone мы видим именно такой пример (рис. 1.10).




Рис. 1.10. Вид выбора, расположенный в верхней части экрана


Как видите, в отдельно взятом виде выбора содержится два независимых визуальных элемента, один слева, другой справа. В левой части вида отображаются часы (0, 1, 2 и т. д.), а в правой — минуты (18, 19, 20, 21, 22 и т. д.). Два этих элемента называются компонентами . В каждом компоненте есть строки (Rows). На самом деле любой элемент в любом компоненте представлен строкой, как мы вскоре увидим. Например, в левом компоненте 0 hours — это строка, 1 — это строка и т. д.

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

Сначала перейдем к файлу реализации. m контроллера нашего вида и определим в нем вид выбора:


@interface ViewController ()

@property (nonatomic, strong) UIPickerView *myPicker;

@end


@implementation ViewController


А теперь создадим вид выбора в методе viewDidLoad контроллера нашего вида:

— (void)viewDidLoad{

[super viewDidLoad];


self.view.backgroundColor = [UIColor whiteColor];


self.myPicker = [[UIPickerView alloc] init];

self.myPicker.center = self.view.center;

[self.view addSubview: self.myPicker];


}


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

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


@interface ViewController () <UIPickerViewDataSource, UIPickerViewDelegate>

@property (nonatomic, strong) UIPickerView *myPicker;

@end


@implementation ViewController



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


— (void)viewDidLoad{

[super viewDidLoad];


self.myPicker = [[UIPickerView alloc] init];

self.myPicker.dataSource = self;

self.myPicker.center = self.view.center;

[self.view addSubview: self.myPicker];


}


После этого, попытавшись скомпилировать приложение, вы увидите, что компилятор начинает выдавать предупреждения. Эти предупреждения сообщают, что вы еще не реализовали некоторые методы, внедрения которых требует протокол UIPickerViewDataSource. Чтобы исправить эту ситуацию, нужно нажать Command+Shift+O, ввести UIPickerViewDataSource и нажать Enter. Так вы попадете к тому месту в вашем коде, где определяется данный протокол, и увидите нечто подобное:


@protocol UIPickerViewDataSource<NSObject>

@required


// Возвращает количество столбцов для отображения

— (NSInteger)numberOfComponentsInPickerView:(UIPickerView *)pickerView;


// Возвращает количество строк в каждом компоненте

— (NSInteger)pickerView:(UIPickerView *)pickerView

numberOfRowsInComponent:(NSInteger)component;

@end


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


— (NSInteger)numberOfComponentsInPickerView:(UIPickerView *)pickerView{


if ([pickerView isEqual: self.myPicker]){

return 1;

}


return 0;


}

— (NSInteger) pickerView:(UIPickerView *)pickerView

numberOfRowsInComponent:(NSInteger)component{


if ([pickerView isEqual: self.myPicker]){

return 10;

}


return 0;

}


Итак, что здесь происходит? Расс


убрать рекламу






мотрим, какие данные предполагает каждый из методов источника:

numberOfComponentsInPickerView: — этот метод передает объект вида выбора в качестве параметра, а в качестве возвращаемого значения ожидает целое число, указывающее, сколько компонентов вы хотели бы отобразить в этом виде выбора;

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

Итак, мы приказываем системе отобразить один компонент всего с 10 строками для вида выбора, который мы создали ранее и назвали myPicker.

Скомпилируйте приложение и запустите его в эмуляторе iPhone (рис. 1.11). Хм-м-м, и что же это?




Рис. 1.11. Вот как выглядит вид выбора, когда неизвестно, какую информацию в нем отображать


По всей видимости, наш вид выбора знает, сколько компонентов в нем должно быть и сколько строк он должен отображать в интересующем нас компоненте, но не знает, какой текст  должен содержаться в каждой строке. Этот вопрос обязательно следует прояснить, и мы решим данную проблему, предоставив делегат для вида выбора. Делегат экземпляра UIPickerView должен подчиняться протоколу UIPickerViewDelegate и реализовывать все методы, помеченные как @required.

Нас интересует только один метод делегата UIPickerViewDelegate, а именно pickerView: titleForRow: forComponent:. Этот метод передает вам индекс актуального раздела и индекс актуальной строки в данном разделе вида выбора и в качестве возвращаемого значения ожидает экземпляр NSString. Строка, представленная NSString, отобразится в заданном ряду внутри компонента. В рассматриваемом случае я предпочитаю просто отобразить первую строку как «Строка 1», а затем продолжить: «Строка 2», «Строка 3» и т. д. Не забывайте, что потребуется также установить свойство delegate нашего вида выбора:


self.myPicker.delegate = self;


А теперь обработаем только что изученный метод делегата:


— (NSString *)pickerView:(UIPickerView *)pickerView

titleForRow:(NSInteger)row

forComponent:(NSInteger)component{


if ([pickerView isEqual: self.myPicker]){


/* Строка имеет нулевое основание, а мы хотим, чтобы первая строка

(с индексом 0) отображалась как строка 1. Таким образом, нужно

прибавить +1 к индексу каждой строки. */

result = [NSString stringWithFormat:@"Row %ld", (long)row + 1];


}

return nil;

}


Теперь запустим приложение и посмотрим, что происходит (рис. 1.12).




Рис. 1.12. Вид выбора с одним разделом и несколькими строками


Виды с возможностью выбора в iOS 6 и старше могут подсвечивать выбранный вариант с помощью свойства showsSelectionIndicator, по умолчанию имеющего значение NO. Вы можете либо напрямую изменить значение этого свойства на YES, либо воспользоваться методом setShowsSelectionIndicator: вида выбора, чтобы включить этот индикатор:


self.myPicker.showsSelectionIndicator = YES;


Снова предположим, что мы создаем вид выбора в окончательной версии нашего приложения. Какая польза от вида выбора, если мы не можем определить, что именно пользователь выбрал в каждом из компонентов? Да, хорошо, что Apple уже позаботилась о решении этой проблемы и предоставила нам возможность спрашивать вид выбора о выбранном варианте. Вызовем метод selectedRowInComponent: класса UIPickerView и передадим индекс компонента (с нулевым основанием), а в качестве возвращаемого значения получим целое число. Это число будет представлять собой индекс с нулевым основанием, сообщающий строку, которая в данный момент выбрана в интересующем нас компоненте.

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

См. также

 Сделать закладку на этом месте книги

Раздел 1.2.

1.5. Выбор даты и времени с помощью UIDatePicker

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

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

Решение

 Сделать закладку на этом месте книги

Воспользуйтесь классом UIDatePicker.

Обсуждение

 Сделать закладку на этом месте книги

Класс UIDatePicker очень напоминает класс UIPickerView. Фактически UIDatePicker — это уже заполненный вид выбора. Хорошим примером такого вида является программа Calendar (Календарь) в iPhone (рис. 1.13).




Рис. 1.13. Вид для выбора даты показан в нижней части экрана


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


#import «ViewController.h»


@interface ViewController ()

@property (nonatomic, strong) UIDatePicker *myDatePicker;

@end


@implementation ViewController



А теперь, как и планировалось, инстанцируем вид для выбора даты:


— (void)viewDidLoad{

[super viewDidLoad];

self.myDatePicker = [[UIDatePicker alloc] init];

self.myDatePicker.center = self.view.center;

[self.view addSubview: self.myDatePicker];

}


После этого запустим приложение и посмотрим, как оно выглядит (рис. 1.14).




Рис. 1.14. Простой вид для выбора даты


Как видите, по умолчанию в виде выбора даты ставится сегодняшняя дата. Начиная работать с такими инструментами, первым делом нужно уяснить, что они могут иметь различные стили оформления и режимы работы. Режим можно изменить, работая со свойством datePickerMode, тип которого — UIDatePickerMode:


typedef enum {

UIDatePickerModeTime,

UIDatePickerModeDate,

UIDatePickerModeDateAndTime,

UIDatePickerModeCountDownTimer,

} UIDatePickerMode;


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

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


NSDate *currentDate = self.myDatePicker.date;

NSLog(@"Date = %@", currentDate);


Подобно классу UISwitch, вид для выбора даты также посылает своим целям инициирующие сообщения (Action Messages) всякий раз, когда отображаемая в виде дата изменяется. Чтобы иметь возможность реагировать на эти сообщения, получатель должен добавить себя в список целей вида выбора даты. Для этого используется метод addTarget: action: forControlEvents: следующим образом:


— (void) datePickerDateChanged:(UIDatePicker *)paramDatePicker{


if ([paramDatePicker isEqual: self.myDatePicker]){

NSLog(@"Selected date = %@", paramDatePicker.date);

}


}


— (void)viewDidLoad{

[super viewDidLoad];

self.myDatePicker = [[UIDatePicker alloc] init];

self.myDatePicker.center = self.view.center;

[self.view addSubview: self.myDatePicker];

[self.myDatePicker addTarget: self

action:@selector(datePickerDateChanged:)

forControlEvents: UIControlEventValueChanged];


}


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

Пользуясь видом для выбора даты, можно задавать минимальную и максимальную даты, которые он способен отображать. Для этого сначала нужно переключить вид выбора даты в режим UIDatePickerModeDate, а потом с помощью свойств maximumDate и minimumDate откорректировать этот диапазон:


— (void)viewDidLoad{

[super viewDidLoad];

self.myDatePicker = [[UIDatePicker alloc] init];

self.myDatePicker.center = self.view.center;

self.myDatePicker.datePickerMode = UIDatePickerModeDate;

[self.view addSubview: self.myDatePicker];


NSTimeInterval oneYearTime = 365 * 24 * 60 * 60;

NSDate *todayDate = [NSDate date];


NSDate *oneYearFromToday = [todayDate

dateByAddingTimeInterval: oneYearTime];


NSDate *twoYearsFromToday = [todayDate

dateByAddingTimeInterval:2 * oneYearTime];


self.myDatePicker.minimumDate = oneYearFromToday;

self.myDatePicker.maximumDate = twoYearsFromToday;

}


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





Рис. 1.15. Минимальная и максимальная даты при работе с видом выбора даты

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


— (void)viewDidLoad{

[super viewDidLoad];

self.view.backgroundColor = [UIColor whiteColor];

self.myDatePicker = [[UIDatePicker alloc] init];

self.myDatePicker.center = self.view.center;

self.myDatePicker.datePickerMode = UIDatePickerModeCountDownTimer;

[self.view addSubview: self.myDatePicker];

NSTimeInterval twoMinutes = 2 * 60;

[self.myDatePicker setCountDownDuration: twoMinutes];

}


Результат показан на рис. 1.16.




Рис. 1.16. Таймер обратного отсчета в виде для выбора даты, где стандартная длительность обратного отсчета равна 2 минутам

1.6. Реализация инструмента для выбора временных рамок с помощью UISlider

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

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

Решение

 Сделать закладку на этом месте книги

Используйте класс UISlider.

Обсуждение

 Сделать закладку на этом месте книги

Вероятно, вы уже знаете, что такое слайдер. Пример слайдера показан на рис. 1.17.




Рис. 1.17. В нижней части экрана находится слайдер, регулирующий уровень громкости


Чтобы создать слайдер, нужно инстанцировать объект типа UISlider. Создадим слайдер и поместим его на вид нашего контроллера. Начнем с файла реализации нашего контроллера вида:


#import «ViewController.h»


@interface ViewController ()

@property (nonatomic, strong) UISlider *slider;

@end


@implementation ViewController



Теперь рассмотрим метод viewDidLoad и создадим сам компонент-слайдер. В этом коде мы будем создавать слайдер, позволяющий выбирать значения в диапазоне от 0 до 100. По умолчанию ползунок слайдера будет установлен в среднем значении шкалы:


— (void)viewDidLoad{

[super viewDidLoad];


self.slider = [[UISlider alloc] initWithFrame: CGRectMake(0.0f,

0.0f,

200.0f,

23.0f)];

self.slider.center = self.view.center;

self.slider.minimumValue = 0.0f;

self.slider.maximumValue = 100.0f;

self.slider.value = self.slider.maximumValue / 2.0;

[self.view addSubview: self.slider];

}

Диапазон слайдера совершенно не зависит от его внешнего вида. С помощью указателя диапазона мы приказываем слайдеру вычислить его (слайдера) значение, основываясь на относительной позиции в рамках диапазона. Например, если для слайдера задан диапазон от 0 до 100, то когда ползунок слайдера расположен у левого края шкалы, свойство слайдера value равно 0, а если ползунок стоит у правого края, оно равно 100.

Как будут выглядеть результаты? Теперь вы можете запустить приложение в эмуляторе (рис. 1.18).




Рис. 1.18. Обычный слайдер в центре экрана


Для получения желаемых результатов мы использовали несколько свойств слайдера. Что это за свойства?

• minimumValue — задает минимальное значение диапазона, поддерживаемого слайдером.

• maximumValue — задает максимальное значение диапазона, поддерживаемого слайдером.

• value — текущее значение слайдера. Это свойство доступно как для чтения, так и для изменения, то есть вы можете как считывать это значение, так и записывать в него информацию. Если вы хотите, чтобы при перемещении ползунка в это значение включалась анимация, то можно вызвать метод слайдера setValue: animated: и передать YES в качестве значения параметра animated.

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


— (void) sliderValueChanged:(UISlider *)paramSender{


if ([paramSender isEqual: self.mySlider]){

NSLog(@"New value = %f", paramSender.value);

}


}

— (void)viewDidLoad{

[super viewDidLoad];

self.view.backgroundColor = [UIColor whiteColor];

self.mySlider = [[UISlider alloc] initWithFrame: CGRectMake(0.0f,

0.0f,

200.0f,

23.0f)];

self.slider.center = self.view.center;

self.slider.minimumValue = 0.0f;

self.slider.maximumValue = 100.0f;

self.slider.value = self.slider.maximumValue / 2.0;

[self.view addSubview: self.slider];


[self.slider addTarget: self

action:@selector(sliderValueChanged:)

forControlEvents: UIControlEventValueChanged];

}


Если сейчас запустить приложение в эмуляторе, вы увидите, что вызывается целевой метод sliderValueChanged: и это происходит всякий раз, как только  перемещается ползунок слайдера. Возможно, именно этого вы и хотели. Но в некоторых случаях уведомление требуется лишь тогда, когда пользователь отпустил ползунок, установив его в новом значении. Если вы хотите дождаться такого уведомления, установите для свойства слайдера continuous значение NO. Если это свойство имеет значение YES (задаваемое по умолчанию), то на цели слайдера вызов будет идти непрерывно все то время, пока движется ползунок.

В SDK iOS разработчик также может изменять внешний вид слайдера. Например, ползунок может иметь нестандартный вид. Чтобы изменить внешний вид ползунка, просто пользуйтесь методом setThumbImage: forState: и передавайте нужное изображение, а также второй параметр, который может принимать одно из двух значений:

• UIControlStateNormal — обычное состояние ползунка, когда его не трогает пользователь;

• UIControlStateHighlighted — изображение, которое должно быть на месте ползунка, когда пользователь начинает его двигать.


Я подготовил два изображения: одно для стандартного состояния ползунка, а другое — для активного (затронутого) состояния. Добавим их к слайдеру:


[self.slider setThumbImage: [UIImage imageNamed:@"ThumbNormal.png"]

forState: UIControlStateNormal];

[self.slider setThumbImage: [UIImage imageNamed:@"ThumbHighlighted.png"]

forState: UIControlStateHighlighted];


Теперь взглянем, как выглядит в эмуляторе неактивный слайдер (рис. 1.19).




Рис. 1.19. Слайдер со специально оформленным ползунком

1.7. Оформление UISlider

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

Вы используете компонент графического интерфейса UISlider, оформленный по умолчанию, и хотите на свой вкус изменить его внешний вид.

Решение

 Сделать закладку на этом месте книги

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

Обсуждение

 Сделать закладку на этом месте книги

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




Рис. 1.20. Различные компоненты UISlider


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

• minimumTrackTintColor — это свойство задает оттенок для области минимальных значений;

• thumbTintColor — это свойство, как понятно из его названия, задает цвет ползунка;

• maximumTrackTintColor — это свойство задает оттенок для области максимальных значений.

Все эти свойства относятся к типу UIColor.

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


— (void)viewDidLoad{

[super viewDidLoad];


/* Создаем слайдер */

self.slider = [[UISlider alloc] initWithFrame: CGRectMake(0.0f,

0.0f,

118.0f,

23.0f)];

self.slider.value = 0.5;

self.slider.minimumValue = 0.0f;

self.slider.maximumValue = 1.0f;

self.slider.center = self.view.center;

[self.view addSubview: self.slider];


/* Задаем оттенок для области минимальных значений */

self.slider.minimumTrackTintColor = [UIColor redColor];


/* Задаем оттенок для ползунка */

self.slider.maximumTrackTintColor = [UIColor greenColor];


/* Задаем цвет для области максимальных значений */

self.slider.thumbTintColor = [UIColor blackColor];

}


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




Рис. 1.21. Оттенки всех составных частей слайдера изменены


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

• Изображение для минимального значения . Это изображение, которое будет находиться за пределами слайдера у его левого края. По умолчанию такое изображение не предоставляется, поэтому вы его и не увидите, если просто создадите в виде новый слайдер. Вы можете задать такое изображение, чтобы подсказывать пользователю, как трактуется минимальное значение в контексте данного слайдера. Например, в приложении, с помощью которого пользователь может увеличивать или уменьшать яркость экрана, минимальному значению может соответствовать картинка в виде потухшей лампочки. Она показывает, что чем дальше пользователь будет перемещать ползунок в сторону минимального значения (влево), тем более тусклым будет становиться экран. Чтобы изменить это изображение, воспользуйтесь относящимся к слайдеру методом экземпляра setMinimumValueImage:. Это изображение должно иметь по 23 точки в высоту и в ширину. При работе с сетчатым дисплеем используйте такое же изображение, только вдвое крупнее.

 Изображение для области минимальных значений . Это изображение, которое будет соответствовать колее слайдера левее от ползунка. Чтобы изменить это изображение, воспользуйтесь относящимся к слайдеру методом экземпляра setMinimumTrackImage: forState:. Это изображение должно иметь 11 точек в ширину и 9 точек в высоту и допускать изменение размера (подробнее о таких изображениях см. в разделе 17.5).

 Изображение для ползунка.  Изображение ползунка — это единственный движущийся элемент слайдера. Чтобы изменить это изображение, воспользуйтесь относящимся к слайдеру методом экземпляра setThumbImage: forState:. Это изображение должно иметь 23 точки в высоту и 23 точки в ширину.

 Изображение для области максимальных значений . Это изображение будет соответствовать той части колеи слайдера, которая находится справа от ползунка. Чтобы изменить это изображение, воспользуйтесь относящимся к слайдеру методом экземпляра setMaximumTrackImage: forState:. Это изображение должно иметь 11 точек в ширину и 9 точек в высоту и допускать изменение размера (подробнее о таких изображениях см. в разделе 17.5).

 Изображение для максимального значения . Это изображение, которое будет находиться у правого края слайдера. Оно должно напоминать изображение, соответствующее минимальному значению, но, разумеется, трактуется противоположным образом. Вернувшись к примеру с яркостью лампочки, допустим, что справа от колеи с ползунком у нас изображена яркая лампочка, испускающая лучи. Так пользователю будет понятно, что чем дальше вправо он передвигает ползунок, тем ярче становится экран. Чтобы изменить это изображение, воспользуйтесь относящимся к слайдеру методом экземпляра setMaximumValueImage:. Это изображение должно иметь 23 точки в высоту и столько же в ширину.

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

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


#import «ViewController.h»


@interface ViewController ()

@property (nonatomic, strong) UISlider *slider;

@end


@implementation ViewController


/*

Этот метод возвращает изображение переменного размера для области слайдера, содержащей минимальные значения

*/

— (UIImage *) minimumTrackImage{

UIImage *result = [UIImage imageNamed:@"MinimumTrack"];

UIEdgeInsets edgeInsets;

edgeInsets.left = 4.0f;

edgeInsets.top = 0.0f;

edgeInsets.right = 0.0f;

edgeInsets.bottom = 0.0f;

result = [result resizableImageWithCapInsets: edgeInsets];

return result;

}


/*

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

*/

— (UIImage *) maximumTrackImage{

UIImage *result = [UIImage imageNamed:@"Maximu


убрать рекламу






mTrack"];

UIEdgeInsets edgeInsets;

edgeInsets.left = 0.0f;

edgeInsets.top = 0.0f;

edgeInsets.right = 3.0f;

edgeInsets.bottom = 0.0f;

result = [result resizableImageWithCapInsets: edgeInsets];

return result;

}


— (void)viewDidLoad{

[super viewDidLoad];


/* Создаем слайдер */

self.slider = [[UISlider alloc] initWithFrame: CGRectMake(0.0f,

0.0f,

218.0f,

23.0f)];

self.slider.value = 0.5;

self.slider.minimumValue = 0.0f;

self.slider.maximumValue = 1.0f;

self.slider.center = self.view.center;

[self.view addSubview: self.slider];


/* Изменяем изображение для минимального значения */

[self.slider setMinimumValueImage: [UIImage imageNamed:@"MinimumValue"]];


/* Изменяем изображение для области минимальных значений */

[self.slider setMinimumTrackImage: [self minimumTrackImage]

forState: UIControlStateNormal];


/* Изменяем изображение ползунка для обоих возможных состояний ползунка: когда

пользователь его касается и когда не касается */

[self.slider setThumbImage: [UIImage imageNamed:@"Thumb"]

forState: UIControlStateNormal];

[self.slider setThumbImage: [UIImage imageNamed:@"Thumb"]

forState: UIControlStateHighlighted];


/* Изменяем изображение для области максимальных значений */

[self.slider setMaximumTrackImage: [self maximumTrackImage]

forState: UIControlStateNormal];


/* Изменяем изображение, соответствующее максимальному значению */

[self.slider setMaximumValueImage: [UIImage imageNamed:@"MaximumValue"]];

}

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

См. также

 Сделать закладку на этом месте книги

Раздел 1.6.

1.8. Группирование компактных параметров с помощью UISegmentedControl

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

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

Решение

 Сделать закладку на этом месте книги

Используйте класс UISegmentedControl. Пример работы с этим классом показан на рис. 1.22.




Рис. 1.22. Сегментированный элемент управления, в котором отображаются четыре параметра

Обсуждение

 Сделать закладку на этом месте книги

Сегментированный элемент управления — это сущность, позволяющая отображать в компактном пользовательском интерфейсе наборы параметров, из которых пользователь может выбирать нужный. Чтобы отобразить сегментированный элемент управления, создайте экземпляр класса UISegmentedControl. Начинаем работу с файла реализации (.m) нашего контроллера вида:


#import «ViewController.h»


@interface ViewController ()

@property (nonatomic, strong) UISegmentedControl *mySegmentedControl;

@end


@implementation ViewController


Создаем сегментированный элемент управления в методе viewDidLoad контроллера нашего вида:

— (void)viewDidLoad{

[super viewDidLoad];

NSArray *segments = [[NSArray alloc] initWithObjects:

@"iPhone",

@"iPad",

@"iPod",

@"iMac", nil];


self.mySegmentedControl = [[UISegmentedControl alloc]

initWithItems: segments];

self.mySegmentedControl.center = self.view.center;

[self.view addSubview: self.mySegmentedControl];


}


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

Теперь пользователь может выбрать в сегментированном элементе управления один  из параметров. Допустим, он выбирает iPad. Тогда пользовательский интерфейс сегментированного элемента управления изменится и покажет пользователю, какой параметр будет выбран. Получится такое изображение, как на рис. 1.23.




Рис. 1.23. Пользователь выбрал один из вариантов в сегментированном элементе управления


Возникает вопрос: как узнать, что пользователь выбрал в сегментированном элементе управления новый параметр? Ответ прост. Как и при работе с UISwitch или UISlider, применяется метод addTarget: action: forControlEvents: сегментированного элемента управления, к которому добавляется цель. Для параметра forControlEvents нужно задать значение UIControlEventValueChanged, так как именно это событие запускается, когда пользователь выбирает в сегментированном элементе управления новый параметр:


— (void) segmentChanged:(UISegmentedControl *)paramSender{

if ([paramSender isEqual: self.mySegmentedControl]){

NSInteger selectedSegmentIndex = [paramSender selectedSegmentIndex];


NSString *selectedSegmentText =

[paramSender titleForSegmentAtIndex: selectedSegmentIndex];

NSLog(@"Segment %ld with %@ text is selected",

(long)selectedSegmentIndex,

selectedSegmentText);

}

}


— (void)viewDidLoad{

[super viewDidLoad];

NSArray *segments = [[NSArray alloc] initWithObjects:

@"iPhone",

@"iPad",

@"iPod",

@"iMac", nil];


self.mySegmentedControl = [[UISegmentedControl alloc]

initWithItems: segments];

self.mySegmentedControl.center = self.view.center;

[self.view addSubview: self.mySegmentedControl];


[self.mySegmentedControl addTarget: self

action:@selector(segmentChanged:)

forControlEvents: UIControlEventValueChanged];

}


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


Segment 0 with iPhone text is selected

Segment 1 with iPad text is selected

Segment 2 with iPod text is selected

Segment 3 with iMac text is selected


Как видите, мы использовали метод selectedSegmentIndex сегментированного элемента управления, чтобы найти индекс варианта, выбранного в настоящий момент. Если ни один из элементов не выбран, метод возвращает значение –1. Кроме того, мы использовали метод titleForSegmentAtIndex:. Просто передаем этому методу индекс параметра, выбранного в сегментированном элементе управления, а сегментированный элемент управления возвратит текст, соответствующий этому параметру. Ведь просто, правда?

Как вы, вероятно, заметили, как только пользователь отмечает один из параметров в сегментированном элементе управления, этот параметр выбирается и остается  выбранным, как показано на рис. 1.23. Если вы хотите, чтобы пользователь выбрал параметр, но кнопка этого параметра не оставалась нажатой, а возвращалась к исходной форме (так сказать, «отщелкивалась обратно», как и обычная кнопка), то нужно задать для свойства momentary сегментированного элемента управления значение YES:


self.mySegmentedControl.momentary = YES;


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


— (void)viewDidLoad{

[super viewDidLoad];

NSArray *segments = [[NSArray alloc] initWithObjects:

@"iPhone",

[UIImage imageNamed:@"iPad"],

@"iPod",

@"iMac",

];


self.mySegmentedControl = [[UISegmentedControl alloc]

initWithItems: segments];


CGRect segmentedFrame = self.mySegmentedControl.frame;

segmentedFrame.size.height = 128.0f;

segmentedFrame.size.width = 300.0f;

self.mySegmentedControl.frame = segmentedFrame;

self.mySegmentedControl.center = self.view.center;


[self.view addSubview: self.mySegmentedControl];

}

В данном примере файл iPad.png — это просто миниатюрное изображение «айпада», добавленное в наш проект.

В iOS 7 Apple отказалась от использования свойства segmentedControlStyle класса UISegmentedControl, поэтому теперь сегментированные элементы управления имеют всего один стиль, задаваемый по умолчанию. Мы больше не можем изменять этот стиль.

1.9. Представление видов и управление ими с помощью UIViewController

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

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

Решение

 Сделать закладку на этом месте книги

Воспользуйтесь классом UIViewController.

Обсуждение

 Сделать закладку на этом месте книги

Стратегия разработки для iOS, предложенная Apple, предполагает использование паттерна «модель — вид — контроллер» (MVC) и соответствующее разделение задач. Виды — это элементы, отображаемые для пользователя, а модель — это абстракция с данными, которыми управляет приложение. Контроллер — это перемычка, соединяющая модель и вид. Контроллер (в данном случае речь идет о контроллере вида) управляет отношениями между видом и моделью. Почему же этими отношениями не занимается вид? Ответ довольно прост: если бы мы возлагали эти задачи на вид, код вида становился бы очень запутанным. Кроме того, такой подход тесно связывал бы виды с моделью, что не очень хорошо.

Контроллеры видов можно загружать из файлов XIB (для использования с конструктором интерфейсов) или просто создавать с помощью программирования. Сначала рассмотрим, как создать контроллер вида, не пользуясь  файлом XIB.

Контроллеры видов удобно создавать в Xcode. Теперь, когда вы уже создали шаблон приложения с помощью шаблона Empty Application (Пустое приложение), выполните следующие шаги, чтобы создать новый контроллер вида для вашего приложения.

1. В Xcode перейдите в меню File (Файл) и там выберите New-New File (Новый— Новый файл).

2. В диалоговом окне New File (Новый файл) убедитесь, что слева выбраны категория iOS и подкатегория Cocoa Touch. Когда сделаете это, выберите класс UIViewController в правой части диалогового окна, а затем нажмите Next (Далее) (рис. 1.24).




Рис. 1.24. Подкласс нового контроллера вида


3. На следующем экране убедитесь, что в текстовом поле Subclass (Подкласс) указано UIViewController, а также что сняты флажки Targeted for iPad (Разработка для iPad) и With XIB for user interface (Использовать файл XIB для пользовательского интерфейса). Именно такая ситуация показана на рис. 1.25. Нажмите Next (Далее).




Рис. 1.25. Собственный контроллер вида, без использования класса XIB


4. На следующем экране (Save as (Сохранить как)) назовите файл контроллера вида RootViewController и нажмите Save (Сохранить) (рис. 1.26).




Рис. 1.26. Сохранение контроллера вида без использования файла XIB


5. Теперь найдем файл реализации (.m) делегата приложения, который обычно называется AppDelegate.m. В этом файле объявим свойство типа ViewController:


#import «AppDelegate.h»

#import «ViewController.h»


@interface AppDelegate ()

@property (nonatomic, strong) ViewController *viewController;

@end


@implementation AppDelegate



6. Найдем в файле реализации метод application: didFinishLaunchingWithOptions:, относящийся к делегату приложения, инстанцируем контроллер вида и добавим его в наше окно как корневой контроллер вида:


— (BOOL) application:(UIApplication *)application

didFinishLaunchingWithOptions:(NSDictionary *)launchOptions{


self.viewController = [[ViewController alloc] initWithNibName: nil

bundle: nil];


self.window = [[UIWindow alloc]

initWithFrame: [[UIScreen mainScreen] bounds]];


/* Делаем наш контроллер вида корневым контроллером вида */

self.window.rootViewController = self.viewController;


self.window.backgroundColor = [UIColor whiteColor];

[self.window makeKeyAndVisible];

return YES;

}


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

Если при создании контроллера вида (см. рис. 1.25) установить флажок With XIB for user interface (Использовать файл XIB для пользовательского интерфейса), то Xcode также сгенерирует файл XIB. В таком случае вам придется загрузить контроллер вашего вида из  этого файла XIB, передав в параметр initWithNibName метода initWithNibName: bundle: контроллера вида полное имя файла XIB:


— (BOOL) application:(UIApplication *)application

didFinishLaunchingWithOptions:(NSDictionary *)launchOptions{


self.viewController = [[ViewController alloc]

initWithNibName:@"ViewController"

bundle: nil];


self.window = [[UIWindow alloc]

initWithFrame: [[UIScreen mainScreen] bounds]];


/* Делаем наш контроллер вида корневым контроллером вида */

self.window.rootViewController = self.viewController;


self.window.backgroundColor = [UIColor whiteColor];

[self.window makeKeyAndVisible];

return YES;

}


Если вы все же создали файл XIB, подготавливая контроллер вашего вида, этот файл теперь можно выбрать в Xcode и смастерить пользовательский интерфейс в конструкторе интерфейсов.

См. также

 Сделать закладку на этом месте книги

Раздел 1.0.

1.10. Предоставление возможностей совместного использования информации с применением UIActivityViewController

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

Внутри вашего приложения вы хотите предоставить пользователям возможность обмениваться контентом с их друзьями. Для этого предполагается использовать интерфейс, подобный тому, что показан на рис. 1.27. В этом интерфейсе предоставляются различные возможности совместного использования информации, имеющиеся в iOS, — например, через Facebook и Twitter.

Решение

 Сделать закладку на этом месте книги

Создайте экземпляр класса UIActivityViewController и реализуйте совместное использование контента в этом классе так, как рассказано в подразделе «Обсуждение» данного раздела.

Экземпляры класса UIActivityViewController на iPhone следует представлять модально, а на iPad — на вспомогательных экранах. Более подробно о вспомогательных экранах рассказано в разделе 1.29.



Рис. 1.27. Контроллер вида для обмена информацией, открытый на устройстве с iOS

Обсуждение

 Сделать закладку на этом месте книги

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

Совместное использование данных в iOS организовано очень просто. Для обеспечения такой работы вам всего лишь потребуется инстанцировать класс UIActivityViewController с помощью его метода-инициализатора initWithActivityItems: applicationActivities:. Вот какие параметры принимает этот метод:

• initWithActivityItems — массив элементов, которые предполагается совместно использовать. Это могут быть экземпляры NSString, UIImage или экземпляры любых других заказных классов, соответствующих протоколу UIActivityItemSource. Далее мы детально рассмотрим этот протокол;

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

Итак, допустим, что у нас есть текстовое поле, где пользователь может ввести текст, который затем будет использоваться совместно. Рядом с этим полем будет находиться кнопка Share (Поделиться). Когда пользователь нажимает кнопку Share, вы просто передаете текст, находящийся в текстовом поле, вашему экземпляру класса UIActivityViewController. Далее приведен соответствующий код. Мы пишем этот код для iPhone, поэтому представим контроллер вида с этой активностью как модальный контроллер вида.

Поскольку мы помещаем в нашем контроллере вида текстовое поле, нам необходимо обеспечить обработку его делегатных сообщений, в особенности тех, что поступают от метода textFieldShouldReturn: из протокола UITextFieldDelegate. Следовательно, мы собираемся выбрать контроллер вида в качестве делегата текстового поля. Кроме того, прикрепим к кнопке Share (Поделиться) метод действия. Когда эта кнопка будет нажата, нам потребуется убедиться, что в текстовом поле есть какая-то информация, которой можно поделиться. Если ее там не окажется, мы просто отобразим для пользователя окно с предупреждением, в котором сообщим, что не можем предоставить содержимое текстового поля для совместного использования. Если в текстовом поле окажется какой-либо текст, мы выведем на экран экземпляр класса UIActivityViewController.

Итак, начнем с файла реализации контроллера вида и определим компоненты пользовательского интерфейса:


@interface ViewController () <UITextFieldDelegate>

@property (nonatomic, strong) UITextField *textField;

@property (nonatomic, strong) UIButton *buttonShare;

@property (nonatomic, strong) UIActivityViewController *activityViewController;

@end



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


— (void) createTextField{

self.textField = [[UITextField alloc] initWithFrame: CGRectMake(20.0f,

35.0f,

280.0f,

30.0f)];

self.textField.translatesAutoresizingMaskIntoConstraints = NO;

self.textField.borderStyle = UITextBorderStyleRoundedRect;

self.textField.placeholder = @"Enter text to share…";

self.textField.delegate = self;

[self.view addSubview: self.textField];

}


— (void) createButton{

self.buttonShare = [UIButton buttonWithType: UIButtonTypeRoundedRect];

self.buttonShare.translatesAutoresizingMaskIntoConstraints = NO;

self.buttonShare.frame = CGRectMake(20.0f, 80.0f, 280.0f, 44.0f);

[self.buttonShare setTitle:@"Share" forState: UIControlStateNormal];


[self.buttonShare addTarget: self

action:@selector(handleShare:)

forControlEvents: UIControlEventTouchUpInside];


[self.view addSubview: self.buttonShare];

}


Когда эта работа будет завершена, нам останется всего лишь вызвать два этих метода в методе viewDidLoad нашего контроллера вида. Таким образом мы правильно разместим компоненты пользовательского интерфейса в окне контроллера вида:


— (void)viewDidLoad{


[super viewDidLoad];

[self createTextField];

[self createButton];


}


В методе textFieldShouldReturn: мы просто убираем с экрана клавиатуру, чтобы отказаться от активного состояния текстового поля. Это просто означает, что если пользователь редактировал текст в текстовом поле, а затем нажал клавишу Enter, то клавиатура должна исчезнуть с экрана. Не забывайте, что только что написанный метод createTextField задает наш контроллер вида в качестве делегата текстового поля. Поэтому потребуется реализовать упомянутый метод следующим образом:


— (BOOL) textFieldShouldReturn:(UITextField *)textField{

[textField resignFirstResponder];

return YES;

}


Последний, но немаловажный элемент — это метод-обработчик нашей кнопки. Как мы уже видели, метод createButton создает для нас кнопку и выбирает метод handleShare: для обработки действия-касания (нажатия) в рамках работы кнопки. Напишем этот метод:


— (void) handleShare:(id)paramSender{


if ([self.textField.text length] == 0){

NSString *message = @"Please enter a text and then press Share";

UIAlertView *alertView = [[UIAlertView alloc] initWithTitle: nil

message: message

delegate: nil

cancelButtonTitle:@"OK"

otherButtonTitles: nil];

[alertView show];

return;

}


self.activityViewController = [[UIActivityViewController alloc]

initWithActivityItems:@[self.textField.text]

applicationActivities: nil];

[self presentViewController: self.activityViewController

animated: YES

completion: ^{

/* Пока ничего не делаем */

}];

}


Теперь, если запустить приложение, ввести в текстовое поле какой-либо текст, а затем нажать кнопку Share (Поделиться), мы получим результат, похожий на то, что изображено на рис. 1.28.




Рис. 1.28. Возможности совместного использования экземпляра строки, которым мы пытаемся поделиться


Вы можете выводить на экран параметры совместного использования уже вместе с контроллером вида. Метод viewDidAppear вашего контроллера вида будет вызываться, когда контроллер вида отобразится на экране и гарантированно окажется в иерархии видов вашего приложения. Это означает, что теперь вы сможете отобразить и другие виды поверх вашего контроллера вида.

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

См. также

 
убрать рекламу






lt='Сделать закладку на этом месте книги' title='Сделать закладку на этом месте книги' />

Раздел 1.29.

1.11. Предоставление специальных возможностей совместного использования данных с применением UIActivityViewController

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

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

Подобные возможности могут понадобиться вам, например, при работе с текстовым редактором. Когда пользователь нажимает кнопку Share (Поделиться), в контроллере вида с функцией должен появиться специальный элемент, в котором написано: Archive (Архивировать). Когда пользователь нажмет кнопку Archive (Архивировать), текст в редактируемой области вашего приложения будет передан специальной функции, а затем ваша функция сможет заархивировать этот текст в файловой системе на устройстве с iOS.

Решение

 Сделать закладку на этом месте книги

Создайте класс типа UIActivity. Иными словами, произведите подкласс от этого класса и дайте новоиспеченному классу любое устраивающее вас имя. Экземпляры подклассов этого класса можно будет передавать методу-инициализатору initWithActivityItems: applicationActivities:, относящемуся к классу UIActivityViewController. Если эти экземпляры реализуют все необходимые методы класса UIActivity, то iOS отобразит их в контроллере вида с функцией.

Обсуждение

 Сделать закладку на этом месте книги

Первый параметр метода initWithActivityItems: applicationActivities: принимает значения различных типов, в частности строки, числа, изображения и т. д. — фактически любые объекты. Если вы представите в параметре initWithActivityItems контроллер активности с массивом объектов произвольных типов, iOS просмотрит все доступные в системе функции — например, для работы с Facebook и Twitter — и предложит пользователю выбрать такую функцию, которая лучше всего отвечает его нуждам. После того как пользователь выберет функцию, iOS передаст тип  объектов, находящихся в вашем массиве, в зарегистрированную системную функцию, выбранную пользователем. Затем такие функции смогут проверять тип объектов, которые вы собираетесь предоставлять в совместное пользование, и решать, может ли та или иная функция обработать такие объекты или нет. Функции передают такую информацию системе iOS посредством особого метода, реализуемого в их классах.

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

1. Произведите подкласс от UIActivity следующим образом:


#import <UIKit/UIKit.h>

@interface StringReverserActivity: UIActivity

@end


2. Поскольку мы собираемся выводить в нашей функции вид с предупреждением и отображать его для пользователя, когда нам будет передан массив строк, мы должны гарантировать соответствие нашей функции протоколу UIAlertViewDelegate. Когда пользователь закроет окно с предупреждением, мы должны пометить нашу функцию как завершенную, вот так:


#import «StringReverserActivity.h»


@interface StringReverserActivity () <UIAlertViewDelegate>

@property (nonatomic, strong) NSArray *activityItems;

@end


@implementation StringReverserActivity


— (void) alertView:(UIAlertView *)alertView

didDismissWithButtonIndex:(NSInteger)buttonIndex{

[self activityDidFinish: YES];

}


3. Далее переопределим метод activityType нашей функции. Возвращаемое значение этого метода представляет собой объект типа NSString, являющийся уникальным идентификатором этой функции. Это значение не будет отображаться для пользователя — оно применяется только на уровне системы iOS для отслеживания идентификатора функции. Нет никаких особых значений, которые требовалось бы возвращать от этого метода, нет также никаких сопутствующих рекомендаций от Apple, но мы будем работать со строками в формате «обратное доменное имя», использовать идентификатор пакета приложения и прикреплять к нему имя нашего класса. Итак, если имеется идентификатор пакета com.pixolity.ios.cookbook.myapp и класс с именем StringReverserActivity, то мы возвратим от этого метода строку com.pixolity.ios.cookbook.myapp.StringReverserActivity, вот так:


— (NSString *) activityType{

return [[NSBundle mainBundle].bundleIdentifier

stringByAppendingFormat:@".%@", NSStringFromClass([self class])];

}


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


— (NSString *) activityTitle{

return @"Reverse String";

}


5. Переходим к методу activityImage, который должен возвращать нам экземпляр UIImage — то самое изображение, что будет выводиться в контроллере вида с функцией. Обязательно предоставляйте по два варианта изображения — для сетчаточного дисплея и для обычного — как для iPad, так и для iPhone/iPod. Разрешение сетчаточного изображения для iPad должно составлять 110 110 пикселов, а для iPhone — 86 86 пикселов. Неудивительно, что, разделив эти значения на 2, получим ширину и высоту обычных изображений. В этом изображении iOS использует только альфа-канал, поэтому убедитесь, что фон вашего изображения является прозрачным и что вы иллюстрируете его черным или белым цветом. Я уже создал изображение в разделе с ресурсами моего приложения и назвал его Reverse (Обратное). Вы можете ознакомиться с ним на рис. 1.29. А вот и код:


— (UIImage *) activityImage{

return [UIImage imageNamed:@"Reverse"];

}




Рис. 1.29. В категории Ресурсы содержатся изображения для создаваемой специальной функции


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


— (BOOL) canPerformWithActivityItems:(NSArray *)activityItems{


for (id object in activityItems){

if ([object isKindOfClass: [NSString class]]){

return YES;

}

}


return NO;

}


7. Теперь реализуем метод prepareWithActivityItems: нашей функции, чей параметр относится к типу NSArray. Этот метод вызывается, если вы возвращаете YES от метода canPerformWithActivityItems:. Придется сохранить данный массив для последующего использования. Но на самом деле можно сохранять не весь массив, а только часть его объектов — те, что относятся к интересующему вас типу. Например, строки:


— (void) prepareWithActivityItems:(NSArray *)activityItems{


NSMutableArray *stringObjects = [[NSMutableArray alloc] init];

for (id object in activityItems){

if ([object isKindOfClass: [NSString class]]){

[stringObjects addObject: object];

}

}


self.activityItems = [stringObjects copy];

}


8. Последнее, но немаловажное: потребуется реализовать метод performActivity нашей функции, который вызывается, если iOS требует от нас произвести выбранные действия над списком ранее предоставленных произвольных объектов. В функции мы собираемся перебрать массив строковых объектов, извлеченных из массива с произвольными типами, обратить их все и отобразить для пользователя в окне с предупреждением:


— (NSString *) reverseOfString:(NSString *)paramString{


NSMutableString *reversed = [[NSMutableString alloc]

initWithCapacity: paramString.length];


for (NSInteger counter = paramString.length — 1;

counter >= 0;

counter—){

[reversed appendFormat:@"%c", [paramString characterAtIndex: counter]];

}


return [reversed copy];


}


— (void) performActivity{


NSMutableString *reversedStrings = [[NSMutableString alloc] init];


for (NSString *string in self.activityItems){

[reversedStrings appendString: [self reverseOfString: string]];

[reversedStrings appendString:@"\n"];

}


UIAlertView *alertView = [[UIAlertView alloc] initWithTitle:@"Reversed"

message: reversedStrings

delegate: self

cancelButtonTitle:@"OK"

otherButtonTitles: nil];


[alertView show];

}


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


#import «ViewController.h»

#import «StringReverserActivity.h»


@implementation ViewController


— (void) viewDidAppear:(BOOL)animated{

[super viewDidAppear: animated];


NSArray *itemsToShare = @[

@"Item 1",

@"Item 2",

@"Item 3",

];


UIActivityViewController *activity =

[[UIActivityViewController alloc]

initWithActivityItems: itemsToShare

applicationActivities:@[[StringReverserActivity new]]];


[self presentViewController: activity animated: YES completion: nil];

}

@end


При первом запуске приложения на экране появится картинка, примерно такая, как на рис. 1.30.




Рис. 1.30. Специальная функция для обращения строк теперь находится в списке доступных функций


Если теперь вы нажмете в этом списке элемент Reverse String (Обращенная строка), то увидите нечто похожее на рис. 1.31.




Рис. 1.31. Наша функция для обращения строк в действии

См. также

 Сделать закладку на этом месте книги

Раздел 1.10.

1.12. Внедрение навигации с помощью UINavigationController

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

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

Решение

 Сделать закладку на этом месте книги

Используйте экземпляр класса UINavigationController.

Обсуждение

 Сделать закладку на этом месте книги

Если вам доводилось работать с iPhone, iPod touch или iPad, то вы, скорее всего, уже видели в действии навигационный инструмент управления. Например, если перейти в приложение Settings (Настройки) телефона, там можно выбрать команду Wallpaper (Обои) (рис. 1.32). В таком случае вы увидите, как основной экран программы Settings (Настройки) отодвигается влево, а на его место справа выходит экран Wallpaper (Обои). В этом и заключается самая интересная черта навигации iPhone. Вы можете складывать  контроллеры видов в стек и поднимать  их из стека. Контроллер вида, в данный момент находящийся на верхней позиции стека, виден пользователю. Итак, только самый верхний контроллер вида показывается зрителю, а чтобы отобразить другой контроллер, нужно либо удалить с верхней позиции контроллер, видимый в настоящий момент, либо поместить на верхнюю позицию в стеке новый контроллер вида.




Рис. 1.32. Контроллер вида настроек, отодвигающий вид с обоями для экрана


Теперь добавим в новый проект навигационный контроллер. Но сначала нужно создать проект. Выполните шаги, описанные в разделе 1.9, чтобы создать пустое приложение с простым контроллером вида. Данный раздел — расширенная версия работы, выполненной в разделе 1.9. Начнем с файла реализации (.m) делегата нашего приложения:


#import «AppDelegate.h»

#import «FirstViewController.h»


@interface AppDelegate ()

@property (nonatomic, strong) UINavigationController *navigationController;

@end


@implementation AppDelegate


Теперь следует инициализировать навигационный контроллер, воспользовавшись его методом initWithRootViewController:, и передать корневой контроллер нашего вида как параметр этого метода. Далее мы зададим навигационный контроллер в в качестве корневого контроллера вида в нашем окне. Здесь главное — не запутаться. UINavigationController — это фактически подкласс UIViewController, а свойство rootViewController, относящееся к нашему окну, принимает любой объект типа UIViewController. Таким образом, если мы хотим сделать навигационный контроллер корневым контроллером нашего вида, мы просто должны задать его в качестве корневого контроллера:


— (BOOL) application:(UIApplication *)application

didFinishLaunchingWithOptions:(NSDictionary *)launchOptions{


FirstViewController *viewController = [[FirstViewController alloc]

initWithNibName: nil

bundle: nil];


self.navigationController = [[UINavigationController alloc]

initWithRootViewController: viewController];


self.window = [[UIWindow alloc]

initWithFrame: [[UIScreen mainScreen] bounds]];


self.window.rootViewController = self.navigationController;


self.window.backgroundColor = [UIColor whiteColor];

[self.window makeKeyAndVisible];

return YES;

}


После этого запустим приложение в эмуляторе (рис. 1.33).




Рис. 1.33. Пустой контроллер вида, отображаемый внутри навигационного контроллера

Файл реализации корневого контроллера вида создает кнопку в центре экрана (как показано на рис. 1.33). Чуть позже мы изучим этот файл реализации.

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

Переходим к файлу реализации корневого контроллера нашего вида в методе viewDidLoad. В качестве свойства контроллера вида укажем First Controller. Здесь же создадим кнопку. Когда пользователь нажмет эту кнопку, мы отобразим на экране второй контроллер вида:


#import «FirstViewController.h»

#import «SecondViewController.h»


@interface FirstViewController ()

@property (nonatomic, strong) UIButton *displaySecondViewController;

@end


@implementation FirstViewController


— (void) performDisplaySecondViewController:(id)paramSender{

SecondViewController *secondController = [[SecondViewController alloc]

initWithNibName: nil

bundle: NULL];

[self.navigationController pushViewController: secondController

animated: YES];

}


— (void)viewDidLoad{

[super viewDidLoad];

self.title = @"First Controller";


self.displaySecondViewController = [UIButton

buttonWithType: UIButtonTypeSystem];


[self.displaySecondViewController

setTitle:@"Display Second View Controller"

forState: UIControlStateNormal];


[self.displaySecondViewController sizeToFit];

self.displaySecondViewController.center = self.view.center;

[self.displaySecondViewController

addTarget: self

action:@selector(performDisplaySecondViewController:)

forControlEvents: UIControlEventTouchUpInside];


[self.view addSubview: self.displaySecondViewController];

}


@end


А теперь создадим второй контроллер вида, уже без файла XIB, и назовем его SecondViewController. Проделайте тот же процесс, что был показан в разделе 1.9. Когда создадите этот контроллер вида, назовите его Second Controller:


#import «SecondViewController.h»


@implementation SecondViewController


— (void)viewDidLoad{

[super viewDidLoad];

self.title = @"Second Controller";

}


Теперь мы собираемся всплыть  из второго контроллера вида обратно в первый контроллер вида через 5 секунд после того, как первый контроллер вида окажется на экране. Для этого используем метод performSelector: withObject: afterDelay: объекта NSObject, чтобы вызвать новый метод goBack. Второй метод будет вызван через 5 секунд после того, как контроллер первого вида успешно отобразит на экране этот первый вид. В методе goBack просто используем свойство navigationController контроллера вида (а оно встроено в UIViewController, и нам самим не приходится его писать), чтобы вернуться к экземпляру FirstViewController. Для этого воспользуемся методом popViewControllerAnimated: навигационного контроллера, который принимает в качестве параметра логическое значение. Если этот параметр имеет значение YES, то переход к предыдущему контроллеру вида будет анимироваться, если NO — не будет. В результате мы увидим примерно такую картинку, как на рис. 1.34.




Рис. 1.34. Контроллер вида размещается поверх другого контроллера вида


#import «SecondViewController.h»


@implementation SecondViewController


— (void)viewDidLoad{

[super viewDidLoad];

self.title = @"Second Controller";

}


— (void) goBack{

[self.navigationController popViewControllerAnimated: YES];

}


— (void) viewDidAppear:(BOOL)paramAnimated{

[super viewDidAppear: paramAnimated];

[self performSelector:@selector(goBack)

withObject: nil

afterDelay:5.0f];


}


@end


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

Итак, если вы теперь откроете приложение в эмуляторе и подождете 5 секунд после того, как отобразится контроллер первого вида, то увидите, что по истечении этого времени на экране автоматически появится контроллер второго вида. Подождите еще 5 секунд — и второй контроллер вида автоматически уйдет с экрана, освободив место первому.

См. также

 Сделать закладку на этом месте книги

Раздел 1.9.

1.13. Управление массивом контроллеров видов, относящихся к навигационному контроллеру

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

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

Решение

 Сделать закладку на этом месте книги

Воспользуйтесь свойством viewControllers из класса UINavigationController для доступа к массиву контроллеров видов, связанных с навигационным контроллером, а также для изменения этого массива:


— (void) goBack{

/* Получаем актуальный массив контроллеров видов. */

NSArray *currentControllers = self.navigationController.viewControllers;


/* Создаем на основе этого массива изменяемый массив. */

NSMutableArray *newControllers = [NSMutableArray

arrayWithArray: currentControllers];


/* Удаляем последний объект из массива. */

[newControllers removeLastObject];


/* Присваиваем этот массив навигационному контроллеру. */

self.navigationController.viewControllers = newControllers

}


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

Обсуждение

 Сделать закладку на этом месте книги

Экземпляр класса UINavigationController содержит массив объектов UIViewController. Получив этот массив, вы можете оперировать им как угодно. Например, можно удалить контроллер вида из произвольного места в массиве.

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


— (void) goBack{

/* Получаем актуальный массив контроллеров видов. */

NSArray *currentControllers = self.navigationController.viewControllers;


/* Создаем на основе этого массива изменяемый массив. */

NSMutableArray *newControllers = [NSMutableArray

arrayWithArray: currentControllers];


/* Удаляем последний объект из массива. */

[newControllers removeLastObject];


/* Присваиваем этот массив навигационному контроллеру. */

[self.navigationController setViewControllers: newControllers

animated: YES];

}

1.14. Демонстрация изображения на навигационной панели

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

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

Решение

 Сделать закладку на этом месте книги

Воспользуйтесь свойством titleView навигационного элемента контроллера вида:


— (void)viewDidLoad{

[super viewDidLoad];


/* Создаем вид с изображением, заменяя им вид с заголовком. */

UIImageView *imageView =

[[UIImageView alloc]

initWithFrame: CGRectMake(0.0f, 0.0f, 100.0f, 40.0f)];


imageView.contentMode = UIViewContentModeScaleAspectFit;


/* Загружаем изображение. Внимание! Оно будет кэшироваться. */

UIImage *image = [UIImage [email protected]"Logo"];


/* Задаем картинку для вида с изображением. */

убрать рекламу






ode>

[imageView setImage: image];


/* Задаем вид с заголовком. */

self.navigationItem.titleView = imageView;


}

Предыдущий код должен выполняться в контроллере вида, находящемся внутри навигационного контроллера.

Я уже загрузил изображение в группу ресурсов моего проекта и назвал это изображение Logo. Как только вы запустите это приложение с приведенным фрагментом кода, увидите результат, напоминающий рис. 1.35.



Рис. 1.35. Вид с изображением на нашей навигационной панели

Обсуждение

 Сделать закладку на этом месте книги

Навигационный элемент каждого конкретного контроллера вида может отображать два различных вида контента в той области контроллера вида, которой этот элемент присвоен:

• обычный текст;

• вид.


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

Свойство titleView навигационной панели — это самый обычный вид, но Apple рекомендует, чтобы его высота не превышала 128 точек. Поэтому считайте его изображением. Если бы вы загружали изображение, имеющее высоту 128 пикселов , то на сетчатом дисплее это соответствовало бы 64 точкам  и все было бы нормально. Но если бы вы загружали изображение высотой 300 пикселов на сетчатом дисплее, то по высоте оно заняло бы 150 точек, то есть заметно превысило бы те 128 точек, которые Apple рекомендует для видов, расположенных в строке заголовка. Для исправления этой ситуации необходимо гарантировать, что вид в строке заголовка по высоте ни в коем случае не окажется больше 128 точек, а также задать для контента режим заполнения вида целиком, а не подгонки вида под содержимое. Для этого можно установить свойство contentMode вашей строки заголовка в UIViewContentModeScaleAspectFit.

1.15. Добавление кнопок на навигационные панели с помощью UIBsrButtonItem

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

Необходимо добавить кнопки на навигационную панель.

Решение

 Сделать закладку на этом месте книги

Используйте класс UIBarButtonItem.

Обсуждение

 Сделать закладку на этом месте книги

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




Рис. 1.36. Различные кнопки, отображаемые на навигационной панели


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

Работая с данным разделом, выполните шаги, перечисленные в подразделе «Создание и запуск вашего первого приложения для iOS» раздела 1.0 данной главы и создайте пустое приложение. Потом проделайте шаги, описанные в разделе 1.12, и добавьте в делегат вашего приложения навигационный контроллер.

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

1. Создать экземпляр класса UIBarButtonItem.

2. Добавить получившуюся кнопку на навигационную панель, воспользовавшись свойством navigationItem, относящимся к контроллеру вида. Свойство navigationItem позволяет взаимодействовать с навигационной панелью. Само это свойство может принимать еще два свойства: rightBarButtonItem и leftBarButtonItem. Оба они относятся к типу UIBarButtonItem.

Теперь рассмотрим пример, в котором добавим кнопку в правую часть нашей навигационной панели. На этой кнопке будет написано Add (Добавить):


— (void) performAdd:(id)paramSender{

NSLog(@"Action method got called.");

}


— (void)viewDidLoad{

[super viewDidLoad];


self.title = @"First Controller";


self.navigationItem.rightBarButtonItem =

[[UIBarButtonItem alloc] initWithTitle:@"Add"

style: UIBarButtonItemStylePlain

target: self

action:@selector(performAdd:)];

}


Если сейчас запустить приложение, появится картинка, примерно как на рис. 1.37.




Рис. 1.37. Навигационная кнопка, добавленная на навигационную панель


Пока все просто. Но если вы регулярно пользуетесь iOS, то, вероятно, заметили, что в системных приложениях iOS применяется готовая конфигурация и кнопка Add (Добавить) там выглядит иначе. На рис. 1.38 показан пример из раздела Alarm (Будильник) приложения Clock (Часы) для iPhone. Обратите внимание на кнопку + в верхней правой части навигационной панели.




Рис. 1.38. Правильный способ создания кнопки Add (Добавить)


Оказывается, в SDK iOS можно создавать системные  кнопки. Это делается с помощью метода-инициализатора nitWithBarButtonSystemItem: target: action:, относящегося к классу UIBarButtonItem:


— (void) performAdd:(id)paramSender{

NSLog(@"Action method got called.");

}


— (void)viewDidLoad{

[super viewDidLoad];

self.title = @"First Controller";


self.navigationItem.rightBarButtonItem =

[[UIBarButtonItem alloc]

initWithBarButtonSystemItem: UIBarButtonSystemItemAdd

target: self

action:@selector(performAdd:)];

}


В результате получится именно то, чего мы добивались (рис. 1.39).

Первый параметр метода-инициализатора initWithBarButtonSystemItem: target: action:, относящегося к навигационной кнопке, может принимать в качестве параметров любые значения из перечня UIBarButtonSystemItem:




Рис. 1.39. Системная кнопка Add (Добавить)


typedef NS_ENUM(NSInteger, UIBarButtonSystemItem) {

UIBarButtonSystemItemDone,

UIBarButtonSystemItemCancel,

UIBarButtonSystemItemEdit,

UIBarButtonSystemItemSave,

UIBarButtonSystemItemAdd,

UIBarButtonSystemItemFlexibleSpace,

UIBarButtonSystemItemFixedSpace,

UIBarButtonSystemItemCompose,

UIBarButtonSystemItemReply,

UIBarButtonSystemItemAction,

UIBarButtonSystemItemOrganize,

UIBarButtonSystemItemBookmarks,

UIBarButtonSystemItemSearch,

UIBarButtonSystemItemRefresh,

UIBarButtonSystemItemStop,

UIBarButtonSystemItemCamera,

UIBarButtonSystemItemTrash,

UIBarButtonSystemItemPlay,

UIBarButtonSystemItemPause,

UIBarButtonSystemItemRewind,

UIBarButtonSystemItemFastForward,

#if __IPHONE_3_0 <= __IPHONE_OS_VERSION_MAX_ALLOWED

UIBarButtonSystemItemUndo,

UIBarButtonSystemItemRedo,

#endif

#if __IPHONE_4_0 <= __IPHONE_OS_VERSION_MAX_ALLOWED

UIBarButtonSystemItemPageCurl,

#endif

};


Один из самых интересных инициализаторов из класса UIBarButtonItem — метод initWithCustomView:. В качестве параметра этот метод может принимать любой вид, то есть мы даже можем добавить на навигационную панель в качестве навигационной кнопки UISwitch (см. раздел 1.2). Это будет выглядеть не очень красиво, но мы просто попробуем:


— (void) switchIsChanged:(UISwitch *)paramSender{

if ([paramSender isOn]){

NSLog(@"Switch is on.");

} else {

NSLog(@"Switch is off.");

}

}


— (void)viewDidLoad{

[super viewDidLoad];

self.view.backgroundColor = [UIColor whiteColor];

self.title = @"First Controller";


UISwitch *simpleSwitch = [[UISwitch alloc] init];

simpleSwitch.on = YES;

[simpleSwitch addTarget: self

action:@selector(switchIsChanged:)

forControlEvents: UIControlEventValueChanged];


self.navigationItem.rightBarButtonItem =

[[UIBarButtonItem alloc] initWithCustomView: simpleSwitch];

}


Вот что получается (рис. 1.40).




Рис. 1.40. Переключатель, добавленный на навигационную панель


На навигационной панели можно создавать очень и очень занятные кнопки. Просто взгляните, что делает Apple со стрелками, направленными вверх и вниз, расположенными в правом верхнем углу на рис. 1.36. А почему бы нам тоже так не сделать? Впечатление такое, как будто в кнопку встроен сегментированный элемент управления (см. раздел 1.8). Итак, нам нужно создать такой элемент управления с двумя сегментами, добавить его на навигационную кнопку и, наконец, поставить эту кнопку на навигационную панель. Начнем:


— (void) segmentedControlTapped:(UISegmentedControl *)paramSender{

switch (paramSender.selectedSegmentIndex){

case 0:{

NSLog(@"Up");

break;

}

case 1:{

NSLog(@"Down");

break;

}

}


}


— (void)viewDidLoad{

[super viewDidLoad];


self.title = @"First Controller";


NSArray *items = @[

@"Up",

@"Down"

];


UISegmentedControl *segmentedControl = [[UISegmentedControl alloc]

initWithItems: items];


segmentedControl.momentary = YES;


[segmentedControl addTarget: self

action:@selector(segmentedControlTapped:)

forControlEvents: UIControlEventValueChanged];


self.navigationItem.rightBarButtonItem =

[[UIBarButtonItem alloc] initWithCustomView: segmentedControl];

}


На рис. 1.41 показано, что должно получиться в итоге.




Рис. 1.41. Сегментированный элемент управления, встроенный в навигационную кнопку


Элемент navigationItem любого контроллера вида имеет еще два замечательных метода:

• setRightBarButtonItem: animated: — задает правую кнопку навигационной панели;

• setLeftBarButtonItem: animated: — определяет левую кнопку навигационной панели.

Оба метода позволяют указывать, хотите ли вы анимировать кнопку. Задайте значение YES для параметра animated, если анимация нужна:


UIBarButtonItem *rightBarButton =

[[UIBarButtonItem alloc] initWithCustomView: segmentedControl];


[self.navigationItem setRightBarButtonItem: rightBarButtonanimated: YES];

См. также

 Сделать закладку на этом месте книги

Подраздел «Создание и запуск вашего первого приложения для iOS» раздела 1.0 данной главы. Разделы 1.2, 1.8, 1.12.

1.16. Представление контроллеров, управляющих несколькими видами, с помощью UITabBarController

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

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

Решение

 Сделать закладку на этом месте книги

Используйте класс UITabBarController.

Обсуждение

 Сделать закладку на этом месте книги

Если вы пользуетесь iPhone как будильником, то, разумеется, замечали на экране панель вкладок. Взгляните на рис. 1.38. В нижней части экрана расположены значки, которые называются World Clock (Мировое время), Alarm (Будильник), Stopwatch (Секундомер) и Timer (Таймер). Вся черная полоса в нижней части экрана — это панель вкладок, а вышеупомянутые ярлыки — ее элементы.

Панель вкладок — это контейнерный контроллер. Это значит, что мы создаем экземпляры UITabBarController и добавляем их в окно нашего приложения. Для каждого элемента панели вкладок мы добавляем на эту панель навигационный контроллер или контроллер вида. Эти элементы будут отображаться как вкладки на панели. Контроллер панели вкладок содержит панель вкладок типа UITabBar. Мы не создаем этот объект вручную — мы создаем контроллер панели вкладок, а уже он создает для нас такой объект. Проще говоря, считайте, что мы инстанцируем контроллер панели вкладок, а потом задаем контроллеры видов для этой панели. Данные контроллеры видов будут относиться к типу UIViewController или UINavigationController, если мы собираемся создать по контроллеру для каждого элемента панели вкладки (они же — контроллеры видов, задаваемые для контроллера панели вкладок). Навигационные контроллеры относятся к типу UINavigationController и являются подклассами от UIViewController. Следовательно, навигационный контроллер — это контроллер вида, но контроллеры видов, относящиеся к типу UIViewController, не являются навигационными контроллерами.

Итак, предположим, что у нас есть два контроллера видов. Классы этих контроллеров называются FirstViewController и SecondViewController:


— (BOOL) application:(UIApplication *)application

didFinishLaunchingWithOptions:(NSDictionary *)launchOptions{


self.window = [[UIWindow alloc] initWithFrame:

[[UIScreen mainScreen] bounds]];


[self.window makeKeyAndVisible];


FirstViewController *firstViewController = [[FirstViewController alloc]

initWithNibName: nil

bundle: NULL];


SecondViewController *secondViewController = [[SecondViewController alloc]

initWithNibName: nil

bundle: NULL];


UITabBarController *tabBarController = [[UITabBarController alloc] init];

[tabBarController setViewControllers:@[firstViewController,

secondViewController

]];


self.window.rootViewController = tabBarController;


return YES;

}


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

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

Первый контроллер вида мы назовем First:

#import «FirstViewController.h»


@implementation FirstViewController


— (id)initWithNibName:(NSString *)nibNameOrNil

bundle:(NSBundle *)nibBundleOrNil{


self = [super initWithNibName: nibNameOrNil

bundle: nibBundleOrNil];

if (self!= nil) {

self.title = @"First";

}

return self;


}


— (void)viewDidLoad{

[super viewDidLoad];

self.view.backgroundColor = [UIColor whiteColor];

}


А второй контроллер вида будет называться Second:


#import «SecondViewController.h»


@implementation SecondViewController


— (id)initWithNibName:(NSString *)nibNameOrNil

bundle:(NSBundle *)nibBundleOrNil{


self = [super initWithNibName: nibNameOrNil

bundle: nibBundleOrNil];

if (self!= nil) {

self.title = @"Second";

}

return self;


}


— (void)viewDidLoad{

[super viewDidLoad];

self.view.backgroundColor = [UIColor whiteColor];


}


Теперь запустим приложение и посмотрим, что получилось (рис. 1.42).




Рис. 1.42. Очень простая панель вкладок, на которой находятся два контроллера вида


Как видите, у контроллеров видов нет навигационной панели. Что делать? Все просто. Как вы помните, UINavigationController — это подкласс UIViewController. Итак, мы можем добавлять экземпляры навигационных контроллеров на панель вкладок, а внутрь каждого навигационного контроллера загрузить контроллер вида. Чего же мы ждем?


— (BOOL) application:(UIApplication *)application

didFinishLaunchingWithOptions:(NSDictionary *)launchOptions{


// Точка переопределения для специальной настройки,

// выполняемой после запуска приложения.

self.window = [[UIWindow alloc] initWithFrame:

[[UIScreen mainScreen] bounds]];


[self.window makeKeyAndVisible];


FirstViewController *firstViewController = [[FirstViewController alloc]

initWithNibName: nil

bundle: NULL];


UINavigationController *firstNavigationController =

[[UINavigationController alloc]

initWithRootViewController: firstViewController];


SecondViewController *secondViewController = [[SecondViewController alloc]

initWithNibName: nil

bundle: NULL];


UINavigationController *secondNavigationController =

[[UINavigationController alloc]

initWithRootViewController: secondViewController];


UITabBarController *tabBarController = [[UITabBarController alloc] init];


[tabBarController setViewControllers:

@[firstNavigationController, secondNavigationController]];


self.window.rootViewController = tabBarController;


return YES;


}


Что получается? Именно то, что мы хотели (рис. 1.43).




Рис. 1.43. Панель вкладок, на которой контроллеры видов находятся внутри навигационных контроллеров


Как было показано на рис. 1.38, каждый элемент панели вкладок может содержать текст или изображение. Мы узнали, что, пользуясь свойством title контроллера вида, можно задавать такой текст. А что насчет изображения? Оказывается, у каждого контроллера вида есть и свойство tabItem. Это свойство соответствует той вкладке, которая находится в актуальном контроллере вида. Вы можете пользоваться этим свойством, чтобы задавать изображение для вкладки. Изображение для вкладки задается через ее свойство image. Я уже сделал два изображения — прямоугольник и кружок, а теперь выведу их как изображения для вкладок, соответствующих каждому из моих контроллеров видов. Вот код для первого контроллера вида:


— (id)initWithNibName:(NSString *)nibNameOrNil

bundle:(NSBundle *)nibBundleOrNil{


self = [super initWithNibName: nibNameOrNil

bundle: nibBundleOrNil];

if (self!= nil) {

self.title = @"First";

self.tabBarItem.image = [UIImage imageNamed:@"FirstTab"];

}

return self;


}

— (void)viewDidLoad{

[super viewDidLoad];

self.view.backgroundColor = [UIColor whiteColor];

}

А вот код для второго контроллера:

— (id)initWithNibName:(NSString *)nibNameOrNil

bundle:(NSBundle *)nibBundleOrNil{


self = [super initWithNibName: nibNameOrNil

bundle: nibBundleOrNil];

if (self!= nil) {

self.title = @"Second";

self.tabBarItem.image = [UIImage imageNamed:@"SecondTab"];

}

return self;


}


— (void)viewDidLoad{

[super viewDidLoad];

self.view.backgroundColor = [UIColor whiteColor];

}


Запустив приложение в эмуляторе, увидим такую картинку, как на рис. 1.44.




Рис. 1.44. Элементы панели вкладок с изображениями

1.17. Отображение статического текста с помощью UILabel

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

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

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

Решение

 Сделать закладку на этом месте книги

Используйте класс UILabel.

Обсуждение

 Сделать закладку на этом месте книги

Подписи (Labels) встречаются в iOS повсюду. Они используются практически в любых приложениях, за исключением игр, для отображения содержимого которых обычно применяется OpenGL ES, а не основные фреймворки отрисовки, входящие в состав iOS. На рис. 1.45 показаны несколько подписей, имеющихся в приложении Settings (Настройки) для iPhone.




Рис. 1.45. Подписи в качестве названий настроек


Как видите, подписи содержат текстовые названия разделов приложения Settings (Настройки), в частности iCloud, Twitter, FaceTime, Safari и т. д.

Чтобы создать подпись, необходимо инстанцировать объект типа UILabel. Установка или получение текста для подписи осуществляется с помощью свойства text. Итак, определим подпись в файле реализации контроллера нашего вида:


#import «ViewController.h»


@interface ViewController ()

@property (nonatomic, strong) UILabel *myLabel;

@end


@implementation ViewController


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


— (void)viewDidLoad{

[super viewDidLoad];


CGRect labelFrame = CGRectMake(0.0f,

0.0f,

100.0f,

23.0f);

self.myLabel = [[UILabel alloc] initWithFrame: labelFrame];

self.myLabel.text = @"iOS 7 Programming Cookbook";

self.myLabel.font = [UIFont boldSystemFontOfSize:14.0f];

self.myLabel.center = self.view.center;

[self.view addSubview: self.myLabel];


}


Теперь запустим приложение и посмотрим, что происходит (рис. 1.46).




Рис. 1.46. Слишком длинная подпись, которая не умещается на экране


Как видите, текст (содержимое) подписи обрезается, а за ним идут точки, поскольку ширины поля для подписи недостаточно для того, чтобы уместился весь текст. Для решения этой проблемы можно было бы увеличить ширину, но что делать с высотой? А что, если мы хотим, чтобы текст переходил на следующую строку. Хорошо, увеличим высоту с 23.0f до 50.0f:


CGRect labelFrame = CGRectMake(0.0f,

0.0f,

100.0f,

50.0f);


Если сейчас запустить приложение, получится тот же самый  результат, чт


убрать рекламу






о и на рис. 1.46. Вы могли бы спросить: «Я увеличил высоту, так почему же текст не переходит на следующую строку»? Оказывается, у класса UILabel есть свойство numberOfLines, в котором нужно указать, на сколько строк должен разбиваться текст подписи, если в ширину для нее будет недостаточно места. Если задать здесь значение 3, то вы сообщите программе, что текст подписи должен занимать не более трех строк, если этот текст не умещается в одной строке:


— (void)viewDidLoad{

[super viewDidLoad];


CGRect labelFrame = CGRectMake(0.0f,

0.0f,

100.0f,

70.0f);

self.myLabel = [[UILabel alloc] initWithFrame: labelFrame];

self.myLabel.numberOfLines = 3;

self.myLabel.lineBreakMode = NSLineBreakByWordWrapping;

self.myLabel.text = @"iOS 7 Programming Cookbook";

self.myLabel.font = [UIFont boldSystemFontOfSize:14.0f];

self.myLabel.center = self.view.center;

[self.view addSubview: self.myLabel];


}


Теперь при запуске программы вы получите желаемый результат (рис. 1.47).




Рис. 1.47. Подпись, текст которой занимает три строки

Бывает, что вы не знаете, сколько строк понадобится, чтобы отобразить текст подписи. В таких случаях для свойства numberOfLines подписи задается значение 0.

Если вы хотите, чтобы рамка, в которой находится подпись, имела постоянные размеры, а размер шрифта корректировался так, чтобы он входил в отведенные границы, необходимо задать для свойства adjustsFontSizeToFitWidth подписи значение YES. Например, если высота подписи равна 23.0f, как показано на рис. 1.46, то можно уместить шрифт подписи в этих границах. Вот как это делается:


— (void)viewDidLoad{

[super viewDidLoad];


self.view.backgroundColor = [UIColor whiteColor];

CGRect labelFrame = CGRectMake(0.0f,

0.0f,

100.0f,

23.0f);

self.myLabel = [[UILabel alloc] initWithFrame: labelFrame];

self.myLabel.adjustsFontSizeToFitWidth = YES;

self.myLabel.text = @"iOS 7 Programming Cookbook";

self.myLabel.font = [UIFont boldSystemFontOfSize:14.0f];

self.myLabel.center = self.view.center;

[self.view addSubview: self.myLabel];


}

1.18. Оформление UILabel

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

Требуется возможность оформлять внешний вид подписей — от настройки теней до настройки выравнивания.

Решение

 Сделать закладку на этом месте книги

Пользуйтесь перечисленными далее свойствами класса UILabel в зависимости от стоящей перед вами задачи.

• shadowColor — свойство типа UIColor. Как понятно из названия, оно указывает цвет отбрасываемой тени для подписи. Устанавливая это свойство, вы должны установить и свойство shadowOffset.

• shadowOffset — это свойство типа CGSize. Оно указывает размер отступа между тенью и текстом. Например, если вы зададите для этого свойства значение (1, 0), то тень будет находиться на одну точку правее текста. Если задать значение (1, 2), то тень окажется на одну правее и на одну точку ниже текста. Если же установить значение (-2, -10), то тень будет отображаться на две точки левее и на десять точек выше текста.

• numberOfLines — свойство представляет собой целое число, указывающее, сколько строк текста может включать в себя подпись. По умолчанию значение этого свойства равно 1. Таким образом, любая создаваемая вами подпись по умолчанию может обработать одну строку текста. Если вы хотите сделать подпись из двух строк, задайте для этого свойства значение 2. Если требуется, чтобы в вашем текстовом поле могло отображаться неограниченное количество текстовых строк, либо вы просто не знаете, сколько строк текста в итоге понадобится отобразить, это свойство должно иметь значение 0. (Лично я нахожу это очень странным. Вместо NSIntegerMax или чего-то подобного в Apple решили обозначать неограниченное количество нулем!)

• lineBreakMode — это свойство относится к типу NSLineBreakMode и указывает способ перехода текста на новую строку внутри текстового поля. Например, если присвоить этому свойству значение NSLineBreakByWordWrapping, то слова разрываться не будут, но если по ширине будет мало места, то текст станет переходить на новую строку. Напротив, если задать для этого свойства значение NSLineBreakByCharWrapping, то при переходе на новую строку может происходить разрыв слова. Вероятно, NSLineBreakByCharWrapping стоит использовать лишь при жестком дефиците места и необходимости уместить на экране как можно больше информации. Я не рекомендую пользоваться этим свойством, если, конечно, вы стремитесь сохранить пользовательский интерфейс аккуратным и четким.

• textAlignment — свойство относится к типу NSTextAlignment и задает выравнивание текста в подписи по горизонтали. Например, для этого свойства можно задать значение NSTextAlignmentCenter, чтобы выровнять текст подписи по центру по горизонтали.

• textColor — это свойство типа UIColor определяет цвет текста подписи.

• font — свойство типа UIFont задает шрифт, которым отображается текст подписи.

• adjustsFontSizeToFitWidth — это свойство типа BOOL. Если оно имеет значение YES, то размер шрифта будет изменяться таким образом, чтобы текст умещался в поле для подписи. Например, когда поле маленькое, а вы хотите записать на нем слишком большой текст. В этом случае среда времени исполнения автоматически уменьшит размер шрифта подписи, чтобы текст гарантированно поместился. Напротив, если для этого свойства задано значение NO, то программа будет действовать в соответствии с актуальной функцией заверстывания строк/слов/символов и текст отобразится не полностью — всего несколько слов.

Обсуждение

 Сделать закладку на этом месте книги

Подписи — одни из простейших компонентов пользовательского интерфейса, которые мы можем использовать в наших приложениях. Но при всей простоте их потенциал очень велик. Поэтому оформление подписей — очень важный фактор, значительно сказывающийся на удобстве использования интерфейса. Поэтому Apple предоставляет нам массу способов оформления экземпляров UILabel. Рассмотрим пример. Мы создаем простое приложение с единственным видом, в котором есть всего один контроллер вида. В центре экрана поместим простую надпись, выполненную огромным шрифтом, — она будет гласить: iOS SDK. Фон вида мы сделаем белым, а цвет тени, отбрасываемой подписью, — светло-серым. Мы убедимся, что тень находится ниже и правее подписи. На рис. 1.48 показан эффект, которого мы стремимся достичь.




Рис. 1.48. Оформление и отображение подписи на экране


А вот и код для этого:


#import «ViewController.h»


@interface ViewController ()

@property (nonatomic, strong) UILabel *label;

@end


@implementation ViewController


— (void)viewDidLoad{

[super viewDidLoad];


self.label = [[UILabel alloc] init];

self.label.backgroundColor = [UIColor clearColor];

self.label.text = @"iOS SDK";

self.label.font = [UIFont boldSystemFontOfSize:70.0f];

self.label.textColor = [UIColor blackColor];

self.label.shadowColor = [UIColor lightGrayColor];

self.label.shadowOffset = CGSizeMake(2.0f, 2.0f);

[self.label sizeToFit];

self.label.center = self.view.center;

[self.view addSubview: self.label];


}


@end

См. также

 Сделать закладку на этом месте книги

Разделы 1.17, 1.26.

1.19. Прием пользовательского текстового ввода с помощью UITextField

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

Необходимо принимать через пользовательский интерфейс программы текст, вводимый пользователем.

Решение

 Сделать закладку на этом месте книги

Воспользуйтесь классом UITextField.

Обсуждение

 Сделать закладку на этом месте книги

Текстовое поле очень похоже на подпись тем, что в нем также можно отображать текстовую информацию. Но текстовое поле, в отличие от подписи, может принимать текстовый ввод и во время исполнения. На рис. 1.49 показаны два текстовых поля в разделе Twitter приложения Settings (Настройки) в iPhone.




Рис. 1.49. Текстовые поля, в которые можно вводить текст

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

Чтобы определить наше текстовое поле, начнем работу с файла реализации контроллера вида:


#import «ViewController.h»


@interface ViewController ()

@property (nonatomic, strong) UITextField *myTextField;

@end


@implementation ViewController



А потом создадим это текстовое поле:


— (void)viewDidLoad{

[super viewDidLoad];


CGRect textFieldFrame = CGRectMake(0.0f,

0.0f,

200.0f,

31.0f);


self.myTextField = [[UITextField alloc]

initWithFrame: textFieldFrame];


self.myTextField.borderStyle = UITextBorderStyleRoundedRect;


self.myTextField.contentVerticalAlignment =

UIControlContentVerticalAlignmentCenter;


self.myTextField.textAlignment = NSTextAlignmentCenter;


self.myTextField.text = @"Sir Richard Branson";

self.myTextField.center = self.view.center;

[self.view addSubview: self.myTextField];


}


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

При создании этого текстового поля мы использовали различные свойства класса UITextField:

• borderStyle — свойство имеет тип UITextBorderStyle и указывает, как должны отображаться границы текстового поля;

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

• textAlignment — это свойство имеет тип UITextAlignment и указывает выравнивание текста в текстовом поле по горизонтали. В данном примере текст выровнен в текстовом поле по центру и по горизонтали;

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




Рис. 1.50. Простое текстовое поле, текст в котором выровнен по центру


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


@interface ViewController () <UITextFieldDelegate>

@property (nonatomic, strong) UITextField *myTextField;

@end


@implementation ViewController


Нажав и удерживая клавишу Command, щелкните на протоколе UITextFieldDelegate в Xcode. Вы увидите методы, которыми позволяет управлять этот протокол. Рассмотрим эти методы, а также укажем, когда они вызываются.

• textFieldShouldBeginEditing: — возвращает логическое значение, сообщающее текстовому полю (текстовое поле является параметром этого метода), может ли пользователь редактировать содержащуюся в нем информацию (то есть разрешено это или нет). Возвратите здесь значение NO, если не хотите, чтобы пользователь изменял текст в этом поле. Метод запускается, как только пользователь касается этого поля, намереваясь его редактировать (при условии, что в поле допускается редактирование).

• textFieldDidBeginEditing: — вызывается, когда пользователь начинает редактировать текстовое поле. Этот метод запускается уже после того, как пользователь коснулся текстового поля, а метод делегата текстового поля textFieldShouldBeginEditing: возвратил значение YES, сообщив таким образом, что пользователь может редактировать содержимое этого поля.

• textFieldShouldEndEditing: — возвращает логическое значение, сообщающее текстовому полю, закончен текущий акт редактирования или нет. Этот метод запускается перед тем, как пользователь собирается покинуть текстовое поле, или после того, как статус активного объекта (First Responder) переходит к другому полю для ввода текста. Если возвратить NO от этого метода, то пользователь не сможет перейти в другое текстовое поле и начать вводить текст в него. Виртуальная клавиатура останется на экране.

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

• textField: shouldChangeCharactersInRange: replacementString: — вызывается всякий раз, когда текст в текстовом поле изменяется. Возвращаемое значение этого метода — логическое. Если возвращается YES, это означает, что текст можно изменить. Если возвращается NO, то любые изменения текста в этом поле приняты не будут и даже не произойдут.

• textFieldShouldClear: — в каждом текстовом поле есть кнопка очистки  — обычно это круглая кнопка с крестиком. Когда пользователь нажимает эту кнопку, все содержимое текстового поля автоматически стирается. Если вы предоставляете кнопку для очистки текста, но возвращаете от этого метода значение NO, то пользователь может подумать, что ваша программа не работает. Поэтому в данном случае вы должны отдавать себе отчет в том, что делаете. Если пользователь видит кнопку «Стереть», нажимает ее, а текст в поле не исчезает, это очень плохо характеризует программу.

• textFieldShouldReturn: — вызывается после того, как пользователь нажимает клавишу Return/Enter, пытаясь убрать клавиатуру с экрана. Текстовое поле должно быть присвоено этому методу в качестве активного элемента.

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


@interface ViewController () <UITextFieldDelegate>

@property (nonatomic, strong) UITextField *myTextField;

@property (nonatomic, strong) UILabel *labelCounter;

@end


@implementation ViewController


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


— (void) calculateAndDisplayTextFieldLengthWithText:(NSString *)paramText{


NSString *characterOrCharacters = @"Characters";

if ([paramText length] == 1){

characterOrCharacters = @"Character";

}


self.labelCounter.text = [NSString stringWithFormat:@"%lu %@",

(unsigned long)[paramText length],

characterOrCharacters];

}


— (BOOL) textField:(UITextField *)textField

shouldChangeCharactersInRange:(NSRange)range

replacementString:(NSString *)string{


if ([textField isEqual: self.myTextField]){

NSString *wholeText =

[textField.text stringByReplacingCharactersInRange: range

withString: string];

[self calculateAndDisplayTextFieldLengthWithText: wholeText];

}


return YES;


}


— (BOOL)textFieldShouldReturn:(UITextField *)textField{

[textField resignFirstResponder];

return YES;

}


— (void)viewDidLoad{

[super viewDidLoad];


CGRect textFieldFrame = CGRectMake(38.0f,

30.0f,

220.0f,

31.0f);


self.myTextField = [[UITextField alloc]

initWithFrame: textFieldFrame];


self.myTextField.delegate = self;


self.myTextField.borderStyle = UITextBorderStyleRoundedRect;


self.myTextField.contentVerticalAlignment =

UIControlContentVerticalAlignmentCenter;


self.myTextField.textAlignment = NSTextAlignmentCenter;


self.myTextField.text = @"Sir Richard Branson";


[self.view addSubview: self.myTextField];


CGRect labelCounterFrame = self.myTextField.frame;

labelCounterFrame.origin.y += textFieldFrame.size.height + 10;

self.labelCounter = [[UILabel alloc] initWithFrame: labelCounterFrame];

[self.view addSubview: self.labelCounter];


[self calculateAndDisplayTextFieldLengthWithText: self.myTextField.text];


}


Мы делаем важное вычисление в методе textField: shouldChangeCharactersInRange: replacementString:. Здесь мы объявляем и используем переменную wholeText. Когда вызывается этот метод, параметр replacementString указывает строку, которую пользователь ввел в текстовое поле. Вы, возможно, полагаете, что пользователь может вводить по одному символу в каждый момент времени, поэтому почему бы не присвоить данному полю значение char? Но не забывайте, что пользователь может вставить в текстовое поле целый фрагмент текста, по этой причине данный параметр должен быть строковым. Параметр shouldChangeCharactersInRange указывает место в текстовом поле, с которого пользователь начинает вводить текст. Итак, с помощью двух этих параметров мы создаем строку, которая сначала считывает весь текст из текстового поля, а потом использует заданный диапазон, чтобы разместить новый текст рядом со старым. Итак, получается, что вводимый нами текст будет появляться в поле после  того, как метод textField: shouldChangeCharactersInRange: replacementString: возвратит YES. На рис. 1.51 показано, как приложение будет выглядеть в эмуляторе.




Рис. 1.51. Реагирование на сообщения-делегаты текстового поля


В текстовом поле может отображаться не только текст, но и подстановочные (джокерные)  символы. Подстановочный текст отображается до того , как пользователь введет в это поле какой-нибудь собственный текст, пока свойство text текстового поля является пустым. В качестве подстановочного текста вы можете использовать любую строку, какую хотите, но лучше этим текстом подсказать пользователю, для ввода какой именно информации предназначено данное поле. Многие программисты указывают в подстановочном тексте, значения какого типа может принимать данное поле. Например, на рис. 1.49 в двух текстовых полях (для ввода имени пользователя и пароля) стоит подстановочный текст Required (Обязательно). Можно использовать свойство placeholder текстового поля для установки или получения актуального подстановочного текста:


CGRect textFieldFrame = CGRectMake(38.0f,

30.0f,

220.0f,

31.0f);

self.myTextField = [[UITextField alloc]

initWithFrame: textFieldFrame];


self.myTextField.delegate = self;


self.myTextField.borderStyle = UITextBorderStyleRoundedRect;


self.myTextField.contentVerticalAlignment =

UIControlContentVerticalAlignmentCenter;


self.myTextField.textAlignment = UITextAlignmentCenter;


self.myTextField.placeholder = @"Enter text here…";

[self.view addSubview: self.myTextField];


Результат показан на рис. 1.52.

У текстовых полей есть два очень приятных свойства, которые называются leftView и rightView. Они относятся к типу UIView и доступны как для чтения, так и для записи. Они проявляются, как понятно из названий, в левой (left) и правой (right) частях текстового поля, когда вы присваиваете им определенный вид. Первое свойство (левый вид) может использоваться, например, при показе курсов валют. В этом случае слева отображается курс валюты страны, в которой проживает пользователь. Поле с этими данными относится к типу UILabel. Вот как можно решить такую задачу:




Рис. 1.52. Подстановочный текст отображается, когда пользователь еще ничего не ввел в поле


UILabel *currencyLabel = [[UILabel alloc] initWithFrame: CGRectZero];

currencyLabel.text = [[[NSNumberFormatter alloc] init] currencySymbol];

currencyLabel.font = self.myTextField.font;

[currencyLabel sizeToFit];

self.myTextField.leftView = currencyLabel;

self.myTextField.leftViewMode = UITextFieldViewModeAlways;


Если просто присвоить вид свойству leftView или rightView текстового поля, то эти виды не появятся автоматически. То, когда они появятся на экране, зависит от режима, управляющего их внешним видом. Данный режим контролируется свойствами leftViewMode и rightViewMode соответственно. Эти режимы относятся к типу UITextFieldViewMode:


typedef NS_ENUM(NSInteger, UITextFieldViewMode) {

UITextFieldViewModeNever,

UITextFieldViewModeWhileEditing,

UITextFieldViewModeUnlessEditing,

UITextFieldViewModeAlways

}


Итак, например, если задать UITextFieldViewModeWhileEditing в качестве режима левого вида и присвоить ему значение, то этот вид будет отображаться только в то время, как пользователь редактирует текстовое поле. И наоборот, если задать здесь значение UITextFieldViewModeUnlessEditing, левый вид будет отображаться, только пока пользователь не  редактирует текстовое поле. Как только редактирование начнется, левый вид исчезнет. Теперь запустим наш код в эмуляторе (рис. 1.53).




Рис. 1.53. Текстовое поле с левым видом

См. также

 Сделать закладку на этом месте книги

Раздел 1.17.

1.20. Отображение длинных текстовых строк с помощью UITextView

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

Требуется отображать в пользовательском интерфейсе несколько строк текста с возможностью прокрутки.

Решение

 Сделать закладку на этом месте книги

Воспользуйтесь классом UITextView.

Обсуждение

 Сделать закладку на этом месте книги

Класс UITextView позволяет отображать несколько строк текста и создавать прокручиваемое содержимое. Это означает, что если содержимое не умещается в границах текстового вида, то внутренние компоненты этого текстового вида позволяют пользователю прокручивать текст вверх и вниз и просматривать различные его части. В качестве примера текстового вида, входящего в приложение iOS, рассмотрим программу Notes (Блокнот) в iPhone (рис. 1.54).




Рис. 1.54. Программа Notes (Блокнот) в iPhone, здесь текст отображается в текстовом виде


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


#import «ViewController.h»


@interface ViewController ()

@property (nonatomic, strong) UITextView *myTextView;

@end


implementation ViewController


Далее необходимо создать сам текстовый вид. Мы сделаем текстовый вид таким же по размеру, как и вид контроллера вида:


— (void)viewDidLoad{

[super viewDidLoad];


self.myTextView = [[UITextView alloc] initWithFrame: self.view.bounds];

self.myTextView.text = @"Some text here…";

self.myTextView.contentInset = UIEdgeInsetsMake(10.0f, 0.0f, 0.0f, 0.0f);

self.myTextView.font = [UIFont systemFontOfSize:16.0f];

[self.view addSubview: self


убрать рекламу






.myTextView];


}


Запустим приложение в эмуляторе iOS и посмотрим, как оно выглядит (рис. 1.55).




Рис. 1.55. Текстовый вид, занимающий все экранное пространство


Если коснуться текстового поля пальцем, то можно увидеть, как снизу всплывает виртуальная клавиатура. Она довольно крупная и закрывает текстовый вид почти наполовину. То есть если пользователь начнет вводить текст и дойдет примерно до середины окна по вертикали, весь остальной текст, который будет вводиться, окажется заслоненным клавиатурой  (рис. 1.56).

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

• UIKeyboardWillShowNotification — система выдает такое уведомление всякий раз, когда клавиатура выводится на экран для работы с каким-либо компонентом: текстовым полем, текстовым видом и т. д.;

• UIKeyboardDidShowNotification — система выдает такое уведомление, когда клавиатура отобразится целиком;

• UIKeyboardWillHideNotification — система выдает такое уведомление перед тем, как клавиатура скроется из вида;




Рис. 1.56. Клавиатура, наполовину занимающая текстовый вид


• UIKeyboardDidHideNotification — система выдает такое уведомление после того, как клавиатура полностью скроется из вида.

Уведомления клавиатуры содержат словарь, доступный с помощью свойства userInfo. Он указывает границы клавиатуры на экране и относится к типу NSDictionary. В словаре среди прочего имеется ключ UIKeyboardFrameEndUserInfoKey, содержащий объект типа NSValue. В свою очередь, этот объект содержит прямоугольник, ограничивающий размеры клавиатуры, когда она полностью отображена на экране. Эта прямоугольная область обозначается как CGRect.

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


— (void) handleKeyboardDidShow:(NSNotification *)paramNotification{


/* Получаем контур клавиатуры. */

NSValue *keyboardRectAsObject =

[[paramNotification userInfo]

objectForKey: UIKeyboardFrameEndUserInfoKey];


/* Помещаем эту информацию в CGRect. */

CGRect keyboardRect;


[keyboardRectAsObject getValue:&keyboardRect];


/* Задаем нижнюю границу нашего текстового вида так, чтобы он доходил ровно до верхней границы клавиатуры. */

self.myTextView.contentInset =

UIEdgeInsetsMake(0.0f,

0.0f,

keyboardRect.size.height,

0.0f);

}


— (void) handleKeyboardWillHide:(NSNotification *)paramNotification{

/* Делаем текстовый вид таким же по размеру, как и вид, содержащий его. */

self.myTextView.contentInset = UIEdgeInsetsZero;

}


— (void) viewWillAppear:(BOOL)paramAnimated{

[super viewWillAppear: paramAnimated];


[[NSNotificationCenter defaultCenter]

addObserver: self

selector:@selector(handleKeyboardDidShow:)

name: UIKeyboardDidShowNotification

object: nil];


[[NSNotificationCenter defaultCenter]

addObserver: self

selector:@selector(handleKeyboardWillHide:)

name: UIKeyboardWillHideNotification

object: nil];


self.myTextView = [[UITextView alloc] initWithFrame: self.view.bounds];

self.myTextView.text = @"Some text here…";

self.myTextView.font = [UIFont systemFontOfSize:16.0f];

[self.view addSubview: self.myTextView];


}


— (void) viewWillDisappear:(BOOL)paramAnimated{

[super viewWillDisappear: paramAnimated];


[[NSNotificationCenter defaultCenter] removeObserver: self];

}


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

Если вы намереваетесь изменять структуру пользовательского интерфейса, когда клавиатура выводится на экран и когда она с него убирается, то вам никак не обойтись без слушания клавиатурных уведомлений. Сообщения делегата UITextField запускаются всякий раз, когда начинается редактирование текстового поля, независимо от того, есть ли в этот момент на экране клавиатура. Не забывайте, что пользователь может подключить к устройству iOS беспроводную клавиатуру (с помощью Bluetooth). С этой клавиатуры он сможет редактировать содержимое текстовых полей, а также любых других информационных объектов вашего приложения. При подключении клавиатуры по Bluetooth виртуальная клавиатура на экране отображаться не будет. И если в вашем приложении пользовательский интерфейс станет обязательно перестраиваться, как только начинается ввод данных с клавиатуры, то при подключении беспроводной клавиатуры по Bluetooth такая перестройка окажется ненужной.

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

1.21. Добавление кнопок в пользовательский интерфейс с помощью UIButton

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

Необходимо отобразить в пользовательском интерфейсе кнопку и обрабатывать события касания, связанные с этой кнопкой.

Решение

 Сделать закладку на этом месте книги

Воспользуйтесь классом UIButton.

Обсуждение

 Сделать закладку на этом месте книги

Кнопки позволяют пользователям инициировать в приложениях те или иные действия. Например, пакет настроек iCloud в приложении Settings (Настройки) содержит кнопку Delete Account (Удалить учетную запись) (рис. 1.57). Если нажать эту кнопку, в приложении iCloud произойдет действие. Оно зависит от конкретного приложения. Не все приложения действуют одинаково, если пользователь нажимает в них кнопку Delete (Удалить). Как мы вскоре увидим, на кнопках могут присутствовать как изображения, так и текст.




Рис. 1.57. Кнопка Delete Account (Удалить учетную запись)


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


#import «ViewController.h»


@interface ViewController ()

@property (nonatomic, strong) UIButton *myButton;

@end


@implementation ViewController

По умолчанию высота UIButton в iOS 7 указывается как 44.0f пункта.

Теперь переходим к реализации кнопки (рис. 1.58):


— (void) buttonIsPressed:(UIButton *)paramSender{

NSLog(@"Button is pressed.");

}


— (void) buttonIsTapped:(UIButton *)paramSender{

NSLog(@"Button is tapped.");

}


— (void)viewDidLoad{

[super viewDidLoad];


self.myButton = [UIButton buttonWithType: UIButtonTypeRoundedRect];


self.myButton.frame = CGRectMake(110.0f,

200.0f,

100.0f,

44.0f);


[self.myButton setTitle:@"Press Me"

forState: UIControlStateNormal];


[self.myButton setTitle:@"I'm Pressed"

forState: UIControlStateHighlighted];


[self.myButton addTarget: self

action:@selector(buttonIsPressed:)

forControlEvents: UIControlEventTouchDown];


[self.myButton addTarget: self

action:@selector(buttonIsTapped:)

forControlEvents: UIControlEventTouchUpInside];


[self.view addSubview: self.myButton];


}




Рис. 1.58. В центре экрана находится системная кнопка


В коде из данного примера мы применяем метод setTitle: forState: кнопки, задавая для нее два разных заголовка. Заголовок — это надпись на кнопке. В разное время кнопка может находиться в различных состояниях: обычном и утопленном (нажатом). В каждом из состояний надпись на ней может меняться. Например, в данном случае, когда пользователь впервые видит кнопку, на ней будет написано Press Me (Нажми меня). А когда он нажмет ее, надпись на кнопке изменится на I'm Pressed (Я нажата).

Аналогичная ситуация складывается и с действиями, инициируемыми кнопкой. Мы используем метод addTarget: action: forControlEvents:, чтобы указать для нашей кнопки два действия:

• действие, инициируемое, когда пользователь нажимает кнопку;

• другое действие, происходящее, когда пользователь уже нажал кнопку и убирает палец с экрана. Такое событие называется окончанием нажатия кнопки  (touch-inside-up).

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


typedef NS_ENUM(NSInteger, UIButtonType) {

UIButtonTypeCustom = 0,

UIButtonTypeSystem NS_ENUM_AVAILABLE_IOS(7_0),

UIButtonTypeRoundedRect,

UIButtonTypeDetailDisclosure,

UIButtonTypeInfoLight,

UIButtonTypeInfoDark,

UIButtonTypeContactAdd,

UIButtonTypeRoundedRect = UIButtonTypeSystem,

}


Кроме того, на кнопке может находиться изображение, которое заменяет ее стандартный внешний вид. Если у вас есть изображение или серия изображений, которые вы хотите присвоить различным состояниям кнопки, убедитесь, что кнопка относится к типу UIButtonTypeCustom. Здесь я подготовил два изображения: одно для обычного состояния кнопки, а другое — для нажатого (утопленного). Сейчас я создам кнопку и присвою ей два этих изображения:


UIImage *normalImage = [UIImage imageNamed:@"NormalBlueButton.png"];

UIImage *highlightedImage = [UIImage imageNamed:@"HighlightedBlueButton"];


self.myButton = [UIButton buttonWithType: UIButtonTypeCustom];


self.myButton.frame = CGRectMake(110.0f,

200.0f,

100.0f,

44.0f);


[self.myButton setBackgroundImage: normalImage

forState: UIControlStateNormal];

[self.myButton setTitle:@"Normal"

forState: UIControlStateNormal];


[self.myButton setBackgroundImage: highlightedImage

forState: UIControlStateHighlighted];

[self.myButton setTitle:@"Pressed"

forState: UIControlStateHighlighted];


На рис. 1.59 показано, как выглядит приложение, если его запустить в эмуляторе iOS. Чтобы задать фоновое изображение, мы используем относящийся к кнопке метод setBackgroundImage: forState:. Работая с фоновым изображением, мы можем пользоваться методами setTitle: forState: для отображения текста поверх фонового изображения. Если ваше изображение содержит текст и, таким образом, никакой надписи на кнопке не требуется, можете воспользоваться методом setImage: forState: или просто удалить заголовки с кнопки.




Рис. 1.59. Кнопка с фоновым изображением

1.22. Показ изображений с помощью UIImageView

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

Требуется демонстрировать пользователям изображения в графическом интерфейсе программы.

Решение

 Сделать закладку на этом месте книги

Воспользуйтесь классом UIImageView.

Обсуждение

 Сделать закладку на этом месте книги

Класс UIImageView — один из наименее сложных в iOS SDK. Как вы знаете, существует особый вид, в котором демонстрируются изображения. Чтобы демонстрировать изображения, нужно всего лишь инстанцировать объект типа UIImageView и добавлять его к вашим видам. Например, у меня есть картинка Apple MacBook Air и я хочу показать ее в виде для изображений. Начнем с файла реализации контроллера:


#import «ViewController.h»


@interface ViewController ()

@property (nonatomic, strong) UIImageView *myImageView;

@end

@implementation ViewController

Инстанцируем вид для изображений и разместим в нем изображение:

— (void)viewDidLoad{

[super viewDidLoad];


UIImage *macBookAir = [UIImage imageNamed:@"MacBookAir"];

self.myImageView = [[UIImageView alloc] initWithImage: macBookAir];

self.myImageView.center = self.view.center;

[self.view addSubview: self.myImageView];


}


Теперь, запустив программу, мы увидим такую картинку, как на рис. 1.60.




Рис. 1.60. Вид с изображением, которое довольно велико и не умещается на экране


Отмечу, что картинка Apple MacBook Air, которую я загружаю в этот вид, имеет разрешение 980 519 пикселов и, конечно же, не умещается на экране iPhone. Как решить эту проблему? Для начала нужно убедиться в том, что мы инициализируем наш вид для изображений с помощью метода initWithFrame:, а не initWithImage:, поскольку второй метод задает высоту и ширину вида с изображением равными высоте и ширине самого изображения. Итак, сначала решим эту проблему:

— (void)viewDidLoad{

[super viewDidLoad];


UIImage *macBookAir = [UIImage imageNamed:@"MacBookAir"];

self.myImageView = [[UIImageView alloc] initWithFrame: self.view.bounds];

self.myImageView.image = macBookAir;

self.myImageView.center = self.view.center;

[self.view addSubview: self.myImageView];


}

Как теперь будет выглядеть наше приложение? Рассмотрим рис. 1.61.




Рис. 1.61. Изображение, которое умещается по ширине на экране устройства


Но мы не этого хотели добиться, правда? Действительно, контуры вида с изображением нам теперь подходят, но сама картинка стала отображаться неправильно. Что же можно сделать? Можно решить возникшую проблему, задав для вида с изображением свойство contentMode. Это свойство типа UIContentMode:


typedef NS_ENUM(NSInteger, UIViewContentMode) {

UIViewContentModeScaleToFill,

UIViewContentModeScaleAspectFit,

UIViewContentModeScaleAspectFill,

UIViewContentModeRedraw,

UIViewContentModeCenter,

UIViewContentModeTop,

UIViewContentModeBottom,

UIViewContentModeLeft,

UIViewContentModeRight,

UIViewContentModeTopLeft,

UIViewContentModeTopRight,

UIViewContentModeBottomLeft,

UIViewContentModeBottomRight,

}


Вот описание некоторых наиболее полезных значений из перечня UIViewContentMode:

• UIViewContentModeScaleToFill — позволяет масштабировать картинку в виде для изображения так, что она целиком заполнит вид в его границах;

• UIViewContentModeScaleAspectFit — позволяет гарантировать, что картинка внутри вида с изображением будет иметь правильное соотношение сторон (характеристическое отношение) и будет вписываться в границы вида с изображением;

• UIViewContentModeScaleAspectFill — позволяет гарантировать, что картинка внутри вида с изображением будет иметь правильное соотношение сторон и будет вписываться в границы вида с изображением. Чтобы данное значение действовало как следует, необходимо присвоить свойству clipsToBounds вида с изображением значение YES.

Свойство clipsToBounds вида UIView определяет, должны ли «подокна» этого вида обрезаться, если они выходят за границы содержащего их вида. Можно пользоваться этим свойством, если вы хотите с абсолютной точностью гарантировать, что «подокна» конкретного вида не будут отображаться вне границ содержащего их вида (или что они при необходимости непременно будут выходить за его границы — в зависимости от того, что именно вам требуется).

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


— (void)viewDidLoad{

[super viewDidLoad];


UIImage *macBookAir = [UIImage imageNamed:@"MacBookAir"];

self.myImageView = [[UIImageView alloc] initWithFrame: self.view.bounds];

self.myImageView.contentMode = UIViewContentModeScaleAspectFit;

self.myImageView.image = macBookAir;

self.myImageView.center = self.view.center;

[self.view addSubview: self.myImageView];

}


Получается как раз такой результат, которого мы добивались (рис. 1.62).




Рис. 1.62. Такое соотношение сторон картинки нам подходит

1.23. Создание прокручиваемого контента с помощью UIScrollView

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

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

Решение

 Сделать закладку на этом месте книги

Воспользуйтесь классом UIScrollView.

Обсуждение

 Сделать закладку на этом месте книги

Прокручиваемый вид (Scroll View) — одно из очевидных достоинств, которые и делают операционную систему iOS такой удобной. Подобные виды встречаются практически в любых программах. Мы уже познакомились с приложениями Clock (Часы) и Contacts (Контакты). Вы заметили, что их содержимое можно прокручивать вверх и вниз? Да, в этом и заключается магия, присущая видам, о которых пойдет речь в этом разделе.

В сущности, есть всего одна базовая концепция, которую необходимо усвоить в связи с видами, чье содержимое можно прокручивать, — это размер содержимого . Учитывая размер содержимого, прокручиваемый вид может адаптироваться к размеру контента, который в нем находится. Размер содержимого — это значение типа CGSize, которое указывает высоту и ширину того материала, который наполняет вид с прокручиваемым контентом. Вид с прокручиваемым контентом, как следует из его названия, является подклассом UIView. Поэтому вы можете просто добавлять ваши виды к видам с прокручиваемым контентом, пользуясь методом addSubview:. Правда, нужно убедиться в том, что размер содержимого для прокручиваемого вида задан правильно. В противном случае эта информация прокручиваться не будет .

Найдем для примера большую картинку и загрузим ее в вид с изображением. Я воспользуюсь той самой картинкой, с которой мы работали в разделе 1.22: MacBook Air. Добавлю ее в вид с изображением, который помещу в вид с прокручиваемым контентом. Потом воспользуюсь свойством contentSize прокручиваемого вида, чтобы убедиться в том, что размеры этого материала равны размерам изображения (высоте и ширине). Начнем работу с файла реализации контроллера нашего вида:


#import «ViewController.h»


@interface ViewController ()

@property (nonatomic, strong) UIScrollView *myScrollView;

@property (nonatomic, strong) UIImageView *myImageView;

@end


@implementation ViewController

И поместим вид с изображением внутрь прокручиваемого вида:

— (void)viewDidLoad{

[super viewDidLoad];


UIImage *imageToLoad = [UIImage imageNamed:@"MacBookAir"];

self.myImageView = [[UIImageView alloc] initWithImage: imageToLoad];

self.myScrollView = [[UIScrollView alloc] initWithFrame: self.view.bounds];

[self.myScrollView addSubview: self.myImageView];

self.myScrollView.contentSize = self.myImageView.bounds.size;

[self.view addSubview: self.myScrollView];


}


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

UIScrollView обладает такой удобной особенностью, как поддержка делегирования. Поэтому такой вид может сообщать приложению о действительно важных событиях с помощью делегата. Делегат для прокручиваемого вида должен отвечать требованиям протокола UIScrollViewDelegate. Вот некоторые методы, определяемые в этом протоколе:

• scrollViewDidScroll: — вызывается всякий раз, когда содержимое прокручиваемого вида прокручивается;

• scrollViewWillBeginDecelerating: — вызывается, когда пользователь прокручивает содержимое вида и отрывает палец от сенсорного экрана в то время, как вид продолжает прокручиваться;

• scrollViewDidEndDecelerating: — вызывается, когда прокручивание информации, содержащейся в виде, заканчивается;

• scrollViewDidEndDragging: willDecelerate: — вызывается, когда пользователь завершает перетаскивание содержимого в прокручиваемом виде. Этот метод очень напоминает scrollViewDidEndDecelerating:, но  следует помнить, что пользователь может перетаскивать элементы содержимого такого вида и не прокручивая его. Можно просто прикоснуться пальцем к элементу содержимого, переместить палец в другую точку на экране, а потом оторвать палец от экрана, не сдвинув содержимое самого вида ни на миллиметр. Этим перетаскивание и отличается от прокрутки. Прокрутка напоминает перетаскивание, но пользователь «сообщает импульс», приводящий к перемещению содержимого, если снимает палец с экрана, пока  информация еще прокручивается. То есть пользователь убирает палец, не дождавшись завершения прокрутки. Перетаскивание можно сравнить с тем, как вы удерживаете педаль газа в машине или педаль велосипеда. Продолжая эту аналогию, можно сравнить прокрутку с движением по инерции на машине или велосипеде.

Сделаем предыдущее приложение немного интереснее. Теперь нужно установить уровень яркости картинки в нашем виде с изображением (этот показатель также называется «альфа-уровень» или «альфа-значение») равным 0.50f (полупрозрачный) на момент, когда пользователь начинает прокрутку изображения, и вернуть этот уровень к значению 1.0f (непрозрачный) к моменту, когда прокрутка завершается. Сначала обеспечим соответствие протоколу UIScrollViewDelegate:


#import «ViewController.h»


@interface ViewController () <UIScrollViewDelegate>

@property (nonatomic, strong) UIScrollView *myScrollView;

@property (nonatomic, strong) UIImageView *myImageView;

@end


@implementation ViewController

Потом реализуем данную функциональность:

— (void)scrollViewDidScroll:(UIScrollView *)scrollView{

/* Вызывается, когда пользователь совершает прокрутку

или перетаскивание. */

self.myScrollView.alpha = 0.50f;

}


— (void)scrollViewDidEndDecelerating:(UIScrollView *)scrollView{

/* Вызывается только после прокрутки. */

self.myScrollView.alpha = 1.0f;

}


— (void)scrollViewDidEndDragging:(UIScrollView *)scrollView

willDecelerate:(BOOL)decelerate{

/* Гарантируем, что альфа-значение вернется к исходному,

даже если пользователь просто перетаскивает элементы. */

self.myScrollView.alpha = 1.0f;

}


— (void)viewDidLoad{

[super viewDidLoad];


UIImage *imageToLoad = [UIImage imageNamed:@"MacBookAir"];

self.myImageView = [[UIImageView alloc] initWithImage: imageToLoad];

self.myScrollView = [[UIScrollView alloc] initWithFrame: self.view.bounds];

[self.myScrollView


убрать рекламу






addSubview: self.myImageView];

self.myScrollView.contentSize = self.myImageView.bounds.size;

self.myScrollView.delegate = self;

[self.view addSubview: self.myScrollView];


}


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

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

self.myScrollView.indicatorStyle = UIScrollViewIndicatorStyleWhite;




Рис. 1.63. Черные индикаторы, появляющиеся справа и снизу прокручиваемого вида


Одна из наиболее замечательных особенностей прокручиваемых видов заключается в том, что в них возможна разбивка на страницы. Она функционально подобна прокрутке, но прокрутка прекращается, как только пользователь переходит на следующую страницу . Вероятно, вы уже знакомы с этой функцией, если вам доводилось пользоваться программой Photos (Фотографии) в iPhone или iPad. Просматривая фотографии, можно перемещаться между ними скольжением. Каждое скольжение открывает на экране предыдущую или последующую фотографию. При одном скольжении вы никогда не прокручиваете последовательность до самого начала или до самого конца. Когда начинается прокручивание и вид обнаруживает следующее изображение, прокрутка останавливается на этом изображении и оно начинает подрагивать на экране. Таким образом, анимация прокрутки прерывается. Это и есть разбивка на страницы. Если вы еще не пробовали ее на практике, настоятельно рекомендую попробовать. Весь дальнейший рассказ останется непонятен, если вы не будете представлять, как выглядит приложение, поддерживающее разбивку на страницы.

В следующем примере с кодом я использую три изображения: iPhone, iPad и MacBook Air. Каждое из них я поместил в отдельный вид типа image view, а потом добавил эти виды к прокручиваемому виду. Затем включаем разбивку на страницы, задавая для свойства pagingEnabled прокручиваемого вида значение YES:


— (UIImageView *) newImageViewWithImage:(UIImage *)paramImage

frame:(CGRect)paramFrame{


UIImageView *result = [[UIImageView alloc] initWithFrame: paramFrame];

result.contentMode = UIViewContentModeScaleAspectFit;

result.image = paramImage;

return result;


}

— (void)viewDidLoad{

[super viewDidLoad];


UIImage *iPhone = [UIImage imageNamed:@"iPhone"];

UIImage *iPad = [UIImage imageNamed:@"iPad"];

UIImage *macBookAir = [UIImage imageNamed:@"MacBookAir"];


CGRect scrollViewRect = self.view.bounds;


self.myScrollView = [[UIScrollView alloc] initWithFrame: scrollViewRect];

self.myScrollView.pagingEnabled = YES;

self.myScrollView.contentSize = CGSizeMake(scrollViewRect.size.width *

3.0f, scrollViewRect.size.height);

[self.view addSubview: self.myScrollView];


CGRect imageViewRect = self.view.bounds;

UIImageView *iPhoneImageView = [self newImageViewWithImage: iPhone

frame: imageViewRect];

[self.myScrollView addSubview: iPhoneImageView];


/* Для перехода на следующую страницу изменяем положение следующего вида с изображением по оси X. */

imageViewRect.origin.x += imageViewRect.size.width;

UIImageView *iPadImageView = [self newImageViewWithImage: iPad

frame: imageViewRect];

[self.myScrollView addSubview: iPadImageView];


/* Для перехода на следующую страницу изменяем положение следующего вида с изображением по оси X. */

imageViewRect.origin.x += imageViewRect.size.width;

UIImageView *macBookAirImageView =

[self newImageViewWithImage: macBookAir

frame: imageViewRect];

[self.myScrollView addSubview: macBookAirImageView];


}


Итак, теперь у нас есть три страницы, содержимое которых можно прокручивать (рис. 1.64).




Рис. 1.64. Прокрутка содержимого в виде, в котором поддерживается разбивка на страницы

1.24. Загрузка веб-страниц с помощью UIWebView

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

Необходимо динамически загрузить веб-страницу прямо в ваше приложение для iOS.

Решение

 Сделать закладку на этом месте книги

Воспользуйтесь классом UIWebView.

Обсуждение

 Сделать закладку на этом месте книги

Веб-вид (Web View) — это окно, которое браузер Safari использует для загрузки в систему iOS информации из Сети. Класс UIWebView позволяет использовать в приложениях для iOS всю мощь Safari. Все, что вам нужно сделать, — поместить веб-вид в вашем пользовательском интерфейсе и применить один из методов загрузки:

• loadData: MIMEType: textEncodingName: baseURL: — загружает в веб-вид экземпляр класса NSData;

• loadHTMLString: baseURL: — загружает в веб-вид экземпляр класса NSString. Строка должна содержать валидный HTML-код так, чтобы ее мог обработать браузер;

• loadRequest: — загружает экземпляр класса NSURLRequest. Этот метод пригодится в тех случаях, когда вы хотите загрузить в веб-вид, расположенный в вашем приложении, удаленное содержимое, на которое указывает URL.

Рассмотрим пример. Начнем с файла реализации контроллера нашего вида:


#import «ViewController.h»


@interface ViewController ()

@property(nonatomic, strong) UIWebView *myWebView;

@end


@implementation ViewController

Теперь я хочу загрузить в веб-вид строку iOS 7 Programming Cookbook. Чтобы убедиться в том, что все работает как надо и что наш веб-вид способен отображать насыщенный (форматированный) текст, я на этом не остановлюсь и выделю слово Cookbook полужирным шрифтом, а остальной текст оставлю без изменений (рис. 1.65):

— (void)viewDidLoad{

[super viewDidLoad];


self.myWebView = [[UIWebView alloc] initWithFrame: self.view.bounds];

[self.view addSubview: self.myWebView];


NSString *htmlString = @"iOS 7 Programming <strong>Cookbook</strong>";

[self.myWebView loadHTMLString: htmlString

baseURL: nil];

}





Рис. 1.65. Загрузка форматированного текста в веб-вид

Еще один способ работы с веб-видом — загрузка в него удаленного контента, на который указывает URL. Для этого можно пользоваться методом loadRequest:. Перейдем к следующему примеру, в котором загрузим основную страницу сайта Apple в веб-вид, расположенный в нашей программе для iOS (рис. 1.66):


— (void)viewDidLoad{

[super viewDidLoad];


self.myWebView = [[UIWebView alloc] initWithFrame: self.view.bounds];

self.myWebView.scalesPageToFit = YES;

[self.view addSubview: self.myWebView];


NSURL *url = [NSURL URLWithString:@"https://www.apple.com"];

NSURLRequest *request = [NSURLRequest requestWithURL: url];


[self.myWebView loadRequest: request];

}




Рис. 1.66. Веб-вид, в который загружена домашняя страница Apple


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




Рис. 1.67. Индикатор процесса загрузки


В iOS эта задача решается с помощью делегирования. Мы сделаем подписку на делегат веб-вида, и веб-вид будет получать уведомление всякий раз, когда делегат станет загружать контент. Когда загрузка контента завершится, мы получим от веб-вида соответствующее сообщение. Все это мы сделаем, применив свойство delegate веб-вида. Делегат веб-вида должен соответствовать протоколу UIWebViewDelegate.

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


@interface ViewController () <UIWebViewDelegate>

@property(nonatomic, strong) UIWebView *myWebView;

@end


@implementation ViewController

Потом перейдем к реализации. Здесь мы будем использовать три метода из тех, которые объявляются в протоколе UIWebViewDelegate:

 webViewDidStartLoad: — вызывается, как только вид начинает загрузку содержимого;

 webViewDidFinishLoad: — вызывается, как только вид заканчивает загрузку содержимого;

 webView: didFailLoadWithError: — вызывается, как только вид останавливает загрузку содержимого, например, из-за возникшей ошибки или разрыва сетевого соединения:

— (void)webViewDidStartLoad:(UIWebView *)webView{

[[UIApplication sharedApplication]

setNetworkActivityIndicatorVisible: YES];

}


— (void)webViewDidFinishLoad:(UIWebView *)webView{

[[UIApplication sharedApplication] setNetworkActivityIndicatorVisible: NO];

}


— (void)webView:(UIWebView *)webView didFailLoadWithError:(NSError *)error{

[[UIApplication sharedApplication] setNetworkActivityIndicatorVisible: NO];

}


— (void)viewDidLoad{

[super viewDidLoad];


self.myWebView = [[UIWebView alloc] initWithFrame: self.view.bounds];

self.myWebView.delegate = self;

self.myWebView.scalesPageToFit = YES;

[self.view addSubview: self.myWebView];


NSURL *url = [NSURL URLWithString:@"https://www.apple.com"];

NSURLRequest *request = [NSURLRequest requestWithURL: url];


[self.myWebView loadRequest: request];


}

1.25. Отображение протекания процессов с помощью UIProgressView

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

Необходимо отображать на экране индикатор протекания процесса (Progress Bar), отражающий ход выполнения той или иной задачи, например индикатор загрузки файла, скачиваемого c определенного URL.

Решение

 Сделать закладку на этом месте книги

Инстанцируйте вид типа UIProgressView и разместите его в другом виде.

Обсуждение

 Сделать закладку на этом месте книги

Вид протекания процесса программисты обычно называют прогресс-баром. Образец такого вида показан на рис. 1.68.




Рис. 1.68. Простой вид с индикатором протекания процесса


Виды, отображающие протекание процессов, обычно демонстрируются пользователю для показа выполнения задачи с четко определенными начальной и конечной точками. Примером такой задачи является, например, скачивание 30 файлов. Очевидно, что такая задача будет выполнена, когда все 30 файлов будут скопированы на устройство. Вид, отображающий протекание процесса, является экземпляром UIProgressView и инициализируется с помощью специального метода-инициализатора данного класса — initWithProgressViewStyle:. В качестве параметра данный метод принимает стиль (оформление) панели протекания, которую предполагается создать. Этот параметр относится к типу UIProgressViewStyle и, соответственно, может иметь одно из следующих значений:

• UIProgressViewStyleDefault — это стандартное оформление вида протекания процесса. Именно в этом стиле оформлен вид, показанный на рис. 1.68;

• UIProgressViewStyleBar — напоминает UIProgressViewStyleDefault, но предназначено для использования с видами отображения протекания процессов, добавляемыми на панель инструментов.

Экземпляр UIProgressView определяет свойство под названием progress (типа float). Это свойство сообщает системе iOS, как должна отображаться полоса в виде, отражающем протекание процесса. Значение этого свойства должно быть в диапазоне от 0 до 1.0. Если сообщается значение 0, то заполнение индикатора состояния еще не началось. Значение 1.0 соответствует 100 %-ной завершенности. Степень прогресса, показанная на рис. 1.68, составляет 0.5 (или 50 %).

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


#import «ViewController.h»


@interface ViewController ()

@property (nonatomic, strong) UIProgressView *progressView;

@end


@implementation ViewController


Далее инстанцируем объект типа UIProgressView:

— (void)viewDidLoad{


[super viewDidLoad];


self.progressView = [[UIProgressView alloc]

initWithProgressViewStyle: UIProgressViewStyleBar];

self.progressView.center = self.view.center;

self.progressView.progress = 20.0f / 30.0f;


[self.view addSubview: self.progressView];


}


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


self.progressView.progress = 20.0f / 30.0f;

Значения 20 и 30 передаются данному равенству как значения с плавающей точкой, поскольку компилятору нужно сообщить, что операция деления будет производиться над числами с плавающей точкой и в результате деления получится десятичная дробь. Если приказать компилятору поместить в свойстве progress вида протекания процесса целочисленное деление 20/30, то вы получите целочисленный результат 0. Это происходит потому, что компилятор выполняет целочисленное деление, отсекая полученный результат до ближайшего предшествующего целого числа. Короче говоря, на индикаторе протекания действия прогресс все время будет оставаться нулевым, пока процесс не завершится и частное от деления 30/30 не станет равно 1. Пользователю такой индикатор загрузки будет ни к чему.

1.26. Создание и отображение текстов с оформлением

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

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

Решение

 Сделать закладку на этом месте книги

Создайте экземпляр класса NSAttributedString или его изменяемого варианта, NSMutableAttributedString, и либо задайте его как текст компонента пользовательского интерфейса (например, как текст подписи UILabel) с помощью специального строкового свойства, снабженного атрибутами, либо просто воспользуйтесь встроенными методами атрибутированной строки для отрисовки текста на холсте.

Обсуждение

 Сделать закладку на этом месте книги

О насыщенном тексте слагают легенды. Многим из наших коллег-программистов приходилось сталкиваться с необходимостью отображения в пользовательском интерфейсе такой текстовой строки, в которой применяется сразу несколько видов форматирования. Например, в одной строке может понадобиться одновременно вывести и обычный текст, и курсив, причем курсивом будет записано всего одно слово. Возможно, одно из слов в предложении потребуется подчеркнуть. Для этого некоторые пытаются использовать веб-виды (Web Views), но это решение не является оптимальным, поскольку веб-виды довольно медленно отображают свой контент и неизбежно негативно воздействуют на производительность приложения. В iOS 7 можно приступать к применению атрибутированных строк. Не знаю, почему Apple решила внедрить такую возможность в iOS только сейчас, ведь Mac-разработчики пользуются атрибутированными строками уже довольно давно.

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




Рис. 1.69. Атрибутированная строка отображена на экране в простой подписи

Необходимо отметить, что этот текст отображается в одном экземпляре класса UILabel.

Итак, что мы видим в этом примере? Перечислю.

• Текст iOS имеет следующие атрибуты:

• полужирный шрифт размером 60 точек;

• черный цвет фона;

• красный цвет шрифта.

• Текст SDK имеет следующие атрибуты:

• полужирный шрифт размером 60 точек;

• белый цвет шрифта;

• светло-серую тень;

• красный цвет фона.


Удобнее всего создавать атрибутированные строки с помощью метода initWithString:, относящегося к изменяемому классу NSMutableAttributedString, и передавать этому методу экземпляр NSString. Так создается атрибутированная строка без каких-либо атрибутов. Затем, чтобы присвоить атрибуты различным частям строки, мы воспользуемся методом setAttributes: range: класса NSMutableAttributedString. Этот метод принимает два параметра:

• setAttributes — словарь, ключи которого являются символьными атрибутами и значение каждого ключа зависит от самого ключа. Вот наиболее важные ключи, которые можно задать в этом словаре:

• NSFontAttributeName — значение этого ключа является экземпляром UIFont и определяет шрифт для того или иного фрагмента строки;

• NSForegroundColorAttributeName — значение этого ключа относится к типу UIColor и определяет цвет шрифта определенного фрагмента строки;

• NSBackgroundColorAttributeName — значение этого ключа относится к типу UIColor и определяет цвет фона, на котором будет отрисовываться определенный фрагмент строки;

• NSShadowAttributeName — значение этого ключа должно быть экземпляром NSShadow и задавать тень, которую будет отбрасывать определенный фрагмент строки;

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

Чтобы просмотреть все ключи, которые можно передавать этому методу, просто изучите онлайновую документацию Apple по классу NSMutableAttributedString. Я не буду помещать здесь ссылку на документацию, так как Apple может рано или поздно изменить эту ссылку, а вот поиск вас точно не подведет.

Разобьем наш пример на два словаря с атрибутами. Словарь атрибутов для слова iOS создается в коде таким образом:


NSDictionary *attributesForFirstWord = @{

NSFontAttributeName: [UIFont boldSystemFontOfSize:60.0f],

NSForegroundColorAttributeName: [UIColor redColor],

NSBackgroundColorAttributeName: [UIColor blackColor]

};

А слово SDK создается с помощью следующих атрибутов:

NSShadow *shadow = [[NSShadow alloc] init];

shadow.shadowColor = [UIColor darkGrayColor];

shadow.shadowOffset = CGSizeMake(4.0f, 4.0f);


NSDictionary *attributesForSecondWord = @{

NSFontAttributeName: [UIFont boldSystemFontOfSize:60.0f],

NSForegroundColorAttributeName: [UIColor whiteColor],

NSBackgroundColorAttributeName: [UIColor redColor],

NSShadowAttributeName: shadow

};


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


#import «ViewController.h»


@interface ViewController ()

@property (nonatomic, strong) UILabel *label;

@end


@implementation ViewController


— (NSAttributedString *) attributedText{


NSString *string = @"iOS SDK";


NSMutableAttributedString *result = [[NSMutableAttributedString alloc]

initWithString: string];

NSDictionary *attributesForFirstWord = @{

NSFontAttributeName: [UIFont boldSystemFontOfSize:60.0f],

NSForegroundColorAttributeName: [UIColor redColor],

NSBackgroundColorAttributeName: [UIColor blackColor]

};


NSShadow *shadow = [[NSShadow alloc] init];

shadow.shadowColor = [UIColor darkGrayColor];

shadow.shadowOffset = CGSizeMake(4.0f, 4.0f);


NSDictionary *attributesForSecondWord = @{

NSFontAttributeName: [UIFont boldSystemFontOfSize:60.0f],

NSForegroundColorAttributeName: [UIColor whiteColor],

NSBackgroundColorAttributeName: [UIColor redColor],

NSShadowAttributeName: shadow

};


/* Находим фрагмент iOS в целой строке и задаем атрибуты для этого фрагмента */

[result setAttributes: attributesForFirstWord

range: [string rangeOfString:@"iOS"]];


/* Делаем то же самое со строкой SDK */

[result setAttributes: attributesForSecondWord

range: [string rangeOfString:@"SDK"]];


return [[NSAttributedString alloc] initWithAttributedString: result];


}


— (void)viewDidLoad{

[super viewDidLoad];


self.label = [[UILabel alloc] init];

self.label.backgroundColor = [UIColor clearColor];

self.label.attributedText = [self attributedText];

[self.label sizeToFit];

self.label.center = self.view.center;

[self.view addSubview: self.label];


}


@end

См. также

 Сделать закладку на этом месте книги

Разделы 1.17 и 1.18.

1.27. Представление видов «Основной — детали» с помощью UISplitViewController

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

Необходимо максимально эффективно использовать большой экран iPad, представив на нем два расположенных рядом контроллера видов.

Решение

 Сделать закладку на этом месте книги

Воспользуйтесь классом UISplitViewController.

Обсуждение

 Сделать закладку на этом месте книги

Контроллеры видов split view (будем называть эти виды разделенными экранами) есть только в iPad. Если вы работаете с iPad, то, вероятно, уже сталкивались с ними. Можно просто открыть приложение Settings (Настройки) в альбомном режиме и посмотреть. Видите, какой контроллер разделенного экрана показан на рис. 1.70?

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

Даже не пытайтесь инстанцировать объект типа UISplitViewController на каком-нибудь устройстве, кроме iPad. В результате вы получите исключение.



Рис. 1.70. Контроллер с разделенным экраном в приложении Settings (Настройки) в iPad


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

1. В Xcode перейдите в меню File (Файл) и выполните New\New Project (Новый\ Новый проект).

2. В окне New Projec


убрать рекламу






t (Новый проект) выберите слева iOS\Application (iOS\Приложение), а потом укажите вариант Master-Detail Application (Приложение «Основной — детали») (рис. 1.71) и нажмите Next (Далее).




Рис. 1.71. Выбираем в Xcode шаблон приложения «Основной — детали»


3. На следующем экране выберите название вашего продукта и убедитесь в том, что для семейства устройств указан параметр Universal (Универсальное). Мы хотим, чтобы создаваемое приложение могло работать и на iPhone, и на iPad (рис. 1.72). Сделав это, нажмите Next (Далее).




Рис. 1.72. Задаем в Xcode настройки проекта «Основной — детали»


4. Теперь выберем место для сохранения проекта. Сделав это, нажмите кнопку Create (Создать).

Итак, проект создан. На кнопке поэтапного выбора Scheme (Схема), расположенной в левом верхнем углу, должно быть указано, что приложение будет работать в эмуляторе iPad, а не в эмуляторе iPhone. Если в Xcode создается универсальное приложение «Основной — детали», то Xcode обеспечивает возможность работы с этим приложением и на iPhone, но при запуске приложения на iPhone структура его будет иной, нежели при запуске на iPad. В приложении окажется навигационный контроллер, внутри которого будет контроллер вида. Если то же самое приложение запустить на iPad, то мы увидим разделенный экран, в котором будут расположены два контроллера вида.

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

• MasterViewController — контроллер основного вида, располагающегося в левой части разделенного экрана в iPad. В iPhone это первый контроллер, который увидит пользователь;

• DetailViewController — контроллер вида с деталями, который отображается в правой части разделенного экрана на iPad. В iPhone это тот контроллер, который занимает верхнюю позицию в стеке, как только пользователь выбирает любой элемент в корневом (первом, основном) контроллере вида.

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

Если запустить такое приложение в эмуляторе iPad, то в альбомном режиме мы увидим контроллеры основного вида и вида с деталями в разделенном экране, но если изменить ориентацию на книжную, то вид с основными параметрами исчезнет и на его месте появится навигационная кнопка Master (Основной). Она будет располагаться в левой верхней части навигационной панели контроллера с детальной информацией. Хотя это и неплохой вариант, но мы ожидали иного, так как сравниваем наш проект с приложением Settings (Настройки) из iPad. Если в iPad повернуть экран с приложением Settings (Настройки) так, чтобы он приобрел книжную ориентацию, то на экране все равно останутся оба контроллера видов: и с основной информацией, и с деталями. Как нам добиться такого результата? Оказывается, Apple предлагает API (интерфейс программирования приложений), с помощью которого как раз и можно решить такую задачу. Просто переходим в файл DetailViewController.m и реализуем следующий метод:


— (BOOL) splitViewController:(UISplitViewController *)svc

shouldHideViewController:(UIViewController *)vc

inOrientation:(UIInterfaceOrientation)orientation{

return NO;

}


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


— (void)splitViewController:(UISplitViewController *)splitController

willHideViewController:(UIViewController *)viewController

withBarButtonItem:(UIBarButtonItem *)barButtonItem

forPopoverController:(UIPopoverController *)popoverController{

barButtonItem.title = NSLocalizedString(@"Master", @"Master");

[self.navigationItem setLeftBarButtonItem: barButtonItem animated: YES];

self.masterPopoverController = popoverController;

}


— (void)splitViewController:(UISplitViewController *)splitController

willShowViewController:(UIViewController *)viewController

invalidatingBarButtonItem:(UIBarButtonItem *)barButtonItem{

[self.navigationItem setLeftBarButtonItem: nil animated: YES];

self.masterPopoverController = nil;

}


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

Заглянув на заголовочный файл контроллера вашего основного вида, вы увидите там нечто подобное:


#import <UIKit/UIKit.h>


@class DetailViewController;


@interface MasterViewController: UITableViewController


@property (strong, nonatomic) DetailViewController *detailViewController;


@end


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

По умолчанию если вы запустите приложение в эмуляторе iPad, то увидите пользовательский интерфейс, очень напоминающий тот, что показан на рис. 1.73. В стандартной реализации, которую Apple предоставляет нам с контроллером основного вида, содержится изменяемый массив. Этот массив заполняется экземплярами NSDate всякий раз, когда вы нажимаете кнопку «плюс» (+) на навигационной панели в этом контроллере вида. Стандартная реализация очень проста, и вы можете ее модифицировать, немного разобравшись в табличных видах. О том, что такое табличные виды и как они заполняются, подробно рассказано в главе 4.




Рис. 1.73. Контроллер пустого вида с разделенным экраном, работающий в эмуляторе iPad

1.28. Организация разбивки на страницы с помощью UIPageViewController

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

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

Решение

 Сделать закладку на этом месте книги

Воспользуйтесь UIPageViewController.

Обсуждение

 Сделать закладку на этом месте книги

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

Контроллеры видов с постраничной организацией работают как в iPhone, так и в iPad.

1. В Xcode перейдите в меню File (Файл) и выберите New\New Project (Новый\ Новый проект).

2. Убедитесь, что в левой части окна New Project (Новый проект) выбрана операционная система iOS, а далее — команда Application (Приложение). Сделав это, укажите справа шаблон Page-Based Application (Приложение с постраничной организацией) (рис. 1.74) и нажмите Next (Далее).




Рис. 1.74. Создание в Xcode приложения с постраничной организацией


3. Теперь выберите имя продукта и убедитесь в том, что указанное вами семейство устройств (Device) является универсальным (Universal). Это необходимо сделать, поскольку, как правило, ваше приложение потребуется использовать и на iPhone, и на iPad (рис. 1.75). Сделав это, нажмите Next (Далее).




Рис. 1.75. Задаем настройки проекта для приложения с постраничной организацией


4. Выберите, где вы хотите сохранить проект. Сделав это, нажмите кнопку Create (Создать). Итак, вы успешно создали проект.

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

• класс делегата — делегат приложения просто создает экземпляр класса RootViewController и представляет его пользователю. Для iPad используется один архив XIB, для iPhone — другой, но оба они при работе опираются на вышеупомянутый класс;

• RootViewController — создает экземпляр UIPageViewController и добавляет к себе этот контроллер вида. Поэтому пользовательский интерфейс контроллера данного вида — это фактически смесь двух контроллеров видов, самого RootViewController и UIPageViewController;

• DataViewController — для каждой страницы в контроллере постраничного вида пользователю предлагается по одному экземпляру данного класса. Данный класс является подклассом UIViewController;

• ModelController — это обычный подкласс NSObject, соответствующий протоколу UIPageViewControllerDataSource. Этот класс является источником данных для контроллера вида-страницы.

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


— (void)pageViewController:(UIPageViewController *)pageViewController

didFinishAnimating:(BOOL)finished

previousViewControllers:(NSArray *)previousViewControllers

transitionCompleted:(BOOL)completed;


— (UIPageViewControllerSpineLocation)pageViewController

:(UIPageViewController *)pageViewController

spineLocationForInterfaceOrientation:(UIInterfaceOrientation)orientation;


Первый метод вызывается, когда пользователь переходит к следующей или предыдущей странице или  решает перелистнуть страницу вперед или назад, но передумывает в момент, пока страница еще движется. (В последнем случае пользователь возвращается к той странице, которую просматривал перед актом листания.) Свойство transitionCompleted получает значение YES, если удалось отобразить анимацию листания страницы, и NO — если пользователь решил страницу не перелистывать и прервал анимацию в ходе ее выполнения.

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


typedef NS_ENUM(NSInteger, UIPageViewControllerSpineLocation) {

UIPageViewControllerSpineLocationNone = 0,

UIPageViewControllerSpineLocationMin = 1,

UIPageViewControllerSpineLocationMid = 2,

UIPageViewControllerSpineLocationMax = 3

};


Возможно, все это выглядит немного запутанно, но позвольте мне продемонстрировать, что имеется в виду. Если мы используем расположение сгиба ViewControllerSpineLocationMin, то для отображения страничного вида пользователю потребуется всего один контроллер вида. Если пользователь перейдет к следующей странице, то увидит уже новый контроллер вида. Но если мы зададим для отображения сгиба UIPageViewControllerSpineLocationMid, то для демонстрации такого варианта нам понадобятся уже два контроллера видов одновременно. Один будет представлять левую страницу, другой — правую, а между ними расположится сгиб. Сейчас покажу, что я имею в виду. На рис. 1.76 изображен пример страничного вида, имеющего альбомную ориентацию. Здесь для расположения изгиба выбрано значение UIPageViewControllerSpineLocationMin.




Рис. 1.76. Один контроллер вида. Представлен контроллер вида-страницы с альбомной ориентацией


Теперь, если вернуть расположение сгиба, соответствующее UIPageViewControllerSpineLocationMid, получим примерно такой результат, как на рис. 1.77.




Рис. 1.77. Два контроллера видов, отображенные в контроллере вида-страницы, где страница имеет альбомную ориентацию


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


— (UIPageViewControllerSpineLocation)pageViewController

:(UIPageViewController *)pageViewController

spineLocationForInterfaceOrientation:(UIInterfaceOrientation)orientation;


Итак, мы разобрались с делегатом контроллера страничного вида, а что насчет источника данных? Источник данных контроллера страничного вида должен соответствовать протоколу UIPageViewControllerDataSource. Этот протокол предоставляет два следующих важных метода:


— (UIViewController *)

pageViewController:(UIPageViewController *)pageViewController

viewControllerBeforeViewController:(UIViewController *)viewController;


— (UIViewController *)

pageViewController:(UIPageViewController *)pageViewController

viewControllerAfterViewController:(UIViewController *)viewController;


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

Как вы могли убедиться, среда Xcode значительно упрощает создание приложений с постраничной организацией. Все, что, по сути, от вас требуется, — предоставить содержимое для модели данных (ModelController) и двигаться дальше. Если требуется отдельно настроить цвета и изображения в контроллерах ваших видов, то можно либо сделать это в конструкторе интерфейса (Interface Builder), позволяющем напрямую изменять файлы раскадровки, либо написать собственный код для реализации каждого из контроллеров видов.

1.29. Отображение вспомогательных экранов с помощью UIPopoverController

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

Вы хотите отображать на iPad окно с информацией, не занимая при этом целый экран.

Решение

 Сделать закладку на этом месте книги

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

Обсуждение

 Сделать закладку на этом месте книги

Вспомогательные экраны (Popover) применяются для вывода на экран iPad дополнительной информации. В качестве примера можно привести браузер Safari из iPad. Если пользователь нажмет кнопку Bookmarks (Закладки), то на экране появится еще одно окошко, в котором будет перечислено содержимое панели закладок (рис. 1.78).




Рис. 1.78. Вспомогательный экран с закладками браузера Safari на планшете iPad


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

Вспомогательные экраны применяются только на устройствах iPad. Если у вас есть контроллер вида, чей код выполняется и на iPad, и на iPhone, необходимо гарантировать, что вспомогательные экраны не будут инстанцироваться на других устройствах, кроме iPad.

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

• открывать их из навигационной кнопки экземпляра UIBarButtonItem;

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


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

Для создания демонстрационного приложения со вспомогательными экранами нужно сначала обдумать стратегию, зависящую от поставленных перед вами требований. Например, требуется написать приложение с контроллером вида, загруженным в навигационный контроллер. В корневом контроллере вида будет отображаться кнопка +, расположенная в правом углу навигационной панели. Если на устройстве iPad нажать кнопку +, откроется вспомогательный экран с двумя кнопками. На одной будет написано Photo (Фото), на другой — Audio (Аудио). При нажатии той же самой навигационной кнопки на iPhone отобразится предупреждающий вид (Alert View) с тремя кнопками — двумя вышеупомянутыми и кнопкой Cancel (Отмена), чтобы пользователь мог сам закрыть это окно, если захочет. При нажатии любой из этих кнопок (и в предупреждающем виде iPhone, и на вспомогательном экране iPad) мы фактически ничего не сделаем — просто уберем это окошко.

Итак, продолжим и создадим в Xcode универсальный проект Single View (Приложение с единственным видом). Назовем проект Displaying Popovers with UIPopoverController («Отображение вспомогательных экранов с помощью UIPopoverController»). Затем, воспользовавшись приемами, описанными в разделе 6.1, добавим в раскадровку навигационный контроллер, чтобы у контроллеров видов появилась навигационная панель.

После этого перейдем к определению корневого контроллера вида и укажем здесь свойство типа UIPopoverController:


#import «ViewController.h»


@interface ViewController () <UIAlertViewDelegate>

@property (nonatomic, strong) UIPopoverController *myPopoverController;

@property (nonatomic, strong) UIBarButtonItem *barButtonAdd;

@end


@implementation ViewController


<# Оставшаяся часть вашего кода находится здесь #>


Как видите, мы также определяем для контроллера вида свойство barButtonAdd. Это навигационная кнопка, которую мы добавим на нашу панель. Мы собираемся отображать вспомогательный экран после того, как пользователь нажмет эту кнопку (подробнее о навигационных кнопках рассказано в разделе 1.15). При этом необходимо гарантировать, что мы инстанцируем вспомогательный экран только для iPad. Прежде чем идти дальше и инстанцировать корневой контроллер вида с навигационной кнопкой, создадим подкласс от UIViewController и назовем его PopoverContentViewController. В дальнейшем будем отображать его содержимое на вспомогательном экране. В разделе 1.9 подробнее рассказано о контроллерах видов и о том, как их создавать.

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


#import <UIKit/UIKit.h>


@interface PopoverContentViewController: UIViewController


/* Не следует определять данное свойство как strong. В противном случае возникнет цикл удержания (Retain Cycle) между контроллером информационного вида и контроллером вспомогательного экрана, так как контроллер вспомогательного экрана не даст исчезнуть контроллеру информационного вида и наоборот. */

@property (nonatomic, weak) UIPopoverController *popoverController;


@end


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


#import «PopoverContentViewController.h»


@interface PopoverContentViewController ()

@property (nonatomic, strong) UIButton *buttonPhoto;

@property (nonatomic, strong) UIButton *buttonAudio;

@end


@implementation PopoverContentViewController


<# Оставшаяся часть вашего кода находится здесь #>


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


— (BOOL) isInPopover{


Class popoverClass = NSClassFromString(@"UIPopoverController");


if (popoverClass!= nil &&

UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad &&

self.popoverController!= nil){

return YES;

} else {

return NO;

}


}


— (void) gotoAppleWebsite:(id)paramSender{


if ([self isInPopover]){

/* Перейти на сайт и закрыть вспомогательный экран. */

[self.popoverController dismissPopoverAnimated: YES];

} else {

/* Обработать ситуацию с iPhone. */

}


}


— (void) gotoAppleStoreWebsite:(id)paramSender{


if ([self isInPopover]){

/* Перейти на сайт и закрыть вспомогательный экран. */

[self.popoverController dismissPopoverAnimated: YES];

} else {

/* Обработать ситуацию с iPhone. */

}


}


— (void)viewDidLoad{

[super viewDidLoad];


self.contentSizeForViewInPopover = CGSizeMake(200.0f, 125.0f);


CGRect buttonRect = CGRectMake(20.0f,

20.0f,

160.0f,

37.0f);


self.buttonPhoto = [UIButton buttonWithType: UIButtonTypeRoundedRect];

[self.buttonPhoto setTitle:@"Photo"

forState: UIControlStateNormal];

[self.buttonPhoto addTarget: self

action:@selector(gotoAppleWebsite:)

forControlEvents: UIControlEventTouchUpInside];


self.buttonPhoto.frame = buttonRect;


[self.view addSubview: self.buttonPhoto];


buttonRect.origin.y += 50.0f;

self.buttonAudio = [UIButton buttonWithType: UIButtonTypeRoundedRect];


[self.buttonAudio setTitle:@"Audio"

forState: UIControlStateNormal];

[self.buttonAudio addTarget: self

action:@selector(gotoAppleStoreWebsite:)

forControlEvents: UIControlEventTouchUpInside];


self.buttonAudio.frame = buttonRect;


[self.view addSubview: self.buttonAudio];


}


Теперь в методе viewDidLoad корневого контроллера вида создадим навигационную кнопку. В зависимости от типа устройства при нажатии навигационной кнопки мы будем отображать либо вспомогательный экран (на iPad), либо предупреждающий вид (на iPhone):


— (void)viewDidLoad{

[super viewDidLoad];


/* Проверяем, существует ли этот класс в том варианте iOS,

где действует приложение. */

Class popoverClass = NSClassFromString(@"UIPopoverController");


if (popoverClass!= nil &&

UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad){


PopoverContentViewController *content =

[[PopoverContentViewController alloc] initWithNibName: nil

bundle: nil];


self.popoverController = [[UIPopoverController alloc]

initWithContentViewController: content];


content.popoverController = self.popoverController;


self.barButtonAdd = [[UIBarButtonItem alloc]

initWithBarButtonSystemItem: UIBarButtonSystemItemAdd

target: self

action:@selector(performAddWithPopover:)];


} else {


self.barButtonAdd = [[UIBarButtonItem alloc]

initWithBarButtonSystemItem: UIBarButtonSystemItemAdd

target: self

action:@selector(performAddWithAlertView:)];


}


[self.navigationItem setRightBarButtonItem: self.barButtonAdd

animated: NO];


}

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


убрать рекламу






ень важно. Контроллер вспомогательного экрана невозможно инициализировать в отсутствие контроллера информационного вида. Как только контроллер вспомогательного экрана инициализирован посредством контроллера информационного вида, можно продолжать работу и изменять контроллер информационного вида в контроллере вспомогательного экрана — но этого нельзя делать в процессе инициализации.

Мы решили, что при нажатии навигационной кнопки + на устройстве iPad будет запускаться метод performAddWithPopover:. Если мы имеем дело не с iPad, то нужно, чтобы при нажатии этой кнопки запускался метод performAddWithAlertView:. Итак, реализуем два этих метода, а также позаботимся о методах делегатов предупреждающего вида — чтобы нам было известно, какую кнопку в предупреждающем виде нажимает пользователь, работающий с iPhone:


— (NSString *) photoButtonTitle{

return @"Photo";

}


— (NSString *) audioButtonTitle{

return @"Audio";

}


— (void) alertView:(UIAlertView *)alertView

didDismissWithButtonIndex:(NSInteger)buttonIndex{


NSString *buttonTitle = [alertView buttonTitleAtIndex: buttonIndex];


if ([buttonTitle isEqualToString: [self photoButtonTitle]]){

/* Добавляем фотографию… */

}

else if ([buttonTitle isEqualToString: [self audioButtonTitle]]){

/* Добавляем аудио… */

}


}


— (void) performAddWithAlertView:(id)paramSender{


[[[UIAlertView alloc] initWithTitle: nil

message:@"Add…"

delegate: self

cancelButtonTitle:@"Cancel"

otherButtonTitles:

[self photoButtonTitle],

[self audioButtonTitle], nil] show];


}


— (void) performAddWithPopover:(id)paramSender{

[self.popoverController

presentPopoverFromBarButtonItem: self.barButtonAdd

permittedArrowDirections: UIPopoverArrowDirectionAny

animated: YES];


}


Если запустить это приложение в эмуляторе iPad, то при нажатии кнопки + на навигационной панели мы увидим примерно такой интерфейс, как на рис. 1.79.




Рис. 1.79. Простой вспомогательный экран, отображаемый после нажатия навигационной кнопки


Если запустить это же универсальное приложение в эмуляторе iPhone и нажать на навигационной панели кнопку +, результат будет примерно как на рис. 1.80.




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


Здесь мы воспользовались важным свойством контроллера информационного вида: preferredContentSize. Когда вспомогательный экран отображает контроллер своего информационного вида, он будет автоматически считывать значение этого свойства и корректировать свой размер (высоту и ширину). Кроме того, мы использовали метод presentPopoverFromBarButtonItem: permittedArrowDirections: animated: вспомогательного экрана в корневом контроллере нашего вида. Этот метод нужен, чтобы вспомогательный экран отображался над кнопкой навигационной панели. Первый параметр, принимаемый данным методом, — это кнопка навигационной панели, та, над которой должен всплывать контроллер вспомогательного экрана. Второй параметр указывает при появлении вспомогательного экрана направление его развертывания относительно объекта, из которого он появляется. Например, на рис. 1.79 видно, что стрелка вспомогательного экрана указывает вверх от кнопки с навигационной панели. Значение, передаваемое этому параметру, должно относиться к типу UIPopoverArrowDirection::


typedef NS_OPTIONS(NSUInteger, UIPopoverArrowDirection) {

UIPopoverArrowDirectionUp = 1UL << 0,

UIPopoverArrowDirectionDown = 1UL << 1,

UIPopoverArrowDirectionLeft = 1UL << 2,

UIPopoverArrowDirectionRight = 1UL << 3,

UIPopoverArrowDirectionAny = UIPopoverArrowDirectionUp |

UIPopoverArrowDirectionDown |

UIPopoverArrowDirectionLeft |

UIPopoverArrowDirectionRight,

UIPopoverArrowDirectionUnknown =

NSUIntegerMax

};

См. также

 Сделать закладку на этом месте книги

Разделы 1.9 и 1.15.

Глава 2. Создание динамических и интерактивных пользовательских интерфейсов

 Сделать закладку на этом месте книги

2.0. Введение

 Сделать закладку на этом месте книги

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

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

Приведу другой пример. Допустим, у вас есть приложение для обмена фотографиями, работающее на iPad. В левой части экрана находятся несколько картинок, которые были извлечены из пользовательского фотоальбома на Рабочий стол. Справа расположен компонент, напоминающий корзину. Каждая фотография, перенесенная в корзину, будет доступна для пакетного совместного использования через какую-нибудь социальную сеть, например Facebook. Вы хотите обогатить интерактивность приложения с помощью анимации так, чтобы пользователь мог «кидать» фотографии в корзину слева, а фотографии закреплялись в корзине. Все это можно было сделать и раньше, но для выполнения таких операций требовались глубокие знания Core Animation, а также довольно хорошее понимание физики.

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

Apple категоризировала такие действия в классах поведений , которые можно прикреплять к аниматору . Например, вы можете добавить к кнопке в вашем виде тяготение . В таком случае кнопка будет падать из верхней части вида (если вы ее там поместили) до самого его низа и даже сможет выпадать за его пределы. Если вы хотите этому воспрепятствовать и сделать так, чтобы кнопка падала только до дна вида и не дальше, то к аниматору нужно прикрепить и другое поведение — столкновение . Аниматор будет управлять поведениями, которые вы добавите к разным видам вашего приложения, а также их взаимодействиями. Вам не придется об этом беспокоиться. Далее перечислены несколько классов, обеспечивающих различное поведение компонентов пользовательского интерфейса:

• UICollisionBehavior — обеспечивает обнаружение столкновений;

• UIGravityBehavior — как понятно из названия, обеспечивает имитацию тяготения;

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

• UISnapBehavior — обеспечивает прикрепление видов к тем или иным местам на экране.


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

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

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

2.1. Добавление тяготения к компонентам пользовательского интерфейса

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

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

Решение

 Сделать закладку на этом месте книги

Инициализируйте объект типа UIGravityBehavior и добавьте к нему те компоненты пользовательского интерфейса, которые должны испытывать тяготение к этому объекту. Сделав это, создайте экземпляр UIDynamicAnimator, добавьте к аниматору поведение тяготения, а всю остальную работу аниматор сделает за вас.

Обсуждение

 Сделать закладку на этом месте книги

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

Итак, определим аниматор и вид:


#import «ViewController.h»


@interface ViewController ()

@property (nonatomic, strong) UIView *squareView;

@property (nonatomic, strong) UIDynamicAnimator *animator;

@end


@implementation ViewController


<# Оставшаяся часть кода вашего контроллера вида находится здесь #>


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


— (void)viewDidAppear:(BOOL)animated{

[super viewDidAppear: animated];


/* Создаем маленький квадратный вид и добавляем его к self.view */

self.squareView = [[UIView alloc] initWithFrame:

CGRectMake(0.0f, 0.0f, 100.0f, 100.0f)];

self.squareView.backgroundColor = [UIColor greenColor];

self.squareView.center = self.view.center;

[self.view addSubview: self.squareView];


/* Создаем аниматор и реализуем тяготение */

self.animator = [[UIDynamicAnimator alloc]

initWithReferenceView: self.view];


UIGravityBehavior *gravity = [[UIGravityBehavior alloc]

initWithItems:@[self.squareView]];


[self.animator addBehavior: gravity];


}

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

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

См. также

 Сделать закладку на этом месте книги

Раздел 2.0.

2.2. Обнаружение столкновений между компонентами пользовательского интерфейса и реагирование на них

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

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

Решение

 Сделать закладку на этом месте книги

Инстанцируйте объект типа UICollisionBehavior и прикрепите его к объекту аниматора. Присвойте свойству translatesReferenceBoundsIntoBoundary поведения столкновений значение YES и убедитесь в том, что аниматор инициализирован с вышестоящим видом в качестве опорной сущности. Так вы гарантируете, что дочерние виды, на которые распространяется поведение столкновения (о чем мы вскоре поговорим), не будут выпадать за пределы вышестоящего вида.

Обсуждение

 Сделать закладку на этом месте книги

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

Если вы хотите, чтобы границы области, в которой действует поведение столкновения, совпадали с границами опорного вида, то присвойте свойству translatesReferenceBoundsIntoBoundary экземпляра поведения столкновения значение YES. Если хотите самостоятельно провести линии, соответствующие границам такой области, просто воспользуйтесь методом экземпляра addBoundaryWithIdentifier: fromPoint: toPoint:, относящимся к классу UICollisionBehavior.

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

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


#import «ViewController.h»


@interface ViewController ()

@property (nonatomic, strong) NSMutableArray *squareViews;

@property (nonatomic, strong) UIDynamicAnimator *animator;

@end

@implementation ViewController


<# Остаток вашего кода находится здесь #>

Потом, когда вид появится на экране, зададим поведения столкновения и тяготения и добавим их к аниматору:

— (void)viewDidAppear:(BOOL)animated{

[super viewDidAppear: animated];


/* Создаем виды */

NSUInteger const NumberOfViews = 2;


self.squareViews = [[NSMutableArray alloc] initWithCapacity: NumberOfViews];

NSArray *colors = @[[UIColor redColor], [UIColor greenColor]];


CGPoint currentCenterPoint = self.view.center;

CGSize eachViewSize = CGSizeMake(50.0f, 50.0f);

for (NSUInteger counter = 0; counter < NumberOfViews; counter++){


UIView *newView =

[[UIView alloc] initWithFrame:

CGRectMake(0.0f, 0.0f, eachViewSize.width, eachViewSize.height)];


newView.backgroundColor = colors[counter];

newView.center = currentCenterPoint;


currentCenterPoint.y += eachViewSize.height + 10.0f;


[self.view addSubview: newView];


[self.squareViews addObject: newView];


}


self.animator = [[UIDynamicAnimator alloc]

initWithReferenceView: self.view];


/* Создаем тяготение */

UIGravityBehavior *gravity = [[UIGravityBehavior alloc]

initWithItems: self.squareViews];

[self.animator addBehavior: gravity];


/* Реализуем обнаружение столкновений */

UICollisionBehavior *collision = [[UICollisionBehavior alloc]

initWithItems: self.squareViews];

collision.translatesReferenceBoundsIntoBoundary = YES;

[self.animator addBehavior: collision];

}


Получим примерно такой же результат, как на рис. 2.1.




Рис. 2.1. Взаимодействующие поведения тяготения и столкновения


В этом примере показано, что поведение обнаружения столкновений работает отлично, если свойство translatesReferenceBoundsIntoBoundary имеет значение YES. Но что, если мы захотим очертить собственные границы столкновений? Здесь и пригодится метод экземпляра addBoundaryWithIdentifier: fromPoint: toPoint:, относящийся к поведению столкновения. Вот параметры, которые следует передать этому методу:

• addBoundaryWithIdentifier — строковый идентификатор для вашей границы. Он используется для того, чтобы впоследствии вы могли получить от границы информацию о столкновении. Вы могли бы передать такой же идентификатор методу boundaryWithIdentifier: и получить в ответ объект границы. Объект относится к типу UIBezierPath и может поддерживать довольно сложные, сильно искривленные границы. Но большинство программистов предпочитают указывать простые горизонтальные или вертикальные границы, что мы и сделаем;

• fromPoint — начальная точка границы, относится к типу CGPoint;

• toPoint — конечная точка границы, относится к типу CGPoint.


Итак, предположим, что вы хотите провести границу в нижней части опорного вида (в данном случае вида с контроллером), но не хотите, чтобы она совпадала с нижним краем. Вместо этого вам нужна граница, расположенная на 100 точек выше нижнего края. В таком случае свойство поведения столкновения translatesReferenceBoundsIntoBoundary не поможет, так как вы хотите задать иную границу, не совпадающую с пределами опорного вида. Нужно воспользоваться методом addBoundaryWithIdentifier: fromPoint: toPoint:, вот так:


/* Создаем обнаружение столкновений */

UICollisionBehavior *collision = [[UICollisionBehavior alloc]

initWithItems: self.squareViews];

[collision

addBoundaryWithIdentifier:@"bottomBoundary"

fromPoint: CGPointMake(0.0f, self.view.bounds.size.height — 100.0f)

toPoint: CGPointMake(self.view.bounds.size.width,

self.view.bounds.size.height — 100.0f)];


[self.animator addBehavior: collision];


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

• collisionBehavior: beganContactForItem: withBoundaryIdentifier: atPoint: — вызывается в делегате, когда один из элементов, обладающих поведением столкновения, ударяется об одну из границ, добавленных к этому поведению;

• collisionBehavior: endedContactForItem: withBoundaryIdentifier: atPoint: — вызывается, когда элемент, столкнувшийся с границей, отскочил от нее и, таким образом, контакт элемента с границей прекратился.


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


NSString *const kBottomBoundary = @"bottomBoundary";


@interface ViewController () <UICollisionBehaviorDelegate>

@property (nonatomic, strong) NSMutableArray *squareViews;

@property (nonatomic, strong) UIDynamicAnimator *animator;

@end


@implementation ViewController


— (void)collisionBehavior:(UICollisionBehavior*)paramBehavior

beganContactForItem:(id <UIDynamicItem>)paramItem

withBoundaryIdentifier:(id <NSCopying>)paramIdentifier

atPoint:(CGPoint)paramPoint{


NSString *identifier = (NSString *)paramIdentifier;


if ([identifier isEqualToString: kBottomBoundary]){


[UIView animateWithDuration:1.0f animations: ^{

UIView *view = (UIView *)paramItem;


view.backgroundColor = [UIColor redColor];

view.alpha = 0.0f;

view.transform = CGAffineTransformMakeScale(2.0f, 2.0f);

} completion: ^(BOOL finished) {

UIView *view = (UIView *)paramItem;

[paramBehavior removeItem: paramItem];

[view removeFromSuperview];

}];


}


}


— (void)viewDidAppearBOOL)animated{

[super viewDidAppear: animated];


/* Создаем виды */

NSUInteger const NumberOfViews = 2;


self.squareViews = [[NSMutableArray alloc] initWithCapacity: NumberOfViews];

NSArray *colors = @[[UIColor redColor], [UIColor greenColor]];


CGPoint currentCenterPoint = CGPointMake(self.view.center.x, 0.0f);

CGSize eachViewSize = CGSizeMake(50.0f, 50.0f);

for (NSUInteger counter = 0; counter < NumberOfViews; counter++){


UIView *newView =

[[UIView alloc] initWithFrame:

CGRectMake(0.0f, 0.0f, eachViewSize.width, eachViewSize.height)];


newView.backgroundColor = colors[counter];

newView.center = currentCenterPoint;


currentCenterPoint.y += eachViewSize.height + 10.0f;

[self.view addSubview: newView];


[self.squareViews addObject: newView];


}


self.animator = [[UIDynamicAnimator alloc]

initWithReferenceView: self.view];


/* Создаем тяготение */

UIGravityBehavior *gravity = [[UIGravityBehavior alloc]

initWithItems: self.squareViews];

[self.animator addBehavior: gravity];


/* Создаем обнаружение столкновений */

UICollisionBehavior *collision = [[UICollisionBehavior alloc]

initWithItems: self.squareViews];

[collision

addBoundaryWithIdentifier: kBottomBoundary

fromPoint: CGPointMake(0.0f, self.view.bounds.size.height — 100.0f)

toPoint: CGPointMake(self.view.bounds.size.width,

self.view.bounds.size.height — 100.0f)];

collision.collisionDelegate = self;


[self.animator addBehavior: collision];


}


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

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


убрать рекламу






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

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

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

• UICollisionBehaviorModeItems — при таком значении поведение будет регистрировать столкновения между динамическими элементами — в данном случае между движущимися квадратиками;

• UICollisionBehaviorModeBoundaries — при этом значении регистрируются столкновения между динамическими элементами и установленными нами границами, расположенными в опорном виде;

• UICollisionBehaviorModeEverything — при таком значении регистрируются любые столкновения, независимо от того, участвуют в них сами элементы, элементы и границы или что-либо еще. Это значение для данного свойства задается по умолчанию.

Можно комбинировать рассмотренные ранее значения с помощью побитового оператора ИЛИ и создавать сочетания режимов столкновения, соответствующие поставленным перед вами бизнес-требованиям.

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

См. также

 Сделать закладку на этом месте книги

Раздел 2.1.

2.3. Анимирование компонентов пользовательского интерфейса с помощью толчков

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

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

Решение

 Сделать закладку на этом месте книги

Инициализируйте объект поведения типа UIPushBehavior с помощью относящегося к нему метода initWithItems: mode: и передайте ему значение UIPushBehaviorModeContinuous. Как только будете готовы толкать элементы под углом, вызовите для толчка метод setAngle:. Этот метод задает угол (в радианах) для данного поведения. Затем потребуется установить магнитуду , то есть силу толчка. Эта величина задается с помощью относящегося к толчку поведения setMagnitude:. Магнитуда рассчитывается следующим образом: магнитуда величиной 1 точка соответствует ускорению 100 точек/с2, прилагаемому к целевым видам.

Обсуждение

 Сделать закладку на этом месте книги

Толчки, прилагаемые к экранным элементам, очень полезны — особенно толчки, вызывающие непрерывное движение. Допустим, вы разрабатываете приложение-фотоальбом для iPad. В верхней части экрана создали три слайда, каждый из которых соответствует странице альбома, созданной пользователем. В нижней части экрана располагаются различные картинки, которые пользователь может перетаскивать и раскладывать на страницах. Один из способов, позволяющих реализовать для пользователя такую возможность, — добавление к опорному виду регистратора жестов касания (tap gesture recognizer), создание которого рассмотрено в разделе 10.5. Этот регистратор обеспечивает отслеживание пользовательских жестов касания и позволяет перемещать изображения на целевой слайд. Процесс выглядит как перетаскивание. Другой, пожалуй, более оптимальный способ решения этой задачи — использование толчкового поведения, которое разработчики Apple включили в UIKit.

Толчковое поведение относится к типу UIPushBehavior и обладает магнитудой и углом. Угол измеряется в радианах, а магнитуда в 1 точку приводит к ускорению движения, равному 100 точек/с2. Толчковые поведения создаются точно так же, как и любые другие: сначала их необходимо инициализировать, а потом добавить к аниматору типа UIDynamicAnimator.

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

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

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




Рис. 2.2. Расчет угла между двумя точками


Итак, начнем с определения всех важных свойств нашего контроллера вида:


#import «ViewController.h»


@interface ViewController ()

@property (nonatomic, strong) UIView *squareView;

@property (nonatomic, strong) UIDynamicAnimator *animator;

@property (nonatomic, strong) UIPushBehavior *pushBehavior;

@end

@implementation ViewController


<# Остальной ваш код находится здесь #>

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

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


— (void) createSmallSquareView{

self.squareView =

[[UIView alloc] initWithFrame:

CGRectMake(0.0f, 0.0f, 80.0f, 80.0f)];

self.squareView.backgroundColor = [UIColor greenColor];


self.squareView.center = self.view.center;


[self.view addSubview: self.squareView];

}

Затем применим регистратор жестов касания, чтобы обнаруживать прикосновения к виду с контроллером:

— (void) createGestureRecognizer{

UITapGestureRecognizer *tapGestureRecognizer =

[[UITapGestureRecognizer alloc] initWithTarget: self

action:@selector(handleTap:)];

[self.view addGestureRecognizer: tapGestureRecognizer];

}

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

И не забудем написать метод, который будет задавать поведение столкновения и толчковое поведение:


— (void) createAnimatorAndBehaviors{

self.animator = [[UIDynamicAnimator alloc]

initWithReferenceView: self.view];


/* Создаем обнаружение столкновений */

UICollisionBehavior *collision = [[UICollisionBehavior alloc]

initWithItems:@[self.squareView]];

collision.translatesReferenceBoundsIntoBoundary = YES;


self.pushBehavior = [[UIPushBehavior alloc]

initWithItems:@[self.squareView]

mode: UIPushBehaviorModeContinuous];


[self.animator addBehavior: collision];

[self.animator addBehavior: self.pushBehavior];

}


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


— (void)viewDidAppear:(BOOL)animated{

[super viewDidAppear: animated];


[self createGestureRecognizer];

[self createSmallSquareView];

[self createAnimatorAndBehaviors];


}


Отлично. Теперь, взглянув на файл реализации метода createGestureRecognizer, вы увидите, что мы устанавливаем регистратор жестов касаний в методе контроллера вида — этот метод называется handleTap:. В методе handleTap: вычисляем расстояние между центральной точкой маленького квадратного вида и той точкой опорного вида, до которой дотронулся пользователь. В результате имеем магнитуду силы толчка. Кроме того, рассчитаем угол между центром маленького квадратного вида и точкой касания, чтобы определить угол толчка:


— (void) handleTap:(UITapGestureRecognizer *)paramTap{


/* Получаем угол между центральной точкой квадратного вида и точкой касания */


CGPoint tapPoint = [paramTap locationInView: self.view];

CGPoint squareViewCenterPoint = self.squareView.center;


/* Вычисляем угол между центральной точкой квадратного вида и точкой касания, чтобы определить угол толчка

Формула для определения угла между двумя точками:

arc tangent 2((p1.x — p2.x), (p1.y — p2.y)) */


CGFloat deltaX = tapPoint.x — squareViewCenterPoint.x;

CGFloat deltaY = tapPoint.y — squareViewCenterPoint.y;

CGFloat angle = atan2(deltaY, deltaX);

[self.pushBehavior setAngle: angle];


/* Используем расстояние между точкой касания и центром квадратного вида для вычисления магнитуды толчка

Формула определения расстояния:

Квадратный корень из ((p1.x — p2.x)^2 + (p1.y — p2.y)^2) */


CGFloat distanceBetweenPoints =

sqrt(pow(tapPoint.x — squareViewCenterPoint.x, 2.0) +

pow(tapPoint.y — squareViewCenterPoint.y, 2.0));

[self.pushBehavior setMagnitude: distanceBetweenPoints / 200.0f];

}

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

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

См. также

 Сделать закладку на этом месте книги

Раздел 2.2.

2.4. Прикрепление нескольких динамических элементов друг к другу

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

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

Решение

 Сделать закладку на этом месте книги

Инстанцируйте поведение прикрепления, относящееся к типу UIAttachmentBehavior, с помощью метода экземпляра initWithItem: point: attachedToAnchor: этого класса. Добавьте это поведение к аниматору (см. раздел 2.0), отвечающему за динамику и физику движения.

Обсуждение

 Сделать закладку на этом месте книги

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

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

В этом примере мы собираемся создать такой эффект, который продемонстрирован на рис. 2.3.




Рис. 2.3. Именно такого эффекта мы хотим добиться в данном разделе с помощью поведения прикрепления


Как видите, на экране находятся три вида. Основной вид расположен в центре, в правом верхнем углу этого вида есть еще один вид, более мелкий. Маленький вид — это и есть тот элемент, который будет следовать за точкой привязки, по принципу, который я описал в примере с фотографией. Наконец, необходимо отметить, что точка привязки в данном примере будет перемещаться по экрану под действием жеста панорамирования и регистратора соответствующих жестов (см. раздел 10.3). Затем в результате таких движений станет двигаться большой вид, расположенный в центре экрана. Итак, начнем с определения необходимых свойств контроллера вида:


#import «ViewController.h»


@interface ViewController ()

@property (nonatomic, strong) UIView *squareView;

@property (nonatomic, strong) UIView *squareViewAnchorView;

@property (nonatomic, strong) UIView *anchorView;

@property (nonatomic, strong) UIDynamicAnimator *animator;

@property (nonatomic, strong) UIAttachmentBehavior *attachmentBehavior;

@end


@implementation ViewController


<# Оставшаяся часть кода контроллера вида находится здесь #>


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


— (void) createSmallSquareView{

self.squareView =

[[UIView alloc] initWithFrame:

CGRectMake(0.0f, 0.0f, 80.0f, 80.0f)];


self.squareView.backgroundColor = [UIColor greenColor];

self.squareView.center = self.view.center;


self.squareViewAnchorView = [[UIView alloc] initWithFrame:

CGRectMake(60.0f, 0.0f, 20.0f, 20.0f)];

self.squareViewAnchorView.backgroundColor = [UIColor brownColor];

[self.squareView addSubview: self.squareViewAnchorView];


[self.view addSubview: self.squareView];

}

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

— (void) createAnchorView{


self.anchorView = [[UIView alloc] initWithFrame:

CGRectMake(120.0f, 120.0f, 20.0f, 20.0f)];

self.anchorView.backgroundColor = [UIColor redColor];

[self.view addSubview: self.anchorView];


}


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


— (void) createGestureRecognizer{

UIPanGestureRecognizer *panGestureRecognizer =

[[UIPanGestureRecognizer alloc] initWithTarget: self

action:@selector(handlePan:)];

[self.view addGestureRecognizer: panGestureRecognizer];

}


— (void) createAnimatorAndBehaviors{


self.animator = [[UIDynamicAnimator alloc]

initWithReferenceView: self.view];


/* Создаем распознавание столкновений */

UICollisionBehavior *collision = [[UICollisionBehavior alloc]

initWithItems:@[self.squareView]];

collision.translatesReferenceBoundsIntoBoundary = YES;


self.attachmentBehavior = [[UIAttachmentBehavior alloc]

initWithItem: self.squareView

point: self.squareViewAnchorView.center

attachedToAnchor: self.anchorView.center];

[self.animator addBehavior: collision];

[self.animator addBehavior: self.attachmentBehavior];

}


— (void)viewDidAppear:(BOOL)animated{

[super viewDidAppear: animated];


[self createGestureRecognizer];

[self createSmallSquareView];

[self createAnchorView];

[self createAnimatorAndBehaviors];

}


Как видите, мы реализуем поведение привязки с помощью его метода экземпляра initWithItem: point: attachedToAnchor:. Этот метод принимает следующие параметры:

• initWithItem — динамический элемент (в нашем примере — вид), который должен быть подключен к точке привязки;

• point — точка внутри динамического элемента, которая должна быть соединена с точкой привязки. В данном поведении центральная точка элемента используется для установки соединения с точкой привязки. Но вы можете изменить этот параметр, присвоив ему другое значение;

• attachedToAnchor — сама точка привязки, измеряемая как значение CGPoint.

Теперь, когда мы соединили верхний правый угол квадратного вида с точкой привязки (представленной как вид точки привязки), необходимо продемонстрировать, что, двигая точку привязки, мы опосредованно будем двигать и квадратный вид. Вернемся к методу createGestureRecognizer, написанному ранее. Там мы задействовали регистратор жестов касания, который будет отслеживать движение пальца пользователя по экрану. Мы решили обрабатывать регистратор жестов в методе handlePan: вида и реализуем этот метод так:


(void) handlePan:(UIPanGestureRecognizer *)paramPan{


CGPoint tapPoint = [paramPan locationInView: self.view];

[self.attachmentBehavior setAnchorPoint: tapPoint];

self.anchorView.center = tapPoint;


}


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

См. также

 Сделать закладку на этом месте книги

Разделы 2.0 и 10.3.

2.5. Добавление эффекта динамического зацепления к компонентам пользовательского интерфейса

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

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

Решение

 Сделать закладку на этом месте книги

Инстанцируйте объект типа UISnapBehavior и добавьте его к аниматору типа UIDynamicAnimator.

Обсуждение

 Сделать закладку на этом месте книги

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

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

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


#import «ViewController.h»


@interface ViewController ()

@property (nonatomic, strong) UIView *squareView;

@property (nonatomic, strong) UIDynamicAnimator *animator;

@property (nonatomic, strong) UISnapBehavior *snapBehavior;

@end

@implementation ViewController


<# Остальной ваш код находится здесь #>

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

— (void) createGestureRecognizer{


UITapGestureRecognizer *tap = [[UITapGestureRecognizer alloc]

initWithTarget: self

action:@selector(handleTap:)];

[self.view addGestureRecognizer: tap];


}


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


— (void) createSmallSquareView{

self.squareView =

[[UIView alloc] initWithFrame:

CGRectMake(0.0f, 0.0f, 80.0f, 80.0f)];


self.squareView.backgroundColor = [UIColor greenColor];

self.squareView.center = self.view.center;


[self.view addSubview: self.squareView];

}


Переходим к созданию аниматора (см. раздел 2.0), после чего прикрепляем к нему поведение зацепления. Инициализируем поведение зацепления типа UISnapBehavior с помощью метода initWithItem: snapToPoint:. Этот метод принимает два параметра:

• initWithItem — динамический элемент (в данном случае наш вид), к которому должно применяться поведение зацепления. Как и другие динамические поведения пользовательского интерфейса, этот элемент должен соответствовать протоколу UIDynamicItem. Все экземпляры UIView по умолчанию соответствуют этому протоколу, поэтому все нормально;

• snapToPoint — точка опорного вида (см. раздел 2.0), за которую должен зацепляться динамический элемент.

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


убрать рекламу






лять это поведение к аниматору:


— (void) createAnimatorAndBehaviors{

self.animator = [[UIDynamicAnimator alloc]

initWithReferenceView: self.view];


/* Создаем обнаружение столкновений */

UICollisionBehavior *collision = [[UICollisionBehavior alloc]

initWithItems:@[self.squareView]];

collision.translatesReferenceBoundsIntoBoundary = YES;


[self.animator addBehavior: collision];


/* Пока зацепляем квадратный вид с его актуальным центром */

self.snapBehavior = [[UISnapBehavior alloc]

initWithItem: self.squareView

snapToPoint: self.squareView.center];

self.snapBehavior.damping = 0.5f; /* Medium oscillation */

[self.animator addBehavior: self.snapBehavior];

}


Как видите, здесь мы зацепляем небольшой квадратный вид, связывая его с текущим центром, — в сущности, просто оставляем его на месте. Позже, когда мы регистрируем на экране жесты касания, мы обновляем поведение зацепления. Кроме того, необходимо отметить, что мы задаем для этого поведения свойство damping. Это свойство будет управлять эластичностью, с которой элемент будет зацеплен за точку. Чем выше значение, тем меньше эластичность, соответственно, тем слабее «колышется» элемент. Здесь можно задать любое значение в диапазоне от 0 до 1. Теперь, когда вид появится на экране, вызовем эти методы, чтобы инстанцировать маленький квадратный вид, установить регистратор жестов касания, а также настроить аниматор и поведение зацепления:


— (void)viewDidAppear:(BOOL)animated{

[super viewDidAppear: animated];


[self createGestureRecognizer];

[self createSmallSquareView];

[self createAnimatorAndBehaviors];

}


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

Здесь необходимо отметить, что вы не сможете просто обновить существующее поведение — потребуется повторно его инстанцировать. Итак, прежде, чем мы инстанцируем новый экземпляр поведения зацепления, понадобится удалить старый экземпляр (при его наличии), а потом добавить к аниматору новый. У каждого аниматора может быть всего одно поведение зацепления, ассоциированное с конкретным динамическим элементом, в данном случае с маленьким квадратным видом. Если добавить к одному и тому же аниматору несколько поведений зацепления, относящихся к одному и тому же динамическому элементу, то аниматор проигнорирует все эти поведения, так как не будет знать, какое из них выполнять первым. Поэтому, чтобы поведения зацепления работали, сначала удалите все зацепления для этого элемента из вашего аниматора, воспользовавшись его методом removeBehavior:, а потом добавьте новое поведение зацепления следующим образом:


— (void) handleTap:(UITapGestureRecognizer *)paramTap{


/* Получаем угол между центром квадратного вида и точкой касания */


CGPoint tapPoint = [paramTap locationInView: self.view];


if (self.snapBehavior!= nil){

[self.animator removeBehavior: self.snapBehavior];

}


self.snapBehavior = [[UISnapBehavior alloc] initWithItem: self.squareView

snapToPoint: tapPoint];

self.snapBehavior.damping = 0.5f; /* Средняя осцилляция */

[self.animator addBehavior: self.snapBehavior];

}

См. также

 Сделать закладку на этом месте книги

Разделы 2.0 и 10.5.

2.6. Присваивание характеристик динамическим эффектам

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

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

Решение

 Сделать закладку на этом месте книги

Инстанцируйте объект типа UIDynamicItemBehavior и присвойте ему ваши динамические элементы. После инстанцирования пользуйтесь различными свойствами этого класса для изменения характеристик динамических элементов. Затем добавьте это поведение к аниматору (см. раздел 2.0) — и все остальное аниматор сделает за вас.

Обсуждение

 Сделать закладку на этом месте книги

Динамические поведения отлично подходят для добавления реалистичной физики к элементам, соответствующим протоколу UIDynamicItem, например ко всем видам типа UIView. Но в некоторых приложениях вам может понадобиться явно указать характеристики конкретного элемента. Например, в приложении, где используются эффекты тяготения и столкновения (см. разделы 2.1 и 2.2), вы, возможно, захотите указать, что один из элементов на экране, подвергающийся действию тяготения и столкновениям, должен отскакивать от границы сильнее, чем другой элемент. В другом случае, возможно, захотите указать, что в ходе воплощения различных визуальных эффектов, применяемых аниматором к элементу, этот элемент вообще не должен вращаться.

Подобные задачи решаются без труда с помощью экземпляров класса UIDynamicItemBehavior. Эти экземпляры также являются динамическими поведениями, и мы можем добавлять их к аниматору с помощью метода экземпляра addBehavior:, относящегося к классу UIDynamicAnimator, — в этой главе мы так уже делали. Когда вы инициализируете экземпляр этого класса, вы вызываете метод-инициализатор initWithItems: и передаете ваш вид либо какой угодно объект, соответствующий протоколу UIDynamicItem. В качестве альтернативы можете инициализировать экземпляр элемента с динамическим поведением с помощью метода init, а потом добавлять к этому поведению разнообразные объекты, пользуясь методом addItem:.

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

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

• resistance — сопротивление элемента движению. Это свойство может иметь значения в диапазоне от 0 до CGFLOAT_MAX. Чем выше значение, тем сильнее будет сопротивление, оказываемое элементом воздействующим на него силам (тем силам, которые вы к нему прикладываете). Например, если вы добавите к аниматору поведение тяготения и создадите в центре экрана вид с сопротивлением CGFLOAT_MAX, то тяготение не сможет сдвинуть этот вид к центру экрана. Вид просто останется там, где вы его создали.

• friction — это значение с плавающей точкой в диапазоне от 0 до 1. Оно указывает силу трения, которая должна действовать на края данного элемента, когда другие элементы соударяются с ним или проскальзывают по его краю. Чем выше значение, тем больше сила трения, применяемая к элементу.


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

• elasticity — это значение с плавающей точкой в диапазоне от 0 до 1. Оно указывает, насколько эластичным должен быть элемент. Чем выше это значение, тем более пластичным и «желеобразным» будет этот элемент с точки зрения аниматора. О том, что такое эластичность, подробно рассказано в разделе 2.5.

• density — это значение с плавающей точкой в диапазоне от 0 до 1 (по умолчанию применяется значение 1). Оно не используется непосредственно для воздействия на поведение динамических поведений элементов, но с его помощью аниматор рассчитывает массу объектов и то, как эта масса отражается на визуальных эффектах. Например, если вы столкнете один элемент с другим (см. раздел 2.3), но у одного из них будет плотность 1, а у другого — 0,5, то при одинаковых высоте и ширине обоих элементов масса первого элемента будет больше, чем масса второго. Аниматор вычисляет массу элементов, исходя из их плотности и размеров экрана. Поэтому если вы столкнете маленький вид с высокой плотностью с большим видом с очень низкой плотностью, то маленький вид, в зависимости от конкретного размера и плотности этого элемента, может быть воспринят аниматором как более массивный объект, нежели крупный вид. В таком случае, аниматор может сильнее оттолкнуть тот элемент, который на экране кажется более крупным, тогда как толчок, сообщаемый крупным элементом мелкому, получится не столь значительным.


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


#import «ViewController.h»


@interface ViewController ()

@property (nonatomic, strong) UIDynamicAnimator *animator;

@end


@implementation ViewController


<# Оставшаяся часть вашего кода находится здесь #>


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


— (UIView *) newViewWithCenter:(CGPoint)paramCenter

backgroundColor:(UIColor *)paramBackgroundColor{


UIView *newView =

[[UIView alloc] initWithFrame:

CGRectMake(0.0f, 0.0f, 50.0f, 50.0f)];

newView.backgroundColor = paramBackgroundColor;

newView.center = paramCenter;


return newView;


}


Теперь, как только основной вид отобразится на экране, создадим два этих вида и также выведем их на дисплей:


UIView *topView = [self newViewWithCenter: CGPointMake(100.0f, 0.0f)

backgroundColor: [UIColor greenColor]];

UIView *bottomView = [self newViewWithCenter: CGPointMake(100.0f, 50.0f)

backgroundColor: [UIColor redColor]];


[self.view addSubview: topView];

[self.view addSubview: bottomView];

Далее добавим к видам поведение тяготения — этому мы научились в разделе 2.1:

self.animator = [[UIDynamicAnimator alloc]

initWithReferenceView: self.view];


/* Создаем тяготение */

UIGravityBehavior *gravity = [[UIGravityBehavior alloc]

initWithItems:@[topView, bottomView]];

[self.animator addBehavior: gravity];


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


/* Создаем обнаружение столкновений */

UICollisionBehavior *collision = [[UICollisionBehavior alloc]

initWithItems:@[topView, bottomView]];

collision.translatesReferenceBoundsIntoBoundary = YES;


[self.animator addBehavior: collision];

Наконец, очень важно добавить видам динамическое поведение, чтобы сделать верхний вид менее эластичным, чем нижний:

/* Теперь указываем эластичность элементов */

UIDynamicItemBehavior *moreElasticItem = [[UIDynamicItemBehavior alloc]

initWithItems:@[bottomView]];


moreElasticItem.elasticity = 1.0f;

UIDynamicItemBehavior *lessElasticItem = [[UIDynamicItemBehavior alloc]

initWithItems:@[topView]];

lessElasticItem.elasticity = 0.5f;

[self.animator addBehavior: moreElasticItem];

[self.animator addBehavior: lessElasticItem];


Итак, можете запустить приложение и посмотреть, как виды будут отскакивать от нижней границы экрана, как только ударятся об нее (рис. 2.4).




Рис. 2.4. Один вид эластичнее другого

См. также

 Сделать закладку на этом месте книги

Раздел 2.0.

Глава3. Автоматическая компоновка и язык визуального форматирования

 Сделать закладку на этом месте книги

3.0. Введение

 Сделать закладку на этом месте книги

Выравнивание компонентов пользовательского интерфейса всегда было для программиста большой проблемой. В большинстве контроллеров видов в сложных приложениях для iOS содержится множество кода, решающего такие якобы тривиальные задачи, как упорядочение на экране фрейма с графическими элементами, выравнивание компонентов по горизонтали и вертикали и обеспечение того, что компоненты будут нормально выглядеть в различных версиях iOS. Причем проблема не только в этом, ведь многие программисты желают пользоваться одними и теми же контроллерами видов на разных устройствах, например на iPhone и iPad. Из-за этого код дополнительно усложняется. Apple упростила для нас решение таких задач, предоставив возможность автоматической компоновки (Auto Layout). Автоматическая компоновка, давно применявшаяся в OS X, теперь реализована и в iOS. Чуть позже мы подробно поговорим об автоматической компоновке, но для начала я позволю себе краткое введение и расскажу, для чего она нужна.

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

• свойство кнопки center.x равно свойству вида center.x;

• свойство кнопки center.y равно свойству вида center.y.

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


object1.property1 = (object2.property2 * multiplier) + constant value


Например, воспользовавшись этой формулой, я могу без труда центрировать кнопку в ее вышестоящем виде, вот так:


button.center.x = (button.superview.center.x * 1) + 0

button.center.y = (button.superview.center.y * 1) + 0


С помощью этой же формулы вы можете делать некоторые по-настоящему отличные вещи при разработке пользовательского интерфейса приложений для iOS — вещи, которые ранее были просто неосуществимы. В iOS SDK вышеупомянутая формула обернута в класс, который называется NSLayoutConstraint. Каждый экземпляр этого класса соответствует ровно одному ограничению. Например, если вы хотите расположить кнопку в центре вида, владеющего этой кнопкой, то требуется центрировать координаты x  и y  этой кнопки. Таким образом, речь идет о создании двух ограничений. Но далее в этой главе мы познакомимся с языком визуального форматирования (Visual Format Language). Он отлично дополняет язык программирования для iOS и еще сильнее упрощает работу с макетами пользовательского интерфейса.

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

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

• Если ограничение находится между видом и его родительским видом, добавьте ограничение к родительскому виду.

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


На рис. 3.1 показано, как именно действуют эти ограничения.




Рис. 3.1. Отношения между ограничениями и видами, к которым эти ограничения должны добавляться


Ограничения создаются с помощью метода класса constraintWithItem: attribute: related By: toItem: attribute: multiplier: constant:, который относится к классу NSLayoutConstraint. Этот метод принимает следующие параметры:

• constraintWithItem — параметр типа id. Он соответствует объекту object1 в формуле, рассмотренной ранее;

• attribute — этот параметр представляет свойство property1 в вышеупомянутой формуле и должен относиться к типу NSLayoutAttribute;

• relatedBy — параметр соответствует знаку равенства в нашей формуле. Значение этого параметра относится к типу NSLayoutRelation и, как вы вскоре убедитесь, может выступать не только в качестве знака равенства, но и в роли знаков «больше» и «меньше». Мы подробно обсудим эти нюансы в данной главе;

• toItem — это параметр типа id. Он соответствует объекту object2 в формуле, рассмотренной ранее;

• attribute — параметр представляет свойство property2 в вышеупомянутой формуле и должен относиться к типу NSLayoutAttribute;

• multiplier — это параметр типа CGFloat, представляющий множитель в нашей формуле;

• constant — параметр также относится к типу CGFloat и представляет константу в формуле.


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

• addConstraint: — метод позволяет добавить к виду одно ограничение типа NSLayoutConstraint;

• addConstraints: — этот метод позволяет добавить к виду массив ограничений. Ограничения должны относиться к типу NSLayoutConstraint, но в данном случае они будут обернуты в массив типа NSArray.


Автоматическая компоновка позволяет решать разнообразные задачи, в чем вы убедитесь в оставшейся части этой главы. Тем не менее чем подробнее вы будете знакомиться с этой темой, тем очевиднее будет становиться следующий факт: применяя автоматическую компоновку, вы вынуждены создавать все новые ограничения типа NSLayoutConstraint. Из-за этого ваш код будет разрастаться, а поддержка его — постоянно усложняться. Именно поэтому компания Apple разработала язык визуального форматирования, на котором можно описывать ограничения, пользуясь обычными символами ASCII. Например, если у вас есть две кнопки и вы хотите, чтобы по горизонтали эти кнопки всегда отстояли друг от друга на 100 точек, то нужно написать на языке визуального форматирования подобный код:


[button1]-100-[button2]


Ограничения, выражаемые на языке визуального форматирования, создаются с помощью метода класса constraintsWithVisualFormat: options: metrics: views:, относящегося к классу NSLayoutConstraint. Вот краткое описание каждого из параметров этого метода:

• constraintsWithVisualFormat — выражение на языке визуального форматирования, записанное как NSString;

• options — параметр типа NSLayoutFormatOptions. При работе с языком визуального форматирования этому параметру обычно передается значение 0;

• metrics — словарь констант, которые вы используете в выражении на языке визуального форматирования. Пока ради упрощения примеров будем передавать этому параметру значение nil;

• views — это словарь видов, для которых вы написали ограничение в первом параметре данного метода. Чтобы создать такой словарь, просто воспользуйтесь функцией NSDictionaryOfVariableBindings из языка C и передайте этому методу ваши новые объекты. Ключи в этом словаре — это названия видов, которые вы должны использовать в первом параметре метода. Не переживайте, если пока все это кажется странным и даже бессмысленным. Вскоре все будет понятно! Как только вы изучите несколько примеров, сразу получится стройная картина.


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

3.1. Размещение компонентов пользовательского интерфейса в центре экрана

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

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

Решение

 Сделать закладку на этом месте книги

Создайте два ограничения: одно для выравнивания позиции center.x целевого вида по позиции center.x вышестоящего вида, другое — для выравнивания позиции center.y целевого вида по позиции center.y вышестоящего вида.

Обсуждение

 Сделать закладку на этом месте книги

Начнем с создания простой кнопки, которую выровняем по центру экрана. Как было указано в подразделе «Решение» текущего раздела, для этого всего лишь требуется гарантировать, что координаты x  и y  центра нашей кнопки будут соответствовать координатам x  и y  центра того вида, в котором находится кнопка. Для этого мы напишем два ограничения и добавим их к виду, включающему нашу кнопку (вышестоящему виду этой кнопки). Вот простой код, позволяющий добиться такого эффекта:


#import «ViewController.h»


@interface ViewController ()

@property (nonatomic, strong) UIButton *button;

@end


@implementation ViewController


— (void)viewDidLoad{

[super viewDidLoad];


/* 1) Создаем кнопку */

self.button = [UIButton buttonWithType: UIButtonTypeSystem];

self.button.translatesAutoresizingMaskIntoConstraints = NO;

[self.button setTitle:@"Button" forState: UIControlStateNormal];

[self.view addSubview: self.button];


UIView *superview = self.button.superview;


/* 2) Создаем ограничение для центрирования кнопки по горизонтали */

NSLayoutConstraint *centerXConstraint =

[NSLayoutConstraint constraintWithItem: self.button

attribute: NSLayoutAttributeCenterX

relatedBy: NSLayoutRelationEqual

toItem: superview

attribute: NSLayoutAttributeCenterX

multiplier:1.0f

constant:0.0f];


/* 3) Создаем ограничение для центрирования кнопки по вертикали */

NSLayoutConstraint *centerYConstraint =

[NSLayoutConstraint constraintWithItem: self.button

attribute: NSLayoutAttributeCenterY

relatedBy: NSLayoutRelationEqual

toItem: superview

attribute: NSLayoutAttributeCenterY

multiplier:1.0f

constant:0.0f];


/* Добавляем ограничения к вышестоящему виду кнопки */

[superview addConstraints:@[centerXConstraint, centerYConstraint]];


}


@end

Этот контроллер вида пытается сообщить iOS, что он поддерживает все возможные ориентации интерфейса, применимые на этом устройстве. Этот факт подтверждает, что кнопка действительно будет расположена в центре экрана, независимо от типа устройства и его ориентации. Тем не менее, прежде чем этот метод начнет действовать, вы должны убедиться, что активировали все необходимые виды ориентации внутри самого проекта. Для этого перейдите в Xcode к свойствам целевого проекта, откройте вкладку General (Общие), а в ней найдите раздел Device Orientation (Ориентация устройства). Затем активизируйте все возможные виды ориентации (рис. 3.2).



Рис. 3.2. Активизируем в Xcode все виды ориентации, поддерживаемые для целевого проекта


Теперь, если запустить это приложение на устройстве или эмуляторе, вы увидите на экране обычную кнопку. Сколько бы вы ни вращали устройство, кнопка никуда не сдвигается с центра экрана. Мы смогли достичь этого, не написав ни строки кода для настройки фрейма кнопки, а также без прослушивания каких-либо изменений ориентации и без корректирования положения кнопки. Фактически здесь были применены только возможности автоматической компоновки (рис. 3.3). Этот подход выигрышен по той простой причине, что наш код теперь будет работать на любом устройстве, независимо от его ориентации и разрешения экрана. Напротив, если бы мы программировали фрейм для компонентов пользовательского интерфейса, то пришлось бы создавать отдельные фреймы для каждого целевого устройства во всех интересующих нас ориентациях, поскольку на разных устройствах с iOS могут использоваться экраны с довольно несхожими разрешениями. В частности, приложение, написанное в этом разделе, будет отлично работать и на iPad, и на iPhone, причем кнопка будет находиться в центре экрана независимо от ориентации устройства и разрешения его экрана.




Рис. 3.3. Кнопка остается в центре экрана при любой ориентации

См. также

 
убрать рекламу






5884743 onclick=setCookie('390376','635884743'); return false;>Сделать закладку на этом месте книги

Разделы 3.0 и 3.2.

3.2. Определение горизонтальных и вертикальных ограничений на языке визуального форматирования

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

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

Решение

 Сделать закладку на этом месте книги

В строке форматирования ограничения пользуйтесь указателем ориентации H:, чтобы задать выравнивание по горизонтали, и указателем V: для выравнивания по вертикали.

Обсуждение

 Сделать закладку на этом месте книги

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

1. Кнопка должна находиться на расстоянии 100 точек от каждого из краев ее вышестоящего вида:


H:|-100-[_button]-100-|


2. Кнопка должна находиться на расстоянии 100 точек или менее от левого края вышестоящего вида. Кроме того, ее ширина должна быть не меньше 50 точек, а расстояние между кнопкой и правым краем вышестоящего вида должно составлять 100 точек или менее:


H:|-(<=100)-[_button(>=50)]-(<=100)-|


3. Кнопка должна находиться на стандартном расстоянии от левого края вышестоящего вида (стандартные расстояния определяются Apple) и иметь ширину не менее 100, но не более 200 точек:


H:|-[_button(>=100,<=200)]


Как видите, может понадобиться некоторое время, чтобы привыкнуть к правилам форматирования. Но, как только вы усвоите основы этого процесса, он постепенно начнет укладываться у вас в голове. Аналогичные правила применяются и к выравниванию по вертикали, при котором используется указатель ориентации V:, например:


V:[_button]-(>=100)-|


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

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




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

Чтобы дизайнерам было проще принимать решения, а сами приложения выглядели более единообразно, Apple регламентирует стандартные расстояния (пробелы), которые следует оставлять между компонентами пользовательского интерфейса. Эти стандарты описаны в документе iOS Human Interface Guidelines.

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

• Поле для адреса электронной почты имеет стандартное расстояние по вертикали до верхней границы вида.

• Поле для подтверждения адреса электронной почты имеет стандартное расстояние по вертикали до поля с адресом электронной почты.

• Кнопка Register (Зарегистрировать) имеет стандартное расстояние по вертикали до поля для подтверждения адреса электронной почты.

• Все компоненты центрированы по горизонтали относительно родительского (вышестоящего) вида.

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

• Ширина кнопки является фиксированной и составляет 128 точек.


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


/* Ограничения для поля с адресом электронной почты */

NSString *const kEmailTextFieldHorizontal = @"H:|-[_textFieldEmail]-|";

NSString *const kEmailTextFieldVertical = @"V:|-[_textFieldEmail]";


/* Ограничения для поля, в котором подтверждается адрес электронной почты */

NSString *const kConfirmEmailHorizontal = @"H:|-[_textFieldConfirmEmail]-|";

NSString *const kConfirmEmailVertical =

@"V:[_textFieldEmail]-[_textFieldConfirmEmail]";


/* Ограничение для регистрационной кнопки */

NSString *const kRegisterVertical =

@"V:[_textFieldConfirmEmail]-[_registerButton]";


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

Теперь определим компоненты пользовательского интерфейса как закрытые (приватные) свойства в файле реализации контроллера вида:


@interface ViewController ()

@property (nonatomic, strong) UITextField *textFieldEmail;

@property (nonatomic, strong) UITextField *textFieldConfirmEmail;

@property (nonatomic, strong) UIButton *registerButton;

@end


@implementation ViewController


<# Оставшаяся часть вашего кода находится здесь #>


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


— (UITextField *) textFieldWithPlaceholder:(NSString *)paramPlaceholder{


UITextField *result = [[UITextField alloc] init];

result.translatesAutoresizingMaskIntoConstraints = NO;

result.borderStyle = UITextBorderStyleRoundedRect;

result.placeholder = paramPlaceholder;

return result;


}


— (void) constructUIComponents{


self.textFieldEmail =

[self textFieldWithPlaceholder:@"Email"];


self.textFieldConfirmEmail =

[self textFieldWithPlaceholder:@"Confirm Email"];


self.registerButton = [UIButton buttonWithType: UIButtonTypeSystem];

self.registerButton.translatesAutoresizingMaskIntoConstraints = NO;

[self.registerButton setTitle:@"Register" forState: UIControlStateNormal];


}


Метод textFieldWithPlaceholder: просто создает текстовые поля, содержащие заданный подстановочный текст, а метод constructUIComponents, в свою очередь, создает два текстовых поля, пользуясь вышеупомянутым методом и кнопкой. Вы, вероятно, заметили, что мы присвоили свойству translatesAutoresizingMaskIntoConstraints всех наших компонентов пользовательского интерфейса значение NO. Так мы помогаем UIKit не перепутать маски автоматической подгонки размеров с ограничениями автоматической компоновки. Как вы знаете, можно задавать маски автоматической подгонки размеров для компонентов пользовательского интерфейса и контроллеров видов как в коде, так и в конструкторе интерфейсов. Об этом мы говорили в главе 1. Устанавливая здесь значение NO, мы гарантируем, что UIKit ничего не перепутает и не будет автоматически преобразовывать маски автоматической подгонки размера в ограничения автоматической компоновки. Эту функцию необходимо задавать, если вы смешиваете свойства автоматической компоновки компонентов с ограничениями макета. Как правило, следует устанавливать это значение у всех компонентов пользовательского интерфейса в NO всякий раз, когда вы работаете с ограничениями автоматической компоновки. Исключение составляют случаи, в которых вы специально приказываете UIKit преобразовать маски автоматической подгонки размеров в ограничения автоматической компоновки.

Мы создаем компоненты пользовательского интерфейса, но вполне очевидно, что методу viewDidLoad контроллера вида необходимо добавить к виду все три компонента пользовательского интерфейса. Почему бы не написать еще один небольшой метод, который будет заниматься именно этим?


— (void) addUIComponentsToView:(UIView *)paramView{


[paramView addSubview: self.textFieldEmail];

[paramView addSubview: self.textFieldConfirmEmail];

[paramView addSubview: self.registerButton];


}


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


— (NSArray *) emailTextFieldConstraints{


NSMutableArray *result = [[NSMutableArray alloc] init];


NSDictionary *viewsDictionary =

NSDictionaryOfVariableBindings(_textFieldEmail);


[result addObjectsFromArray:

[NSLayoutConstraint constraintsWithVisualFormat: kEmailTextFieldHorizontal

options:0

metrics: nil

views: viewsDictionary]

];


[result addObjectsFromArray:

[NSLayoutConstraint constraintsWithVisualFormat: kEmailTextFieldVertical

options:0

metrics: nil

views: viewsDictionary]

];


return [NSArray arrayWithArray: result];


}


— (NSArray *) confirmEmailTextFieldConstraints{


NSMutableArray *result = [[NSMutableArray alloc] init];

NSDictionary *viewsDictionary =

NSDictionaryOfVariableBindings(_textFieldConfirmEmail, _textFieldEmail);


[result addObjectsFromArray:

[NSLayoutConstraint constraintsWithVisualFormat: kConfirmEmailHorizontal

options:0

metrics: nil

views: viewsDictionary]

];


[result addObjectsFromArray:

[NSLayoutConstraint constraintsWithVisualFormat: kConfirmEmailVertical

options:0

metrics: nil

views: viewsDictionary]

];


return [NSArray arrayWithArray: result];


}


— (NSArray *) registerButtonConstraints{


NSMutableArray *result = [[NSMutableArray alloc] init];


NSDictionary *viewsDictionary =

NSDictionaryOfVariableBindings(_registerButton, _textFieldConfirmEmail);


[result addObject:


[NSLayoutConstraint constraintWithItem: self.registerButton

attribute: NSLayoutAttributeCenterX

relatedBy: NSLayoutRelationEqual

toItem: self.view

attribute: NSLayoutAttributeCenterX

multiplier:1.0f

constant:0.0f]


];


[result addObjectsFromArray:

[NSLayoutConstraint constraintsWithVisualFormat: kRegisterVertical

options:0

metrics: nil

views: viewsDictionary]


];


return [NSArray arrayWithArray: result];

}


— (NSArray *)constraints{

NSMutableArray *result = [[NSMutableArray alloc] init];

[result addObjectsFromArray: [self emailTextFieldConstraints]];

[result addObjectsFromArray: [self confirmEmailTextFieldConstraints]];

[result addObjectsFromArray: [self registerButtonConstraints]];

return [NSArray arrayWithArray: result];

}


Фактически здесь мы имеем метод экземпляра constraints, относящийся к контроллеру вида; этот метод собирает ограничения от всех трех компонентов пользовательского интерфейса, а потом возвращает их все как один большой массив. Теперь переходим к основной части контроллера — методу viewDidLoad:


— (void)viewDidLoad{


[super viewDidLoad];


[self constructUIComponents];

[self addUIComponentsToView: self.view];

[self.view addConstraints: [self constraints]];

}


Этот метод просто собирает пользовательский интерфейс, добавляя сам к себе все компоненты пользовательского интерфейса и связанные с ними ограничения. При этом он использует методы, написанные нами ранее. Отлично, но что мы увидим на экране, когда запустим эту программу? Мы уже видели, как этот интерфейс выглядит на устройстве, работающем в книжной ориентации (см. рис. 3.4). А теперь повернем устройство и посмотрим, что получится при альбомной ориентации (рис. 3.5).





Рис. 3.5. Ограничения функционируют в альбомном режиме не хуже, чем в книжном

См. также

 Сделать закладку на этом месте книги

Разделы 3.0 и 3.1.

3.3. Применение ограничений при работе с перекрестными видами

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

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

Решение

 Сделать закладку на этом месте книги

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

Обсуждение

 Сделать закладку на этом месте книги

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





Рис. 3.6. Важные ограничения, налагаемые перекрестными видами на две кнопки

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

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

• Нужна кнопка, которая будет вертикально центрирована относительно обоих серых видов.

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

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

• Серые виды должны автоматически изменять размер по мере того, как меняется ориентация вида с контроллером.

• Высота обоих серых видов должна составлять по 100 точек.

Итак, начнем. Чтобы выполнить все перечисленные задачи, вначале обратимся к методу viewDidLoad контроллера вида. Всегда стоит продумывать максимально чистый способ объединения методов. Конечно, в данном примере мы оперируем довольно большим количеством ограничений и видов. Как же нам не захламлять метод viewDidLoad контроллера вида? Вот так:


— (void)viewDidLoad{

[super viewDidLoad];

[self createGrayViews];


[self createButtons];


[self applyConstraintsToTopGrayView];

[self applyConstraintsToButtonOnTopGrayView];


[self applyConstraintsToBottomGrayView];

[self applyConstraintsToButtonOnBottomGrayView];


}


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


#import «ViewController.h»


@interface ViewController ()

@property (nonatomic, strong) UIView *topGrayView;

@property (nonatomic, strong) UIButton *topButton;

@property (nonatomic, strong) UIView *bottomGrayView;

@property (nonatomic, strong) UIButton *bottomButton;

@end

@implementation ViewController


<# Оставшаяся часть вашего кода находится здесь #>


Далее следует реализовать метод createGrayViews. Как понятно из названия, этот метод отвечает за создание серых видов:


— (UIView *) newGrayView{


UIView *result = [[UIView alloc] init];

result.backgroundColor = [UIColor lightGrayColor];

result.translatesAutoresizingMaskIntoConstraints = NO;

[self.view addSubview: result];

return result;


}


— (void) createGrayViews{


self.topGrayView = [self newGrayView];

self.bottomGrayView = [self newGrayView];

}


Пока несложно? Оба серых вида добавляются к контроллеру нашего вида. Отлично. Что дальше? Теперь нужно реализовать метод createButtons, поскольку он вызывается в методе viewDidLoad контроллера вида. Этот метод должен просто создать кнопки и поместить каждую в ассоциированном с ней сером виде:


— (UIButton *) newButtonPlacedOnView:(UIView *)paramView{


UIButton *result = [UIButton buttonWithType: UIButtonTypeSystem];

result.translatesAutoresizingMaskIntoConstraints = NO;

[result setTitle:@"Button" forState: UIControlStateNormal];

[paramView addSubview: result];

return result;


}


— (void) createButtons{

self.topButton = [self newButtonPlacedOnView: self.topGrayView];

self.bottomButton = [self newButtonPlacedOnView: self.bottomGrayView];

}


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

• верхний вид должен находиться на стандартном расстоянии от вида с контроллером по левому и верхнему краю;

• высота этого серого вида должна составлять 100 точек.


— (void) applyConstraintsToTopGrayView{


NSDictionary *views =


NSDictionaryOfVariableBindings(_topGrayView);


NSMutableArray *constraints = [[NSMutableArray alloc] init];


NSString *const kHConstraint = @"H:|-[_topGrayView]-|";

NSString *const kVConstraint = @"V:|-[_topGrayView(==100)]";


/* Горизонтальные ограничения */

[constraints addObjectsFromArray:

[NSLayoutConstraint constraintsWithVisualFormat: kHConstraint

options:0

metrics: nil

views: views]

];


/* Вертикальные ограничения */

[constraints addObjectsFromArray:

[NSLayoutConstraint constraintsWithVisualFormat: kVConstraint

options:0

metrics: nil

views: views]

];


[self.topGrayView.superview addConstraints: constraints];


}


Здесь следует остановиться на том, как создается вертикальное ограничение верхнего серого вида. Как видите, мы задаем высоту верхнего вида равной 100 точкам и записываем эту информацию в формате (==100). Среда времени исполнения интерпретирует это значение именно как высоту, поскольку здесь есть указатель V:. Он сообщает среде времени исполнения о следующем: те числа, которые мы сообщаем системе, как-то связаны с высотой и вертикальным выравниванием целевого вида, а не с его шириной и горизонтальным выравниванием.

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

• она должна быть вертикально центрирована в верхнем сером виде;

• она должна быть удалена на стандартное расстояние от левого и верхнего края этого серого вида.


У нее не должно быть жестко заданных высоты и ширины; эти значения будут зависеть от содержимого кнопки, в данном случае — от текста Button, который мы решили на ней написать:


— (void) applyConstraintsToButtonOnTopGrayView{

NSDictionary *views = NSDictionaryOfVariableBindings(_topButton);


NSMutableArray *constraints = [[NSMutableArray alloc] init];


NSString *const kHConstraint = @"H:|-[_topButton]";


/* Горизонтальные ограничения */

[constraints addObjectsFromArray:

[NSLayoutConstraint constraintsWithVisualFormat: kHConstraint

options:0

metrics: nil

views: views]

];


/* Вертикальные ограничения */

[constraints addObject:

[NSLayoutConstraint constraintWithItem: self.topButton

attribute: NSLayoutAttributeCenterY

relatedBy: NSLayoutRelationEqual

toItem: self.topGrayView

attribute: NSLayoutAttributeCenterY

multiplier:1.0f

constant:0.0f]

];


[self.topButton.superview addConstraints: constraints];


}


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

• вид удален на стандартное расстояние от верхнего и левого края вышестоящего вида с контроллером;

• вид удален на стандартное расстояние от нижней границы верхнего серого вида;

• высота нижнего серого вида составляет 100 точек.


— (void) applyConstraintsToBottomGrayView{


NSDictionary *views =

NSDictionaryOfVariableBindings(_topGrayView,

_bottomGrayView);


NSMutableArray *constraints = [[NSMutableArray alloc] init];


NSString *const kHConstraint = @"H:|-[_bottomGrayView]-|";

NSString *const kVConstraint =

@"V:|-[_topGrayView]-[_bottomGrayView(==100)]";


/* Горизонтальные ограничения */

[constraints addObjectsFromArray:

[NSLayoutConstraint constraintsWithVisualFormat: kHConstraint

options:0

metrics: nil

views: views]

];


/* Вертикальные ограничения */

[constraints addObjectsFromArray:

[NSLayoutConstraint constraintsWithVisualFormat: kVConstraint

options:0

metrics: nil

views: views]

];


[self.bottomGrayView.superview addConstraints: constraints];


}


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

Следующий и, пожалуй, последний компонент пользовательского интерфейса, для которого мы собираемся написать ограничения, — это кнопка, расположенная в нижнем сером виде. Метод, который будет заниматься ее ограничениями, называется applyConstraintsToButtonOnBottomGrayView. Перед тем как его реализовать, обсудим требования, которым должны соответствовать ограничения для нижней кнопки:

• кнопка должна быть вертикально центрирована в нижнем сером виде;

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

• с ней не должны применяться строго определенные значения высоты и ширины; ее высота и ширина должны зависеть от содержимого — в данном случае от текста Button, который мы на ней записываем.


— (void) applyConstraintsToButtonOnBottomGrayView{


NSDictionary *views = NSDictionaryOfVariableBindings(_topButton,

_bottomButton);


NSString *const kHConstraint = @"H:[_topButton][_bottomButton]";


/* Горизонтальные ограничения */

[self.bottomGrayView.superview addConstraints:

[NSLayoutConstraint constraintsWithVisualFormat: kHConstraint

options:0

metrics: nil

views: views]

];

/* Вертикальные ограничения */

[self.bottomButton.superview addConstraint:

[NSLayoutConstraint constraintWithItem: self.bottomButton

attribute: NSLayoutAttributeC


убрать рекламу






enterY

relatedBy: NSLayoutRelationEqual

toItem: self.bottomGrayView

attribute: NSLayoutAttributeCenterY

multiplier:1.0f

constant:0.0f]

];


}


Наконец, мы должны удостовериться в том, что контроллер вида сообщает среде времени исполнения, что он может обрабатывать любые варианты ориентации. Ведь именно этот аспект наиболее сильно интересовал нас в данном разделе. Поэтому мы переопределим метод supportedInterfaceOrientations в виде UIViewController:


— (NSUInteger) supportedInterfaceOrientations{

return UIInterfaceOrientationMaskAll;

}


Итак, работа с этим контроллером вида завершена. Запустим приложение и посмотрим, как оно работает при книжной ориентации (рис. 3.7).




Рис. 3.7. Приложение отображает компоненты пользовательского интерфейса в книжной ориентации согласно требованиям, которые мы предъявили


А теперь момент истины! Будет ли оно работать в альбомном режиме? Попробуем (рис. 3.8).




Рис. 3.8. Как и ожидалось, тот же самый код отлично работает и при альбомной ориентации экрана


Отлично! Все получилось.

См. также

 Сделать закладку на этом месте книги

Раздел 3.0.

3.4. Конфигурирование ограничений автоматической компоновки в конструкторе интерфейсов

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

Требуется задействовать весь потенциал конструктора интерфейсов для создания ограничений при работе с пользовательским интерфейсом.

Решение

 Сделать закладку на этом месте книги

Выполните следующие шаги.

1. Откройте в конструкторе интерфейсов файл XIB или файл раскадровки, который вы собираетесь редактировать.

2. Убедитесь, что в конструкторе интерфейсов вы выбрали объект вида, в котором собираетесь активизировать автоматическую компоновку. Просто щелкните на этом объекте.

3. Щелкните на элементе меню View — Utilities — Show File Inspector (Вид — Утилиты — Показать инспектор файлов).

4. Убедитесь, что в элементе File Inspector (Инспектор файлов) в разделе Interface Builder Document (Документ конструктора интерфейсов) установлен флажок Use Autolayout (Использовать автоматическую компоновку) (рис. 3.9).




Рис. 3.9. Активизируем автоматическую компоновку в конструкторе интерфейсов

Обсуждение

 Сделать закладку на этом месте книги

Конструктор интерфейсов значительно упрощает для программиста создание ограничений, причем наше участие в этом сводится к минимуму. До того как в iOS появилась возможность автоматической компоновки, приходилось, как правило, пользоваться специальными ориентировочными панелями (guideline bars). Эти панели появлялись на экране, пока вы перемещали компоненты пользовательского интерфейса. Ориентировочные панели были связаны с масками для автоматической подгонки размеров, которые вы могли создавать и в коде, точно так же, как ограничения. Но после того, как в конструкторе интерфейсов будет установлен флажок Use Autolayout (Использовать автоматическую компоновку), ориентировочные панели приобретут несколько иное значение. Теперь они сообщают о тех ограничениях, которые создает для вас в фоновом режиме сам конструктор интерфейсов.

Немного поэкспериментируем. Создадим в Xcode приложение с одним видом (Single View Application). Таким образом, будет создано приложение, содержащее всего один контроллер вида. Этот контроллер вида будет относиться к классу ViewController, а. xib-файл для него будет называться ViewController.xib. Просто щелкните на этом файле, чтобы конструктор интерфейсов открыл его. Убедитесь, что в инспекторе файлов установлен флажок Use Autolayout (Использовать автоматическую компоновку) так, как описано в подразделе «Решение» этого раздела.

Теперь просто найдите в библиотеке объектов кнопку  (Button) и перетащите ее в центр экрана. Дождитесь, пока в конструкторе интерфейсов появятся ориентировочные панели, по которым будет понятно, что центр кнопки соответствует центру экрана. В меню Edit (Правка) установите флажок Show Document Outline (Показать структуру документа). Если у вас в конструкторе интерфейсов уже открыт раздел Document Outline (Структура документа), то вместо Show Document Outline (Показать структуру документа) на этом месте будет отображаться надпись Hide Document Outline (Скрыть структуру документа) — в таком случае ничего делать не надо. Теперь найдите в разделе Document Outline (Структура документа) новый подраздел, отмеченный голубым цветом. Он был создан специально для вас и называется Constraints (Ограничения). Раскройте ограничения, созданные конструктором интерфейсов для этой кнопки. То, что вы теперь увидите, должно напоминать рис. 3.10.




Рис. 3.10. Конструктор интерфейсов создал ограничения компоновки


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

См. также

 Сделать закладку на этом месте книги

Раздел 3.0.

Глава 4. Создание и использование табличных видов

 Сделать закладку на этом месте книги

4.0. Введение

 Сделать закладку на этом месте книги

Табличный вид — это обычный вид с прокручиваемым контентом, который разделен на секции. Каждая такая секция, в свою очередь, подразделяется на строки. Каждая строка (Row) является экземпляром класса UITableViewCell. Вы можете создавать собственные варианты строк в табличном виде, делая подклассы  этого класса.

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

Табличный вид можно наполнить данными, используя источник данных табличного вида. Вы можете получать различные события и управлять оформлением табличных видов с помощью объекта-делегата табличного вида. Источник данных для табличного вида определяется в протоколе UITableViewDataSource, а делегат табличного вида — в протоколе UITableViewDelegate.

Хотя экземпляр UITableView является подклассом от UIScrollView, табличные виды можно прокручивать только по вертикали. Это скорее благо, чем ограничение. В данной главе мы обсудим различные способы создания табличных видов, их настройки и управления ими.

Табличные виды можно использовать двумя способами:

• с помощью класса UITableViewController. Этот класс напоминает UIViewController (см. раздел 1.9) в том, что фактически это контроллер вида, но в нем отображается не обычный вид, а таблица. Красота этого класса заключается в том, что каждый его экземпляр уже соответствует протоколам UITableViewDelegate и UITableViewDataSource. Итак, по умолчанию контроллер табличного вида становится источником данных и одновременно делегатом того табличного вида, которым он управляет. Таким образом, чтобы реализовать, например, источник данных для табличного вида, вам всего лишь потребуется реализовать контроллер для табличного вида, а не устанавливать вручную контроллер вида в качестве источника данных для табличного вида;

• вручную инстанцировав класс UITableView.

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


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

Класс UITableView инстанцируется с помощью метода initWithFrame: style:. Далее перечислены параметры, которые мы должны передать этому методу, а также значения этих параметров.

• initWithFrame — это параметр типа CGRect. Он указывает, как именно должен быть расположен табличный вид в вышестоящем виде. Если вы хотите, чтобы таблица просто полностью накрывала вышестоящий вид, передайте этому параметру значение свойства bounds вида с контроллером.

• style — это параметр типа UITableViewStyle, определяемый следующим образом:


typedef NS_ENUM(NSInteger, UITableViewStyle) {

UITableViewStylePlain,

UITableViewStyleGrouped

};


На рис. 4.1 показана разница между обычным и сгруппированным табличными видами.




Рис. 4.1. Табличные виды различных типов


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

• tableView: viewForHeaderInSection: — вызывается в делегате, когда табличному виду требуется отобразить заголовочный вид раздела. Каждый раздел табличного вида может содержать верхний колонтитул, некоторое количество ячеек и нижний колонтитул. В этой главе мы подробно обсудим все эти участки таблицы. Верхний и нижний колонтитул — это обычные экземпляры UIView. Данный метод является необязательным, но если вы хотите сконфигурировать заголовок для разделов вашего табличного вида, то пользуйтесь этим методом, чтобы создать экземпляр вида и передать его обратно в качестве возвращаемого значения. О верхних и нижних колонтитулах табличных видов подробнее рассказано в разделе 4.5.

• tableView: viewForFooterInSection: — делегатный метод, аналогичный tableView: viewForHeaderInSection:, но он возвращает вид с нижним колонтитулом таблицы. Как и заголовок, нижний колонтитул таблицы не является обязательным, но если он вам нужен, то его следует создавать здесь. Подробнее о верхних и нижних колонтитулах табличных видов рассказано в разделе 4.5.

• tableView: didEndDisplayingCell: forRowAtIndexPath: — вызывается в объекте-делегате, когда в ходе прокрутки таблицы ячейка уходит с экрана. Этот метод действительно очень удобен для вызова в делегате, так как вы можете удалять объекты и выбрасывать их из памяти, если эти объекты ассоциированы с ячейкой, которая ушла с экрана, а вы полагаете, что связанные с ней объекты вам больше не понадобятся.

• tableView: willDisplayCell: forRowAtIndexPath: — этот метод вызывается в делегате табличного вида всякий раз, когда ячейка вот-вот отобразится на экране.

Чтобы задать делегат для табличного вида, просто укажите в качестве значения свойства delegate экземпляра UITableView такой объект, который соответствует протоколу UITableViewDelegate. Если табличный вид является частью контроллера вида, то можно просто сделать этот контроллер делегатом вашего табличного вида, вот так:


#import «ViewController.h»


@interface ViewController () <UITableViewDelegate>

@property (nonatomic, strong) UITableView *myTableView;

@end


@implementation ViewController


— (void)viewDidLoad{

[super viewDidLoad];


self.myTableView = [[UITableView alloc]

initWithFrame: self.view.bounds

style: UITableViewStylePlain];


self.myTableView.delegate = self;


[self.view addSubview: self.myTableView];


}


@end


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

Объект-делегат обязан отвечать на сообщения, помеченные протоколом UITableViewDelegate как @required. Отвечать на другие сообщения не обязательно, но делегат должен отвечать на все сообщения, которые, по вашему замыслу, будут изменять табличный вид.

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


— (CGFloat) tableView:(UITableView *)tableView

heightForRowAtIndexPath:(NSIndexPath *)indexPath{

if ([tableView isEqual: self.myTableView]){

return 100.0f;

}

return 40.0f;

}

}


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

4.1. Наполнение табличного вида данными

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

Требуется наполнить табличный вид данными.

Решение

 Сделать закладку на этом месте книги

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


#import «ViewController.h»


static NSString *TableViewCellIdentifier = @"MyCells";


@interface ViewController () <UITableViewDataSource>

@property (nonatomic, strong) UITableView *myTableView;

@end


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

В методе viewDidLoad контроллера вида создадим табличный вид и присвоим ему контроллер вида в качестве источника данных:


— (void)viewDidLoad{

[super viewDidLoad];


self.myTableView =

[[UITableView alloc] initWithFrame: self.view.bounds

style: UITableViewStylePlain];


[self.myTableView registerClass: [UITableViewCell class]

forCellReuseIdentifier: TableViewCellIdentifier];


self.myTableView.dataSource = self;


/* Убеждаемся, что табличный вид правильно масштабируется. */

self.myTableView.autoresizingMask =

UIViewAutoresizingFlexibleWidth |

UIViewAutoresizingFlexibleHeight;


[self.view addSubview: self.myTableView];


}


В этом фрагменте кода все элементарно, кроме метода registerClass: forCellReuseIdentifier:, который мы вызываем в экземпляре табличного вида. Что же делает этот метод? Параметр registerClass этого метода просто принимает имя класса, соответствующее типу объекта, который вы хотите загружать в табличном виде при отображении каждой ячейки. Все ячейки внутри табличного вида должны быть прямыми или непрямыми потомками класса UITableViewCell. Сам этот класс предоставляет программистам довольно широкий функционал. Но при желании этот класс можно и расширить — достаточно произвести от него подкласс, добавив к новому классу требуемый функционал. Итак, возвращаемся к параметру registerClass вышеупомянутого метода. Вам потребуется сообщить имя класса ячеек этому параметру, а потом передать идентификатор параметру forCellReuseIdentifier. Вот по какой причине мы ассоциируем классы табличного вида с идентификаторами: когда позже вы заполняете табличный вид данными, можете просто передать тот же самый идентификатор методу dequeueReusableCellWithIdentifier: forIndexPath: табличного вида, после чего приказать табличному виду инстанцировать ячейку таблицы, если в наличии нет ячеек, доступных для повторного использования. Все это просто отлично, так как в предыдущих версиях iOS SDK программистам приходилось инстанцировать эти ячейки самостоятельно, если из табличного вида не удавалось добыть уже готовый код, пригодный для повторного использования.

Теперь необходимо убедиться в том, что наш табличный вид реагирует на методы протокола UITableViewDataSource, помеченные как @required (обязательные). Нажмите на клавиатуре комбинацию клавиш Command+Shift+O, введите в диалоговое окно имя этого протокола, затем нажмите клавишу Enter. В результате вы увидите обязательные методы данного протокола.

Класс UITableView определяет свойство под названием dataSource. Это нетипизированный объект, который должен подчиняться протоколу UITableViewDataSource. Всякий раз, когда табличный вид обновляется и перезагружается с помощью метода reloadData, табличный вид будет вызывать в своем источнике данных различные методы, чтобы получить информацию о тех данных, которыми вы хотите заполнить таблицу. Источник данных табличного вида может реализовывать три важных метода, два из которых являются обязательными для любого источника данных:

• numberOfSectionsInTableView: — позволяет источнику данных информировать табличный вид о количестве разделов, которые должны быть загружены в таблицу;

• tableView: numberOfRowsInSection: — сообщает контроллеру вида, сколько ячеек или строк следует загрузить в каждый раздел. Номер раздела передается источнику данных в параметре numberOfRowsInSection. Реализация этого метода является обязательной для объекта источника данных;

• tableView: cellForRowAtIndexPath: — отвечает за возвращение экземпляров класса UITableViewCell как строк таблицы, которыми должен заполняться табличный вид. Реализация этого метода обязательна для объекта источника данных.

Итак, продолжим и реализуем эти методы в контроллере вида один за другим. Сначала сообщим табличному виду, что мы хотим отобразить три раздела:


— (NSInteger)numberOfSectionsInTableView:(UITableView *)tableView{


if ([tableView isEqual: self.myTableView]){

return 3;

}


return 0;


}


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


— (NSInteger)tableView:(UITableView *)tableView

numberOfRowsInSection:(NSInteger)section{


if ([tableView isEqual: self.myTableView]){

switch (section){

case 0:{

return 3;

break;

}

case 1:{

return 5;

break;

}

case 2:{

return 8;

break;

}

}

}

return 0;


}


Итак, на данный момент мы приказали табличному виду отобразить три раздела. В первом разделе три строки, во втором — пять, в третьем — восемь. Что дальше? Нужно вернуть табличному виду экземпляры UITableViewCell — тех ячеек, которые мы хотим отобразить в таблице:


— (UITableViewCell *) tableView:(UITableView *)tableView

cellForRowAtIndexPath:(NSIndexPath *)indexPath{


UITableViewCell *result = nil;


if ([tableView isEqual: self.myTableView]){


cell = [tableView

dequeueReusableCellWithIdentifier: TableViewCellIdentifier

forIndexPath: indexPath];


cell.textLabel.text = [NSString stringWithFormat:

@"Section %ld, Cell %ld",

(long)indexPath.section,

(long)indexPath.row];


}


return cell;


}


Теперь, если запустить приложение в эмуляторе iPhone, мы увидим результат работы (рис. 4.2).




Рис. 4.2. Обычный табличный вид с тремя разделами


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

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

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

4.2. Использование дополнительных элементов в ячейке табличного вида

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

Требуется привлечь внимание пользователя, отображая в таблице дополнительные элементы, и предложить альтернативные способы взаимодействия с каждой ячейкой в табличном виде.

Решение

 Сделать закладку на этом месте книги

Используйте свойство accessoryType класса UITableViewCell. Экземпляры этого класса вы предоставляете табличному виду в объекте его источника данных:


— (UITableViewCell *) tableView:(UITableView *)tableView

cellForRowAtIndexPath:(NSIndexPath *)indexPath{


UITableViewCell* result = nil;


if ([tableView isEqual: self.myTableView]){


result = [tableView

dequeueReusableCellWithIdentifier: MyCellIdentifier

forIndexPath: indexPath];


result.textLabel.text =

[NSString stringWithFormat:@"Section %ld, Cell %ld",

(long)indexPath.section,

(long)indexPath.row];


result.accessoryType = UITableViewCellAccessoryDetailDisclosureButton;


}


return result;


}


— (NSInteger) tableView:(UITableView *)tableView

numberOfRowsInSection:(NSInteger)section{

return 10;

}


— (void)viewDidLoad{

[super viewDidLoad];


self.myTableView = [[UITableView alloc]

initWithFrame: self.view.bounds

style: UITableViewStylePlain];


[self.myTableView registerClass: [UITableViewCell class]

forCellReuseIdentifier: MyCellIdentifier];


self.myTableView.dataSource = self;


self.myTableView.autoresizingMask =

UIViewAutoresizingFlexibleWidth |

UIViewAutoresizingFlexibleHeight;


[self.view addSubview: self.myTableView];


}

Обсуждение

 Сделать закладку на этом месте книги

убрать рекламу






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

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




Рис. 4.3. Две ячейки табличного вида с различными дополнительными элементами


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

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


— (void) tableView:(UITableView *)tableView

accessoryButtonTappedForRowWithIndexPath:(NSIndexPath *)indexPath{


/* Делаем что-либо при нажатии дополнительной кнопки. */

NSLog(@"Accessory button is tapped for cell at index path = %@",

indexPath);


UITableViewCell *ownerCell = [tableView cellForRowAtIndexPath: indexPath];


NSLog(@"Cell Title = %@", ownerCell.textLabel.text);


}


Данный код ищет ячейку табличного вида, в которой была нажата кнопка детализации, и выводит в окне консоли содержимое текстовой метки данной ячейки. Напоминаю: чтобы отобразить окно консоли в Xcode, нужно выполнить команду Run\Console (Запуск\Консоль).

4.3. Создание специальных дополнительных элементов в ячейке табличного вида

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

Дополнительных элементов, предоставляемых в iOS, недостаточно для решения задачи, и вы хотели бы создать собственные дополнительные элементы.

Решение

 Сделать закладку на этом месте книги

Присвойте экземпляр класса UIView свойству accessoryView любого экземпляра класса UITableViewCell:


— (UITableViewCell *) tableView:(UITableView *)tableView

cellForRowAtIndexPath:(NSIndexPath *)indexPath{


UITableViewCell* cell = nil;


cell = [tableView dequeueReusableCellWithIdentifier: MyCellIdentifier

forIndexPath: indexPath];


cell.textLabel.text = [NSString stringWithFormat:@"Section %ld, Cell %ld",

(long)indexPath.section,

(long)indexPath.row];


UIButton *button = [UIButton buttonWithType: UIButtonTypeSystem];

button.frame = CGRectMake(0.0f, 0.0f, 150.0f, 25.0f);


[button setTitle:@"Expand"

forState: UIControlStateNormal];


[button addTarget: self

action:@selector(performExpand:)

forControlEvents: UIControlEventTouchUpInside];


cell.accessoryView = button;


return cell;


}


Как видите, в этом коде используется метод performExpand:. Он играет роль селектора для каждой кнопки. Вот определение данного метода:


— (void) performExpand:(id)paramSender{

/* Обрабатываем событие нажатия кнопки */

}


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




Рис. 4.4. Ячейки табличного вида со специальными дополнительными видами

Обсуждение

 Сделать закладку на этом месте книги

Объект типа UITableViewCell содержит свойство accessoryView. Это тот вид, которому вы можете присвоить значение, если вас не вполне устраивают встроенные в SDK iOS дополнительные виды для табличных ячеек. После того как задано это свойство, Cocoa Touch будет игнорировать значение свойства accessoryType и станет использовать вид, присвоенный свойству accessoryView, в качестве дополнительного элемента, который отображается в ячейке таблицы.

В коде, приведенном в подразделе «Решение» данного раздела, мы создаем кнопки для всех ячеек, находящихся в табличном виде. При нажатии кнопки в любой ячейке вызывается метод performExpand:. И если вы думаете примерно так же, как я, то вы уже стали задаваться вопросом: как же определить, к какой именно ячейке относится кнопка-отправитель? Итак, теперь нам нужно как-то связать кнопки с теми ячейками, к которым они относятся.

Один из способов разрешения этой ситуации связан с использованием свойства tag экземпляра кнопки. Это свойство-метка представляет собой обычное целое число, которое, как правило, используется для ассоциирования вида с другим объектом. Например, если вы хотите ассоциировать кнопку с третьей ячейкой в вашем табличном виде, то следует задать для свойства-метки этой кнопки значение 3. Но здесь возникает проблема: в табличных видах есть разделы, и каждый раздел может содержать n  ячеек. Следовательно, нам требуется возможность определить и раздел таблицы, и ячейку, которая владеет нашей кнопкой. А поскольку значением свойства-метки может быть только одно целое число, эта задача существенно усложняется. Поэтому мы можем отказаться от метки и вместо работы с ней запрашивать вышестоящий вид о дополнительном виде, рекурсивно проходя вверх по цепочке видов, пока не найдем ячейку типа UITableViewCell, вот так:


— (UIView *) superviewOfType:(Class)paramSuperviewClass

forView:(UIView *)paramView{


if (paramView.superview!= nil){

if ([paramView.superview isKindOfClass: paramSuperviewClass]){

return paramView.superview;

} else {

return [self superviewOfType: paramSuperviewClass

forView: paramView.superview];

}


}


return nil;


}


— (void) performExpand:(UIButton *)paramSender{


/* Обрабатываем событие нажатия кнопки */

__unused UITableViewCell *parentCell =

(UITableViewCell *)[self superviewOfType: [UITableViewCell class]

forView: paramSender];


/* Теперь, если желаете, можете еще что-нибудь сделать с ячейкой */


}


Здесь мы используем простой рекурсивный метод, принимающий вид (в данном случае нашу кнопку) и имя класса (в данном случае UITableViewCell), а затем просматриваем иерархию вида, являющегося вышестоящим для данного, чтобы найти вышестоящий вид, относящийся к интересующему нас классу. Итак, он начинает работу с вида, являющегося вышестоящим для заданного, и если этот вышестоящий вид не относится к требуемому типу, то просматривает и его вышестоящий вид, и так до тех пор, пока не найдет один из вышестоящих видов, относящийся к требуемому классу. Как видите, в качестве первого параметра метода superviewOfType: forView: мы используем структуру Class. В этом типе данных может содержаться имя любого класса из языка Objective-C, и это весьма кстати, если вы ищете или запрашиваете у программиста конкретные имена классов.

4.4. Обеспечение удаления смахиванием в ячейках табличных видов

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

Необходимо предоставить пользователям приложения возможность без труда удалять строки из табличного вида.

Решение

 Сделать закладку на этом месте книги

Реализуйте в делегате табличного вида селектор tableView: editingStyleForRowAtIndexPath:, а в источнике данных табличного вида — селектор tableView: commitEditingStyle: forRowAtIndexPath::


— (UITableViewCellEditingStyle)tableView:(UITableView *)tableView

editingStyleForRowAtIndexPath:(NSIndexPath *)indexPath{


return UITableViewCellEditingStyleDelete;


}


— (void) setEditing:(BOOL)editing

animated:(BOOL)animated{


[super setEditing: editing

animated: animated];


[self.myTableView setEditing: editing

animated: animated];


}


— (void) tableView:(UITableView *)tableView

commitEditingStyle:(UITableViewCellEditingStyle)editingStyle

forRowAtIndexPath:(NSIndexPath *)indexPath{


if (editingStyle == UITableViewCellEditingStyleDelete){


/* Сначала удаляем этот объект из источника данных */

[self.allRows removeObjectAtIndex: indexPath.row];


/* Потом удаляем ассоциированную с ним ячейку из табличного вида */

[tableView deleteRowsAtIndexPaths:@[indexPath]

withRowAnimation: UITableViewRowAnimationLeft];


}


}


Метод tableView: editingStyleForRowAtIndexPath: позволяет выполнять операции удаления. Он вызывается табличным видом, а его возвращаемое значение определяет, какие операции пользователь может делать в табличном виде (вставлять информацию, удалять информацию и т. д.). Метод tableView: commitEditingStyle: forRowAtIndexPath: выполняет затребованную пользователем операцию удаления. Второй из указанных методов определяется в делегате, но его функционал несколько перегружен: этот метод применяется не только для удаления данных, но и для удаления строк из таблицы.

Обсуждение

 Сделать закладку на этом месте книги

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




Рис. 4.5. Кнопка для удаления, появляющаяся в ячейке табличного вида


Такой режим активизируется путем реализации метода tableView: editingStyleForRowAtIndexPath: (определяемого в протоколе UITableViewDelegate), чье возвращаемое значение указывает, будут ли в таблице разрешаться операции вставки, или удаления, или обе эти операции, или ни одна из них. Реализуя метод tableView: commitEditingStyle: forRowAtIndexPath: в источнике данных табличного вида, можно также получать уведомление о том, какую операцию выполнил пользователь, вставку или удаление.

Второй параметр метода deleteRowsAtIndexPaths: withRowAnimation: позволяет указывать метод анимации, который будет выполняться при удалении строк из табличного вида. В примере мы задали, что удаляемые строки будут уходить с экрана в направлении справа налево.

4.5. Создание верхних и нижних колонтитулов в табличных видах

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

Необходимо создать в таблице верхний и/или нижний колонтитул.

Решение

 Сделать закладку на этом месте книги

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

Обсуждение

 Сделать закладку на этом месте книги

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




Рис. 4.6. Нижний колонтитул в верхнем разделе и верхний колонтитул Shortcuts (Быстрый доступ) в последнем разделе табличного вида


Как видите, в верхнем разделе (там, где находятся элементы Check Spelling (Проверка правописания) и Enable Caps Lock (Зафиксировать верхний регистр)) в нижнем колонтитуле написано: Double tapping the space bar will insert a period followed by a space (Двойное нажатие клавиши пробела вставляет точку, за которой следует пробел). Это нижний колонтитул верхнего раздела рассматриваемого вида. Причина, по которой этот фрагмент находится именно в нижнем, а не в верхнем колонтитуле, в том, что он прикреплен к нижней, а не к верхней части раздела. В последнем разделе данной таблицы также есть верхний колонтитул, на котором написано Shortcuts (Быстрый доступ). Здесь, наоборот, колонтитул является верхним, а не нижним, так как он прикреплен к верхней части раздела.

Для указания высоты верхнего и нижнего колонтитулов в разделе табличного вида применяются методы, определяемые в протоколе UITableViewDataSource. Чтобы задать сам вид, который будет соответствовать верхнему/нижнему колонтитулу в разделе табличного вида, нужно использовать методы, определяемые в протоколе UITableViewDelegate.

Идем дальше. Создадим простое приложение, внутри которого будет табличный вид. Потом сделаем две метки типа UILabel, одна будет играть роль верхнего колонтитула, а другая — нижнего в единственном разделе нашего табличного вида. Этот раздел будет заполнен всего тремя ячейками. В верхнем колонтитуле мы напишем Section 1 Header (Верхний колонтитул раздела 1), а в нижнем — Section 1 Footer (Нижний колонтитул раздела 1). Начнем с файла реализации контроллера вида, где определим табличный вид:


#import «ViewController.h»


static NSString *CellIdentifier = @"CellIdentifier";


@interface ViewController () <UITableViewDelegate, UITableViewDataSource>

@property (nonatomic, strong) UITableView *myTableView;

@end


@implementation ViewController

После этого создадим сгруппированный табличный вид и загрузим в него три ячейки:

— (UITableViewCell *) tableView:(UITableView *)tableView

cellForRowAtIndexPath:(NSIndexPath *)indexPath{


UITableViewCell *cell = nil;


cell = [tableView dequeueReusableCellWithIdentifier: CellIdentifier

forIndexPath: indexPath];


cell.textLabel.text = [[NSString alloc] initWithFormat:@"Cell %ld",

(long)indexPath.row];


return cell;


}


— (NSInteger) tableView:(UITableView *)tableView

numberOfRowsInSection:(NSInteger)section{

return 3;

}

— (void)viewDidLoad{

[super viewDidLoad];


self.myTableView =

[[UITableView alloc] initWithFrame: self.view.bounds

style: UITableViewStyleGrouped];

[self.myTableView registerClass: [UITableViewCell class]

forCellReuseIdentifier: CellIdentifier];


self.myTableView.dataSource = self;

self.myTableView.delegate = self;

self.myTableView.autoresizingMask = UIViewAutoresizingFlexibleWidth |

UIViewAutoresizingFlexibleHeight;


[self.view addSubview: self.myTableView];


}


И тут начинается самое интересное. Мы можем воспользоваться двумя важными методами (определяемыми в протоколе UITableViewDelegate), чтобы сделать метку и для верхнего и для нижнего колонтитула того раздела, который мы загрузили в табличный вид. Вот эти методы:

• tableView: viewForHeaderInSection: — ожидает возвращаемого значения типа UIView. Вид, возвращаемый этим методом, отобразится как верхний колонтитул раздела и будет указан в параметре viewForHeaderInSection;

• tableView: viewForFooterInSection: — ожидает возвращаемого значения типа UIView. Вид, возвращаемый этим методом, отобразится как нижний колонтитул раздела и будет указан в параметре viewForFooterInSection.

Теперь наша задача заключается в том, чтобы реализовать эти методы и вернуть экземпляр UILabel. На метке верхнего колонтитула мы укажем текст Section 1 Header (Верхний колонтитул раздела 1), а на метке нижнего — Section 1 Footer (Нижний колонтитул раздела 1), как и планировали:


— (UILabel *) newLabelWithTitle:(NSString *)paramTitle{

UILabel *label = [[UILabel alloc] initWithFrame: CGRectZero];

label.text = paramTitle;

label.backgroundColor = [UIColor clearColor];

[label sizeToFit];

return label;

}


— (UIView *) tableView:(UITableView *)tableView

viewForHeaderInSection:(NSInteger)section{


if (section == 0){

return [self newLabelWithTitle:@"Section 1 Header"];

}


return nil;


}


— (UIView *) tableView:(UITableView *)tableView

viewForFooterInSection:(NSInteger)section{


if (section == 0){

return [self newLabelWithTitle:@"Section 1 Footer"];

}


return nil;


}


Если теперь запустить приложение в эмуляторе, получится такая картинка, как на рис. 4.7.




Рис. 4.7. Метки для верхнего и нижнего колонтитулов табличного вида, выровненные неправильно


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

• tableView: heightForHeaderInSection: — возвращаемое значение данного метода относится к типу CGFloat. Оно указывает высоту верхнего колонтитула раздела табличного вида. Индекс раздела передается в параметре heightForHeaderInSection;

• tableView: heightForFooterInSection: — возвращаемое значение данного метода относится к типу CGFloat. Оно указывает высоту нижнего колонтитула раздела табличного вида. Индекс раздела передается в параметре heightForHeaderInSection.


— (CGFloat) tableView:(UITableView *)tableView

heightForHeaderInSection:(NSInteger)section{


if (section == 0){

return 30.0f;

}

return 0.0f;

}


— (CGFloat) tableView:(UITableView *)tableView

heightForFooterInSection:(NSInteger)section{


if (section == 0){

return 30.0f;

}


return 0.0f;


}


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




Рис. 4.8. Левые поля меток в верхнем и нижнем колонтитулах — неправильные


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

Теперь изменим реализацию методов tableView: viewForHeaderInSection: и tableView: viewForFooterInSection::


— (UIView *) tableView:(UITableView *)tableView

viewForHeaderInSection:(NSInteger)section{

UIView *header = nil;

if (section == 0){

UILabel *label = [self newLabelWithTitle:@"Section 1 Header"];

/* Перемещаем метку на 10 точек вправо. */

label.frame = CGRectMake(label.frame.origin.x + 10.0f,

5.0f, /* Опускаемся на 5 точек вниз

по оси y. */

label.frame.size.width,

label.frame.size.height);


/* Делаем ширину содержащего вида на 10 точек больше,

чем ширина метки, так как для метки требуется

10 дополнительных точек ширины в левом поле. */


CGRect resultFrame = CGRectMake(0.0f,

0.0f,

label.frame.size.width + 10.0f,

label.frame.size.height);

header = [[UIView alloc] initWithFrame: resultFrame];

[header addSubview: label];


}


return header;


}


— (UIView *) tableView:(UITableView *)tableView

viewForFooterInSection:(NSInteger)section{


UIView *footer = nil;

if (section == 0){


UILabel *label = [[UILabel alloc] initWithFrame: CGRectZero];


/* Перемещаем метку на 10 точек вправо. */

label.frame = CGRectMake(label.frame.origin.x + 10.0f,

5.0f, /* Опускаемся на 5 точек вниз по оси y*/

label.frame.size.width,

label.frame.size.height);


/* Делаем ширину содержащего вида на 10 точек больше,

чем ширина метки, так как для метки требуется

10 дополнительных точек ширины в левом поле. */

CGRect resultFrame = CGRectMake(0.0f,

0.0f,

label.frame.size.width + 10.0f,

label.frame.size.height);

footer = [[UIView alloc] initWithFrame: resultFrame];

[footer addSubview: label];


}


return footer;


}


Теперь, запустив приложение, вы получите примерно такой результат, как на рис. 4.9.




Рис. 4.9. В табличном виде отображаются метки верхнего и нижнего колонтитулов


Пользуясь изученными здесь методами, вы также можете размещать изображения в верхнем и нижнем колонтитулах табличных видов. Экземпляры класса UIImageView являются производными от класса UIView, поэтому вы легко можете ставить картинки в виды для изображений и возвращать их как верхние/нижние колонтитулы табличного вида. Если вы не собираетесь помещать в верхних и нижних колонтитулах табличных видов ничего, кроме текста, то можете пользоваться двумя удобными методами, определяемыми в протоколе UITableViewDataSource. Эти методы избавят вас от массы проблем. Чтобы не создавать собственные метки и не возвращать их как верхние/нижние колонтитулы табличного вида, просто пользуйтесь следующими методами:

• tableView: titleForHeaderInSection: — возвращаемое значение этого метода относится к типу NSString. Табличный вид будет автоматически помещать в метке строку, которая будет отображаться как верхний колонтитул раздела, указываемый в параметре titleForHeaderInSection;

• tableView: titleForFooterInSection: — возвращаемое значение этого метода относится к типу NSString. Табличный вид будет автоматически помещать в метке строку, которая будет отображаться как нижний колонтитул раздела, указываемый в параметре titleForFooterInSection.

Итак, чтобы упростить код приложения, избавимся от реализаций методов tableView: viewForHeaderInSection: и tableView: viewForFooterInSection:, заменив их реализациями методов tableView: titleForHeaderInSection: и tableView: titleForFooterInSection::


— (NSString *) tableView:(UITableView *)tableView

titleForHeaderInSection:(NSInteger)section{


if (section == 0){

return @"Section 1 Header";

}


return nil;


}

— (NSString *) tableView:(UITableView *)tableView

titleForFooterInSection:(NSInteger)section{


if (section == 0){

return @"Section 1 Footer";

}


return nil;


}


Теперь запустите ваше приложение в эмуляторе iPhone. Вы увидите, что табличный вид автоматически создал для верхнего колонтитула метку, выровненную по левому краю, а для нижнего колонтитула — метку, выровненную по центру, и поместил их в единственном разделе табличного вида. В iOS 7 по умолчанию верхний и нижний колонтитулы выравниваются по левому краю. В более ранних версиях iOS верхний колонтитул выравнивался по левому краю, а нижний — по центру. В любой версии выравнивание этих меток может задаваться табличным видом (рис. 4.10).








390376/i_104png.jpg">

Рис. 4.10. Табличный вид, в верхнем и нижнем колонтитулах которого отображается текст

4.6. Отображение контекстных меню в ячейках табличных видов

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

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

Решение

 Сделать закладку на этом месте книги

Реализуйте следующие три метода протокола UITableViewDelegate в объекте-делегате вашего табличного вида.

• tableView: shouldShowMenuForRowAtIndexPath: — возвращаемое значение данного вида относится к типу BOOL. Если вернуть от этого метода значение YES, то система iOS отобразит для ячейки табличного вида контекстное меню. Индекс этой ячейки будет передан вам в параметре shouldShowMenuForRowAtIndexPath.

• tableView: canPerformAction: forRowAtIndexPath: withSender: — возвращаемое значение данного метода также относится к типу BOOL. Как только вы позволите iOS отображать контекстное меню для ячейки табличного вида, iOS вызовет этот метод несколько раз и сообщит вам селектор действия. После этого вы сможете решить, следует ли отображать это действие в командах контекстного меню. Итак, если iOS спрашивает вас, хотите ли вы отобразить для пользователя меню Copy (Копировать), то рассматриваемый метод будет вызван в объекте-делегате вашего табличного вида и параметр canPerformAction данного метода будет равен @selector(copy:). Подробнее этот вопрос рассматривается в подразделе «Обсуждение» данного раздела.

• tableView: performAction: forRowAtIndexPath: withSender: — как только вы разрешите отобразить определенное действие в списке вариантов контекстного меню ячейки табличного вида, возникает такая ситуация: когда пользователь выбирает это действие в меню, данный метод вызывается в объекте-делегате вашего табличного вида. Здесь нужно сделать все необходимое, чтобы удовлетворить пользовательский запрос. Например, если пользователь выбрал меню Copy (Копировать), то вы должны применить буфер обмена (Pasteboard), куда помещается содержимое из ячейки табличного вида.

Обсуждение

 Сделать закладку на этом месте книги

Табличный вид может дать системе iOS ответ «да» или «нет», позволив или не позволив отобразить доступные системные элементы меню для данной табличной ячейки. iOS пытается вывести контекстное меню для табличной ячейки, когда пользователь удерживает эту ячейку пальцем в течение определенного временного промежутка — обычно примерно 1 с. Затем iOS пытается узнать табличный вид, одна из ячеек которого инициировала появление контекстного меню на экране. Если табличный вид ответит, то iOS сообщит ему, какие команды можно отобразить в контекстном меню, а табличный вид сможет утвердительно или отрицательно отреагировать на каждый из этих вариантов. Например, если доступны пять вариантов (элементов) и табличный вид отвечает «да» на два из них, то будут отображены только два этих элемента.

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

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


— (NSInteger) tableView:(UITableView *)tableView

numberOfRowsInSection:(NSInteger)section{

return 3;

}


— (UITableViewCell *) tableView:(UITableView *)tableView

cellForRowAtIndexPath:(NSIndexPath *)indexPath{


UITableViewCell *cell = nil;


cell = [tableView dequeueReusableCellWithIdentifier: CellIdentifier

forIndexPath: indexPath];


cell.textLabel.text = [[NSString alloc]

initWithFormat:@"Section %ld Cell %ld",

(long)indexPath.section,

(long)indexPath.row];


return cell;


}


— (void)viewDidLoad{

[super viewDidLoad];


self.myTableView = [[UITableView alloc]

initWithFrame: self.view.bounds

style: UITableViewStylePlain];

[self.myTableView registerClass: [UITableViewCell class]

forCellReuseIdentifier: CellIdentifier];


self.myTableView.autoresizingMask = UIViewAutoresizingFlexibleWidth |

UIViewAutoresizingFlexibleHeight;


self.myTableView.dataSource = self;

self.myTableView.delegate = self;


[self.view addSubview: self.myTableView];


}


Теперь реализуем три упомянутых ранее метода, определенных в протоколе UITableViewDelegate, и просто преобразуем доступные действия (типа SEL) в строку, после чего выведем доступные результаты на консоль:


— (BOOL) tableView:(UITableView *)tableView

shouldShowMenuForRowAtIndexPath:(NSIndexPath *)indexPath{


/* Разрешаем отображение контекстного меню для каждой ячейки */

return YES;


}


— (BOOL) tableView:(UITableView *)tableView

canPerformAction:(SEL)action

forRowAtIndexPath:(NSIndexPath *)indexPath

withSender:(id)sender{


NSLog(@"%@", NSStringFromSelector(action));


/* Пока разрешим любые действия. */

return YES;

}


— (void) tableView:(UITableView *)tableView

performAction:(SEL)action

forRowAtIndexPath:(NSIndexPath *)indexPath

withSender:(id)sender{


/* Пока оставим пустым. */


}


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


cut:

copy:

select:

selectAll:

paste:

delete:

_promptForReplace:

_showTextStyleOptions:

_define:

_addShortcut:

_accessibilitySpeak:

_accessibilitySpeakLanguageSelection:

_accessibilityPauseSpeaking:

makeTextWritingDirectionRightToLeft:

makeTextWritingDirectionLeftToRight:


Все это действия, которые система iOS позволяет вывести на экран для пользователя, если такие действия вам понадобятся. Допустим, вы хотите разрешить пользователям операцию копирования (Copy). Для этого перед отображением команды просто найдите в методе tableView: canPerformAction: forRowAtIndexPath: withSender:, на какое действие запрашивает у вас разрешение система iOS, а потом верните значение YES или NO:


— (BOOL) tableView:(UITableView *)tableView

canPerformAction:(SEL)action

forRowAtIndexPath:(NSIndexPath *)indexPath

withSender:(id)sender{


if (action == @selector(copy:)){

return YES;

}


return NO;

}


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


— (void) tableView:(UITableView *)tableView

performAction:(SEL)action

forRowAtIndexPath:(NSIndexPath *)indexPath

withSender:(id)sender{


if (action == @selector(copy:)){


UITableViewCell *cell = [tableView cellForRowAtIndexPath: indexPath];

UIPasteboard *pasteBoard = [UIPasteboard generalPasteboard];

[pasteBoard setString: cell.textLabel.text];


}


}




Рис. 4.11. Команда Copy (Копировать), отображенная в контекстном меню ячейки табличного вида

4.7. Перемещение ячеек и разделов в табличных видах

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

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

Решение

 Сделать закладку на этом месте книги

Используйте метод moveSection: toSection: табличного вида, чтобы переместить раздел на новое место. Кроме того, можно применять метод moveRowAtIndexPath: toIndexPath:, чтобы перемещать ячейку табличного вида на новое место с того места, которое она сейчас занимает.

Обсуждение

 Сделать закладку на этом месте книги

Процесс перемещения разделов и ячеек таблицы отличается от их замены. Рассмотрим пример, помогающий лучше понять эту разницу. Допустим, у нас есть табличный вид с тремя разделами, A, B и C. Если передвинуть раздел A к разделу C, то табличный вид заметит это и переместит раздел B туда, где до этого находился раздел A. Но если раздел B будет перемещен на место раздела C, то табличному виду вообще не придется перемещать раздел A, так как он находится «выше» двух перемещаемых разделов и не участвует в передвижениях B и C. В данном случае раздел B попадет на место раздела C, а раздел C — на место раздела B. Такая же логика применяется в табличных видах при перемещении ячеек.

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


#import «ViewController.h»


static NSString *CellIdentifier = @"CellIdentifier";


@interface ViewController () <UITableViewDelegate, UITableViewDataSource>

@property (nonatomic, strong) UITableView *myTableView;

@property (nonatomic, strong) NSMutableArray *arrayOfSections;

@end


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


— (NSMutableArray *) newSectionWithIndex:(NSUInteger)paramIndex

withCellCount:(NSUInteger)paramCellCount{


NSMutableArray *result = [[NSMutableArray alloc] init];


NSUInteger counter = 0;

for (counter = 0;

counter < paramCellCount;

counter++){


[result addObject: [[NSString alloc] initWithFormat:@"Section %lu

Cell %lu",

(unsigned long)paramIndex,

(unsigned long)counter+1]];


}


return result;


}


— (NSMutableArray *) arrayOfSections{

if (_arrayOfSections == nil){

NSMutableArray *section1 = [self newSectionWithIndex:1

cellCount:3];

NSMutableArray *section2 = [self newSectionWithIndex:2

cellCount:3];

NSMutableArray *section3 = [self newSectionWithIndex:3

cellCount:3];

_arrayOfSections = [[NSMutableArray alloc] initWithArray:@[

section1,

section2,

section3

]

];

}

return _arrayOfSections;

}


Затем мы инстанцируем табличный вид и реализуем необходимые методы в протоколе UITableViewDataSource, чтобы заполнить табличный вид данными:


— (NSInteger) numberOfSectionsInTableView:(UITableView *)tableView{


return self.arrayOfSections.count;


}


— (NSInteger) tableView:(UITableView *)tableView

numberOfRowsInSection:(NSInteger)section{


NSMutableArray *sectionArray = self.arrayOfSections[section];

return sectionArray.count;


}


— (UITableViewCell *) tableView:(UITableView *)tableView

cellForRowAtIndexPath:(NSIndexPath *)indexPath{


UITableViewCell *cell = nil;


cell = [tableView dequeueReusableCellWithIdentifier: CellIdentifier

forIndexPath: indexPath];


NSMutableArray *sectionArray = self.arrayOfSections[indexPath.section];


cell.textLabel.text = sectionArray[indexPath.row];


return cell;


}


— (void)viewDidLoad{

[super viewDidLoad];


self.myTableView =

[[UITableView alloc] initWithFrame: self.view.bounds

style: UITableViewStyleGrouped];


[self.myTableView registerClass: [UITableViewCell class]

forCellReuseIdentifier: CellIdentifier];


self.myTableView.autoresizingMask =

UIViewAutoresizingFlexibleWidth |

UIViewAutoresizingFlexibleHeight;


self.myTableView.delegate = self;

self.myTableView.dataSource = self;


[self.view addSubview: self.myTableView];


}

Теперь посмотрим, что получается. Сначала проверим, как разделы перемещаются на новое место. Напишем метод, который будет перемещать раздел 1 на место раздела 3:


— (void) moveSection1ToSection3{


NSMutableArray *section1 = [self.arrayOfSections objectAtIndex:0];

[self.arrayOfSections removeObject: section1];

[self.arrayOfSections addObject: section1];


[self.myTableView moveSection:0

toSection:2];


}


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

Как только вы запустите приложение в обычном режиме, на экране появятся разделы с 1-го по 3-й (рис. 4.12).




Рис. 4.12. Табличный вид с тремя разделами, в каждом из которых находятся по три ячейки


После запуска метода moveSection1ToSection3 вы увидите, что раздел 1 переходит на место раздела 3, раздел 3 переходит на место, ранее занятое разделом 2, и, наконец, раздел 2 перемещается на то место, где раньше находился раздел 1 (рис. 4.13).




Рис. 4.13. Раздел 1 перешел на место раздела 3, после чего последовательно переместились и другие разделы


Перемещение ячеек очень напоминает перемещение разделов. Для этого нужно просто пользоваться методом moveRowAtIndexPath: toIndexPath:. Не забывайте, что ячейка может перемещаться либо в пределах одного раздела, либо из одного раздела в другой. Начнем с простого — переместим ячейку 1 из 1-го раздела на место ячейки 2 того же раздела и посмотрим, что получится:


— (void) moveCell1InSection1ToCell2InSection1{


NSMutableArray *section1 = [self.arrayOfSections objectAtIndex:0];

NSString *cell1InSection1 = [section1 objectAtIndex:0];

[section1 removeObject: cell1InSection1];

[section1 insertObject: cell1InSection1

atIndex:1];


NSIndexPath *sourceIndexPath = [NSIndexPath indexPathForRow:0

inSection:0];

NSIndexPath *destinationIndexPath = [NSIndexPath indexPathForRow:1

inSection:0];

[self.myTableView moveRowAtIndexPath: sourceIndexPath

toIndexPath: destinationIndexPath];


}


Что же происходит в этом коде? Нам нужно гарантировать, что в источнике данных содержится корректная информация, которая отобразится в табличном виде по окончании всех перестановок. Поэтому сначала убираем ячейку 1 в разделе 1. В результате ячейка 2 переходит на место, освобожденное ячейкой 1, а ячейка 3 — на место, ранее занятое ячейкой 2. В массиве остается всего 2 ячейки. Потом мы вставляем ячейку 1 в индекс 1 (второй объект) массива. Таким образом, в массиве будут содержаться ячейка 2, ячейка 1, а потом ячейка 3. И вот теперь мы на самом деле переместили ячейки в табличном виде.

Теперь немного усложним задачу. Попробуем переместить ячейку 2 из раздела 1 на место ячейки 1 из раздела 2:


— (void) moveCell2InSection1ToCell1InSection2{


NSMutableArray *section1 = [self.arrayOfSections objectAtIndex:0];

NSMutableArray *section2 = [self.arrayOfSections objectAtIndex:1];


NSString *cell2InSection1 = [section1 objectAtIndex:1];

[section1 removeObject: cell2InSection1];


[section2 insertObject: cell2InSection1

atIndex:0];


NSIndexPath *sourceIndexPath = [NSIndexPath indexPathForRow:1

inSection:0];

NSIndexPath *destinationIndexPath = [NSIndexPath indexPathForRow:0

inSection:1];


[self.myTableView moveRowAtIndexPath: sourceIndexPath

toIndexPath: destinationIndexPath];


}


Результаты перехода показаны на рис. 4.14.




Рис. 4.14. Ячейка 2 из раздела 1 перемещена на место ячейки 1 из раздела 2

4.8. Удаление ячеек и разделов в табличных видах

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

Требуется удалять из табличных видов разделы и/или ячейки, сопровождая этот процесс анимацией.

Решение

 Сделать закладку на этом месте книги

Для удаления разделов из табличного вида выполните следующие шаги.

1. Сначала удалите раздел (-ы) в источнике данных независимо от того, с какой именно моделью данных вы работаете — Core Data или словарь/массив.

2. Примените к табличному виду метод экземпляра deleteSections: withRowAnimation:, относящийся к UITableView. Первый параметр, который нужно передать данному методу, имеет тип NSIndexSet. Этот объект можно инстанцировать с помощью метода класса indexSetWithIndex:, относящегося к классу NSIndexSet, где указываемый индекс — это беззнаковое целое число. Применяя такой подход, вы можете удалять только один раздел за раз. Если вы собираетесь удалить за раз более одного раздела, пользуйтесь методом класса indexSetWithIndexesInRange:, также относящимся к классу NSIndexSet, чтобы создать индексное множество с указанием диапазона. Это индексное множество передается описанному ранее методу экземпляра, относящемуся к UITableView.

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

1. Сначала удалите ячейку (ячейки) из источника данных. Здесь также не имеет значения, работаете ли вы с Core Data, обычным словарем, массивом или чем-то еще. Самое важное в данном случае — удалить из источника данных те объекты, которые соответствуют ячейкам табличного вида.

2. Теперь для удаления самих ячеек, соответствующих объектам данных, примените метод экземпляра deleteRowsAtIndexPaths: withRowAnimation:, относящийся к табличному виду. Первый параметр, который необходимо передать данному методу, — это массив типа NSArray. Данный массив должен содержать объекты типа NSIndexPath, и каждый индексный путь представляет одну ячейку в табличном виде. В каждом индексном пути содержится указание на раздел и на строку табличного вида. Этот путь составляется с помощью метода класса indexPathForRow: inSection:, относящегося к классу NSIndexPath.

Обсуждение

 Сделать закладку на этом месте книги

В коде вашего пользовательского интерфейса вам может понадобиться удалять ячейки и/или разделы. Например, у вас может иметься переключатель (типа UISwitch, см. раздел 1.2). Когда пользователь нажимает переключатель, вам, возможно, требуется добавить в табличный вид несколько строк. После того как пользователь вернет переключатель в исходное положение, вам, вероятно, потребуется вновь убрать эти строки с экрана. Но такие операции удаления не всегда ограничиваются ячейками (строками) табличного вида. Иногда из табличного вида требуется одновременно удалить целый раздел (или несколько разделов). Ключевой аспект при удалении разделов и ячеек из табличных видов состоит в том, что сначала из источника данных удаляется информация, соответствующая этим элементам (ячейкам или разделам), а потом вызываются соответствующие методы удаления, применяемые к табличному виду. После того как метод удаления завершит работу, табличный вид снова будет ссылаться на свой объект из источника данных. Если же после операции удаления количество ячеек/разделов в источнике данных не совпадет с количеством ячеек/разделов в табличном виде, приложение аварийно завершится. Но не волнуйтесь — даже если вы и допустите такую ошибку, то отладочное сообщение, которое появится на консоли, будет достаточно подробным для того, чтобы вы могли подправить код.

Рассмотрим, как удалять разделы из табличного вида. В данном разделе мы отобразим табличный вид в контроллере вида, который, в свою очередь, будет находиться в навигационном контроллере. Внутри табличного вида будет два раздела: один для нечетных чисел, другой — для четных. В табличном виде в разделе с нечетными числами мы отобразим только 1, 3, 5 и 7, а в разделе с четными — 0, 2, 4 и 6. В первом упражнении мы собираемся создать на навигационной панели специальную кнопку, которая будет удалять раздел с нечетными числами. На рис. 4.15 показано, какой результат мы хотим получить.




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


Начнем с главного. Определим контроллер вида:


#import <UIKit/UIKit.h>

static NSString *CellIdentifier = @"NumbersCellIdentifier";


@interface ViewController: UIViewController <UITableViewDelegate,

UITableViewDataSource>


@property (nonatomic, strong) UITableView *tableViewNumbers;

@property (nonatomic, strong) NSMutableDictionary *dictionaryOfNumbers;

@property (nonatomic, strong) UIBarButtonItem *barButtonAction;


@end


Свойство tableViewNumbers соответствует нашему табличному виду. Свойство barButtonAction соответствует кнопке для удаления, которая будет отображаться на навигационной панели. И последнее, но немаловажное свойство dictionaryOfNumbers — это источник данных для табличного вида. В данном словаре мы поместим два значения типа NSMutableArray, которые будут содержать числа типа NSNumber. Это изменяемые массивы, позже в данной главе мы сможем удалять их отдельно от массивов, содержащихся в словаре. Ключи для этих массивов мы будем хранить как статические значения в файле реализации контроллера вида. По этой причине позже просто сможем извлечь массивы из словаря, пользуясь статическими ключами. (Если бы ключи не были статическими, то для нахождения массивов в словаре пришлось бы выполнять сравнение строк. А эта операция требует больше времени, чем обычное ассоциирование объекта со статическим ключом, не изменяющимся на протяжении всего существования контроллера вида.) Теперь синтезируем наши свойства и определим статические строковые ключи для массивов, находящихся в словаре источника данных:


static NSString *SectionOddNumbers = @"Odd Numbers";

static NSString *SectionEvenNumbers = @"Even Numbers";


@implementation ViewController


Теперь, перед тем как создать табличный вид, необходимо заполнить информацией словарь источника данных. Вот простой метод, который автоматически заполнит словарь:


— (NSMutableDictionary *) dictionaryOfNumbers{


if (_dictionaryOfNumbers == nil){

NSMutableArray *arrayOfEvenNumbers =

[[NSMutableArray alloc] initWithArray:@[

@0,

@2,

@4,

@6,

]];

NSMutableArray *arrayOfOddNumbers =

[[NSMutableArray alloc] initWithArray:@[

@1,

@3,

@5,

@7,

]];

_dictionaryOfNumbers =

[[NSMutableDictionary alloc]

initWithDictionary:@{

SectionEvenNumbers: arrayOfEvenNumbers,

SectionOddNumbers: arrayOfOddNumbers,

}];

}

return _dictionaryOfNumbers;

}


Пока все нормально?


убрать рекламу






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


— (void)viewDidLoad

{

[super viewDidLoad];


self.barButtonAction =

[[UIBarButtonItem alloc]

initWithTitle:@"Delete Odd Numbers"

style: UIBarButtonItemStylePlain

target: self

action:@selector(deleteOddNumbersSection:)];

[self.navigationItem setRightBarButtonItem: self.barButtonAction

animated: NO];


self.tableViewNumbers = [[UITableView alloc]

initWithFrame: self.view.frame

style: UITableViewStyleGrouped];

self.tableViewNumbers.autoresizingMask = UIViewAutoresizingFlexibleWidth |

UIViewAutoresizingFlexibleHeight;

self.tableViewNumbers.delegate = self;

self.tableViewNumbers.dataSource = self;

[self.view addSubview: self.tableViewNumbers];


}


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


— (NSInteger) numberOfSectionsInTableView:(UITableView *)tableView{


return self.dictionaryOfNumbers.allKeys.count;


}


— (NSInteger) tableView:(UITableView *)tableView

numberOfRowsInSection:(NSInteger)section{


NSString *sectionNameInDictionary =

self.dictionaryOfNumbers.allKeys[section];


NSArray *sectionArray = self.dictionaryOfNumbers[sectionNameInDictionary];

return sectionArray.count;


}


— (UITableViewCell *) tableView:(UITableView *)tableView

cellForRowAtIndexPath:(NSIndexPath *)indexPath{


UITableViewCell *cell = nil;


cell = [tableView dequeueReusableCellWithIdentifier: CellIdentifier

forIndexPath: indexPath];


NSString *sectionNameInDictionary =

self.dictionaryOfNumbers.allKeys[indexPath.section];


NSArray *sectionArray = self.dictionaryOfNumbers[sectionNameInDictionary];


NSNumber *number = sectionArray[indexPath.row];


cell.textLabel.text = [NSString stringWithFormat:@"%lu",

(unsigned long)[number unsignedIntegerValue]];


return cell;


}


— (NSString *) tableView:(UITableView *)tableView

titleForHeaderInSection:(NSInteger)section{


return self.dictionaryOfNumbers.allKeys[section];


}


Навигационная кнопка связана с селектором deleteOddNumbersSection:. Этот метод нам сейчас предстоит запрограммировать. Цель метода, как видно из его названия[2], — найти раздел, соответствующий всем нечетным числам в источнике данных, найти табличный вид, а потом удалить искомый раздел и из таблицы, и из источника данных. Вот как это делается:


— (void) deleteOddNumbersSection:(id)paramSender{


/* Сначала удаляем раздел из источника данных. */

NSString *key = SectionOddNumbers;

NSInteger indexForKey = [[self.dictionaryOfNumbers allKeys]

indexOfObject: key];

if (indexForKey == NSNotFound){

NSLog(@"Could not find the section in the data source.");

return;

}

[self.dictionaryOfNumbers removeObjectForKey: key];


/* Затем удаляем раздел из табличного вида. */

NSIndexSet *sectionToDelete = [NSIndexSet indexSetWithIndex: indexForKey];

[self.tableViewNumbers deleteSections: sectionToDelete

withRowAnimation: UITableViewRowAnimationAutomatic];


/* Наконец, убираем с навигационной панели кнопку,

так как она нам больше не понадобится. */

[self.navigationItem setRightBarButtonItem: nil animated: YES];


}


Все довольно просто. Теперь, когда пользователь нажмет кнопку на навигационной панели, раздел Odd Numbers (Нечетные числа) исчезнет из табличного вида. Как видите, в процессе удаления раздела табличный вид анимируется. Это происходит потому, что мы передали анимационный тип UITableViewRowAnimationAutomatic параметру withRowAnimation: метода deleteSections: withRowAnimation: табличного вида. Теперь запустите приложение в эмуляторе iOS и выполните Debug — Toggle Slow Animations (Отладка — Включить медленную анимацию). Потом попробуйте нажать кнопку на навигационной панели и посмотрите, что происходит. Как видите, удаление сопровождается медленной анимацией (движением). Красиво, правда? Когда удаление завершится, приложение будет выглядеть, как на рис. 4.16.




Рис. 4.16. Раздел, содержащий нечетные числа, удален из табличного вида


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


— (void)viewDidLoad {

[super viewDidLoad];


self.barButtonAction =

[[UIBarButtonItem alloc]

initWithTitle:@"Delete Numbers > 2"

style: UIBarButtonItemStylePlain

target: self

action:@selector(deleteNumbersGreaterThan2:)];

[self.navigationItem setRightBarButtonItem: self.barButtonAction

animated: NO];


self.tableViewNumbers = [[UITableView alloc]

initWithFrame: self.view.frame

style: UITableViewStyleGrouped];

self.tableViewNumbers.autoresizingMask =

UIViewAutoresizingFlexibleWidth |

UIViewAutoresizingFlexibleHeight;

self.tableViewNumbers.delegate = self;

self.tableViewNumbers.dataSource = self;

[self.view addSubview: self.tableViewNumbers];


}


На рис. 4.17 показано, как выглядит приложение при запуске в эмуляторе iPhone.




Рис. 4.17. Кнопка, удаляющая все ячейки с числами больше 2


Теперь кнопка навигационной панели связана с селектором deleteNumbersGreaterThan2:. Селектор — это метод, реализованный в контроллере вида. Но прежде, чем перейти к его программированию, определим, что этот метод должен сделать.

1. Найти оба массива с нечетными и четными числами в источнике данных и собрать индексные пути (типа NSIndexPath) чисел больше 2. Позже мы будем пользоваться этими индексными путями для удаления соответствующих ячеек в табличном виде.

2. Удалить все числа больше 2 из источника данных — как из словаря для нечетных чисел, так и из словаря для четных.

3. Удалить из табличного вида соответствующие ячейки. Индексные пути к этим ячейкам мы собрали на первом этапе.

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


— (void) deleteNumbersGreaterThan2:(id)paramSender{


NSMutableArray *arrayOfIndexPathsToDelete =

[[NSMutableArray alloc] init];

NSMutableArray *arrayOfNumberObjectsToDelete =

[[NSMutableArray alloc] init];


/* Шаг 1: собираем объекты, которые мы хотим удалить из

источника данных, а также их индексные пути. */

__block NSUInteger keyIndex = 0;

[self.dictionaryOfNumbers enumerateKeysAndObjectsUsingBlock:

^(NSString *key, NSMutableArray *object, BOOL *stop) {


[object enumerateObjectsUsingBlock:

^(NSNumber *number, NSUInteger numberIndex, BOOL *stop) {


if ([number unsignedIntegerValue] > 2){

NSIndexPath *indexPath =

[NSIndexPath indexPathForRow: numberIndex

inSection: keyIndex];

[arrayOfIndexPathsToDelete addObject: indexPath];

[arrayOfNumberObjectsToDelete addObject: number];

}


}];


keyIndex++;

}];


/* Шаг 2: удаляем объекты из источника данных. */

if ([arrayOfNumberObjectsToDelete count] > 0){

NSMutableArray *arrayOfOddNumbers =

self.dictionaryOfNumbers[SectionOddNumbers];

NSMutableArray *arrayOfEvenNumbers =

self.dictionaryOfNumbers[SectionEvenNumbers];

[arrayOfNumberObjectsToDelete enumerateObjectsUsingBlock:

^(NSNumber *numberToDelete, NSUInteger idx, BOOL *stop) {

if ([arrayOfOddNumbers indexOfObject: numberToDelete]

!= NSNotFound){

[arrayOfOddNumbers removeObject: numberToDelete];

}

if ([arrayOfEvenNumbers indexOfObject: numberToDelete]

!= NSNotFound){

[arrayOfEvenNumbers removeObject: numberToDelete];

}

}];

}

/* Шаг 3: удаляем все ячейки, соответствующие объектам. */

[self.tableViewNumbers

deleteRowsAtIndexPaths: arrayOfIndexPathsToDelete

withRowAnimation: UITableViewRowAnimationAutomatic];

[self.navigationItem setRightBarButtonItem: nil animated: YES];

}


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




Рис. 4.18. Мы удалили все ячейки, в которых содержались числа больше 2

См. также

 Сделать закладку на этом месте книги

Раздел 1.2.

4.9. Использование UITableViewController для удобства при создании табличных видов

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

Требуется возможность быстро создавать табличные виды.

Решение

 Сделать закладку на этом месте книги

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

Обсуждение

 Сделать закладку на этом месте книги

В инструментарии iOS SDK есть очень удобный класс UITableViewController, который предоставляется с заранее заготовленным экземпляром табличного вида. Чтобы пользоваться всеми его преимуществами, всего лишь потребуется создать новый класс, наследующий от указанного. Здесь я подробно опишу все этапы создания нового проекта Xcode, использующего табличный контроллер вида.

1. На панели меню Xcode выберите File-New-Project (Файл-Новый-Проект).

2. Убедитесь, что в левой части экрана выбрана категория iOS. Затем перейдите в подкатегорию Application (Приложение). В правой части экрана выберите шаблон Empty Application (Пустое приложение), а потом нажмите кнопку Next (Далее) (рис. 4.19).




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


3. На следующем экране просто выберите название для вашего проекта. Кроме того, убедитесь, что вся информация у вас на экране, кроме Organization Name (Название организации) и Company Identifier (Идентификатор компании), в точности соответствует той, что приведена на рис. 4.20. Как только все будет готово, нажмите кнопку Next (Далее).




Рис. 4.20. Конфигурирование нового пустого приложения в Xcode


4. На следующем экране вам будет предложено сохранить приложение на диске. Просто сохраните приложение в месте, которое кажется вам целесообразным, и нажмите кнопку Create (Создать).

5. В Xcode выберите меню File-New-File (Файл-Новый-Файл).

6. Убедитесь, что в левой части диалогового окна категория iOS выбрана в качестве основной и при этом также выбрана подкатегория Cocoa Touch. Далее в правой части диалогового окна выберите класс Objective-C (рис. 4.21).




Рис. 4.21. Создание нового класса для табличного вида с контроллером


7. На следующем экране вам будет предложено выбрать суперкласс для нового класса. Это очень важный этап. Убедитесь, что в качестве суперкласса задан UITableViewController. Удостоверьтесь, что все остальные настройки у вас точно такие же, как и у меня на рис. 4.22. Когда все будет готово, нажмите кнопку Next (Далее).




Рис. 4.22. Задаем суперкласс для нового объекта, который станет контроллером табличного вида


8. На следующем экране вы сможете сохранить табличный контроллер вида в проекте. Сохраните его как класс ViewController и нажмите кнопку Create (Создать).

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


#import «AppDelegate.h»

#import «ViewController.h»


@implementation AppDelegate


— (BOOL) application:(UIApplication *)application

didFinishLaunchingWithOptions:(NSDictionary *)launchOptions{


ViewController *controller = [[ViewController alloc]

initWithStyle: UITableViewStylePlain];


self.window = [[UIWindow alloc]

initWithFrame: [[UIScreen mainScreen] bounds]];


self.window.rootViewController = controller;


self.window.backgroundColor = [UIColor whiteColor];

[self.window makeKeyAndVisible];

return YES;

}


Теперь, если вы попытаетесь скомпилировать проект, компилятор выдаст вам следующие предупреждения[3]:


ViewController.m:47:2: Potentially incomplete method implementation.

ViewController.m:54:2: Incomplete method implementation.

Итак, необходимо иметь в виду, что компилятор выдает определенные предупреждения, об устранении которых придется позаботиться в файле реализации контроллера вида. Открыв этот файл, вы увидите, что Apple вставила в шаблон класса табличного контроллера вида макрокоманды #warning — инструкции для компилятора (именно они приводят к тому, что на экран выводятся показанные ранее предупреждения). Одно из предупреждений находится в методе numberOfSectionsInTableView:, другое — в методе tableView: numberOfRowsInSection:. Мы видим на экране предупреждения, потому что не запрограммировали логику для этих методов. Минимальная информация, необходимая табличному контроллеру вида, — это количество разделов для отображения, количество строк для отображения, а также объект ячейки, который должен отображаться в каждой из строк. Мы не видим никаких предупреждений, связанных с отсутствием реализации объекта ячейки, но только потому, что Apple по умолчанию предоставляет формальную реализацию этого метода, создающую за вас пустые ячейки.

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

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


#import «ViewController.h»


static NSString *CellIdentifier = @"Cell";


@interface ViewController ()

@property (nonatomic, strong) NSArray *allItems;

@end


@implementation ViewController


— (id)initWithStyle:(UITableViewStyle)style

{

self = [super initWithStyle: style];

if (self) {

// Специальная инициализация

self.allItems = @[

@"Anthony Robbins",

@"Steven Paul Jobs",

@"Paul Gilbert",

@"Yngwie Malmsteen"

];


[self.tableView registerClass: [UITableViewCell class]

forCellReuseIdentifier: CellIdentifier];


}


return self;

}


— (void) viewDidLoad{

[super viewDidLoad];

}


— (NSInteger)numberOfSectionsInTableView:(UITableView *)tableView{

return 1;

}


— (NSInteger)tableView:(UITableView *)tableView

numberOfRowsInSection:(NSInteger)section{

return self.allItems.count;

}


— (UITableViewCell *)tableView:(UITableView *)tableView

cellForRowAtIndexPath:(NSIndexPath *)indexPath{


UITableViewCell *cell = [tableView

dequeueReusableCellWithIdentifier: CellIdentifier

forIndexPath: indexPath];


cell.textLabel.text = self.allItems[indexPath.row];


return cell;

}


@end


Теперь, запустив приложение, мы увидим результат, напоминающий рис. 4.23.




Рис. 4.23. Строки правильно отображаются в табличном виде


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

См. также

 Сделать закладку на этом месте книги

Раздел 4.1.

4.10. Отображение элемента управления, предназначенного для обновления информации в табличных видах

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

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




Рис. 4.24. Элемент управления для обновления информации, расположенный над табличным видом

Решение

 Сделать закладку на этом месте книги

Создайте табличный контроллер вида (так, как описано в разделе 4.9) и задайте в качестве значения его свойства refreshControl новый экземпляр класса UIRefreshControl, как показано далее:


— (id)initWithStyle:(UITableViewStyle)style{

self = [super initWithStyle: style];

if (self) {


[self.tableView registerClass: [UITableViewCell class]

forCellReuseIdentifier: CellIdentifier];

self.allTimes = [NSMutableArray arrayWithObject: [NSDate date]];


/* Создаем элемент управления для обновления информации */

self.refreshControl = [[UIRefreshControl alloc] init];

self.refreshControl = self.refreshControl;

[self.refreshControl addTarget: self

action:@selector(handleRefresh:)

forControlEvents: UIControlEventValueChanged];


}

return self;

}

Обсуждение

 Сделать закладку на этом месте книги

Элементы управления для обновления информации — это простые визуальные индикаторы, располагающиеся над табличным видом и сообщающие пользователю, что какая-то информация в таблице сейчас обновится. Например, чтобы обновить содержимое почтового ящика в приложении Mail в версиях старше iOS 6, вам приходилось нажимать на специальную кнопку Refresh (Обновить). В новой iOS 7 вы можете просто потянуть список ваших писем вниз, как если бы хотели ознакомиться с какими-то письмами из верхней части списка, которые пока не успели прочитать. Как только iOS зафиксирует такой жест, система инициирует обновление. Круто, правда? Это нововведение впервые появилось в Twitter-клиенте для iPhone, большое спасибо за это его разработчикам. Apple по достоинству оценила всю элегантность и логичность этой возможности обновления видов, поэтому в SDK был добавлен специальный компонент для реализации такой функции. Класс, соответствующий этому компоненту, называется UIRefreshControl.

Чтобы создать новый экземпляр этого класса, достаточно просто вызвать его метод init. Сделав это, добавьте экземпляр к табличному контроллеру вида, как описано в подразделе «Решение» данного раздела.

Итак, вы хотите знать, когда пользователь инициирует обновление информации в табличном виде. Для этого просто вызовите метод экземпляра addTarget: action: forControlEvents: обновляющего элемента и передайте ему целевой объект вместе с селектором этого объекта — остальное система сделает за вас. Передайте событие UIControlEventValueChanged параметру forControlEvents этого метода.

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


#import «ViewController.h»


static NSString *CellIdentifier = @"Cell";

@interface ViewController ()

@property (nonatomic, strong) NSMutableArray *allTimes;

@property (nonatomic, strong) UIRefreshControl *refreshControl;

@end


@implementation ViewController


Свойство allTimes — это обычный изменяемый массив, который будет содержать все экземпляры NSDate в момент, когда завершится обновление таблицы. Мы уже рассмотрели инициализацию табличного контроллера вида в подразделе «Решение» данного раздела, поэтому я не буду вновь писать об этом. Но, как вы помните, мы прикрепили событие UIControlEventValueChanged обновляющего элемента управления к методу handleRefresh:. В этом методе мы всего лишь собираемся добавить к массиву дату и время, после чего обновить табличный вид:


— (void) handleRefresh:(id)paramSender{


/* Оставляем небольшую задержку между высвобождением обновляющего элемента

управления и самим моментом обновления. Так весь процесс выглядит

в интерфейсе более плавно, чем при использовании обычной анимации */

int64_t delayInSeconds = 1.0f;

dispatch_time_t popTime =

dispatch_time(DISPATCH_TIME_NOW, delayInSeconds * NSEC_PER_SEC);


dispatch_after(popTime, dispatch_get_main_queue(), ^(void){


/* Добавляем актуальную дату к имеющемуся списку дат;

Таким образом, при обновлении табличного вида новый информационный

элемент на экране будет находиться над старым и пользователь увидит

разницу во времени до и после обновления */

[self.allTimes addObject: [NSDate date]];


[self.refreshControl endRefreshing];


NSIndexPath *indexPathOfNewRow =

[NSIndexPath indexPathForRow: self.allTimes.count-1 inSection:0];

[self.tableView

insertRowsAtIndexPaths:@[indexPathOfNewRow]

withRowAnimation: UITableViewRowAnimationAutomatic];

});


}


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


— (NSInteger)numberOfSectionsInTableView:(UITableView *)tableView{

return 1;

}


— (NSInteger) tableView:(UITableView *)tableView

numberOfRowsInSection:(NSInteger)section{

return self.allTimes.count;

}


— (UITableViewCell *)tableView:(UITableView *)tableView

cellForRowAtIndexPath:(NSIndexPath *)indexPath{


UITableViewCell *cell = [tableView

dequeueReusableCellWithIdentifier: CellIdentifier

forIndexPath: indexPath];


cell.textLabel.text = [NSString stringWithFormat:@"%@",

self.allTimes[indexPath.row]];


return cell;

}


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


убрать рекламу






значение даты и времени в списке. Но если потянуть таблицу вниз, то постепенно перед вами будут открываться новые элементы (см. рис. 4.24).

См. также

 Сделать закладку на этом месте книги

Раздел 4.9.

Глава 5. Выстраивание сложных макетов с помощью сборных видов

 Сделать закладку на этом месте книги

5.0. Введение

 Сделать закладку на этом месте книги

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

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

Именно поэтому в 6-й версии iOS компания Apple впервые внедрила сборные виды. Сборный вид можно сравнить с сильно усовершенствованным прокручиваемым видом. У него есть источник данных и делегат, как и у табличного вида. Но он обладает одним свойством, делающим его совершенно несхожим с табличным или прокручиваемым видами. Речь идет о макетном объекте .

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

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




Рис. 5.1. Типичный макет с последовательной компоновкой в сборном виде


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




Рис. 5.2. Специальный вариант компоновки для сборного вида

5.1. Создание сборных видов

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

Требуется отобразить на экране сборный вид.

Решение

 Сделать закладку на этом месте книги

Либо воспользуйтесь экземпляром UICollectionView, который в таком случае нужно сделать дочерним видом одного из видов вашего приложения (если хотите создать полноэкранный сборный вид), либо примените класс UICollectionViewController.

Обсуждение

 Сделать закладку на этом месте книги

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

Сначала рассмотрим вариант с полноэкранным видом.

1. Откройте Xcode.

2. В меню File (Файл) выберите New (Новый), а затем Project (Проект).

3. Слева в качестве основной категории выберите iOS, а под ней — Application (Приложение). В правой части экрана выберите Empty Application (Пустое приложение), после чего нажмите кнопку Next (Далее).

4. На следующем экране введите информацию о вашем проекте и убедитесь, что установлен флажок Use Automatic Reference Counting (Использовать автоматический подсчет ссылок) (рис. 5.3). Как только введете все необходимые значения, нажмите кнопку Next (Далее).




Рис. 5.3. Создание нового проекта Пустое приложение (Empty Application) для сборного вида


5. После этого вам будет предложено сохранить проект на диске. Выберите подходящее для этого место и нажмите кнопку Create (Создать).

6. Теперь, когда проект подготовлен, создайте в нем новый класс и назовите его ViewController. Этот класс должен наследовать от UICollectionViewController. Вам не понадобится. xib-файл для этого контроллера вида, поэтому откажитесь от этой возможности (рис. 5.4).




Рис. 5.4. Добавляем в проект новый класс сборного вида


7. Найдите в проекте файл AppDelegate.m (это файл реализации делегата приложения) и откройте его, после чего создайте экземпляр сборного вида, а затем сделайте этот сборный вид корневым контроллером вида вашего приложения, как показано здесь:


— (BOOL) application:(UIApplication *)application

didFinishLaunchingWithOptions:(NSDictionary *)launchOptions{


/* Инстанцируем контроллер сборного вида с нулевым макетным объектом.

Примечание: в результате программа выдаст исключение, но позже мы

изучим, как создавать макетные объекты и предоставлять их нашим сборным

видам */

ViewController *viewController = [[ViewController alloc]

initWithCollectionViewLayout: nil];


self.window = [[UIWindow alloc] initWithFrame:

[[UIScreen mainScreen] bounds]];


self.window.backgroundColor = [UIColor whiteColor];


/* Устанавливаем сборный вид в качестве корневого для нашего окна */

self.window.rootViewController = viewController;

[self.window makeKeyAndVisible];

return YES;

}

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

Итак, мы уже научились создавать контроллер сборного вида, и это хорошо, если вы хотите, чтобы такой вид при отображении занимал на устройстве весь экран. Однако если вы разрабатываете специальный компонент, входящий в состав другого, более крупного вида, то попробуйте просто инстанцировать объект типа UICollectionView, воспользовавшись его выделенным инициализатором — методом initWithFrame: collectionViewLayout:.

Чтобы это сделать, требуется просто инстанцировать сборный вид, воспользовавшись указанным инициализатором. После инициализации вы сможете добавить сборный вид в качестве дочернего к другому виду. Например, если вы хотите добавить его к вашему виду контроллера вида, просто вызовите метод addSubview: этого вида с контроллером и передайте экземпляр вашего сборного вида этому методу в качестве параметра. Кроме того, нужно убедиться, что в качестве значений свойств delegate и dataSource сборного вида заданы валидные объекты, соответствующие протоколам UICollectionViewDelegate и UICollectionViewDataSource. Выполнить остальные операции не составляет труда. Далее в этой главе описаны все приемы, используемые для наполнения сборного вида информацией из источника данных и реагирования на события с помощью объекта-делегата.

См. также

 Сделать закладку на этом месте книги

Раздел 5.0.

5.2. Присваивание источника данных сборному виду

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

Требуется предоставить для сборного вида данные, которые будут выводиться на экран.

Решение

 Сделать закладку на этом месте книги

Присвойте сборному виду источник данных, воспользовавшись свойством dataSource класса UICollectionView. Источник данных должен быть объектом, который соответствует протоколу UICollectionViewDataSource. Кроме того, само собой разумеется, что объект источника данных обязательно должен реализовывать методы и свойства этого протокола, относящиеся к категории required.

Обсуждение

 Сделать закладку на этом месте книги

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

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

• collectionView: numberOfItemsInSection: — этот метод возвращает объект NSInteger, сообщающий сборному виду количество элементов, которые должны быть отображены в заданной секции. Задаваемая секция сообщается данному методу как целое число, представляющее собой индекс с нулевым основанием для данной секции. Именно так происходит и при работе с табличными видами.

• collectionView: cellForItemAtIndexPath: — ваша реализация этого метода должна возвращать экземпляр UICollectionViewCell, соответствующий ячейке, к которой ведет указанный индексный путь. Класс UICollectionViewCell наследует от UICollectionReusableView. Фактически любая доступная для повторного использования ячейка, передаваемая сборному виду для отображения, должна прямо или косвенно наследовать от UICollectionReusableView, о чем мы подробно поговорим в этой главе. Индексный путь указывается в параметре cellForItemAtIndexPath этого метода. Вы можете запросить индексы section и row этого элемента из индексного пути.

Перейдем к файлу реализации контроллера сборного вида (ViewController.m). Этот контроллер мы создали в разделе 5.1. Реализуем в данном файле рассмотренные ранее методы источника данных сборного вида:


#import «ViewController.h»


@implementation ViewController


/* Пока мы не собираемся возвращать никаких секций */

— (NSInteger)collectionView:(UICollectionView *)collectionView

numberOfItemsInSection:(NSInteger)section{

return 0;

}


/* Мы пока не знаем, как возвращать секции в сборный вид, поэтому для начала возвратим здесь nil */

— (UICollectionViewCell *)collectionView:(UICollectionView *)collectionView

cellForItemAtIndexPath:(NSIndexPath *)indexPath{

return nil;

}


@end


На данном этапе  этот код можно считать полным. Но, как было указано в разделе 5.1, при попытке его запустить приложение аварийно завершится. Дело в том, что делегат приложения устанавливает макетный объект сборного вида в значение nil. Эта проблема никуда не исчезла, мы собираемся устранить ее в разделе 5.3.

См. также

 Сделать закладку на этом месте книги

Разделы 5.0 и 5.1.

5.3. Обеспечение последовательной компоновки в сборном виде

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

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

Решение

 Сделать закладку на этом месте книги

Создайте экземпляр класса UICollectionViewFlowLayout, инстанцируйте контроллер сборного вида с помощью выделенного метода-инициализатора initWithCollectionViewLayout: из класса UICollectionViewController, а затем передайте этому методу ваш макетный объект.

Обсуждение

 Сделать закладку на этом месте книги

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

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

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

• itemSize — величина CGSize, соответствующая размеру каждой ячейки в сборном виде.

• scrollDirection — значение типа UICollectionViewScrollDirection, сообщающее макету с последовательной компоновкой, как должно прокручиваться содержимое сборного вида. Содержимое может прокручиваться либо по горизонтали, либо по вертикали, но не в обоих направлениях одновременно. По умолчанию это свойство имеет значение UICollectionViewScrollDirectionVertical, но вы можете изменить его на UICollectionViewScrollDirectionHorizontal.

• sectionInset — значение типа UIEdgeInsets, задающее размер полей вокруг каждой секции. В принципе, поля — это пространство, которое не относится ни к одной из ячеек. Для создания таких отступов можно воспользоваться функцией UIEdgeInsetsMake. У каждого поля есть верхний, нижний, правый и левый край, все они обозначаются числами с плавающей точкой. Не волнуйтесь, если это объяснение кажется путаным — вскоре все встанет на свои места.

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


#import «AppDelegate.h»

#import «ViewController.h»


@implementation AppDelegate

— (UICollectionViewFlowLayout *) flowLayout{


UICollectionViewFlowLayout *flowLayout =

[[UICollectionViewFlowLayout alloc] init];


flowLayout.minimumLineSpacing = 20.0f;

flowLayout.minimumInteritemSpacing = 10.0f;

flowLayout.itemSize = CGSizeMake(80.0f, 120.0f);

flowLayout.scrollDirection = UICollectionViewScrollDirectionVertical;

flowLayout.sectionInset = UIEdgeInsetsMake(10.0f, 20.0f, 10.0f, 20.0f);


return flowLayout;

}


— (BOOL) application:(UIApplication *)application

didFinishLaunchingWithOptions:(NSDictionary *)launchOptions{


/* Инстанцируем контроллер сборного вида с валидным макетом

для последовательной компоновки */

ViewController *viewController =

[[ViewController alloc]

initWithCollectionViewLayout: [self flowLayout]];


self.window = [[UIWindow alloc] initWithFrame:

[[UIScreen mainScreen] bounds]];


self.window.backgroundColor = [UIColor whiteColor];


/* Задаем сборный вид в качестве корневого контроллера вида окна */

self.window.rootViewController = viewController;

[self.window makeKeyAndVisible];

return YES;


}


Реализация контроллера сборного вида остается такой же, как в разделе 5.2. Если сейчас запустить приложение, то вы увидите просто черный экран, так как в стандартной реализации контроллера сборного вида фон вида даже не заменяется на белый. Пока нас это устраивает. Как минимум приложение уже не завершается аварийно, поскольку у нас уже есть объекты макета.

См. также

 Сделать закладку на этом месте книги

Разделы 5.1 и 5.2.

5.4. Наполнение сборного вида простейшим содержимым

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

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

Решение

 Сделать закладку на этом месте книги

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

Обсуждение

 Сделать закладку на этом месте книги

В данном разделе я исхожу из того, что вы уже проработали разделы 5.1–5.3 и выполнили базовую настройку проекта.

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

Мы собираемся запрограммировать сборный вид с последовательной компоновкой, в котором будут отображаться три секции. В каждой из секций будет находиться от 20 до 40 ячеек, причем в первой секции все ячейки красные, во второй — зеленые, в третьей — синие (рис. 5.5).




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


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


/* У нас будет три секции, и для каждой из них мы определим свой цвет ячеек. Для представления цвета используются самые обычные экземпляры UIColor, которые мы позже применим к каждой из ячеек в соответствующих секциях */

— (NSArray *) allSectionColors{


static NSArray *allSectionColors = nil;


if (allSectionColors == nil){

allSectionColors = @[

[UIColor redColor],

[UIColor greenColor],

[UIColor blueColor],

];

}


return allSectionColors;


}


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

В более ранних версиях iOS приходилось вручную создавать ячейки, если табличному виду не удавалось найти готовые ячейки для повторного использования (сборные виды в ранних версиях iOS отсутствовали). Однако с появлением новых API Apple выполнила очень интересную работу, связанную с многократно используемыми ячейками. Компания предоставила новые API как для табличных, так и для сборных видов. Поэтому вы можете зарегистрировать вызов и с табличным видом, и со сборным видом. Если же вам приходится конфигурировать новую ячейку, то вы просто требуете от табличного или сборного вида новую ячейку нужного рода. Если такая ячейка имеется в очереди многократного использования, то она (ячейка) будет вам предоставлена. Если нет — то табличный или сборный вид автоматически создаст такую ячейку. Этот механизм называется регистрацией многоразовой ячейки , он реализуется двумя способами:

• регистрацией ячейки с использованием имени класса;

• регистрацией ячейки с использованием. xib-файла.

Оба этих способа регистрации многоразовых ячеек вполне хороши и отлично работают со сборными видами. Чтобы зарегистрировать новую ячейку для сборного вида, воспользовавшись ее именем класса, применяется метод registerClass: forCellWithReuseIdentifier: класса UICollectionView, где идентификатор — обычная строка, которую вы сообщаете сборному виду. При попытке получить многоразовые ячейки вы запрашиваете у сборного вида ячейку с заданным идентификатором. Чтобы зарегистрировать со сборным видом. xib-файл, необходимо использовать метод экземпляра registerNib: forCellWithReuseIdentifier: сборного вида. Идентификатор этого метода также вполне функционален, об этом рассказано ранее в данном абзаце.

Nib-файл — это объект типа UINib, с ним мы подробнее познакомимся далее в этой главе.


— (instancetype) initWithCollectionViewLayout:(UICollectionViewLayout *)layout{


self = [super initWithCollectionViewLayout: layout];

if (self!= nil){

/* Регистрируем со сборным видом ячейку для ее удобного получения */

[self.collectionView registerClass: [UICollectionViewCell class]

forCellWithReuseIdentifier: kCollectionViewCellIdentifier];

}

return self;


}


Как видите, в качестве идентификатора для ячеек мы используем константное значение kCollectionViewCellIdentifier. Необходимо определить его в контроллере вида:


#import «ViewController.h»


static NSString *kCollectionViewCellIdentifier = @"Cells";


@implementation ViewController


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


— (NSInteger)numberOfSectionsInCollectionView

:(UICollectionView *)collectionView{

return [self allSectionColors].count;

}


Одно из требований, предъявляемых к нашему приложению, такое: каждая секция должна содержать не менее 20, но не более 40 ячеек. Эту задачу можно решить с помощью функции arc4random_uniform(x). Она возвращает положительные целые числа в диапазоне от 0 до x , где x  — параметр, который вы сообщаете этой функции. Следовательно, если требуется сгенерировать число в диапазоне от 20 до 40, всего лишь нужно прибавить 20 к возвращаемому значению этой функции, а значение x  также сделать равным 20. Зная это, реализуем метод collectionView: numberOfItemsInSec


убрать рекламу






tion: из источника данных сборного вида:


— (NSInteger)collectionView:(UICollectionView *)collectionView

numberOfItemsInSection:(NSInteger)section{

/* Генерируем от 20 до 40 ячеек для заполнения каждой секции */

return 20 + arc4random_uniform(21);

}


Наконец, требуется предоставить ячейки для сборного вида. Для этого реализуем метод collectionView: cellForItemAtIndexPath:, относящийся к источнику данных сборного вида:


— (UICollectionViewCell *)collectionView:(UICollectionView *)collectionView

cellForItemAtIndexPath:(NSIndexPath *)indexPath{


UICollectionViewCell *cell =

[collectionView

dequeueReusableCellWithReuseIdentifier: kCollectionViewCellIdentifier

forIndexPath: indexPath];


cell.backgroundColor = [self allSectionColors][indexPath.section];


return cell;


}

Индексные пути просто содержат номер секции и номер строки. Поэтому индексный путь 0, 1 указывает, что речь идет о второй строке первой секции, поскольку индексы имеют нулевое основание. Если же мы захотим указать пятую строку десятой секции, то обозначим индексный путь как 9, 4. Индексные пути очень широко используются при работе с табличными и сборными видами, так как органично подходят для описания секций, каждая из которых наполнена ячейками. Делегаты и источники данных для табличных и сборных видов при работе указывают целевую ячейку именно по ее индексному пути. Например, если пользователь нажмет ячейку в сборном виде, то вы получите его индексный путь. С помощью этого индексного пути вы также сможете просмотреть базовую структуру данных конкретной ячейки (речь идет о данных, которые использовались в вашем классе для создания этой ячейки).

Как видите, здесь используется метод экземпляра dequeueReusableCellWithReuseIdentifier: forIndexPath:, относящийся к сборному виду. Этот метод применяется для извлечения многоразовых ячеек из очереди. Этот метод ожидает получения двух параметров: идентификатора ячейки, которую вы ранее зарегистрировали с этим сборным видом, а также индексного пути, по которому должна быть отображена ячейка. Индексный путь вы получаете в том же самом методе collectionView: cellForItemAtIndexPath: в качестве параметра, поэтому остается всего лишь сообщить идентификатор ячейки.

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

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


— (void) viewDidLoad{

[super viewDidLoad];

self.collectionView.backgroundColor = [UIColor whiteColor];

}

Экземпляр UICollectionViewController имеет вид типа UIView, к которому можно получить доступ по его свойству view. Не путайте этот вид со свойством collectionView вашего контроллера, соответствующим той сущности, в которой располагается сам сборный вид.

Красота решения, предложенного в данном разделе, заключается в том, что оно отлично работает и на iPad, и на iPhone. На рис. 5.5 показано, как результат выглядит на iPad, на рис. 5.6 — как на iPhone.




Рис. 5.6. Простой сборный вид, изображенный в эмуляторе iPhone

См. также

 Сделать закладку на этом месте книги

Разделы 5.1–5.3.

5.5. Заполнение сборных видов специальными ячейками с помощью XIB-файлов

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

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

Решение

 Сделать закладку на этом месте книги

Выполните следующие шаги.

1. Создайте подкласс UICollectionViewCell и назовите его (в данном примере мы будем использовать имя CollectionViewCell).

2. Создайте пустой . xib-файл и назовите его MyCollectionViewCell.xib.

3. Поместите в конструктор интерфейса ячейку сборного вида (ее вы найдете в библиотеке объектов). Она должна оказаться в вашем пустом. xib-файле (рис. 5.7). В конструкторе интерфейсов измените имя объекта-ячейки на MyCollectionViewCell (рис. 5.8). Поскольку вы устанавливаете такую ассоциацию, когда загружаете. xib-файл программно, специальный класс MyCollectionViewCell будет автоматически попадать в память. Волшебство, да и только!




Рис. 5.7. Объект пользовательского интерфейса «ячейка сборного вида» в библиотеке объектов конструктора интерфейса




Рис. 5.8. Присваивание специального класса. xib-файлу ячейке специального сборного вида


4. Оформите ячейку в конструкторе интерфейса. Необходимо гарантировать, что для каждого компонента пользовательского интерфейса, который вы помещаете в ячейку, создается также ассоциированный с ней объект IBOutlet, расположенный либо в заголовочном файле, либо в файле реализации вашего класса (MyCollectionViewCell).

5. Зарегистрируйте с вашим сборным видом. nib-файл, воспользовавшись для этого методом экземпляра registerNib: forCellWithReuseIdentifier: сборного вида. Чтобы загрузить. nib-файл в память, используется метод класса nibWithNibName: bundle:, относящийся к классу UINib. Об этом методе мы вскоре поговорим.

Обсуждение

 Сделать закладку на этом месте книги

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

1. Откройте File — New — File (Файл — Новый — Файл).

2. В левой части экрана в категории iOS выберите запись User Interface (Пользовательский интерфейс), а в правой части — вариант Empty (Пустой).

3. Теперь система запросит у вас семейство устройств, к которому относится данный. xib-файл. Здесь просто выберите iPhone.

4. Далее вам будет предложено сохранить. xib-файл на диск. Сохраните его под именем MyCollectionViewCell.xib.


Кроме того, потребуется создать класс, который вы сможете связать с содержимым. xib-файла. Этот класс мы назовем MyCollectionViewCell, он будет наследовать от UICollectionViewCell. Чтобы его создать, выполните следующие шаги.

1. Откройте File-New-File (Файл-Новый-Файл).

2. В диалоговом окне для создания нового файла в категории iOS выберите вариант Cocoa Touch. В правой части экрана выберите Objective-C class (Класс Objective-C).

3. Назовите класс MyCollectionViewCell и выберите UICollectionViewCell в качестве его класса-предка.

4. Когда вам будет предложено сохранить файл на диске, так и сделайте.


Теперь нужно ассоциировать созданный класс с. xib-файлом. Для этого выполните следующие шаги.

1. Откройте файл MyCollectionViewCell.xib в конструкторе интерфейса. В библиотеке объектов просто найдите объект Collection View Cell (Ячейка сборного вида) и поместите ее в. xib-файл. По умолчанию эта ячейка будет очень маленькой (50 50 точек) и будет иметь черный фон.

2. Явно выберите эту ячейку в вашем. xib-файле, щелкнув на ней. Откройте инспектор идентичности (Identity Inspector) в конструкторе интерфейса и измените значение поля Class (Класс) на MyCollectionViewCell, как было показано на рис. 5.8.


Далее следует добавить в ячейку нужные компоненты пользовательского интерфейса. Позже при заполнении сборного вида информацией значения этих компонентов можно будет изменить. Для данного примера лучше всего подойдет вид с изображением. Поэтому, когда у вас в конструкторе интерфейса открыт файл MyCollectionViewCell.xib, поместите в него экземпляр UIImageView. Подключите этот вид с изображением к заголовочному файлу вашей ячейки (MyCollectionViewCell.h) и назовите его imageViewBackgroundImage, чтобы заголовочный файл ячейки выглядел примерно так:


#import <UIKit/UIKit.h>


@interface MyCollectionViewCell: UICollectionViewCell


@property (weak, nonatomic) IBOutlet UIImageView *imageViewBackgroundImage;


@end


Мы собираемся заполнить этот вид разными изображениями. В этом разделе я создал для работы три простых изображения, каждое размером 50 50 точек. Вы можете пользоваться любыми другими картинками на ваш выбор — просто поищите их в Интернете. Когда найдете понравившиеся вам картинки, добавьте их в свой проект. Убедитесь, что изображения называются 1.png, 2.png и 3.png и что их увеличенные вдвое аналоги для сетчатого дисплея называются [email protected], [email protected] и [email protected].

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

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


— (NSArray *) allImages{


static NSArray *AllSectionImages = nil;


if (AllSectionImages == nil){

AllSectionImages = @[

[UIImage imageNamed:@"1"],

[UIImage imageNamed:@"2"],

[UIImage imageNamed:@"3"]

];

}


return AllSectionImages;


}


— (UIImage *) randomImage{

return [self allImages][arc4random_uniform([self allImages].count)];

}


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


— (instancetype) initWithCollectionViewLayout:(UICollectionViewLayout *)layout{


self = [super initWithCollectionViewLayout: layout];

if (self!= nil){

/* Регистрируем nib-файл со сборным видом для удобства получения информации */

UINib *nib = [UINib nibWithNibName:

NSStringFromClass([MyCollectionViewCell class])

bundle: [NSBundle mainBundle]];


[self.collectionView registerNib: nib

forCellWithReuseIdentifier: kCollectionViewCellIdentifier];

}

return self;

}


В ответ на запрос о том, сколько у нас секций, также возвратим случайное число в диапазоне от 3 до 6. Это требование не является обязательным — мы вполне могли бы обойтись и одной секцией, но если их будет больше, это точно не помешает. Кроме того, в каждой секции должно быть от 10 до 15 ячеек:


— (NSInteger)numberOfSectionsInCollectionView

:(UICollectionView *)collectionView{

/* От 3 до 6 секций */

return 3 + arc4random_uniform(4);

}


— (NSInteger)collectionView:(UICollectionView *)collectionView

numberOfItemsInSection:(NSInteger)section{

/* В каждой секции — от 10 до 15 ячеек */

return 10 + arc4random_uniform(6);

}


Наконец, запросим у сборного вида ячейки, а затем сконфигурируем их со случайными фоновыми изображениями:


— (UICollectionViewCell *)collectionView:(UICollectionView *)collectionView

cellForItemAtIndexPath:(NSIndexPath *)indexPath{


MyCollectionViewCell *cell =

[collectionView

dequeueReusableCellWithReuseIdentifier: kCollectionViewCellIdentifier

forIndexPath: indexPath];


cell.imageViewBackgroundImage.image = [self randomImage];

cell.imageViewBackgroundImage.contentMode = UIViewContentModeScaleAspectFit;


return cell;


}

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

#import «ViewController.h»

#import «MyCollectionViewCell.h»



Запустив приложение, вы увидите примерно такую картинку, как на рис. 5.9. Разумеется, если вы используете в примере другие изображения, она будет другой, но у меня тут показаны нотки.




Рис. 5.9. Сборный вид со специальными ячейками, загруженными из. nib-файла

См. также

 Сделать закладку на этом месте книги

Раздел 5.4.

5.6. Обработка событий в сборных видах

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

Необходимо обрабатывать события, происходящие в сборных видах, например касания.

Решение

 Сделать закладку на этом месте книги

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

Обсуждение

 Сделать закладку на этом месте книги

У сборных видов есть свойства delegate, которые должны соответствовать протоколу UICollectionViewDelegate. Делегатный объект, создаваемый с их помощью, будет получать различные делегатные вызовы от сборного вида, сообщающего делегату о различных событиях, например о том, что элемент был подсвечен или выделен. Необходимо различать подсвеченное и выделенное состояние ячейки сборного вида. Когда пользователь нажимает пальцем на ячейку сборного вида, но не поднимает палец сразу после этого, ячейка под пальцем становится подсвеченной . Когда пользователь нажимает на ячейку, а затем сразу поднимает палец (это означает, что он хочет совершить с ячейкой какое-то действие), данная ячейка становится выделенной .

Ячейки сборных видов, относящиеся к типу UICollectionViewCell, имеют два очень полезных свойства — highlighted и selected.

Если вы хотите всего лишь изменить визуальное оформление вашей ячейки, когда она выделена, то задача тем более упрощается, поскольку ячейки типа UICollectionViewCell предоставляют свойство selectedBackgroundView типа UIView. В качестве значения этого свойства можно задать любой валидный вид. Затем этот вид отобразится на экране, как только ячейка будет выделена. Продемонстрируем эти возможности на основе кода, который мы написали в разделе 5.5. Как вы помните, там мы создали специальную ячейку, одно из свойств которой (imageViewBackgroundImage) снабжало ее фоновым изображением. Изображение заполняло весь фон ячейки. В этот вид с изображением мы загружали специально подобранные картинки. Теперь мы собираемся залить фон  ячейки голубым цветом, как только она будет выделена. Поскольку вид с изображением находится поверх всех остальных компонентов сборного вида, перед заданием фонового цвета нам придется гарантировать, что этот вид с изображением будет прозрачным. Для этого оттенок фона вида с изображением нужно изменить на проницаемый. Дело в том, что по умолчанию фон у вида с изображением непрозрачный, поэтому если расположить такой вид поверх другого вида, имеющего фоновый цвет, то этот фоновый цвет, естественно, виден не будет. Соответственно, чтобы оставался виден фоновый цвет того вида, который является вышестоящим для вида с изображением, фон самого вида с изображением должен быть прозрачным. Итак, начнем:


#import «MyCollectionViewCell.h»


@implementation MyCollectionViewCell


— (void) awakeFromNib{

[super awakeFromNib];

self.imageViewBackgroundImage.backgroundColor = [UIColor clearColor];

self.selectedBackgroundView = [[UIView alloc] initWithFrame: self.bounds];

self.selectedBackgroundView.backgroundColor = [UIColor blueColor];

}


@end


Вот и все! Теперь если нажать любую ячейку в вашей программе, она сразу приобретет голубой цвет фона.

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

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

• collectionView: didHighlightItemAtIndexPath: — вызывается в делегате, когда ячейка подсвечивается.

• collectionView: didUnhighlightItemAtIndexPath: — вызывается в делегате, когда ячейка выходит из подсвеченного состояния. Этот метод срабатывает, когда пользователь успешно завершает событие касания (попадает пальцем по нужному элементу, а потом поднимает палец, совершая, таким образом, жест касания). В другом случае этот метод срабатывает, когда пользователь отменяет сделанное ранее выделение, выводя палец за пределы ячейки.

• collectionView: didSelectItemAtIndexPath: — этот метод вызывается в делегатном объекте, когда конкретная ячейка становится выделенной. Ячейка всегда является подсвеченной, перед тем как стать выделенной.

• collectionView: didDeselectItemAtIndexPath: — вызывается в делегате, когда ячейка выходит из выделенного состояния.


Итак, напишем приложение в соответствии с изложенными выше требованиями. Мы хотим, чтобы ячейка «развоплощалась», а потом вновь «вырисовывалась» на экране, когда ее выделяют. В экземпляре UICollectionViewController реализуем метод collectionView: didSelectItemAtIndexPath:, вот так:


#import «ViewController.h»

#import «MyCollectionViewCell.h»


static NSString *kCollectionViewCellIdentifier = @"Cells";


@implementation ViewController


— (void) collectionView:(UICollectionView *)collectionView

didSelectItemAtIndexPath:(NSIndexPath *)indexPath{


UICollectionViewCell *selectedCell =

[collectionView cellForItemAtIndexPath: indexPath];


const NSTimeInterval kAnimationDuration = 0.20;


[UIView animateWithDuration: kAnimationDuration animations: ^{

selectedCell.alpha = 0.0f;

} completion: ^(BOOL finished) {

[UIView animateWithDuration: kAnimationDuration animations: ^{

selectedCell.alpha = 1.0f;

}];

}];

}


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

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

Итак, тут все было просто. Рассмотрим другой пример. Допустим, когда ячейка подсвечивается, мы хотим сделать ее вдвое крупнее обычного ее размера, а при выходе этой ячейки из подсвеченного состояния вернуть ей исходный размер. Таким образом, когда пользователь прикасается пальцем к ячейке (но еще не поднимает палец), ячейка увеличивается вдвое, а когда пользователь убирает палец — вновь уменьшается, тоже вдвое. Для этого нам потребуется реализовать в контроллере сборного вида методы collectionView: didHighlightItemAtIndexPath: и collectionView: didUnhighlightItemAtIndexPath: из протокола UICollectionViewDelegate. Как вы помните, контроллеры сборных видов по умолчанию соответствуют протоколам UICollectionViewDelegate и UICollectionViewDataSource:


#import «ViewController.h»

#import «MyCollectionViewCell.h»


static NSString *kCollectionViewCellIdentifier = @"Cells";

const NSTimeInterval kAnimationDuration = 0.20;


@implementation ViewController


— (void) collectionView:(UICollectionView *)collectionView

didHighlightItemAtIndexPath:(NSIndexPath *)indexPath{


UICollectionViewCell *selectedCell =

[collectionView cellForItemAtIndexPath: indexPath];


[UIView animateWithDuration: kAnimationDuration animations: ^{

selectedCell.transform = CGAffineTransformMakeScale(2.0f, 2.0f);

}];


}


— (void) collectionView:(UICollectionView *)collectionView

didUnhighlightItemAtIndexPath:(NSIndexPath *)indexPath{


UICollectionViewCell *selectedCell =

[collectionView cellForItemAtIndexPath: indexPath];


[UIView animateWithDuration: kAnimationDuration animations: ^{

selectedCell.transform = CGAffineTransformMakeScale(1.0f, 1.0f);

}];


}



Как видите, мы используем функцию CGAffineTransformMakeScale из фреймворка Core Graphics для создания аффинного преобразования, а потом присваиваем это преобразование самой ячейке. Достигается нужный эффект: сначала ячейка увеличивается вдвое, а потом уменьшается до исходного размера. Эта функция подробнее описана в разделе 17.12.

См. также

 Сделать закладку на этом месте книги

Разделы 5.2, 5.3, 5.5, 17.12.

5.7. Создание верхних и нижних колонтитулов в макете с последовательной компоновкой

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

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

Решение

 Сделать закладку на этом месте книги

Выполните следующие шаги.

1. Создайте по файлу. xib для верхнего и для нижнего колонтитулов.

2. Найдите в библиотеке объектов конструктора интерфейса по одному объекту Collection Reusable View и перетащите их в ваши. xib-файлы. Убедитесь, что эти многоразовые сборные виды являются единственными видами в своих. xib-файлах. Таким образом, многоразовый сборный вид становится корневым видом вашего. xib-файла. Именно так создаются колонтитулы в сборных видах.

3. Если вы хотите более полно контролировать поведение. xib-файлов, создайте класс Objective-C и ассоциируйте с ним корневой вид вашего. xib-файла. Таким образом, всякий раз, когда iOS будет загружать с диска содержимое. xib-файла, ассоциированный с ним класс также будет загружаться в память и вы будете получать доступ к иерархии видов в. xib-файле.

4. Инстанцируйте метод экземпляра registerNib: forSupplementaryViewOfKind: withReuseIdentifier: сборного вида и зарегистрируйте ваши nib-файлы для разновидностей видов UICollectionElementKindSectionHeader и UICollectionElementKindSectionFooter.

5. Чтобы правильно оформить виды верхних и нижних колонтитулов перед тем, как они будут отображены, реализуйте метод collectionView: viewForSupplementaryElementOfKind: atIndexPath: источника данных сборного вида, а в этом методе запустите другой метод сборного вида, dequeueReusableSupplementaryViewOfKind: withReuseIdentifier: forIndexPath:, чтобы извлечь из очереди многоразовый вид верхнего или нижнего колонтитула.

6. Наконец, необходимо убедиться, что размер видов для верхних и нижних колонтитулов задается путем присваивания соответствующих значений свойствам headerReferenceSize и footerReferenceSize макетного объекта, отвечающего


убрать рекламу






за последовательную компоновку.

Обсуждение

 Сделать закладку на этом месте книги

Итак, теперь нам требуется создать. xib-файлы для специальных верхних и нижних колонтитулов. Назовем их Header.xib и Footer.xib. Мы создаем их по тому же принципу, который описан в разделе 5.5, поэтому я не буду вновь повторять здесь этот материал. Убедитесь в том, что и для верхнего и для нижнего колонтитула у вас есть по одному классу Objective-C. Назовите их соответственно Header и Footer. Необходимо гарантировать, что оба этих класса наследуют от UICollectionReusableView. Закончив с этим, сконфигурируйте в конструкторе интерфейса подпись и кнопку, затем перетащите подпись в файл Header, а кнопку — в файл Footer. Свяжите их с вашими классами так, как показано на рис. 5.10 и 5.11.




Рис. 5.10. Конфигурирование ячейки верхнего колонтитула для сборного вида в конструкторе интерфейса




Рис. 5.11. Конфигурирование ячейки нижнего колонтитула для сборного вида в конструкторе интерфейса



#import <UIKit/UIKit.h>


@interface Header: UICollectionReusableView

@property (weak, nonatomic) IBOutlet UILabel *label;

@end


То же самое я делаю и в нижнем колонтитуле, связав кнопку из файла Footer.xib с аутлетом из файла Footer.h и назвав аутлет button:


#import <UIKit/UIKit.h>


@interface Footer: UICollectionReusableView

@property (weak, nonatomic) IBOutlet UIButton *button;

@end

Теперь в контроллере сборного вида определим идентификаторы для ячеек верхнего и нижнего колонтитулов:

#import «ViewController.h»

#import «MyCollectionViewCell.h»

#import «Header.h»

#import «Footer.h»


static NSString *kCollectionViewCellIdentifier = @"Cells";

static NSString *kCollectionViewHeaderIdentifier = @"Headers";

static NSString *kCollectionViewFooterIdentifier = @"Footers";


@implementation ViewController


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


— (instancetype) initWithCollectionViewLayout:(UICollectionViewLayout *)layout{


self = [super initWithCollectionViewLayout: layout];

if (self!= nil){

/* Регистрируем nib-файл со сборным видом для удобного получения */

UINib *nib = [UINib nibWithNibName:

NSStringFromClass([MyCollectionViewCell class])

bundle: [NSBundle mainBundle]];


[self.collectionView registerNib: nib

forCellWithReuseIdentifier: kCollectionViewCellIdentifier];


/* Регистрируем nib-файл верхнего колонтитула */

UINib *headerNib = [UINib

nibWithNibName: NSStringFromClass([Header class])

bundle: [NSBundle mainBundle]];

[self.collectionView registerNib: headerNib

forSupplementaryViewOfKind: UICollectionElementKindSectionHeader

withReuseIdentifier: kCollectionViewHeaderIdentifier];


/* Регистрируем nib-файл нижнего колонтитула */

UINib *footerNib = [UINib

nibWithNibName: NSStringFromClass([Footer class])

bundle: [NSBundle mainBundle]];

[self.collectionView registerNib: footerNib

forSupplementaryViewOfKind: UICollectionElementKindSectionFooter

withReuseIdentifier: kCollectionViewFooterIdentifier];

}

return self;


}


Переходим к реализации метода collectionView: viewForSupplemen taryElementOfKind: atIndexPath: сборного вида. Этот метод нужен нам для конфигурирования верхних и нижних колонтитулов и предоставления их обратно сборному виду:


— (UICollectionReusableView *)collectionView:(UICollectionView *)collectionView

viewForSupplementaryElementOfKind:(NSString *)kind

atIndexPath:(NSIndexPath *)indexPath{


NSString *reuseIdentifier = kCollectionViewHeaderIdentifier;

if ([kind isEqualToString: UICollectionElementKindSectionFooter]){

reuseIdentifier = kCollectionViewFooterIdentifier;

}


UICollectionReusableView *view =

[collectionView dequeueReusableSupplementaryViewOfKind: kind

withReuseIdentifier: reuseIdentifier

forIndexPath: indexPath];


if ([kind isEqualToString: UICollectionElementKindSectionHeader]){

Header *header = (Header *)view;

header.label.text = [NSString stringWithFormat:@"Section Header %lu",

(unsigned long)indexPath.section + 1];

}

else if ([kind isEqualToString: UICollectionElementKindSectionFooter]){

Footer *footer = (Footer *)view;


NSString *title = [NSString stringWithFormat:@"Section Footer %lu",

(unsigned long)indexPath.section + 1];

[footer.button setTitle: title forState: UIControlStateNormal];


}


return view;


}


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


— (UICollectionViewFlowLayout *) flowLayout{


UICollectionViewFlowLayout *flowLayout =

[[UICollectionViewFlowLayout alloc] init];


flowLayout.minimumLineSpacing = 20.0f;

flowLayout.minimumInteritemSpacing = 10.0f;

flowLayout.itemSize = CGSizeMake(80.0f, 120.0f);

flowLayout.scrollDirection = UICollectionViewScrollDirectionVertical;

flowLayout.sectionInset = UIEdgeInsetsMake(10.0f, 20.0f, 10.0f, 20.0f);

/* Задаем базовый размер для видов с верхними и нижними колонтитулами */

flowLayout.headerReferenceSize = CGSizeMake(300.0f, 50.0f);

flowLayout.footerReferenceSize = CGSizeMake(300.0f, 50.0f);


return flowLayout;


}


Итак, все готово! Если вы теперь запустите приложение в эмуляторе iPad, то увидите примерно такой результат, как на рис. 5.12.




Рис. 5.12. Верхние и нижние колонтитулы в сборном виде

См. также

 Сделать закладку на этом месте книги

Разделы 5.2, 5.3, 5.5.

5.8. Добавление собственных вариантов взаимодействий к сборным видам

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

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

Решение

 Сделать закладку на этом месте книги

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

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

Обсуждение

 Сделать закладку на этом месте книги

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

Рассмотрим пример. В этом примере мы собираемся добавить к сборному виду возможность уменьшения и увеличения изображения (то есть его масштабирования). Этот пример будет выстроен на основе того, который мы подготовили в разделе 5.5. Итак, первым делом мы должны добавить распознаватель щипков в коллекцию распознавателей жестов, имеющихся в сборном виде. Мы сделаем это в методе viewDidLoad контроллера сборного вида:


— (void) viewDidLoad{

[super viewDidLoad];

self.collectionView.backgroundColor = [UIColor whiteColor];


UIPinchGestureRecognizer *pinch = [[UIPinchGestureRecognizer alloc]

initWithTarget: self

action:@selector(handlePinches:)];

for (UIGestureRecognizer *recognizer in

self.collectionView.gestureRecognizers){

if ([recognizer isKindOfClass: [pinch class]]){

[recognizer requireGestureRecognizerToFail: pinch];

}

}

[self.collectionView addGestureRecognizer: pinch];

}


Настраиваем распознаватель жестов щипка для вызова метода handlePinches: контроллера вида. Сейчас мы напишем этот метод:


— (void) handlePinches:(UIPinchGestureRecognizer *)paramSender{


CGSize DefaultLayoutItemSize = CGSizeMake(80.0f, 120.0f);


UICollectionViewFlowLayout *layout =

(UICollectionViewFlowLayout *)self.collectionView.collectionViewLayout;


layout.itemSize =

CGSizeMake(DefaultLayoutItemSize.width * paramSender.scale,

DefaultLayoutItemSize.height * paramSender.scale);


[layout invalidateLayout];

}


В этом коде есть две очень важные детали.

1. Предполагается, что по умолчанию размер элемента в макете последовательной компоновки сборного вида имеет ширину 80 точек и высоту 120 точек. Именно так мы создали макет с последовательной компоновкой для сборного вида в разделе 5.3. Затем мы берем коэффициент масштабирования, полученный от распознавателя жестов щипка, и умножаем на него размер элементов из сборного вида. В результате эти экранные элементы могут уменьшиться или увеличиться в зависимости от того, как именно пользователь масштабирует экран.

2. После того как был изменен размер элемента, применяемый по умолчанию в макете с последовательной компоновкой, макет необходимо обновить. В табличных видах мы обновляли либо нужные секции таблицы, либо всю таблицу, но в данном случае обновляем или упраздняем макет, прикрепленный к сборному виду. Это делается, чтобы сборный вид полностью «перерисовал» себя после изменения макета. Поскольку сборный вид в каждый момент времени может содержать всего один макетный объект, при упразднении такого макетного объекта потребуется перезагрузить весь сборный вид. Если бы мы могли иметь отдельный макет для каждой секции, то могли бы перезагружать только те секции, которые связаны с данным макетом. Но, имея такой код, как сейчас, при упразднении макетного объекта придется перерисовывать весь сборный вид.

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

См. также

 Сделать закладку на этом месте книги

Разделы 5.3 и 5.5.

5.9. Представление контекстных меню в ячейках сборных видов

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

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

Решение

 Сделать закладку на этом месте книги

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

• collectionView: shouldShowMenuForItemAtIndexPath: — среда времени исполнения передает этому методу индексный путь к элементу. Метод возвращает логическое значение, указывающее дальнейшее действие: должен этот элемент открывать контекстное меню или нет.

• collectionView: canPerformAction: forItemAtIndexPath: withSender: — среда времени исполнения передает этому методу селектор типа SEL. Можно проверить селектор (обычно для этого он преобразуется в строку, которая затем сравнивается со строкой, представляющей действие) и определить, хотите ли вы, чтобы указанное действие произошло. Возвратите YES, чтобы разрешить такое действие, либо NO, чтобы подавить его. Не забывайте, что вы всегда можете преобразовать селектор в строку, воспользовавшись методом NSStringFromSelector. Типичные примеры селекторов — copy: или paste: для команд контекстного меню Копировать или Вставить соответственно.

• collectionView: performAction: forItemAtIndexPath: withSender: — здесь выполняется действие, которое было с вашего разрешения отображено в сборном виде с помощью вышеупомянутых делегатных методов.

Обсуждение

 Сделать закладку на этом месте книги

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

Первым делом реализуем в делегате сборного вида метод collectionView: shouldShowMenuForItemAtIndexPath:. В данном примере мы работаем с контроллером сборного вида, который сам является и делегатом и источником данных. Поэтому фактически нам придется всего лишь реализовать вышеупомянутый метод в контроллере сборного вида, вот так:


— (BOOL) collectionView:(UICollectionView *)collectionView

shouldShowMenuForItemAtIndexPath:(NSIndexPath *)indexPath{

return YES;

}


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


— (BOOL) collectionView:(UICollectionView *)collectionView

canPerformAction:(SEL)action

forItemAtIndexPath:(NSIndexPath *)indexPath

withSender:(id)sender{


if (action == @selector(copy:)){

return YES;

}


return NO;

}


Как видите, нам даже не требуется преобразовывать селектор в строку, чтобы сравнить его с такими строками, как copy:. Мы всего лишь используем оператор равенства, чтобы проверить, отвечает ли запрошенный селектор нашим ожиданиям. Если это так, возвращаем YES, в противном случае — NO.

Наконец, нам потребуется реализовать в делегате метод collectionView: performAction: forItemAtIndexPath: withSender:. С помощью этого метода мы узнаем, было ли вызвано действие копирования, а потом копируем изображение, взятое из ячейки, в буфер обмена. Пользователь сможет вставить из буфера изображение в файл из совершенно другого приложения:


— (void) collectionView:(UICollectionView *)collectionView

performAction:(SEL)action

forItemAtIndexPath:(NSIndexPath *)indexPath

withSender:(id)sender{


if (action == @selector(copy:)){


MyCollectionViewCell *cell = (MyCollectionViewCell *)[collectionView

cellForItemAtIndexPath: indexPath];


[[UIPasteboard generalPasteboard]

setImage: cell.imageViewBackgroundImage.image];


}


}


Теперь, если вы запустите приложение и нажмете один из элементов в сборном виде, а потом будете удерживать на нем палец, то получите примерно такой результат, как на рис. 5.13.




Рис. 5.13. Элемент контекстного меню, отображаемый в ячейке сборного вида

См. также

 Сделать закладку на этом месте книги

Раздел 5.5.

Глава 6. Раскадровки

 Сделать закладку на этом месте книги

6.0. Введение

 Сделать закладку на этом месте книги

Программисты iOS уже привыкли работать с контроллерами видов. Мы умеем пользоваться навигационными контроллерами, чтобы выводить на экран и убирать с него контроллеры видов. Но Apple полагает, что такие задачи можно решать и проще, и поэтому в системе появились раскадровки. Раскадровки  — это новый способ определения связей между экранами вашего приложения. Например, если в вашем приложении 20 уникальных контроллеров видов, вы написали эти контроллеры год назад, а сейчас  снова изучаете исходный код, то вам придется снова распутывать все замысловатые соединения между контроллерами видов. Вы будете пытаться запомнить, какой именно контроллер вида поднимается вверх по стеку, когда пользователь совершает то или иное действие. Это может быть очень сложно, особенно если вы не слишком подробно документировали код. И вот тут вам поможет раскадровка. Раскадровка позволяет просматривать или создавать сразу весь пользовательский интерфейс приложения, а также выстраивать связи между контроллерами видов на одном экране. Да, все настолько просто.

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

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

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

6.1. Добавление в раскадровку навигационного контроллера

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

Требуется возможность управлять несколькими котроллерами видов в приложении, построенном на основе раскадровки.

Решение

 Сделать закладку на этом месте книги

Задайте навигационный контроллер как исходный контроллер вида в файле раскадровки.

Обсуждение

 Сделать закладку на этом месте книги

Если вы создали в Xcode новое универсальное приложение, воспользовавшись шаблоном Single View Application (Приложение с единственным видом), то у вас будет два файла раскадровок: Main_iPhone.storyboard и Main_iPad.storyboard. Если просмотреть их в конструкторе интерфейса, то легко заметить, что контроллер вида применяется в них в качестве корневого контроллера. На рис. 6.1 показано содержимое простого готового файла раскадровки для iPhone.




Рис. 6.1. Контроллер вида в качестве корневого элемента файла раскадровки


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

1. Выберите контроллер вида на холсте раскадровки.

2. В меню Edit (Правка) выберите команду Embed in (Встроить), а затем Navigation Controller (Навигационный контроллер) (рис. 6.2).




Рис. 6.2. Активизация контроллера вида в навигационном контроллере


Как только справитесь с этим, вы заметите, что контроллер вида в раскадровке превратился в навигационный контроллер (рис. 6.3).




Рис. 6.3. Навигационный контроллер теперь является корневым контроллером раскадровки

См. также

 Сделать закладку на этом месте книги

Раздел 6.0.

6.2. Передача данных с одного экрана на другой

 Сделать закладку на этом месте книги

Постановка задачи

 Сделать закладку на этом месте книги

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

Решение

 Сделать закладку на этом месте книги

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

Обсуждение

 Сделать закладку на этом месте книги

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

Рассмотрим прикладной пример с использованием сегвеев. В этом разделе мы собираемся отобразить на экране примерно такой контроллер вида, как показан на рис. 6.4.




Рис. 6.4. Первый контроллер вида в нашем приложении; на контроллере вида есть текстовое поле и кнопка


Та информация, которую пользователь внесет в текстовое поле, будет передана второму контроллеру вида посредством сегвея и задана в качестве заголовка этого контроллера вида. Хо


убрать рекламу






лст второго контроллера вида будет пуст. Итак, воспользуйтесь приемами, изученными в разделе 6.1, и поместите первый контроллер вида в навигационный контроллер. Теперь возьмите в библиотеке объектов другой контроллер вида, поместите его в раскадровку, а также разместите в первом контроллере вида кнопку и текстовое поле. Вы заметите, что положение текстовог