Программирование КПК и смартфонов на .NET Compact Framework (fb2)

- Программирование КПК и смартфонов на .NET Compact Framework 1.48 Мб, 233с.  (читать) (читать постранично) (скачать fb2) (скачать исправленную) - Александр Петрович Климов

Настройки текста:



Программирование КПК и смартфонов на .NET Compact Framework

Введение

Сейчас очень трудно найти книги, в которых описываются проблемы программирования для карманных компьютеров и смартфонов при помощи технологии .NET Compact Framework. Одним из главных источников получения информации является сама документация, входящая в состав Visual Studio 2005. Но одной документации явно недостаточно. Именно поэтому и появилась на свет книга, которую вы держите в руках.

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

На кого рассчитана эта книга

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

Требования

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

Примеры к книге

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

В качестве основного языка программирования был выбран язык C#, но в третьей главе были также добавлены примеры программирования на языке Visual Basic.NET. Если среди читателей книги найдется много приверженцев этого языка, то на сайте автора будут выложены все необходимые примеры, написанные на Visual Basic.NET.

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

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

В первую очередь надо поблагодарить издательство «Питер» (www.piter.com), которое согласилось выпустить данную книгу.

Хочу также выразить благодарность тем людям, которые любезно разрешили использовать исходные коды своих чудесных программ в качестве учебных примеров. Это Кристиан Форсберг (Christian Forsberg), Алекс Яхнин (Alex Yakhnin) и Роб Майлз (Rob Miles). Без примеров этих авторов книга получилась бы скучной и неинтересной.

Так получилось, что во время написания книги мне пришлось поменять работу. В этом процессе участвовали несколько человек, которые способствовали переходу. Поэтому хочется поблагодарить и этих людей, благодаря которым у меня появились дополнительные возможности для работы над книгой. В первую очередь хотелось бы отметить генерального директора гостиничного комплекса «Вега» Воробьева Алексея Петровича, главного инженера Миклушова Владимира Павловича и начальницу АХО Егоркину Галину Владимировну. Хочу поблагодарить также всех сотрудников отдела информационных технологий, возглавляемого Рогулиным Виктором Васильевичем, которые делились своими знаниями на новой работе: Храмцову В., Пузикову Н. (особенно), Фетисову Е., Шумова Е., Князева Л., Алдохина А., Дробота В., Терехова А., Нечеухина Н.

Отзывы и предложения

Все свои отзывы и критические замечания вы можете посылать на электронный адрес автора rusproject@mail.ru. Также стоит почаще заглядывать на сайт http://rusproject.narod.ru, на котором я постараюсь размещать новые дополнительные материалы по тематике книги.

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

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

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

Все исходные тексты, приведенные в книге, вы можете найти по адресу http://www.piter.com/download.

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

Глава 1 Знакомство с .NET Compact Framework

Мобильные устройства

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

В последнее время на рынок активно выходят смартфоны под управлением операционной системы Windows Mobile 5.0. Пока в этом сегменте рынка прочные позиции удерживают смартфоны под управлением Symbian, производимые фирмами Nokia и Sony Ericsson. Но умение Microsoft завоевывать себе место под солнцем давно стало общеизвестным. Достаточно вспомнить противоборство браузеров Netscape и Internet Explorer, а также КПК Palm и PocketPC. Эта тенденция позволяет считать, что и «умные» телефоны под управлением Windows Mobile скоро потеснят своих конкурентов.

И в этой ситуации очень ярко проявляется преимущество изучения .NET Compact Framework. Если вы знакомы с программированием для .NET Framework, то вам не составит труда перейти к освоению особенностей программирования для КПК и мобильных телефонов под управлением Windows Mobile. Ведь писать программы придется в уже знакомой вам среде Visual Studio .NET. Более того, вам даже не обязательно иметь сам карманный компьютер или смартфон для проверки написанного кода, так как в Visual Studio .NET уже имеются эмуляторы для этих мобильных устройств.

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

В данной книге все примеры написаны на новых языках семейства .NET, таких как C# и Visual Basic .NET.

Общие сведения

Главная страница, посвященная .NET Compact Framework, находится по адресу http://msdn.microsoft.com/netframework/programming/netcf/default.aspx. Там можно найти все последние новости о рассматриваемой технологии, обновления программ, ссылки на другие полезные сайты, примеры.

Технология .NET Compact Framework поддерживается операционными системами Pocket PC 2000, Pocket PC 2002, Windows Mobile 2003, Windows Mobile 2005 и Windows CE .NET 4.1.

Конечно, технология .NET Compact Framework несколько отличается от .NET Framework. Подробную информацию о различиях между этими технологиями можно найти на странице по адресу msdn.microsoft.com/library/default.asp?url=/library/en-us/dv_evtuv/html/etconComparisonsWithNETFramework.asp. Считается, что .NET Compact Framework является частью полной библиотеки .NET Framework. Действительно, между двумя этими платформами очень много общего. Но все же говорить о .NET Compact Framework как о подмножестве полной .NET Framework не совсем корректно. Дело в том, что .NET Compact Framework поддерживает серию классов, которых нет в полной библиотеке классов. Эти классы созданы специально для мобильных устройств и позволяют поддерживать, например, программную клавиатуру, возможности инфракрасной связи и отправки SMS.

Библиотека .NET Compact Framework действительно компактна. Вместо 20 Мбайт полного пакета .NET Framework, устанавливаемого на настольные компьютеры, она занимает около 2 Мбайт. Полная версия .NET Framework содержит 18 700 классов и 80 000 методов, a NET Compact Framework — всего лишь 4 700 классов и 13 000 методов. Но следует помнить, что это лишь приблизительная оценка.

Развитие .NET Compact Framework

Поначалу .NET Compact Framework устанавливалась в карманные компьютеры Pocket PC отдельно. Это порождало определенные проблемы для разработчиков. Не каждый пользователь хотел устанавливать пакет .NET Compact Framework, необходимый для работы программы, когда оперативной памяти и так не хватает. Впервые библиотека .NET Compact Framework стала встраиваться в портативные устройства под управлением Windows Mobile 2003 (Pocket PC 2003). На борту компьютеров под управлением Windows Mobile Second Edition уже находился пакет .NET Compact Framework 1.0 SP2). По уверениям Microsoft, работа с ресурсами стала быстрее на 600%, работа с XML с помощью класса XMLTextReader стала быстрее на 40%, а работа с ADO.NET — на 20%. Естественно, с выходом библиотеки .NET Compact Framework 2.0 создатели снова стали говорить о повышении быстродействия и надежности. Но следует учитывать, что устройства с предустановленной библиотекой .NET Compact Framework 2.0 еще не выпускаются, и пользователь должен сам установить необходимый пакет. Возможно, когда книга выйдет из печати, в мире уже появятся устройства встроенной версией .NET Compact Framework 2.0.

Что нового в .NET Compact Framework 2.0

Список основных изменений в .NET Compact Framework 2.0 приведен на странице msdn.microsoft.com/netframework/programming/netcf/default.aspx?pull=/library/en-us/dnnetcomp/html/whats_new_netcf2.asp. К основным улучшениям библиотеки .NET Compact Framework 2.0 относятся усовершенствованные возможности создания пользовательского интерфейса, новая мобильная база данных, существенные усовершенствования эмулятора, усиленная поддержка COM Interop и Managed Interfaces для D3D. Библиотека .NET Compact Framework 2.0 расширила существующую функциональность в .NET CF 1.0 новыми возможностями. Также разработчики добавили поддержку новых классов, которые ранее были доступны только в полной .NET Framework. В этой книге обязательно будут рассмотрены наиболее значительные новинки. А сейчас можно лишь упомянуть основные моменты.

Пакет .NET Compact Framework 2.0 в Visual Studio 2005 стал поддерживать новые элементы управления, позволяющие создавать очень сложные приложения без написания громоздкого кода. В частности, появилась поддержка элементов управления MonthCalendar и DateTimePicker, позволяющих создавать интерфейс календаря. Также появился новый элемент для уведомлений Notification. Кроме него разработчики получили доступ к элементам DocumentList и HardwareButton. Более подробно они будут рассматриваться в главе, посвященной элементам управления. Новое свойство ScreenOrientation позволяет без использования неуправляемого кода вращать экран устройства. Кроме того, стало значительно проще создавать собственные элементы управления, как это делается в полной версии .NET Framework.

Элементы пользовательского интерфейса в .NET Compact Framework 2.0 теперь поддерживают присоединение (docking). При перемещении элемента управления к определенной стороне контейнера он всегда заполняет эту сторону контейнера.

Некоторые элементы управления стали поддерживать свойство AutoScaleMode. Свойство AutoScaleMode показывает, как нужно перерисовывать элемент при изменении разрешения экрана. Также формы стали поддерживать свойство AutoScroll.

Помимо этого класс Control теперь поддерживает методы SuspendLayout и ResumeLayout. Также в .NET Compact Framework появилась полноценная поддержка буфера обмена.

Класс Graphics тоже получил новые возможности, и теперь при помощи свойств DpiX и DpiY разработчик может узнать размеры экрана. Помимо этого сейчас можно отображать текст под различными углами при помощи класса LogFont. Также разработчик может создавать перья заданных цвета и размера.

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

Новые возможности позволяют разрабатывать приложения с использованием управляемого кода для Windows Mobile 5.0 при помощи классов из пространства имен Microsoft.Windows.DirectX. Поддержка DirectX позволяет писать игры с использованием управляемого кода, обеспечивая более быструю разработку приложений, чем при использовании неуправляемого DirectX.

Так как на рынке все чаще стали появляться устройства со встроенной клавиатурой, то в библиотеку .NET Compact Framework 2.0 была введена поддержка клавиатуры.

Также следует отметить, что элементы управления теперь распознают события KeyUp, KeyDown и KeyPress. Объект Form теперь имеет свойство KeyPreview.

Тестировать программы тоже стало намного проще, так как эмулятор в .NET Compact Framework 2.0 подвергся значительной переработке. Перечень функциональных возможностей эмуляторов Pocket PC и смартфонов был расширен, что облегчает создание, проверку и развертывание приложений. Особое внимание было уделено поддержке сетевого взаимодействия. Кроме того, было улучшено быстродействие эмулятора. Появилась поддержка программы ActiveSync, можно работать с общими папками и использовать четыре COM-порта. Также эмулятор стал поддерживать работу с портретным и альбомным режимами отображения. Кроме того, эмулятор теперь эмулирует работу ARM-процессора.

Технология Smart Device CAB Project упростила развертывание мобильных приложений. Эта технология позволяет использовать в визуальном редакторе перемещение файлов, создавать папки и записи в реестре. Теперь создавать CAB-проект для установочного пакета так же просто, как при создании проекта Windows Installer для настольных компьютеров.

Новый компилятор теперь создает еще лучший и более быстрый код. Если в предыдущей версии использовались два JIT-компилятора, то теперь .NET CF 2.0 применяет единый компилятор для всех поддерживаемых процессоров.

В области безопасности добавлена поддержка идентификации NTLM и Kerberos. Также улучшена работа с технологией XML, и в распоряжение программистов поступил новый класс XmlSerialization.

Намного удобнее стало разрабатывать дизайн форм в среде разработки Visual Studio .NET 2005. Процесс создания программы стал еще более наглядным. Программист может создавать собственные элементы управления так же, как и для обычных приложений.

Что нового в Visual Studio .NET 2005

Если у вас уже был опыт программирования под Visual Studio .NET 2003, то вы заметите, что на панели инструментов появились новые элементы управления. Они будут рассматриваться в главе, посвященной элементам управления. При разработке дизайна приложения будет заметно, как Windows Forms Designer помогает выравнивать элементы и предлагает выбрать минимальное расстояние между элементами. Автоматически проявляющиеся линии выравнивания помогают создавать аккуратные интерфейсы за очень короткий срок. Также появилась возможность разработки приложений, которые могут переключаться между портретным и альбомным режимами экрана.

Глава 2 Первое приложение для .NET Compact Framework

Первые шаги

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

Прежде всего нужно запустить среду разработки Microsoft Visual Studio 2005 и создать новый проект. Первые различия в процессе разработки можно увидеть уже на этой стадии. Если для создания обычных приложений надо было выбрать раздел Windows, то на этот раз необходимо выбрать раздел Smart Device. В этом разделе содержатся подразделы, которые отвечают за создание приложений для КПК, смартфонов и устройств под управлением операционной системы Windows СЕ. Итак, нужно указать язык программирования Visual С#, перейти в раздел Smart Device и выбрать подраздел Pocket PC 2003 (рис. 2.1).

Рис. 2.1. Выбор типа платформы

ПРИМЕЧАНИЕ

Список подразделов на рисунке может отличаться от списка подразделов на вашем компьютере. Например, пункты Windows Mobile 5.0 Pocket PC и Windows Mobile 5.0 Smartphone появились после установки соответствующих пакетов SDK.

В выбранном подразделе присутствуют несколько шаблонов для реализации различных задач. Как правило, используется шаблон Device Application. Нужно отметить, что существует еще один похожий шаблон с названием Device Application (1.0). Эти два шаблона различаются применяемой версией .NET Compact Framework. По умолчанию в Visual Studio 2005 используется .NET Compact Framework версии 2.0. Если выделить первый шаблон, то в строке состояния можно увидеть сообщение A project for creating a .NET Compact Framework 2.0 forms application for Pocket PC 2003 and later. В примерах будет использоваться, как правило, версия 2.0, так как она имеет ряд преимуществ.

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

Обычно в качестве первого примера создается стандартная программа, которая выводит приветствие на экран. На форме надо расположить кнопку Button и элемент Label для отображения надписи. Также потребуется написать код для обработчика события Click созданной кнопки. Этот код приведен в листинге 2.1.


Листинг 2.1

private void butSayHello_Click(object sender, EventArgs e) {

 lblHello.Text = "Здравствуй, мир!";

}

Теперь можно запустить проект при помощи команды Start Debugging или клавиши быстрого вызова F5. При этом на экране появится диалоговое окно Deploy (рис. 2.2).

Рис. 2.2. Диалоговое окно Deploy

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

Практически все примеры из этой книги сначала запускались на эмуляторе. Поэтому можно выбрать любой эмулятор из предложенного списка. Чаще всего применяется эмулятор Pocket PC 2003 SE. После выбора соответствующего значения в списке нужно нажать кнопку Deploy. Сначала на экране монитора будет отображен сам эмулятор (рис. 2.3), а спустя некоторое время в эмуляторе будет запущена созданная программа.

Рис. 2.3. Первый запуск эмулятора

Мышью можно щелкнуть на кнопке с надписью Поздороваться. В результате на форме появится строка Здравствуй, мир! (рис. 2.4).

Рис. 2.4. Отображение сообщения

Теперь, когда вы поверили в свои силы, вам захочется начать переписывать свои старые программы, написанные на С# или Visual Basic .NET, для карманных компьютеров. Но торопиться все же не стоит. Между полной версией .NET Framework и .NET Compact Framework существует довольно много различий, которые придется последовательно устранять.

Кнопки минимизации и закрытия формы

При создании пустой формы можно заметить, что отображается всего одна кнопка минимизации вместо привычных трех кнопок свертывания, восстановления и закрытия формы. Причем кнопка минимизации в виде крестика очень похожа на кнопку закрытия формы в обычных настольных приложениях. У начинающих программистов это поначалу вызывает недоумение. Стандартная модель поведения программ на карманном компьютере устроена таким образом, что когда пользователь нажимает кнопку с крестиком, то он сворачивает программу, а не закрывает ее. Об этом говорит значение True свойства формы MinimizeBox. Если для этого свойства задать значение False, то вместо кнопки с крестиком будет отображаться кнопка OK (рис. 2.5). При нажатии на эту кнопку программа завершит свою работу.

Рис. 2.5. Приложение с кнопкой OK

Размеры и позиция формы

По умолчанию любая форма занимает весь экран. Ее верхний левый угол находится в точке с координатами (0, 26). Если попробовать вручную изменить значения свойства Location, то среда разработки проигнорирует эти попытки и вернет значения. Что же касается размеров формы, то при желании все же можно изменить высоту и ширину формы. Но на практике подобная необходимость встречается редко, поэтому мы не будем заострять на этом внимание.

Меню

По умолчанию в создаваемой форме уже содержится элемент управления MainMenu. Однако в первом примере он не применялся. Чтобы использовать этот элемент управления, нужно создать простое меню с одним пунктом. В области Component tray нужно выделить мышью элемент mainMenu1. На форме появится надпись Type here. В этой области нужно ввести слово «Поздороваться». Для обработчика события menuItem1_Click будет применяться тот же код, который вызывался при нажатии на кнопку. Код обработчика события приведен в листинге 2.2.

Листинг 2.2

private void menuItem1_Click(object sender, EventArgs e) {

 lblHello.Text = "Здравствуй, мир!";

}

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

Рис. 2.6. Меню в нижней части окна

Следует отметить, что меню в приложениях для Pocket PC располагается не на форме, а на панели задач. Также на панели задач находится значок виртуальной клавиатуры SIP для ввода информации. Когда пользователь запускает приложение, то его меню появляется на панели задач. Но если удалить меню из формы, то при запуске программы панель задач вообще не будет отображаться (рис. 2.7).

Рис. 2.7. Экран без панели задач

Панель ввода SIP

В этой главе уже упоминалась виртуальная клавиатура. Большинство карманных компьютеров не имеют встроенных клавиатур для ввода информации. Вместо клавиатуры в этом случае используется специальная панель ввода SIP (Software Input Panel), которая позволяет вводить текст (рис. 2.8).

Рис. 2.8. Активированная панель ввода SIP

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

Стилус вместо мыши

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

Вместо кнопок в карманных компьютерах применяется технология Tap-and-Hold. Для выделения элемента управления пользователь должен точно попасть в него кончиком стилуса. По аналогии с мышью, можно легко щелкнуть по экрану (Click), а можно нажать на экран и удерживать стилус на месте (Press).

Глава 3 Элементы управления

Сходство и различия

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

Рис. 3.1. Свойства, поддерживаемые в .NET Compact Framework

Нужно помнить, что даже поддерживаемые элементы управления имеют порой ограниченные возможности. Чтобы узнать, какие свойства, методы или события не поддерживаются элементом управления, нужно запустить справочную систему, найти нужный класс и просмотреть все члены класса. Если нужное свойство поддерживается в .NET Compact Framework, то у его описания будет присутствовать значок мобильного устройства (рис. 3.1). В качестве примера можно открыть страницу с описанием класса Registry. Легко заметить, что поля CurrentUser, LocalMachine и Users поддерживаются в .NET Compact Framework, а поля DynData и PerfomanceData — нет.

Но даже если необходимый объект поддерживается в .NET Compact Framework, то все равно следует внимательно ознакомиться с его описанием. Например, поле LocalMachine поддерживается только в NET Compact Framework 2.0, поэтому при разработке нужно решить, стоит ли использовать это поле (рис. 3.2).

Рис. 3.2. Просмотр поддержки версий .NET Compact Framework

В следующем списке перечислены элементы управления, которые не входят в состав классов библиотеки .NET Compact Framework 1.0:

□ CheckedListBox;

□ ColorDialog;

□ ErrorProvider;

□ FontDialog;

□ GroupBox;

□ HelpProvider;

□ LinkLabel (поддерживается в .NET Compact Framework 2.0);

□ NotificationBubble;

□ NotifyIcon;

□ элементы управления, связанные с печатью;

□ RichTextBox;

□ Splitter (поддерживается в .NET Compact Framework 2.0).

В Compact .NET Framework 2.0 были добавлены новые элементы управления, которые перечислены в следующем списке.

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

□ DateTimePicker — элемент для выбора даты и времени. Он достаточно компактен, что позволяет широко использовать его в приложениях.

□ WebBrowser — элемент, который реализует функциональность браузера.

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

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

□ DataGrid — элемент для отображения данных в табличном виде. Теперь может использоваться и в приложениях для смартфонов.

□ LinkLabel — элемент управления для создания гипертекстовых ссылок.

□ Splitter — элемент управления, позволяющий изменять размеры других элементов.

□ HardwareButton — элемент управления, позволяющий управлять кнопками карманного компьютера.

Урезанная функциональность элементов управления

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

□ AcceptButton;

□ CancelButton;

□ AutoScroll (поддерживается в .NET Compact Framework 2.0);

□ Anchor (поддерживается в .NET Compact Framework 2.0);

□ элементы Multiple Document Interface (MDI);

□ KeyPreview (поддерживается в .NET Compact Framework 2.0);

□ TabIndex (поддерживается в .NET Compact Framework 2.0);

□ TabStop (поддерживается в .NET Compact Framework 2.0).

Также наложены ограничения на технологию drag and drop и на поддержку графики. Во многих классах поддерживаются не все свойства, события и методы.

Однако в .NET Compact Framework 2.0 ограничений стало меньше. Например, элементы управления теперь обладают свойствами TabIndex и TabStop.

Элемент Form

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

Свойство FormBorderStyle

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

Свойство ControlBox

Свойство ControlBox отвечает за отображение контейнера для элемента управления. Если свойство ControlBox имеет значение True, то контейнер будет отображаться. В противном случае он на экран не выводится. Для устройств Pocket PC подобный контейнер может содержать только одну кнопку.

Свойства MinimizeBox и MaximizeBox

В приложениях для Pocket PC форма может содержать только одну кнопку. Она отвечает либо за минимизацию формы, либо за ее закрытие. Разработчик может управлять внешним видом кнопки при помощи свойства MinimizeBox. Если оно имеет значение True, то кнопка при нажатии будет сворачивать форму. Значение False позволяет создавать кнопку закрытия формы. Значение свойства MaximizeBox игнорируется системой.

Свойство WindowsState

Свойство WindowsState определяет состояние окна при первоначальной загрузке. Разработчик может использовать значения FormWindowState.Normal и FormWindowState.Maximized. Если свойство имеет значение FormWindowState.Normal, то форма заполняет весь экран, за исключением нижней полоски меню и верхней полоски системного меню Start (Пуск). При использовании значения FormWindowState.Maximized форма заполняет экран полностью, скрывая системное меню Start (Пуск), но при этом нижняя полоса меню остается видимой.

Размеры и расположение формы

Свойство Size позволяет задавать размеры формы. Это свойство игнорируется, если свойство FormBorderStyle имеет значение FixedSingleProperty.

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

Элементы управления

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

Элемент Button

Для создания обычной кнопки используется класс System.Windows.Forms.Button. Эта кнопка обладает всеми основными функциями, которые есть у такого же класса в полной версии .NET Framework. Кнопка предназначена для обработки нажатия стилуса на соответствующую область экрана. В этом случае возникает событие Click. Код, приведенный в листинге 3.1, является обработчиком этого события. Он выводит текущее время в текстовое поле после нажатия на кнопку с надписью Узнать время.

Листинг 3.1

private void butGetTime_Click(object sender, EventArgs e) {

 txtCurTime.Text = DateTime.Now.ToLongTimeString();

}

Рисунок 3.3 показывает приложение в момент нажатия на кнопку.

Рис. 3.3. Результат нажатия на кнопку

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

Функциональность элемента управления Button очень сильно урезана по сравнению с полной версией .NET Framework. В частности, у данного элемента нет свойств Image и ImageList, которые применяются для отображения на кнопке графики.

Элемент TextBox

В предыдущем примере дата отображалась в текстовом поле. Это поле создается при помощи класса TextBox, который позволяет вводить текст. Данный элемент поддерживает такие стандартные свойства, как BackColor и ForeColor. Событие Click элементом TextBox не поддерживается, но разработчик может воспользоваться событиями KeyPress, KeyUp и KeyDown. Следует отметить особенность этого элемента. Несмотря на то что класс TextBox поддерживает свойство PasswordChar, при вводе пароля на экране всегда будет использоваться символ звездочки. Задать другой символ не получится.

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

Листинг 3.2

private void txtCurTime_KeyPress(object sender, KeyPressEventArgs e) {

 if (Char.IsLetter(e.KeyChar)) {

  // сохраняем текущую позицию каретки

  int pos = txtCurTime.SelectionStart;

  // переводим в верхний регистр

  txtCurTime.Text =

   txtCurTime.Text.Insert(txtCurTime.SelectionStart,

    Char.ToUpper(e.KeyChar).ToString());

  // перемещаем каретку в новую позицию

  txtCurTime.SelectionStart = pos + 1;

  e.Handled = true;

 }

}

ПРИМЕЧАНИЕ

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

Элемент Label

В рассмотренном примере также использовался элемент Label для отображения текстовой строки. Как правило, надпись используется для отображения некоторого текста, который пользователь не может изменить. Сама отображаемая строка задается при помощи свойства Text. Текст на экране можно выравнивать с помощью свойства TextAlign. Разработчик может использовать значения TopLeft, TopCenter и TopRight. При изменении текста в метке инициируется событие TextChanged. При создании элемента нужно следить за длиной отображаемой строки. Если текст слишком большой и не помещается в пределах элемента, то он попросту обрезается.

В отличие от полной версии .NET Framework, элемент Label в .NET Compact Framework не поддерживает такие свойства, как AutoSize, BorderStyle, Image, ImageList и многие другие. Также не поддерживается событие Click. Впрочем, на практике редко возникает нужда в обработке этого события.

Элемент RadioButton

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

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

При изменении состояния переключателя в классе RadioButton инициируются события Click и CheckedChanged. Событие Click возникает, когда пользователь щелкает стилусом на самом переключателе. Событие CheckedChanged возникает, когда состояние элемента RadioButton меняется программно или в результате действий пользователя. Событие Click не инициируется, когда свойство CheckedChanged меняется программно.

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

Листинг 3.3

private void radClub1_CheckedChanged(object sender, EventArgs e) {

 if (this.radClub1.Checked)

  MessageBox.Show("Увы, вы проиграли", "Ошибка!");

}


private void radClub2_CheckedChanged(object sender, EventArgs e) {

 if (this.radClub2.Checked)

  MessageBox.Show("Поздравляю! Вы выиграли миллион!", "Миллион!");

}


private void radClub3_CheckedChanged(object sender. EventArgs e) {

 if (this.radClub3.Checked)

  MessageBox.Show("Увы, вы проиграли", "Ошибка!");

}


private void radClub4_CheckedChanged(object sender. EventArgs e) {

 if (this.radClub4.Checked)

  MessageBox.Show ("Увы, вы проиграли", "Ошибка!");

}

На рис. 3.4 показан внешний вид этого приложения.

Рис. 3.4. Демонстрация работы независимых переключателей

В полной версии .NET Framework в качестве контейнера для переключателей часто используется элемент GroupBox, который на данный момент не поддерживается в библиотеке .NET Compact Framework. Также не поддерживаются некоторые свойства, к которым относятся Appearance, Image и ImageList.

Элемент Panel

Элемент управления Panel используется в качестве контейнера для размещения других элементов управления. Так как .NET Compact Framework не поддерживает элемент управления GroupBox, то для группировки таких элементов, как переключатели RadioButton, приходится использовать именно Panel.

В версии .NET Compact Framework элемент не поддерживает свойства BorderStyle, BackGroundImage и AutoScroll.

Элемент CheckBox

Элемент управления CheckBox позволяет создавать независимый переключатель в виде флажка. Элемент CheckBox имеет свойство CheckState, позволяющее определить состояние переключателя. Программист может использоваться значения Unchecked, Checked и Indeterminate. Значение Unchecked свидетельствует о том, что флажок в переключателе не взведен. Если переключатель все же включен, то используется значение Checked. Но значение Indeterminate требует некоторых пояснений. Состояние Indeterminate используется, когда для свойства ThreeState элемента CheckBox установлено значение True. Если свойство CheckState имеет значение Indeterminate, то элемент окрашен серым цветом, но, тем не менее, считается помеченным. При этом пользователь не может изменить состояние переключателя.

Также элемент не распознает событие Click, если свойство AutoCheck имеет значение False. Для этого свойства нужно задать значение True, чтобы пользователь мог пользоваться стилусом для работы с переключателем.

Также элемент также не поддерживает некоторые свойства, в частности, ImageIndex.

Элемент ComboBox

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

Добавлять текстовые элементы в ComboBox можно как в режиме проектирования, так и программно во время работы программы.

В листинге 3.4 приведен пример добавления пунктов программным путем. Для этого нужно вызвать метод Add в свойстве коллекции Items элемента ComboBox. Отдельные пункты можно удалять с помощью метода Remove, а чтобы удалить все пункты сразу, применяется метод Clear. Приведенный пример показывает, как можно добавить три строки в элемент ComboBox с именем comboBox1.

Листинг 3.4

comboBox1.Items.Add("Мурзик");

comboBox1.Items.Add("Барсик");

comboBox1.Items.Add("Рыжик");

Чтобы узнать, какой элемент выбрал пользователь, применяется свойство SelectedIndex или SelectedItem. Свойство SelectedIndex возвращает порядковый номер выбранного пункта. Этот номер можно использовать для доступа к выбранному пункту при помощи свойства Items. Следует помнить, что нумерация элементов начинается с нуля. Пример работы со свойством SelectedIndex приведен в листинге 3.5. Также в этом листинге показано, как можно получить доступ к выбранному пункту при помощи свойства SelectedItem.

Листинг 3.5

// Получим выделенный пункт с помощью SelectedIndex

string selItem = (string)cmbCats.Items[cmbCats.SelectedIndex];

MessageBox.Show(selItem);

// Второй способ - получим пункт с помощью

SelectedItem string selItem = cmbCats.SelectedItem.ToString();

MessageBox.Show(selItem);

В полной версии .NET Framework у элемента ComboBox для свойства DropDownStyle можно задавать значения Simple, DropDownList или DropDown. В .NET Compact Framework значение Simple не используется. До выхода .NET Compact Framework 2.0 также не поддерживалось и значение DropDown. Кроме того, по умолчанию в .NET Compact Framework применяется значение DropDownList, тогда как в полной версии .NET Framework по умолчанию используется стиль DropDown. Также не поддерживаются многие методы из основной версии библиотеки. В .NET Compact Framework 2.0 у поля со списком появилась поддержка методов BeginUpdate и EndUpdate, которые позволяют избежать мерцания при загрузке большого числа элементов.

ВНИМАНИЕ

Внешний вид и поведение элемента ComboBox в смартфонах немного отличается от аналогичных элементов в КПК. Более подробно об отличиях будет рассказано в соответствующей главе.

Элемент ListBox

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

Элементы ComboBox и ListBox имеют почти одинаковый набор свойств и методов. В листинге 3.6 показано, как можно программно добавить несколько строк в список ListBox.

Листинг 3.6

lstFruit.Items.Add("Яблоко");

lstFruit.Items.Add("Груша");

lstFruit.Items.Add("Слива");

lstFruit.Items.Add("Персик");

Свойство SelectedIndex содержит порядковый номер выбранного элемента списка. Если указать этот индекс в коде приложения, то выбранный элемент будет немедленно выделен в списке соответствующим цветом. Если никакой элемент не выбран, то свойство SelectedIndex имеет значение -1. Также класс поддерживает свойство SelectedItem, которое соответствует одноименному свойству класса ComboBox.

Из часто используемых свойств элемента ListBox в полной версии NET Framework можно выделить свойство MultiColumn, которое не поддерживается в .NET Compact Framework. В нем отсутствует горизонтальная полоска прокрутки, даже если строки текста не умещаются в списке полностью. Также не поддерживается многострочное выделение, поэтому пользователь может выбрать только один элемент списка.

Элемент NumericUpDown

Элемент NumericUpDown позволяет создавать счетчик с числовым полем ввода. Такой элемент интерфейса помогает пользователю быстро выбрать число из заданного диапазона. Элемент может работать только с целыми числа типа Integer. Десятичные значения округляются.

Разработчик управляет поведением элемента NumericUpDown при помощи свойств Minimum, Maximum, Value и Increment. Свойства Minimum и Maximum определяют максимальное и минимальное значения элемента. Свойство Value содержит текущее значение в поле ввода. Свойство Increment определяет величину увеличения или уменьшения значения в поле, когда пользователь нажимает кнопки со стрелками. Текущее значение всегда увеличивается и уменьшается на значение свойства Increment, даже если результат выходит за диапазон, определенный свойствами Minimum и Maximum.

Пользователь также может изменить свойство Value, просто указав соответствующее значение в поле. Если это значение находится в интервале между Minimum и Maximum, тогда свойства Value и Text изменятся в соответствии с введенным значением. Если новое значение выходит за рамки заданных значений, то свойство Text отображает введенное число, а свойство Value принимает значение, которое приписано свойству Maximum. Чтобы запретить пользователю указывать числа в поле ввода, нужно для свойства ReadOnly задать значение True.

При изменении значения элемента NumericUpDown инициируется событие ValueChanged. Оно возникает только в том случае, если значение меняется программно или когда пользователь нажал кнопки со стрелками. При вводе числа событие не инициируется. В листинге 3.7 продемонстрирован пример использования элемента NumericUpDown и обработки события ValueChanged.

Листинг 3.7

private void numericUpDown1_ValueChanged(object sender, EventArgs e) {

 int year = (int)this.numericUpDown1.Value;

 this.lblNote.Text = "Вы выбрали " + year.ToString() + "год";

}

На рис. 3.5 показано, как функционирует элемент NumericUpDown.

Рис. 3.5. Выбор года при помощи элемента NumericUpDown

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

Стоит проиллюстрировать эту ситуацию. Итак, у нас установлено текущее значение, равное 1992. Значение свойства Increment равно 6, а максимум ограничен значением 2006. Последовательные нажатия стрелки вверх доведут значение с 1992 до 2006. Итак, максимальное значение достигнуто. Теперь надо нажать кнопку со стрелкой, направленной вниз. Казалось бы, на экране должно быть показано число 2000 (2006-6), но следует учитывать, что перед превышением максимального значения счетчик запомнил число 2004. Именно от него будет отсчитываться разница, и на экране будет отображено число 1998.

Элемент DomainUpDown

Элемент DomainUpDown позволяет создавать счетчик с текстовым полем ввода. Этот элемент похож на элемент NumericUpDown, а его функциональность схожа с теми возможностями, которые предоставляют ComboBox или ListBox. Но в элементе DomainUpDown вместо чисел используются строки. Этот элемент очень широко применяется для построения интерфейса, так как он весьма компактен и не занимает много места на маленьком экране карманного компьютера. Следует учитывать, что пользователь не может увидеть весь список. Если свойство ReadOnly имеет значение True, то пользователь может выбирать только заранее заданные строки из списка. Если это свойство имеет значение False, то пользователь сможет добавить свой текст в поле ввода. Впрочем, напечатанный текст все равно не войдет в список.

Так же как и элемент NumericUpDown, данный элемент управления содержит текстовое поле и две кнопки со стрелками с правой стороны. Пользователь может использовать эти стрелки для прокрутки списка строк или ввести в поле свой текст, если свойство ReadOnly имеет значение False.

При создании объекта свойство SelectedIndex имеет значение -1, показывающее, что ни один элемент списка пока еще не выбран. Если нужно выделить тот или иной пункт списка при загрузке элемента, то в свойстве SelectedIndex нужно указать соответствующий порядковый номер. В листинге 3.8 приведен пример, иллюстрирующий программное добавление строк в список и методику обработки события SelectedItemChanged.

Листинг 3.8

private void Form1_Load(object sender, System.EventArgs e) {

 domainUpDown1.Items.Add("Item 1");

 domainUpDown1.Items.Add("Item 2");

 domainUpDown1.Items.Add("Item 3");

 domainUpDown1.Items.Add("Item 4");

 domainUpDown1.ReadOnly = true;

}


private void domainUpDown1_SelectedItemChanged(object sender,

 System.EventArgs e) {

 label1.Text = domainUpDown1.SelectedIndex.ToString();

 label2.Text = domainUpDown1.Items[domainUpDown1.SelectedIndex].ToString();

}

Элемент ProgressBar

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

Чаще всего разработчик оперирует свойствами Minimum, Maximum и Value. Свойства Minimum и Maximum задают минимальное и максимальное значения свойства Value. А свойство Value определяет текущее значение индикатора.

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

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

Листинг 3.9

private void tmrCook_Tick(object sender, EventArgs e) {

 if (this.progressBar1.Value < this.progressBar1.Maximum) {

  this.progressBar1.Value += 1;

  lblCounter.Text = this.progressBar1.Value.ToString();

 }

 if (this.progressBar1.Value >= this.progressBar1.Maximum) {

  tmrCook.Enabled = false;

  MessageBox.Show("Яйца сварились!");

  this.progressBar1.Value = 0;

  lblCounter.Text = "0";

 }

}


private void butStart_Click(object sender, EventArgs e) {

 tmrCook.Enabled = true;

}

На рис. 3.6 показан внешний вид приложения в момент отсчета времени.

Рис. 3.6. Индикатор прогресса, позволяющий сварить яйца вкрутую

Элемент StatusBar

Строка состояния выглядит как небольшая полоска в нижней части приложения, в которой отображается текстовая информация для пользователя. Этот элемент интерфейса реализуется при помощи элемента StatusBar. Чтобы изменить текст в элементе StatusBar, достаточно присвоить новое значение свойству Text. На рис. 3.7 показан внешний вид приложения в тот момент, когда пользователь нажимает на кнопку, а в листинге 3.10 приведен пример кода, который меняет текст в строке состояния.

Рис. 3.7. Пример работы со строкой состояния

Листинг 3.10

private void butClickMe_Click(object sender, EventArgs e) {

 this.statusBar1.Text = "Вы нажали на кнопку";

}

Строка состояния поддерживает только одну информационную панель, а также не распознает события Click.

Элемент TrackBar

Элемент управления TrackBar предназначен для установки числового значения при помощи перемещения ползунка по числовой шкале. Основную работу с элементом разработчик выполняет при помощи свойств Minimum, Maximum и Value. Ползунок может располагаться как вертикально, так и горизонтально. Ориентация ползунка задается при помощи свойства Orientation. Свойство TickFrequency регулирует дистанцию между метками шкалы. По умолчанию значение свойства TickFrequency равно единице.

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

Свойство LargeChange показывает, на сколько будет изменено основное значение, когда пользователь щелкнет стилусом на самом ползунке. При изменении значения свойства Value инициируется событие ValueChanged.

Для иллюстрации работы ползунка нужно создать новый проект и разместить на форме два элемента TrackBar. Один из них будет расположен горизонтально, а второй — вертикально. При этом положение ползунков на шкалах будет синхронизировано (рис. 3.8).

Рис. 3.8. Пример работы с ползунками

В листинге 3.11 приведен код, отвечающий за функциональность ползунков.

Листинг 3.11

private void trackVert_ValueChanged(object sender, EventArgs e) {

 this.trackHoriz.Value = this.trackVert.Value;

}


private void trackHoriz_ValueChanged(object sender, EventArgs e) {

 this.trackVert.Value = this.trackHoriz.Value;

}

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

Элемент ToolBar

Элемент управления ToolBar позволяет создавать собственную панель инструментов. Во многих случаях использование панели инструментов может принести разработчику больше выгод, чем применение меню. Следует учитывать, что панель инструментов позволяет использовать изображения, что делает работу с этим элементом удобным и наглядным. В .NET Compact Framework элемент ToolBar не может содержать текст. Все инструменты маркируются только при помощи графических изображений. Изображения связываются с элементом при помощи класса ImageList. В приложениях для КПК панель инструментов всегда располагается в нижней части экрана справа от пунктов меню (рис. 3.9).

Рис. 3.9. Панель инструментов в приложении

Чтобы добавить в приложение элемент ToolBar, нужно сначала переместить на форму элемент управления ImageList. Значок ImageList появится в нижней части окна Form Designer рядом с элементом mainMenu. В окне редактора свойств Properties нужно выбрать свойство Images и нажать кнопку редактирования. В результате будет открыто диалоговое окно Image Collection Editor.

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

Теперь на форму надо перенести элемент ToolBar. В его свойстве ImageList надо указать имя добавленного ранее элемента ImageList. В рассматриваемом примере использовалось имя по умолчанию ImageList1. Затем надо перейти к свойству Buttons и активировать окно редактора ToolBarButton Collection Editor. Так как было добавлено три изображения для кнопок, то нужно три раза нажать кнопку Add. Для каждой добавленной кнопки следует задать свойство ImageIndex. При необходимости разработчик может изменить стиль отображения кнопок. По умолчанию используется стиль PushButton, который создает обычные кнопки. Если для кнопки задать стиль DropDownButton, то при ее нажатии будет отображаться меню или другое окно. Справа от кнопки на панели инструментов отображается стрелка.

Стиль Separator позволяет создавать разделители между кнопками на панели управления. Стиль ToggleButton позволяет создавать переключаемую кнопку. При первом нажатии она переходит в активированное состояние, в котором и остается до тех пор, пока кнопку не нажмут повторно.

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

Листинг 3.12

private void toolBar1_ButtonClick(object sender,

 ToolBarButtonClickEventArgs e) {

 if (e.Button == this.toolBarButton1) {

  MessageBox.Show("Вы выбрали первую кнопку");

 } else if (e.Button == this.toolBarButton2) {

  MessageBox.Show("Вы выбрали вторую кнопку");

 }

}

Элемент MainMenu

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

Следует помнить, что в приложениях для Pocket PC меню располагается в нижней части окна программы, тогда как в приложениях для обычных компьютеров меню располагается в верхней части окна. Если в программе одновременно присутствуют меню и панель инструментов, то они будут отображаться вместе. Но меню будет прижато к левой границе окна, а панель инструментов — к правой. Пример работы с меню приведен в листинге 3.13.

Листинг 3.13

private void mnuAboutClick(object sender, EventArgs e) {

 MessageBox.Show("Это моя программа!");

}


private void mnuExitClick(object sender, EventArgs e) {

 this.Close();

}

Элемент ContextMenu

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

ВНИМАНИЕ

Если вы пользуетесь эмулятором, то для имитации tap-and-hold нужно щелкнуть левой кнопки мыши и не отпускать ее некоторое время.

Чтобы добавить элемент ContextMenu в приложение, нужно сначала переместить его значок на форму. Он появится в нижней части редактора Form Designer, там же, где и элемент MainMenu. Но на самом деле во время выполнения программы контекстное меню будет отображаться рядом с выбранным элементом интерфейса. Также контекстное меню можно создавать программно во время запуска приложения.

При вызове контекстного меню инициируется событие Popup. Когда пользователь выбирает какой-то пункт меню, то возникает событие Click. Чтобы привязать созданное контекстное меню к конкретному элементу интерфейса, нужно выбрать его на форме и в свойстве ContextMenu указать созданное контекстное меню.

ПРИМЕЧАНИЕ

До выхода .NET Compact Framework 2.0 элемент управления ContextMenu не поддерживал свойство ContextMenu.SourceControl

Элемент Timer

Элемент Timer позволяет выполнять некоторые действия по истечении заданных интервалов времени. Чаще всего для работы с таймером разработчик применяет событие Tick. Данное событие инициируется только в том случае, если свойство Enabled имеет значение True. Если нужно остановить таймер, то достаточно присвоить данному свойству значение False.

Интервал отсчета времени задается свойством Interval, а его значение указывает используемый промежуток времени в миллисекундах. Если рабочий интервал таймера должен составлять 3 с, то надо установить значение 3000.

Этот элемент управления уже применялся при работе с объектом ProgressBar.

Элементы OpenFileDialog и SaveFileDialog

Практически в каждом приложении пользователь должен иметь возможность сохранить файл или открыть его. Разработчикам регулярно приходится реализовывать подобную функциональность в своих программах. При желании можно самому придумать и разработать интерфейс для подобной задачи. Но можно воспользоваться и стандартными диалоговыми окнами открытия и сохранения файла. Именно для этого применяются элементы управления OpenFileDialog и SaveFileDialog. К сожалению, в версии .NET Compact Framework возможности данных элементов управления серьезно урезаны. Разработчик может манипулировать файлами только в пределах папки My Documents и вложенных папок следующего уровня. Поэтому папка My Documents\Programming\Sample будет уже недоступна.

Рассматриваемые элементы управления размещаются в нижней части дизайнера формы рядом с элементом MainMenu. При работе с данными элементами прежде всего надо позаботиться о свойстве Filter, которое ограничивает список доступных файлов, фильтруя их по расширению. Свойство InitalDirectory содержит имя папки, в которой по умолчанию располагаются файлы. Если это свойство оставить пустым, то обзор файлов начнется с самой папки My Documents.

Основным методом для этих элементов является ShowDialog. После его вызова на экране отображается модальное окно, в котором пользователь должен нажать кнопку OK или Cancel. При этом метод ShowDialog возвращает значения DialogResult.OK и DialogResult.Cancel соответственно. Если получено значение DialogResult.OK, то пользователь нажал кнопку OK и в свойстве Filename содержится полный путь к выбранному файлу.

Пример работы с элементами OpenFileDialog и SaveFileDialog приведен в листинге 3.14.

Листинг 3.14

private void butOpen_Click(object sender, EventArgs e) {

 ofd.Filter = "DLL|*.dll|Картинки|*.jpg";

 ofd.InitialDirectory = "\\My Documents\\Templates";

 if (DialogResult.OK == ofd.ShowDialog()) {

  statusBar1.Text = ofd.FileName;

 } else {

  statusBar1.Text = "Вы нажали на кнопку Отмена!";

 }

}

Элементы HScrollBar и VScrollBar

Элементы управления HScrollBar и VScrollBar позволяют создавать полосы прокрутки для элементов, которые изначально не обладают этой функциональностью. Пользоваться этими полосами прокрутки совсем не сложно. Свойство Minimum задает значение элемента, когда ползунок находится в крайней левой или в крайней верхней позиции, для HScrollBar или VScrollBar соответственно. Свойство Maximum, задает максимальное значение для полос прокрутки. Значение свойства Value зависит от положения ползунка. Оно всегда находится в диапазоне между значениями свойств Minimum и Maximum.

Когда пользователь щелкает на полосе прокрутки, то свойство Value изменяется в соответствии со значением, заданным в свойстве LargeChange. Когда пользователь нажимает на кнопку навигации со стрелкой, то свойство Value изменяется в соответствии со значением, заданным в свойстве SmallChange. Следует обратить внимание на то, что если ползунок находится в положении, определяемом свойством Maximum, то свойство Value не равно значению Maximum. В этом случае значение свойства Value вычисляется по формуле Maximum - LargeChange + 1.

При изменении свойства Value инициируется событие ValueChanged. В листинге 3.15 приведен пример работы с полосами прокрутки.

Листинг 3.15

private void vScrollBar1_ValueChanged(object sender, EventArgs e) {

 this.lblScroll.Text = this.vScrollBar1.Value.ToString();

}

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

Рис. 3.10. Пример работы с полосами прокрутки


Список рисунков (ImageList)

Элемент управления ImageList уже рассматривался при знакомстве с элементом ToolBar. Элемент ImageList используется для хранения коллекций растровых изображений. Как и многие другие элементы, список рисунков не отображается во время выполнения программы, а используется как контейнер, из которого по мере необходимости извлекаются хранимые изображения. Как правило, данный элемент используется совместно с такими элементами управления, как ListView, TreeView и ToolBar.

Изображения можно добавлять в элемент управления во время работы приложения. Для этого используется метод Add, который входит в состав члена класса Images. Сами картинки могут располагаться как в отдельных файлах, так и в ресурсах приложения. В листинге 3.16 показано, как можно добавить картинку из ресурсов в ImageList, а затем отобразить ее в элементе интерфейса PictureBox.

Листинг 3.16

Bitmap image = new Bitmap(Assembly.GetExecutingAssembly(),

 GetManifestResourceStream(@"ImageList_CS.home.gif"));

imgList.Images.Add(image);

picTest.Image = imgList.Images[0];

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

Листинг 3.17

private void butFromImageListClick(object sender, EventArgs e) {

 picTest.Image = imgList.Images[1];

}

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

Элемент PictureBox

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

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

Листинг 3.18

private void butFromFile_Click(object sender, EventArgs e) {

 picTest.Image = new Bitmap(@"\Windows\banner.gif");

}

Если использовать этот способ для добавления картинки, то нужно добавить изображение в проект и для свойства Build Action в окне свойств Properties задать значение Content. В процессе подготовки приложения к инсталляции изображение будет рассматриваться как часть программы. В рассмотренном примере использовалась готовая картинка, которая находится в папке Windows.

Также можно загрузить изображение из ресурсов приложения. В этом случае надо добавить картинку в проект и для свойства Build Action задать значение Embedded Resource. Тогда не придется специально включать изображения в состав инсталлятора. В листинге 3.19 приведен пример, иллюстрирующий добавление изображения из ресурсов.

Листинг 3.19

private void butRes_Click(object sender, EventArgs e) {

 // Загружаем из ресурсов

 picTest.Image = new Bitmap(Assembly.GetExecutingAssembly().

  GetManifestResourceStream("PictureBox_CS.kristina.jpg"));

}

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

Листинг 3.20

private void butImgList_Click(object sender, EventArgs e) {

 // изменяем размеры картинки

 imageList1.ImageSize = new System.Drawing.Size(160, 120);

 // загружаем картинку с измененными размерами

 picTest.Image = imageList1.Images[0];

}

На рис. 3.11 показан внешний вид приложения, в котором для работы с изображениями применяются все три описанных варианта.

Рис. 3.11. Пример работы с элементом PictureBox

Элемент ListView

Элемент управления ListView похож на элемент ListBox, но вместо обычного текста данный элемент может показывать изображения. Фактически, правая часть рабочего окна Проводника в Windows XP является типичным примером использования этого органа управления. Элементы в ListView могут отображаться в виде таблицы, списка, а также как группа крупных и мелких значков. За способ отображения содержимого отвечает свойство View. Значение Details позволяет отображать содержимое в виде таблицы, значение List создает список, значение LargeIcon позволяет отображать элементы списка в виде больших пиктограмм, а значение SmallIcon отображает их как маленькие пиктограммы.

В режиме Details элемент управления ListView позволяет создавать дополнительные столбцы. Их можно добавлять как во время проектирования, так и во время исполнения программы. Пример добавления столбцов во время работы приложения приведен в листинге 3.21.

Листинг 3.21

private void Form1_Load(object sender, EventArgs e) {

 // Устанавливаем нужный вид

 listView1.View = View.Details;

 // Выделяем всю строку при выделении любого элемента

 listView1.FullRowSelect = true;


 ColumnHeader columnHeader1 = new ColumnHeader();

 ColumnHeader columnHeader2 = new ColumnHeader();

 ColumnHeader columnHeader3 = new ColumnHeader();


 columnHeader1.Text = "Фамилия";

 columnHeader2.Text = "Имя";

 columnHeader3.Text = "E-mail";


 listView1.Columns.Add(columnHeader1);

 listView1.Columns.Add(columnHeader2);

 listView1.Columns.Add(columnHeader3);


 ListViewItem Contact1 = new ListViewItem("Иванов");

 Contact1.SubItems.Add("Иван");

 Contact1.SubItems.Add("ivan@ivanov.ru");


 ListViewItem Contact2 = new ListViewItem("Петров");

 Contact2.SubItems.Add("Петр");

 Contact2.SubItems.Add("peter@petrov.ru");


 ListViewItem Contact3 = new ListViewItem("Сидоров");

 Contact3.SubItems.Add("Арнольд");

 Contact3.SubItems.Add("goat@sidorov.ru");


 listView1.Items.Add(Contact1);

 listView1.Items.Add(Contact2);

 listView1.Items.Add(Contact3);

}

На рис. 3.12 показан внешний вид приложения со списком в виде таблицы.

Рис. 3.12. Пример работы с элементом ListView

В полной версии .NET Framework элемент управления ListView поддерживает свойство MultiSelect, позволяющее одновременно выбрать несколько элементов из списка. Версия .NET Compact Framework не поддерживает данное свойство, поэтому пользователь может выбрать только один элемент.

Элемент TabControl

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

В устройствах Pocket PC вкладки располагаются в нижней части окна. Следует обратить внимание на то, что элемент TabControl всегда располагается в верхнем левом углу контейнера. Например, если поместить TabControl на форму, то он появится в ее верхнем левом углу. Если же нужно изменить расположение этого элемента, то надо поместить его на панель, которая является контейнером. При перемещении панели будет перемещаться и TabControl.

Элемент TabControl следует расположить на форме. У него по умолчанию будут созданы вкладки tabPage1 и tabPage2. Если нужно добавить новую вкладку, то следует щелкнуть на маленькой стрелке в верхней части элемента TabControl и выбрать пункт меню Add Tab (рис. 3.13).

Рис. 3.13. Добавление новой закладки в элементе TabControl

В результате у элемента TabControl появится новая закладка, которую можно настроить в соответствии с потребностями разработчика. Также программист может воспользоваться услугами редактора TabPage Collection Editor для добавления новых закладок. В этом случае надо выбрать элемент TabControl в дизайнере формы, найти свойство TabPages и нажать кнопку редактирования этого свойства. В результате будет открыт редактор закладок. Для управления закладками можно также выделить TabControl, щелкнуть на нем правой кнопкой мыши и выбрать пункты контекстного меню Add Tab или Remove Tab.

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

Листинг 3.22

private void tabControl1_SelectedIndexChanged(object sender, EventArgs e) {

 switch (this.tabControl1.SelectedIndex) {

 case 0:

  MessageBox.Show("Вы выбрали первую вкладку");

  break;

 case 1:

  MessageBox.Show("Вы выбрали вторую вкладку");

  break;

 case 2:

  MessageBox.Show("Вы выбрали третью вкладку");

  break;

 }

}

Элемент TreeView

Элемент управления TreeView позволяет представить данные в иерархическом виде. Именно в этом виде отображается структура дисковой системы в левой части рабочего окна программы Проводник Windows. Основой элемента TreeView являются объекты TreeNode и Nodes. При работе с TreeView также широко используется элемент управления ImageList, используемый как хранилище изображений для узлов.

Заполнять древовидную структуру можно как на этапе конструирования формы, так и во время выполнения программы. Для создания дерева в дизайнере формы нужно переместить на нее элемент TreeView. Затем следует выбрать свойство Nodes и запустить редактор TreeNode Editor. Кнопка Add Root отвечает за создание узлов дерева. Кнопка Add Child позволяет добавить дочерний узел к выбранному узлу. Кнопка Delete удаляет выбранный узел.

Чтобы задать текст, отображаемый в узлах, можно использовать свойство Text. Также в узлах можно использовать изображения, для чего применяется комбинация элемента управления ImageList и свойства SelectedImageList. Для определения текущего узла используется свойство SelectedNode.

На рис. 3.14 показан внешний вид приложения, использующего элемент интерфейса TreeView.

Рис. 3.14. Использование элемента TreeView

Элемент InputPanel

Элемент управления InputPanel позволяет вводить текстовую информацию при помощи виртуальной клавиатуры или панели распознавания знаков SIP (Soft Input Panel). Так как в полной версии .NET Framework данного элемента нет, то стоит рассмотреть его несколько подробнее.

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

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

□ Bounds — прямоугольник, определяющий размеры и позицию SIP.

□ VisibleDesktop — прямоугольная часть экрана, на которой не отображается SIP.

□ Enabled — возможность работы с SIP.

□ EnabledChanged — событие, возникающее при изменении состояния SIP.

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

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

Свойство Enabled имеет значение True, если виртуальная клавиатура отображается на экране. Значение свойства можно задавать программно, скрывая или отображая клавиатуру.

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

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

Листинг 3.23

private void txtTest_GotFocus(object sender, EventArgs e) {

 // Когда пользователь выбирает текстовое поле.

 // то автоматически активируем SIP

 inputPanel1.Enabled = true;

}


private void txtTest_LostFocus(object sender, EventArgs e) {

 // При потере фокуса сворачиваем SIP

 inputPanel1.Enabled = false;

}

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

Теперь если стилусом активировать текстовое поле, то автоматически будет отображена виртуальная клавиатура. Если на появившейся клавиатуре нажать клавишу Tab или щелкнуть на кнопке с надписью Просто кнопка, то панель ввода автоматически свернется.


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

Листинг 3.24

private void inputPanel1_EnabledChanged(object sender,EventArgs e) {

 // Отслеживаем состояние панели ввода

 // Свойство Bounds возвращает размеры и позицию SIP

 if (inputPanel1.Enabled == true)

  this.txtJump.Top = 200 — inputPanel1.Bounds.Height;

 else

  this.txtJump.Top = 200;

}

На рис. 3.15 показан внешний вид окна тестового приложения.

Рис. 3.15. Пример работы с элементом InputPanel

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

Элемент управления DataGrid

Элемент управления DataGrid позволяет отображать данные в виде таблицы, как это сделано в электронной таблице MS Excel. Как и многие другие элементы управления, он имеет обрезанные возможности по сравнению с полной версией .NET Framework. Например, отключена поддержка свойства DataMember.

Элемент управления DataGrid может быть связан с источниками данных при помощи свойства DataSource. Рассмотрим простейший пример работы с данным элементом. Прежде всего, потребуется создать XML-файл, содержащий некоторые данные. Для примера был использован файл artists.xml, в котором содержится информация о некоторых известных артистов шоу-бизнеса. Файл содержит записи о фамилии, дате рождения и адресе проживания. Созданный файл нужно добавить в проект, расположить на форме элемент DataGrid и присвоить ему имя grdArtists. В листинге 3.25 приведен код обработчика события Form1_Load.

Листинг 3.25

private void Form1_Load(object sender, EventArgs e) {

 Cursor.Current = Cursors.WaitCursor;

 try {

  // Загружаем данные DataSet

  DataSet ds = new DataSet();

  ds.ReadXml(@"\Program Files\DataGrid_CS\artists.xml");

  grdArtists.DataSource = ds.Tables[0];

 } catch (Exception) {

  MessageBox.Show("Не могу загрузить данные в DataGrid!", this.Text);

 }


 // Устанавливаем стили

 DataGridTableStyle ts = new DataGridTableStyle();

 ts.MappingName = "Order";


 DataGridColumnStyle artistDate = new DataGridTextBoxColumn();

 artistDate.MappingName = "BirthDate";

 artistDate.HeaderText = "Дата рождения";

 ts.GridColumnStyles.Add(artistDate);


 DataGridColumnStyle artistName = new DataGridTextBoxColumn();

 artistName.MappingName = "ArtistName";

 artistName.HeaderText = "Артист";

 artistName.Width = this.Width - artistDate.Width - 35;

 ts.GridColumnStyles.Add(artistName);


 grdArtists.TableStyles.Add(ts);


 Cursor.Current = Cursors.Default;

}

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

Рис. 3.16. Пример работы с элементом DataGrid

Также стоит прочитать статью «Using the DataGrid Control in Pocket PC Applications», которую можно найти в справочной системе MSDN. В этой статье иллюстрируются различные приемы программирования, которые помогут расширить возможности данного элемента.

Элемент Splitter

Элемент управления Splitter появился только в .NET Compact Framework 2.0. В предыдущей версии его не было. Этот элемент реализует разделитель, который используется для изменения размеров закрепленных элементов управления во время выполнения программы. Элемент Splitter обычно используется вместе с элементами управления, содержащими данные переменной длины.

Стоит рассмотреть работу данного элемента на конкретном примере. На форме следует расположить графическое поле PictureBox и присвоить его свойству Dock значение Top. Затем на форме надо расположить объект Splitter и его свойству Dock тоже присвоить значение Top. Также следует расположить на форме текстовое поле TextBox. Его свойству Multiline надо присвоить значение True, а свойству Dock — значение Fill. Внешний вид получившегося приложения показан на рис. 3.17.

Рис. 3.17. Применение элемента Splitter в приложении

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

Элемент MonthCalendar

Элемент управления MonthCalendar появился только в последней версии .NET Compact Framework 2.0. Данный элемент позволяет легко выбрать необходимую дату.

Для создания тестового приложения на форме надо разместить элементы MonthCalendar и Label. Метка должна получить имя lblSelectDate, а для свойства Text нужно задать значение Выбранная дата. Затем следует дважды щелкнуть на элементе monthCalendar1, чтобы задать код обработчика события DateChanged. Этот код приведен в листинге 3.26.

Листинг 3.26

private void monthCalendar1_DateChanged(object sender, DateRangeEventArgs e) {

 lblSelectDate.Text =

  "Выбранная дата: " + monthCalendar1.SelectionStart.ToShortDateString();

}

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

Рис. 3.18. Выбираем дату из месячного календаря

Элемент DateTimePicker

Элемент управления DateTimePicker также является новым элементом, который появился в .NET Compact Framework 2.0. Он позволяет выбирать не только дату, но и время.

На форме надо разместить элемент DateTimePicker и две текстовые метки Label, в которых будут отображаться дата и время. Затем нужно дважды щелкнуть на элементе DateTimePicker, чтобы задать код обработчика события ValueChanged. Этот код приведен в листинге 3.27.

Листинг 3.27

private void dateTimePicker1_ValueChanged(object sender, EventArgs e) {

 lblDate.Text = "Дата: " + dateTimePicker1.Value.ToShortDateString();

 lblTime.Text = "Время: " + dateTimePicker1.Value.ToShortTimeString();

}

Внешний вид получившегося приложения показан на рис. 3.19.

Рис. 3.19. Выбор даты при помощи элемента DateTimePicker

В документации MSDN есть небольшая статья «How to: Use the DateTimePicker Class in the .NET Compact Framework», в которой приводится небольшой пример использования этого элемента. Поддержка данного элемента появилась и в смартфонах под управлением Windows Mobile 5.0. Но в этом случае внешний вид элемента будет несколько иным.

Элемент DocumentList

Новый элемент управления DocumentList, который появился в .NET Compact Framework 2.0, может заменить такие элементы, как SaveFileDialog и OpenFileDialog, так как имеет все необходимые средства для работы с файлами. Помимо этого элемент DocumentList имеет дополнительные возможности, которые наверняка понравятся разработчикам программ. Он позволяет очень просто реализовать основные задачи манипулирования файлами, к которым относятся копирование, удаление, переименование и перемещение файлов. С помощью этого элемента также можно сортировать файлы по имени, дате создания, размеру. Кроме того, существует даже возможность посылать файлы по электронной почте или передавать на другое устройство при помощи инфракрасной связи.

Элемент DocumentList работает с файлами в пределах папки My Documents, включая подпапки. Следует обратить внимание на то, что DocumentList является классом из пространства Microsoft.WindowsCE.Forms и не является частью полной версии .NET Framework. Поэтому есть смысл поближе познакомиться с данным элементом.

Для разработки тестового приложения сначала потребуется создать новый проект, а затем переместить на форму элемент DocumentList. Для свойства Name надо задать значение DocListFile, свойство Dock должно получить значение Top, свойству Height присваивается значение 160, а для свойства SelectedDirectory задается значение My Documents.

Также на форме надо разместить элементы ComboBox и StatusBar. Элементу ComboBox надо присвоить имя cboFileType. Затем следует выбрать свойство Items и открыть окно редактора String Collection Editor. Для списка надо задать значения BMP и WAV.

Затем нужно дважды щелкнуть на элементе ComboBox, чтобы задать код обработчика события SelectedIndexChanged. Код обработчика приведен в листинге 3.28.

Листинг 3.28

private void cboFileType_SelectedIndexChanged(object sender, EventArgs e) {

 if (cboFileType.Text = "BMP") {

  docListFile.Filter = "Рисунки (*.bmp)|*.bmp";

  docListFile.SelectedDirectory = "My Pictures";

 } else {

  docListFile.Filter = "Звуки (*.wav)|*.wav";

  docListFile.SelectedDirectory = "My Music";

 }

}

Данный код динамически меняет значение свойства Filter элемента DocumentList для отображения файлов определенного типа. Также меняется папка просмотра файлов. Если пользователь выберет расширение .BMP, то следует выбрать папку My Pictures, специально предназначенную для хранения картинок. При выборе типа файлов .WAV выбирается папка My Music.

Теперь следует дважды щелкнуть на элементе DocumentList, чтобы создать обработчик события DocumentActivated. Соответствующий код приведен в листинге 3.29.

Листинг 3.29

private void docListFile_DocumentActivated(object sender,

 Microsoft.WindowsCE.Forms.DocumentListEventArgs e) {

 statusBar1.Text = e.Path;

 // работа с выбранным файлом

}

Перед началом тестирования стоит скопировать несколько соответствующих файлов в папки My Pictures и My Music. После запуска программы нужно перейти в поле со списком и выбрать тип файлов. После этого будет активирован элемент DocumentList с выбранной папкой. Из списка документов можно будет выбрать конкретный файл.

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

Рис. 3.20. Выбор файла при помощи элемента DocumentList

Элемент Notification

Еще один новый элемент управления, который появился в последней версии .NET Compact Framework 2.0, носит имя Notification. Данный элемент управления позволяет отображать интерактивные сообщения. В документации по данному элементу приводится довольно интересный пример с использованием HTML-текста. Но в книге можно ограничиться более наглядным примером.

Для создания тестового примера нужно переместить на форму элементы Notification и Button. При нажатии на кнопку необходимо отобразить соответствующее сообщение. Это реализуется при помощи кода, приведенного в листинге 3.30.

Листинг 3.30

private void button1_Click(object sender, EventArgs e) {

 notification1.Text = "Позвони родителям!";

 notification1.Caption = "Демонстрация примера";

 notification1.Critical = true;


 // Уведомление висит на экране 10 секунд

 notification1.InitialDuration = 10;

 notification1.Visible = true;

}

На рис. 3.21 показано сообщение, которое будет отображаться на экране КПК в течение 10 секунд.

Рис. 3.21. Вывод сообщения с помощью элемента Notification

ПРИМЕЧАНИЕ

Элемент Notification применяется только в приложениях для карманных компьютеров. Смартфоны его не поддерживают.

Элемент HardwareButton

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

Следует рассмотреть пример использования этого нового элемента. Прежде всего нужно создать новый проект и поместить на панели Component tray два элемента HardwareButton с именами hrdLeftRotate и hrdRightRotate. Для каждой переопределяемой кнопки необходимо создать свой экземпляр элемента HardwareButton. В рассматриваемом примере будут переопределяться вторая и третья кнопки.

Также на форме надо разместить графическое поле PictureBox. В него надо загрузить любое изображение и растянуть картинку таким образом, чтобы она заняла верхнюю половину экрана. Изображение надо пристыковать к верхней части формы. Для этого свойству Dock присваивается значение Top. Также на форме надо разместить надпись Label, при помощи которой будут отображаться подсказки. Надпись следует пристыковать к нижней части формы. Для этого свойству Dock присваивается значение Bottom. У обоих добавленных элементов HardwareButton нужно отыскать свойство AssociatedControl и задать значение Form1. Также надо изменить значения свойств HardwareKey. Для первого элемента применяется значение ApplicationKey2, что соответствует второй кнопке. Для второго элемента задается значение ApplicationKey3, что соответствует третьей кнопке под экраном. Теперь, когда все необходимые свойства установлены, нужно написать код для события Form1_KeyUp. Код приведен в листинге 3.31.

Листинг 3.31

private void Form1_Load(object sender, EventArgs e) {

 label1.Text = "Нажмите вторую кнопку для поворота экрана на 90 градусов";

}


private void Form1_KeyUp(object sender, KeyEventArgs e) {

 switch ((HardwareKeys)e.KeyCode) {

 case HardwareKeys.ApplicationKey2:

  if (SystemSettings.ScreenOrientation == ScreenOrientation.Angle0) {

   SystemSettings.ScreenOrientation = ScreenOrientation.Angle90;

   label1.Text =

    "Нажмите третью кнопку для поворота экрана в первоначальную позицию";

  }

  break;

 case HardwareKeys.ApplicationKey:

  if (SystemSettings.ScreenOrientation == ScreenOrientation.Angle90) {

   SystemSettings.ScreenOrientation = ScreenOrientation.Angle();

   label1.Text = "Нажмите вторую кнопку для поворота экрана на 90 градусов";

  }

  break;

 default:

  break;

 }

}

Запустите программу и попытайтесь нажимать по очереди на вторую и третью кнопки под экраном карманного компьютера. Результат показан на рис. 3.22.

Рис. 3.22. Поворот экрана при помощи аппаратных кнопок

ПРИМЕЧАНИЕ

В документации говорится, что различные модели КПК имеют различное число кнопок, причем не все из них поддерживаются на системном уровне. Например, Windows Mobile 2003 для Pocket PC поддерживает четыре кнопки, a Windows Mobile 5.0 для Pocket PC поддерживает пять кнопок. При этом класс HardwareButton не поддерживается смартфонами и другими устройствами на базе Windows СЕ, которые не является устройствами Pocket PC.

Глава 4 Улучшаем элементы управления

В каждой новой версии Visual Studio .NET разработчики из Microsoft добавляют новые элементы управления, а также улучшают функциональность уже существующих элементов. Особенно это заметно на примере .NET Compact Framework. Уже простое сравнение имеющихся элементов управления в версиях 1.0 и 2.0 показывает, как много было добавлено новых элементов управления. Но, тем не менее, Microsoft не может создать элементы на все случаи жизни. Поэтому программистам иногда приходится создавать собственные элементы. Также для улучшения существующих элементов программисты прибегают к различным трюкам и хитростям. В этой главе будут рассмотрены некоторые приемы, которые, возможно, пригодятся в вашей практике.

Текстовые поля

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

Листинг 4.1

private void textBox1_KeyUp(object sender, KeyEventArgs e) {

 if (e.KeyCode == Keys.Enter) textBox2.Focus();

}


private void textBox2_KeyUp(object sender, KeyEventArgs e) {

 if (e.KeyCode = Keys.Enter) textBox3.Focus();

}


private void textBox3_KeyUp(object sender, KeyEventArgs e) {

 if (e.KeyCode == Keys.Enter) textBox1.Focus();

}

Управление полосой прокрутки

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

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

Листинг 4.2

[DllImport("coredll.dll")]

extern static int SendMessage(IntPtr hWnd, uint Msg, int wParam, int lParam);


/// <summary>

/// Сообщение Windows для работы с полосой прокрутки

/// </summary>

const int WM_VSCROLL = 0x115;


// константы для сообщения WM_VSCROLL

const int SB_LINEUP = 0:

const int SB_LINEDOWN = 1;

const int SB_PAGEUP = 2;

const int SB_PAGEDOWN = 3;


private void Form1_Load(object sender, EventArgs e) {

 // Отрывок из повести А.С.Пушкина "Дубровский"

 txtBook.Text = @"Несколько лет тому назад в одном из своих

 поместий жил старинный русский барин, Кирила Петрович Троекуров.

 Его богатство, знатный род и связи давали ему большой вес в губерниях,

 где находилось его имение. Соседи рады были угождать малейшим его

 прихотям; губернские чиновники трепетали при его имени; Кирила

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

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

 разделяя шумные, а иногда и буйные его увеселения.";

}


private void butUp_Click(object sender, EventArgs e) {

 // на одну строчку вверх

 SendMessage(txtBook.Handle, WM_VSCROLL, SB_LINEUP, 0);

}


private void butDown_Click(object sender, EventArgs e) {

 // на одну строчку вниз

 SendMessage(txtBook.Handle, WM_VSCROLL, SB_LINEDOWN, 0);

}


private void butPageUp_Click(object sender, EventArgs e) {

 // на одну страницу вверх

 SendMessage(txtBook.Handle, WM_VSCROLL, SB_PAGEUP, 0);

}


private void butPageDown_Click(object sender, EventArgs e) {

 // на одну страницу вниз

 SendMessageCtxtBook.Handle, WM_VSCROLL, SB_PAGEDOWN, 0);

}

Внешний вид приложения показан на рис. 4.1.

Рис. 4.1. Программная прокрутка текста

Многострочный текст в кнопке

По умолчанию текст для кнопок может содержать только одну строку. Но при желании можно изменить этот стиль с помощью функций GetWindowLong и SetWindowLong, как показано в листинге 4.3.


Листинг 4.3

[DllImport("coredll.dll")]

private static extern IntPtr GetCapture();


[DllImport("coredll.dll")]

private static extern int GetWindowLong(IntPtr hWnd, int nIndex);


[DllImport("coredll.dll")]

private static extern int SetWindowLong(IntPtr hWnd, int nIndex,

 int dwNewLong);


public const int GWLSTYLE = -16;


// стиль многострочного текста

public const int BS_MULTILINE = 0x2000;


private void Form1_Load(object sender, EventArgs e) {

 IntPtr hWnd;

 int style;

 this.butMultiline.Capture = true;

 hWnd = GetCapture();

 this.butMultiline.Capture = false;

 style = GetWindowLong(hWnd, GWL_STYLE);

 SetWindowLong(hWnd, GWL_STYLE, style | BS_MULTILINE);

}

В этом примере для сравнения использовались две кнопки. На каждой из них размещен достаточно длинный текст (рис. 4.2).

Рис. 4.2. Вид кнопок в процессе программирования

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

Рис. 4.3. Создание многострочного текста на кнопке

ВНИМАНИЕ

Данный пример был написан еще для .NET Compact Framework 1.0. В .NET Compact Framework 2.0 нет надобности вызывать функцию GetCapture() для получения дескриптора hWnd, так как теперь поддерживается свойство Control.Handle.

Увеличение ширины выпадающего списка ComboBox

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

Листинг 4.4

/// <summary>

/// Сообщение, получающее размеры выпадающего списка

/// комбинированного окна

/// </summary>

const int CB_GETDROPPEDWIDTH = 0x015f;


/// <summary>

/// Сообщение, устанавливающее размеры выпадающего списка

/// комбинированного окна

/// </summary>

const int CB_SETDROPPEDWIDTH = 0x0160;


[DllImport("coredll.dll")]

static extern int SendMessage(IntPtr hwnd, int msg, int wParam, int lParam);


private void Form1_Load(object sender, EventArgs e) {

 comboBox1.Items.Add("Раз");

 comboBox1.Items.Add("Два");

 comboBox1.Items.Add("Три");


 comboBox2.Items.Add("Длинный текст");

 comboBox2.Items.Add("Очень длинный текст");

 comboBox2.Items.Add("Hy очень длинный текст");

 // Устанавливаем желаемую ширину

 SendMessage(comboBox2.Handle, CB_SETDROPPEDWIDTH, 200, 0);


 // Получим ширину выпадающего окна

 int retval = SendMessage(comboBox2.Handle, CB_GETDROPPEDWIDTH, 0, 0);

 this.Text = retval.ToString();

}

На форме надо разместить два элемента ComboBox. Один из них будет стандартным. А второй элемент обработает сообщение CB_SETDROPPEDWIDTH со значением второго параметра 200. В результате выпадающий список будет в ширину занимать 200 пикселов.

После запуска программы сначала надо обратить внимание на работу первого комбинированного окна (рис. 4.4). Оно ведет себя стандартным образом.

Рис. 4.4. Стандартный размер выпадающего списка

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

Рис. 4.5. Увеличенный размер выпадающего списка у ComboBox

ListBox

Элемент ListBox имеет множество возможностей, которые пока не реализованы в рамках платформы .NET Compact Framework. В частности, данный элемент не позволяет осуществлять поиск элементов по первым символам. Но для решения этой задачи можно использовать сообщение LB_FINDSTRING.

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

Листинг 4.5

const int LB_FINDSTRING = 0x018F;

const int LB_FINDSTRINGEXACT = 0x01A2;


[DllImport("coredll.dll")]

static extern int SendMessage(IntPtr hwnd, int msg,

 int wParam, string lParam);


private void textBox1_TextChanged(object sender, EventArgs e) {

 //поиск строки по вводимым символам

 listBox1.SelectedIndex =

  SendMessage(listBox1.Handle, LB_FINDSTRING, -1, textBox1.Text);

}


private void Form1_Load(object sender. EventArgs e) {

 listBox1.Items.Add("bank");

 listBox1.Items.Add("banana");

 listBox1.Items.Add("ball");

 listBox1.Items.Add("bounty");

 listBox1.Items.Add("bar");

}

После запуска проекта можно попробовать ввести в текстовом поле любое слово. Если в списке есть слова, начинающиеся с введенных символов, то они начнут выделяться в списке. Например, можно сначала ввести символ b, затем a и, наконец, l. Сначала будет выделено слово bank, а после третьего введенного символа выделение перейдет на слово ball.

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

Листинг 4.6

private void button1_Click(object sender, EventArgs e) {

 listBox1.SelectedIndex =

  SendMessage(listBox1.Handle, LB_FINDSTRINGEXACT, -1, "ball");

}

ListView

Возможно, вы замечали, что в некоторых программах используется элемент ListView с градиентной заливкой. Например, такое оформление интерфейса можно увидеть в списке контактов. Оказывается, совсем не сложно применить такую раскраску в своем приложении. Но для этого надо использовать стиль LVS_GRADIENT, как показано в листинге 4.7.

Листинг 4.7

using System.Runtime.InteropServices;


[DllImport("coredll.dll")]

static extern int SendMessage(IntPtr hwnd, uint msg, int wParam, int lParam);


const int LVS_EX_GRADIENT = 0x20000000;

const int LVM_SETEXTENDEDLISTVIEWSTYLE = 0x1000 + 54;


// Создаем градиентный фон для ListView

private void CreateGradientListView(ListView listView) {

 // Получим дескриптор ListView

 IntPtr hLV = listView.Handle;


 // Устанавливаем расширенный стиль

 SendMessage(hLV, (uint)LVM_SETEXTENDEDLISTVIEWSTYLE, 0, LVS_EX_GRADIENT);

 // Обновляем вид

 listView.Refresh();

}


private void Form1_Load(object sender, EventArgs e) {

 CreateGradientListView(listView1);

}

Создание кнопки, содержащей изображение

В статье «How to: Create a Custom Image Button Control», которую можно отыскать по адресу msdn2.microsoft.com/en-us/library/ms172532(VS.80).aspx, описывается процесс создания кнопки, которая может содержать в качестве фона любое изображение. В первых версиях .NET Compact Framework кнопку вообще нельзя было сделать цветной, так как не существовало свойства BackColor. Потом данный недостаток был исправлен, но стандартными средствами пока не получится отобразить на кнопке рисунок. С помощью примера, который приводится в статье, можно обойти это ограничение.

Список с расширенными возможностями

В другой статье — «How to: Create an Owner-Drawn List Box», расположенной по адресу msdn2.microsoft.com/en-us/library/ms229679(VS.80).aspx, — описывается создание списка ListBox с расширенными возможностями. В этом примере показано, как можно использовать графику и различные шрифты для отображения элементов списка.

Текстовое поле для ввода чисел

Очень часто программистам необходимо создавать текстовые поля, в которых можно указывать только числа. В статье «How to: Create a Numeric Text Box», которую можно найти по адресу msdn2.microsoft.com/en-us/library/ms229644(VS.80).aspx, рассказывается об одном из таких способов. Прочитав статью, вы поймете, как создавать текстовые поля, допускающие ввод только чисел, минуса, пробела и разделителя десятичных чисел.

Сортировка элементов ListView

Элемент управления ListView в .NET Compact Framework не поддерживает метод Sort, который позволил бы отсортировать элементы списка. В документации MSDN есть статья «How to: Sort ListView Items», в которой рассказывается о том, как решить эту проблему при помощи метода Sort класса ArrayList и интерфейса IComparer.

Использование элемента DateTimePicker

Элемент управления DateTimePicker появился только в последней версии .NET Compact Framework 2.0. В документации MSDN есть ряд замечательных статей о том, как создать собственный элемент DateTimePicker для программ, работающих на платформе .NET Compact Framework 1.0. Стоит ознакомиться со статьями «Adding Designer Support to the .NET Compact Framework DateTimePicker Control» и «Microsoft .NET Compact Framework-based DateTimePicker Control».

Глава 5 Мышь и клавиатура

Мышь и стилус

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

Но стоит заметить, что у стилуса нет возможности эмулировать нажатие правой кнопки мыши. Когда пользователь применяет стилус, то генерируются события MouseDown, MouseMove, MouseUp и Click. Первые три события могут сообщить о позиции курсора, как и события из настольной версии Windows.

Курсоры

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

Песочные часы

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

Листинг 5.1

// Устанавливаем курсор ожидания

Cursor.Current = Cursors.WaitCursor;


// возвращаем курсор по умолчанию

Cursor.Current = Cursors.Default;

На рис. 5.1 показано приложение с соответствующим курсором.

Рис. 5.1. Отображение курсора ожидания

Обработка события Tap-and-Hold

Так как в карманных компьютерах не используется правая кнопка мыши, то для вызова контекстного меню используется операция Tap-and-Hold. Пользователь касается стилусом экрана и некоторое время удерживает нажатие. Если элемент, на поверхности которого находится стилус, связан с элементом ContexMenu, то на экране появится контекстное меню. А что делать, если мы хотим создать собственный обработчик события Tap-and-Hold? В этом случае надо добавить в проект таймер и написать код для обработки событий Mouse_Down, Mouse_Up и timer1_Tick. Для таймера следует задать интервал, необходимый для инициирования события. Сам код приведен в листинге 5.2.

Листинг 5.2

private void Form1_MouseDown(object sender, MouseEventArgs e) {

 // включаем таймер

 timer1.Enabled = true;

}


private void Form1_MouseUp(object sender, MouseEventArgs e) {

 timer1.Enabled = false;

 label1.Text = "";

}


private void timer1_Tick(object sender, EventArgs e) {

 label1.Text = "Вы нажали на экран";

}

Клавиатура

На большинстве карманных компьютеров нет стандартной клавиатуры, поэтому ввод текста осуществляется с помощью виртуальной клавиатуры SIP. В Visual Studio 2005 клавиатура SIP представлена элементом InputPanel. Но в последнее время стали появляться устройства с настоящей встроенной клавиатурой. Как правило, эти устройства имеют квадратный экран. Среда разработки поддерживает эмуляторы подобных моделей (рис. 5.2). Эти эмуляторы в своем названии содержат слово «Square».

Рис. 5.2. Эмулятор устройства с клавиатурой

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

Клавиши навигации

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

Листинг 5.3

private void Form1_KeyDown(object sender, KeyEventArgs e) {

 if ((e.KeyCode == System.Windows.Forms.Keys.Up)) {

  label1.Text = "Клавиша Вверх";

 }

 if ((e.KeyCode = System.Windows.Forms.Keys.Down)) {

  label1.Text = "Клавиша Вниз";

 }

 if ((e.KeyCode == System.Windows.Forms.Keys.Left)) {

  label1.Text = "Клавиша Влево";

 }

 if ((e.KeyCode == System.Windows.Forms.Keys.Right)) {

  label1.Text = "Клавиша Вправо";

 }

 if ((e.KeyCode == System.Windows.Forms.Keys.Enter)) {

  label1.Text = "Клавиша Enter";

 }

}


Как видите, приложение определяет нажатую клавишу при помощи перечисления System.Windows.Forms.Keys. Если открыть виртуальную клавиатуру и нажать на клавиши со стрелками, то можно убедиться, что они тоже инициируют событие Form_KeyDown (рис. 5.3). Если протестировать пример на устройстве с настоящей клавиатурой, то можно заметить, что приложение правильно обрабатывает нажатие на встроенные клавиши со стрелками.

Рис. 5.3. Обработка нажатий клавиш навигации

Выключение устройства

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

Листинг 5.4

/// <summary>

/// Функция имитирует нажатия клавиш на клавиатуре

/// </summary>

/// <param name="bVk">Виртуальный код клавиши для имитации

/// нажатия и отпускания клавиши</param>

/// <param name="bScan">Зарезервировано - установлено в

// 0</param>

/// <param name="dwFlags">Флаг</param>

/// <param name="dwExtraInfo">Дополнительная информация</param>

[DllImport("coredll.dll", CharSet = CharSet.Unicode)]

public static extern void

keybd_event(byte bVk, byte bScan, int dwFlags, int dwExtraInfo);


// константа для кнопки выключения устройства

public const int VK_OEM_8 = 0xDF;


private void butOff_Click(object sender, EventArgs e) {

 // Имитируем нажатие кнопку выключения устройства

 keybd_event(VK_OEM_8, 0, 0, 0);

}

Дополнительные материалы

Если вы хотите узнать о клавиатуре еще больше, то стоит обратить внимание на блог Алекса Яхнина, который можно найти по адресу blog.opennetcf.org/ayakhnin. Там можно найти статью «Keyboard hook in the CF v2». В данной статье рассказывается о перехвате всех сообщений, которые посылаются при нажатии любых кнопок устройства. Также может быть полезна статья «Custom SIP Control for CF». Автор статьи предлагает собственную реализацию элемента InputControl, который содержит свою виртуальную клавиатуру. Этот пример может пригодиться при создании приложения, в котором не используется стандартная панель ввода SIP, но при этом пользователь должен иметь возможность ввода информации.

Глава 6 Графика

Классы для программирования графики

Программирование графики в .NET Compact Framework опирается на те же базовые приемы, что и работа с графикой для полной версии .NET Framework. Все основные классы для работы с графикой сосредоточены в пространстве имен System.Drawing. С помощью этих классов можно рисовать всевозможные фигуры, отображать линии, работать с изображениями и даже манипулировать текстом. В качестве своеобразного холста для графических опытов можно использовать поверхность формы или элементов управления. Самым главным классом является класс Graphics, который предоставляет поверхность и методы для вывода графики. Также широко используются в графике такие классы, как Pen, Brush, Color, Rectangle, Line, Image.

Класс Pen

Класс Pen используется для создания пера, при помощи которого проводятся прямые и кривые линии. В отличие от полной версии .NET Framework, поддерживающей четыре перегруженных версии конструктора Pen, .NET Compact Framework позволяет создавать перо только с помощью двух конструкторов. При вызове метода Pen(Color) создается перо указанного цвета. Конструктор Pen(Color, Single) позволяет создавать перо указанных цвета и ширины. Но второй вариант поддерживается только в .NET Compact Framework 2.0.

В листинге 6.1 приведен пример создания перьев синего и красного цветов. Затем при помощи перьев создаются две линии.

Листинг 6.1

private void Form1_Paint(object sender, PaintEventArgs e) {

 Graphics g = e.Graphics;

 // Синее перо толщиной 1 пиксел

 Pen bluePen = new Pen(Color.Blue);

 // Красное перо толщиной 5 пикселов

 Pen redFatPen = new Pen(Color.Red, 5);

 g.DrawLine(bluePen, 10, 10, 230, 10);

 g.DrawLine(redFatPen, 10, 20, 230, 20);

}

Класс Brush

Класс Brush является абстрактным классом для создания кистей, с помощью которых можно рисовать фигуры и текст на графической поверхности. Библиотека .NET Compact Framework поддерживает классы SolidBrush и TextureBrush. К сожалению, класс LinearGradientBrush, позволяющий рисовать красивые фигуры, в настоящее время не поддерживается.

Класс SolidBrush

При создании объекта SolidBrush нужно просто указать цвет, который будет использоваться для отображения фигур. Чтобы сменить цвет кисти, достаточно указать новый цвет в свойстве Color. В листинге 6.2 приведен код, который позволяет нарисовать зеленый круг и желтый прямоугольник.

Листинг 6.2

private void Form1_Paint(object sender, PaintEventArgs e) {

 Graphics g = e.Graphics;

 // Создаем кисть зеленого цвета

 SolidBrush myBrush = new SolidBrush(Color.Green);

 // Рисуем закрашенный круг

 g.FillEllipse(myBrush, 10, 30, 30, 30);

 // Меняем цвет кисти на желтый

 myBrush.Color = Color.Yellow;

 // Рисуем закрашенный прямоугольник

 g.FillRectangle(myBrush, 50, 30, 50, 25);

}

Класс TextureBrush

Класс TextureBrush позволяет создавать текстурную кисть. Подобная текстурная кисть позволяет не рисовать однородным цветом, а применять текстурное заполнение отображаемых графических примитивов. Использование подобной кисти позволяет добиваться красивых эффектов. В листинге 6.3 приведен пример использования текстурной кисти с использованием изображения, входящего в состав Windows Mobile 2003.

Листинг 6.3

private void Form1_Paint(object sender, PaintEventArgs e) {

 Graphics g = e.Graphics;


 // выбираем рисунок

 Image myImage = new Bitmap(@"\Windows\alerts.bmp");

 // создаем текстурную кисть TextureBrush

 texture = new TextureBrush(myImage);

 // Рисуем эллипс, заполненный рисунком

 g.FillEllipse(texture, 10, 60, 120, 120);

 g.Dispose();

}

ВНИМАНИЕ

Такие свойства класса TextureBrush, как Transform и WrapMode, не поддерживаются в .NET Compact Framework 2.0.

Класс Color

При создании перьев или кистей применялся класс Color. Он позволяет задавать цвет либо с помощью предопределенного названия, либо указывая составные части цвета в модели RGB. Например, для создания красного цвета можно использовать код, приведенный в листинге 6.4.

Листинг 6.4

// красный цвет по названию

Color redColor = Color.Red;

// красный цвет из компонентов RGB

Color redColor2 = Color.FromArgb(255, 0, 0);

// Выводим на экран две красные линии

g.DrawLine(new Pen(redColor), 10, 190, 100, 190);

g.DrawLine(new Pen(redColor2), 10, 195, 100, 195);

Класс Font

Класс Font используется для вывода текста. Как ни странно, вывод текстовой информации тоже является графической операцией, что немного смущает новичков. Из четырнадцати возможных перезагруженных версий конструктора класса в .NET Compact Framework доступно только три. Для создания объекта Font нужно определить семейство шрифтов, размер символов и стиль начертания. Пример использования шрифта приведен в листинге 6.5.

Листинг 6.5

Font myFont = new Font("Tahoma", 9, FontStyle.Italic);

g.DrawString("Карманный компьютер", myFont, myBrush, 14, 200);

Класс Icon

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

Листинг 6.6

Icon myIcon = new Icon(Assembly.GetExecutingAssembly().

 GetManifestResourceStream("MyApp.Icon.ico"));

Класс Bitmap

Класс Bitmap предназначен для работы с растровыми изображениями. Программист может загрузить картинку в объект Bitmap из потока Stream, скопировать из существующего объекта Bitmap или загрузить из файла. Также можно создать новый пустой объект Bitmap, указав только размеры картинки. Ранее класс Bitmap уже использовался при создании текстурной кисти. Но при этом применялся родственный объект Image. В листинге 6.7 приведен новый вариант создания кисти.

Листинг 6.7

// выбираем рисунок

Bitmap myImage = new Bitmap(@"\Windows\alerts.bmp");

// создаем текстурную кисть

TextureBrush texture = new TextureBrush(myImage);

Структура Point

Структура Point содержит координаты X и Y для указания расположения некоей точки. В библиотеке .NET Compact Framework поддерживается только один конструктор для создания объекта Point, в котором указываются эти координаты. Структура Point часто используется в методах DrawPolygon и FillPolygon, которые будут рассматриваться позже.

Структура Rectangle

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

Листинг 6.8

Rectangle myRectangle = new Rectangled(10, 10, 70, 210);

Графические методы

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

Метод CreateGraphics формы или элемента управления позволяет получить объект Graphics, предоставляющий возможность рисовать на форме или элементе управления. Этот метод демонстрируется в листинге 6.9.

Листинг 6.9

Graphics g = this.CreateGraphics();

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

Листинг 6.10

Bitmap bmp = new Bitmap(150, 90);

Graphics g = Graphics.FromImage(bmp);

Метод OnPaint класса Form получает в качестве параметра объект PaintEventArgs. Одним из членов данного объекта является объект Graphics, связанный с формой. Переопределяя метод OnPaint класса Form, можно получить доступ к объекту Graphics из параметра PaintEventArgs, после чего можно работать с графикой в клиентской области формы. Вызов этого метода показан в листинге 6.11.

Листинг 6.11

Protected override void OnPaint(PaintEventArgs e) {

 Graphics g = e.Graphics;

}

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

Метод DrawImage рисует заданный объект Image в указанной позиции экрана. Всего существует четыре перегруженные версии метода. Но в самой простой его версии достаточно указать координаты выводимой картинки, как показано в листинге 6.12.

Листинг 6.12

g.DrawImage(myImage, 10, 10);

С помощью метода DrawImage можно выводить на экран не все изображение, а только его часть. В этом случае надо указать размеры прямоугольника, который определяет размеры выводимой области картинки, как показано в листинге 6.13. В примере используется перечисление GraphicsUnit.Pixel, которое позволяет указывать единицы измерения.

Листинг 6.13

Bitmap myBMP = new Bitmap(@"\windows\banner.gif");

Rectangle portion = new Rectangle(1, 1, 150, 25);

g.DrawImage(myBMP, 20, 220, portion, GraphicsUnit.Pixel);

Метод FillRectangle уже применялся при рассмотрении кистей. Метод DrawRectangle использует перо вместо кисти, поэтому на экран выводится незакрашенный прямоугольник.

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

Листинг 6.14

// Нарисуем ромб

// Зададим массив точек

Point[] arrPoint = {

 new Point(150, 50),

 new Point(200, 100),

 new Point(150, 150),

 new Point(100, 100),

 new Point(150, 50),

};

g.DrawPolygon(bluePen, arrPoint);

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

Рис. 6.1. Основные приемы работы с графикой

Создание собственных методов DrawPie и FillPie

В данный момент .NET Compact Framework не поддерживает графические методы DrawPiе и FillPie, которые позволяли бы рисовать круговые секторы. Но можно создать свою версию этих методов, используя математические вычисления, как показано в листинге 6.15.

Листинг 6.15

///<summary>

///Рисуем закрашенный сектор

///Параметры функции

///g - Объект Graphics

///solidBrush - Кисть для закраски сегмента

///x,y - Координаты центра

///width - Ширина сегмента

///height - Высота сегмента

///startAngle - Значение начального угла

///endAngle - Значение конечного угла

///</summary>

private void FillPie(Graphics g, SolidBrush solidBrush, int x, int y,

 int width, int height, double startAngle, double endAngle) {

 double[] xAngle = new double[12];

 double[] yAngle = new double[12];

 double angleIncrement = (endAngle - startAngle) / 10;

 double angle = startAngle;


 for (int i = 0; i <= 10; i++) {

  xAngle[i] = x + (Math.Cos(angle * (Math.PI / 180)) * (width / 2));

  yAngle[i] = y + (Math.Sin(angle * (Math.PI / 180)) * (height / 2));

  angle += angleIncrement;

 }

 xAngle[11] = x + (Math.Cos(endAngle * (Math.PI / 180)) * (width / 2));

 yAngle[11] = y + (Math.Sin(endAngle * (Math.PI / 180)) * (height / 2));


 Point[] anglePoints = {

  new Point(x, y),

  new Point((int)xAngle[0], (int)yAngle[0]),

  new Point((int)xAngle[1], (int)yAngle[1]),

  new Point((int)xAngle[2], (int)yAngle[2]),

  new Point((int)xAngle[3], (int)yAngle[3]),

  new Point((int)xAngle[4], (int)yAngle[4]),

  new Point((int)xAngle[5], (int)yAngle[5]),

  new Point((int)xAngle[6], (int)yAngle[6]),

  new Point((int)xAngle[7], (int)yAngle[7]),

  new Point((int)xAngle[8], (int)yAngle[8]),

  new Point((int)xAngle[9], (int)yAngle[9]),

  new Point((int)xAngle[10], (int)yAngle[10]),

  new Point((int)xAngle[11], (int)yAngle[11])

 };


 g.FillPolygon(solidBrush, anglePoints);

}


///<summary>

/// Рисуем границы сектора

///g - Объект Graphics

///pen - Перо для рисования сегмента

///x,y - Центр сегмента

///width - Ширина сегмента

///height - Высота

///startAngle - Значение начального угла

///endAngle - Значение конечного угла

///</summary>

private void DrawPie(Graphics g, Pen pen, int x, int y,

 int width, int height, double startAngle, double endAngle) {

 double[] xAngle = new double[12];

 double[] yAngle = new double[12];

 double angleIncrement = (endAngle - startAngle) / 10;

 double angle = startAngle;


 for (int i = 0; i <= 10; i++) {

  xAngle[i] = x + (Math.Cos(angle * (Math.PI / 180)) * (width /2));

  yAngle[i] = y + (Math.Sin(angle * (Math.PI / 180)) * (height / 2));

  angle += angleIncrement;

 }

 xAngle[11] = x + (Math.Cos(endAngle * (Math.PI / 180)) * (width / 2));

 yAngle[11] = y + (Math.Sin(endAngle * (Math.PI / 180)) * (height /2));


 Point[] anglePoints = {

  new Point(x, y),

  new Point((int)xAngle[0], (int)yAngle[0]),

  new Point((int)xAngle[1], (int)yAngle[1]),

  new Point((int)xAngle[2], (int)yAngle[2]),

  new Point((int)xAngle[3], (int)yAngle[3]),

  new Point((int)xAngle[4], (int)yAngle[4]),

  new Point((int)xAngle[5], (int)yAngle[5]),

  new Point((int)xAngle[6], (int)yAngle[6]),

  new Point((int)xAngle[7], (int)yAngle[7]),

  new Point((int)xAngle[8], (int)yAngle[8]),

  new Point((int)xAngle[9], (int)yAngle[9]),

  new Point((int)xAngle[10], (int)yAngle[10]),

  new Point((int)xAngle[11], (int)yAngle[11])

 };


 g.DrawPolygon(pen, anglePoints);

}


private void Form1_Paint(object sender, PaintEventArgs e) {

 // Выводим несколько секторов на экран

 DrawPie(e.Graphics, new Pen(Color.Red), 130, 165, 100, 100, 0, 45);

 FillPie(e.Graphics, new SolidBrush(Color.Green),

  120, 160, 100, 100, 46, 90);

 FillPie(e.Graphics, new SolidBrush(Color.Yellow),

  120, 160, 100, 100, 91, 120);

 FillPie(e.Graphics, new SolidBrush(Color.Blue),

  120, 160, 100, 100, 121, 260);

 FillPie(e.Graphics, new SolidBrush(Color.Red),

  120, 160, 100, 100, 261, 360);

}

Результат работы этой программы показан на рис. 6.2.

Рис. 6.2. Создание секторов

Создание фонового рисунка для формы

К сожалению, .NET Compact Framework не поддерживает свойство BackgroundImage, которое создает фоновый рисунок для формы. Но каждый программист может восполнить данный пробел, переопределяя метод OnPaint.

Нужно создать новый проект и разместить на форме какой-нибудь элемент управления, например кнопку. Кнопка не будет выполнять никаких функций. Она потребуется лишь для демонстрации технологии. Также надо добавить в проект изображение, которое будет использоваться в качестве фона для формы. В нашем примере картинка будет внедрена в программу как ресурс, хотя можно загрузить ее из обычного графического файла. Чтобы все работало так, как запланировано, необходимо переопределить метод OnPaint(). Новый код метода приведен в листинге 6.16.

Листинг 6.16

protected override void OnPaint(PaintEventArgs e) {

 // получим картинку из ресурсов Bitmap

 backgroundImage = new Bitmap(Assembly.GetExecutingAssembly().

  GetManifestResourceStream("BackgroundImageCS.sochicat.jpg"));


 e.Graphics.DrawImage(backgroundImage, this.ClientRectangle,

  new Rectangle(0, 0, backgroundImage.Width, backgroundImage.Height),

 GraphicsUnit.Pixel);

}

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

Рис. 6.3. Заполнение фона формы своим рисунком

Копирование рисунка

Библиотека .NET Compact Framework 1.0 не поддерживает метод System.Drawing.Image.Clone, позволяющий создать точную копию картинки. Это ограничение легко обходится с помощью создания собственных методов. Кроме того, можно расширить возможности метода и добавить функциональность, позволяющую копировать часть картинки. Соответствующий код приведен в листинге 6.17.

Листинг 6.17

// Копируем всю картинку

protected Bitmap CopyBitmap(Bitmap source) {

 return new Bitmap(source);

}


// Копируем часть картинки

protected Bitmap CopyBitmap(Bitmap source, Rectangle part) {

 Bitmap bmp = new Bitmap(part.Width, part.Height);

 Graphics g = Graphics.FromImage(bmp);

 g.DrawImage(source, 0, 0, part, GraphicsUnit.Pixel);

 g.Dispose();

 return bmp;

}


private void button1_Click(object sender, EventArgs e) {

 Graphics g = CreateGraphics();

 Bitmap myBMP = new Bitmap(@"\windows\banner.gif");


 // Половина ширины картинки

 int left = myBMP.Size.Width / 2;

 // Копируем всю картинку Bitmap

 clone = CopyBitmap(myBMP);


 // копируем левую часть картинки

 Bitmap part =

  CopyBitmap(myBMP, new Rectangle(0, 0, left, myBMP.Size.Height));


 // Выводим три картинки по вертикали:

 // источник, копию и копию левой части

 int y = 10;


 // картинка-источник

 g.DrawImage(myBMP, 10, y);

 y += myBMP.Height + 10;


 // картинка-копия

 g.DrawImage(clone, 10, y);

 y += clone.Height + 10;


 // копия левой части картинки

 g.DrawImage(part, 10, y);

 y += part.Height + 10;

 g.Dispose();

}


private void button2_Click(object sender, EventArgs e) {

 Graphics g = CreateGraphics();

 Bitmap myBMP = new Bitmap(@"\windows\banner.gif");

 g.Clear(Color.White);


 int left = myBMP.Size.Width / 2; // Копия картинки

 Bitmap clone = (Bitmap)myBMP.Clone();

 int y = 10;

 g.DrawImage(myBMP, 10, y);

 y += myBMP.Height + 10;

 g.DrawImage(clone, 10, y);

 y += clone.Height + 10;

 g.Dispose();

}

В этом примере создаются две перегруженные версии метода CopyImage. При помощи этого метода можно копировать картинку или ее часть. Для сравнения в примере было показано, как можно скопировать картинку с помощью метода Clone, доступного в .NET Compact Framework 2.0. Результат работы соответствующего приложения показан на рис. 6.4.

Рис. 6.4. Копирование картинки разными способами

Поддержка прозрачности

Библиотека .NET Compact Framework позволяет использовать прозрачный цвет, но при этом налагает определенные ограничения на эту возможность. Например, в библиотеке нет такого удобного метода, как MakeTransparent. Но разработчик может задать прозрачный цвет при помощи метода SetColorKey класса ImageAttributes. При этом разрешается использовать один и тот же цвет для минимального и максимального значений цветового ключа в версии метода ImageAttributes.SetColorKey(Color.Color).

ПРИМЕЧАНИЕ

Вторая перегруженная версия метода ImageAttributes.SetColorKey(Color, Color, ColorAdjustType) в .NET Compact Framework не поддерживается.

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

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

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

Основной код приложения приведен в листинге 6.18.

Листинг 6.18

private void butAddImage_Click(object sender, EventArgs e) {

 Graphics g = CreateGraphics();

 // получим картинки из ресурсов

 Bitmap imgCat = new Bitmap(Assembly.GetExecutingAssembly().

  GetManifestResourceStream("TransparentCS.mycat.jpg"));

 Bitmap imgName = new Bitmap(Assembly.GetExecutingAssembly().

  GetManifestResourceStream("Transparent_CS.catname.bmp"));

 g.DrawImage(imgCat, 0, 0,

  new Rectangle(0, 0, imgCat.Width, imgCat.Height), GraphicsUnit.Pixel);

 g.DrawImage(imgName, 50, 120,

  new Rectangle(0, 0, imgName.Width.imgName.Height), GraphicsUnit.Pixel);

 g.Dispose();

}


private void butImage2_Click(object sender, EventArgs e) {

 Graphics g = CreateGraphics();

 // получим картинки из ресурсов

 Bitmap imgCat = new BitmapCAssembly.GetExecutingAssembly().

  GetManifestResourceStream("Transparent_CS.mycat.jpg"));

 Bitmap imgName = new Bitmap(Assembly.GetExecutingAssembly().

  GetManifestResourceStream("Transparent_CS.catname.bmp"));

 // Очистим экран

 g.Clear(Color.White);

 // Выводим первую картинку

 g.DrawImage(imgCat, 0, 0,

  new Rectangle(0, 0, imgCat.Width, imgCat.Height), GraphicsUnit.Pixel);


 ImageAttributes attr = new ImageAttributes();

 // Устанавливаем красный цвет как прозрачный

 attr.SetColorKey(Color.Red, Color.Red);

 // Выводим вторую картинку с установленными атрибутами

 Rectangle dstRect = new Rectangle(50, 120, imgName.Width, imgName.Height);

 g.DrawImage(imgName, dstRect, 0, 0,

  imgName.Width, imgName.Height, GraphicsUnit.Pixel.attr);

 g.Dispose();

}

ВНИМАНИЕ

He забудьте импортировать пространство имен System.Drawing.Imaging при работе с этим примером.

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

Рис. 6.5. Неудачный вариант наложения двух картинок

Если же воспользоваться методом SetColorKey для установки прозрачного цвета, то результат наложения двух изображений будет выглядеть достойно (рис. 6.6).

Рис. 6.6. Наложение картинки с использованием прозрачности

Округленные прямоугольники

Так как .NET Compact Framework не позволяет создавать округленные прямоугольники встроенными средствами, то необходимо самостоятельно реализовать эту задачу. В этом разделе будет рассматриваться решение, предложенное Алексом Яхниным (Alex Yakhnin) в его блоге blog.opennetcf.org/ayakhnin/. Для достижения заданного эффекта надо нарисовать серию линий, которые соединяют эллипсы, и закрасить внутреннюю область сплошным цветом (рис. 6.7).

Рис. 6.7. Создание прямоугольника со скругленным углами

Соответствующий код приведен в листинге 6.19.

Листинг 6.19

public static void DrawRoundedRectangle(Graphics g, Pen p, Color backColor,

 Rectangle rc, Size size) {

 Point[] points = new Point[8];

 // подготовим точки для фигуры

 points[0].X = rc.Left + size.Width / 2;

 points[0].Y = rc.Top + 1;

 points[1].X = rc.Right - size.Width / 2;

 points[1].Y = rc.Top + 1;

 points[2].X = rc.Right;

 points[2].Y = rc.Top + size.Height / 2;

 points[3].X = rc.Right;

 points[3].Y = rc.Bottom - size.Height / 2;

 points[4].X = rc.Right - size.Width / 2;

 points[4].Y = rc.Bottom;

 points[5].X = rc.Left + size.Width / 2;

 points[5].Y = rc.Bottom;

 points[6].X = rc.Left + 1;

 points[6].Y = rc.Bottom - size.Height / 2;

 points[7].X = rc.Left + 1;

 points[7].Y = rc.Top + size.Height / 2;


 // приготовим кисть для фона

 Brush fillBrush = new SolidBrush(backColor);

 // рисуем отрезки и круги для округленного прямоугольника

 g.DrawLine(p, rc.Left + size.Width / 2, rc.Top,

  rc.Right - size.Width / 2, rc.Top);

 g.FillEllipse(fillBrush, rc.Right - size.Width, rc.Top,

  size.Width, size.Height);

 g.DrawEllipse(p, rc.Right - size.Width, rc.Top, size.Width, size.Height);

 g.DrawLine(p, rc.Right, rc.Top + size.Height / 2, rc.Right,

  rc.Bottom - size.Height /2);

 g.FillEllipse(fillBrush, rc.Right - size.Width, rc.Bottom - size.Height,

  size.Width, size.Height);

 g.DrawEllipse(p, rc.Right - size.Width, rc.Bottom - size.Height,

  size.Width, size.Height);


 g.DrawLine(p, rc.Right - size.Width / 2, rc.Bottom,

  rc.Left + size.Width / 2, rc.Bottom);

 g.FillEllipse(fillBrush, rc.Left, rc.Bottom - size.Height,

  size.Width, size.Height);

 g.DrawEllipse(p, rc.Left, rc.Bottom - size.Height,

  size.Width, size.Height);


 g.DrawLine(p, rc.Left, rc.Bottom - size.Height / 2,

  rc.Left, rc.Top + size.Height / 2);

 g.FillEllipse(fillBrush. rc.Left, rc.Top, size.Width, size.Height);

  g.DrawEllipse(p, rc.Left, rc.Top, size.Width. size.Height);


 // заполняем прямоугольник, скрывая внутренние эллипсы

 g.FillPolygon(fillBrush, points);

 // освобождаем ресурсы

 fillBrush.Dispose();

}


private void butDrawRoundedRectangle_Click(object sender, EventArgs e) {

 Graphics g = CreateGraphics();

 Rectangle rc = new Rectangle(10, 10, 200, 50);

 DrawRoundedRectangle(g,

  new Pen(Color.Black), Color.CadetBlue, rc, new Size(8, 8));

}

Результат работы этого кода показан на рис. 6.8.

Рис. 6.8. Отображение закрашенного прямоугольника со скругленными углами

Создание экранных снимков

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

Листинг 6.20

[DllImport("coredll.dll", EntryPoint = "GetDesktopWindow")]

public static extern IntPtr GetDesktopWindow();

[DllImport("coredll.dll", EntryPoint = "GetDC")]

public static extern IntPtr GetDC(IntPtr hWnd);

[DllImport("coredll.dll", EntryPoint = "ReleaseDC")]

public static extern IntPtr ReleaseDC(IntPtr hWnd, IntPtr hDC);

[DllImport("coredll.dll")]

public static extern int BitBlt(IntPtr hdcDest, int nXDest, int nYDest,

 int nWidth, int nHeight, IntPtr hdcSrc, int nXSrc, int nYSrc, uint dwRop);

 const int SRCCOPY = 0x00CC0020;


private void screenshot(string filename, Graphics gx, Rectangle rect) {

 Bitmap bmp = new Bitmap(rect.Width, rect.Height);

 Graphics g = Graphics.FromImage(bmp);

 BitBlt(g.GetHdc(), 0, 0, rect.Width, rect.Height, gx.GetHdc(),

  rect.Left, rect.Top, SRCCOPY);

 bmp.Save(filename, System.Drawing.Imaging.ImageFormat.Bmp);

 bmp.Dispose();

 g.Dispose();

}


private void butPartOfWindow_Click(object sender, EventArgs e) {

 // Делаем снимок списка

 ScreenShot(@"\My Documents\save.bmp", this.CreateGraphics(),

  listBox1.Bounds);

}


private void butScreen_Click(object sender, EventArgs e) {

 // Делаем снимок экрана

 Rectangle rect = new Rectangle(0,0,240,240);

 Bitmap bmp = new Bitmap(rect.Width, rect.Height);

 Graphics g = Graphics.FromImage(bmp);

 IntPtr hwnd = GetDesktopWindow();

 IntPtr hdc = GetDC(hwnd);

 BitBlt(g.GetHdc(), 0, 0, rect.Width, rect.Height, hdc, rect.Left,

  rect.Top, SRCCOPY);

 bmp.Save(@"\My Documents\screen.bmp",

 System.Drawing.Imaging.ImageFormat.Bmp);

 // Освобождаем ресурсы

 ReleaseDC(hwnd, hdc);

 bmp.Dispose();

 g.Dispose();

}


private void timer1_Tick(object sender, EventArgs e) {

 // Делаем снимок экрана через 5 секунд

 Rectangle rect = new Rectangle(0, 0. 240, 240);

 Bitmap bmp = new Bitmap(rect.Width, rect.Height);

 Graphics g = Graphics.FromImage(bmp);

 IntPtr hwnd = GetDesktopWindow();

 IntPtr hdc = GetDC(hwnd);

 BitBlt(g.GetHdc(), 0, 0, rect.Width, rect.Height, hdc, rect.Left,

  rect.Top, SRCCOPY);

 bmp.Save(@"\My Documents\5sec.bmp", System.Drawing.Imaging.ImageFormat.Bmp);

 // Освобождаем ресурсы

 ReleaseDC(hwnd, hdc);

 bmp.Dispose();

 g.Dispose();

 timer1.Enabled = false;

}


private void but5Sec_Click(object sender, EventArgs e) {

 timer1.Enabled = true;

}

Функция ScreenShot позволяет быстро получить участок экрана и сохранить его в графическом файле. В рассмотренном примере внешний вид списка сохраняется в файле listbox.bmp. Для этого достаточно было указать имя файла, объект Graphics и размеры списка ListBox. Для получения снимка экрана пример пришлось несколько усложнить, добавив вызовы функций GetDesktopWindow и GetDC.

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

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

ВНИМАНИЕ

Нужно проявлять определенную осторожность при работе с методом Bitmap.Save(). Дело в том, что в Windows Mobile 2003 и более ранних версиях операционных систем библиотека .NET Compact Framework не поддерживает сохранение графических файлов в форматах GIF, JPEG или PNG. Сохранять файлы можно только в формате BMP. Причем во время написания кода редактор не заметит ошибки и позволит запустить программу с неправильным вызовом метода. Однако при вызове метода возникнет исключение NotSupportedException. К счастью, в Windows Mobile 5.0 поддерживаются все четыре графических формата.

Метод Lockbits

В .NET Compact Framework 2.0 появилась ограниченная поддержка метода LockBits, при помощи которого можно манипулировать массивом пикселов изображения. Перечисление ImageLockMode в данном методе позволяет использовать значения ReadWrite, ReadOnly и WriteOnly. А перечисление PixelFormat поддерживает значения, перечисленные в следующем списке:

□ Format16bppRgb555;

□ Format16bppRgb565;

□ Format24bppRgb;

□ Format32bppRgb.

На сайте MSDN можно найти статью «How to: Use LockBits» с примером, в котором создается картинка и меняется интенсивность синих пикселов с помощью метода LockBits. В листинге 6.21 приведен пример, который для большей наглядности пришлось немного изменить.

Листинг 6.21

private Bitmap CreateBitmap(int width, int height) {

 Bitmap bmp = new Bitmap(@"\Windows\msn.gif");

 width = bmp.Size.Width;

 height = bmp.Size.Height;

 Graphics g = Graphics.FromImage(bmp);

 g.Dispose();

 return bmp;

}


protected override void OnPaint(PaintEventArgs e) {

 Bitmap bmp = CreateBitmap(100, 100);

 // Выводим картинку-оригинал

 e.Graphics.DrawImage(bmp, 0, 0);

 MakeMoreBlue(bmp);

 // Рисуем модифицированную картинку ниже исходного изображения

 e.Graphics.DrawImage(bmp, 0, 50);

 bmp.Dispose();

}


private void MakeMoreBlue(Bitmap bmp) {

 // Задаём формат данных о цвете для каждой точки изображения

 PixelFormat pxf = PixelFormat.Format24bppRgb;

 // Блокируем изображение в памяти

 Rectangle rect = new Rectangle(0, 0, bmp.Width, bmp.Height);

 BitmapData bmpData = bmp.LockBits(rect, ImageLockMode.ReadWrite, pxf);

 // Получаем адрес первой строки развертки

 IntPtr ptr = bmpData.Scan();

 // Массив, содержащий байты изображения

 int numBytes = bmp.Width * bmp.Height * 3;

 byte[] rgbValues = new byte[numBytes];

 // Копируем значения RGB в массив

 Marshal.Copy(ptr, rgbValues, 0, numBytes);

 // Модифицируем изображение, устанавливая

 // синий цвет для каждой точки в картинке

 for (int counter = 0; counter < rgbValues.Length; counter += 6)

  rgbValues[counter] = 255;

 // Копируем значения RGB обратно в изображение

 Marshal.Сору(rgbValues, 0, ptr, numBytes);

 // Разблокируем биты в памяти

 bmp.UnlockBits(bmpData);

}

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

Графический редактор

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

Весь код программы сводится к обработке событий мыши MouseDown, MouseMove и MouseUp. В принципе, приемы создания графических эффектов ничем не отличаются от соответствующих приемов, применяемых на обычных персональных компьютерах. Я взял два примера из своей книги «Занимательное программирование на Visual Basic .NET» и перенес код в проект с учетом синтаксиса языка С#, что иллюстрирует листинг 6.22.

Листинг 6.22

private int x_md, y_md;

Pen myPen = new Pen(Color.LightBlue);

private bool bPaint;

Graphics g;


private Pen erasePen;

private Point ptsStart;

private Point ptsPrevious;

private Point ptsCurrent;


private void Form1_MouseDown(object sender, MouseEventArgs e) {

 // Начинаем рисование

 bPaint = true;

 if (mnuLines.Checked) {

  ptsStart.X = e.X;

  ptsStart.Y = e.Y;

  ptsPrevious = ptsStart;

 }

 if (mnuPaint.Checked) {

  // координаты стилуса при нажатии

  x_md = e.X;

  y_md = e.Y;

 }

}


private void Form1_MouseMove(object sender, MouseEventArgs e) {

 if (bPaint) {

  if (mnuLines.Checked) {

   ptsCurrent.X = e.X;

   ptsCurrent.Y = e.Y;

   g = CreateGraphics();

   g.DrawLine(erasePen, ptsStart.X, ptsStart.Y, ptsPrevious.X, ptsPrevious.Y);

   g.DrawLine(myPen. ptsStart.X, ptsStart.Y, ptsCurrent.X, ptsCurrent.Y);

   ptsPrevious = ptsCurrent;

   g.Dispose();

  }

  if (mnuPaint.Checked) {

   g = CreateGraphics();

   int x_mm = e.X;

   int y_mm = e.Y;

   g.DrawLine(myPen, x_md, y_md, x_mm, y_mm);

   x_md = x_mm;

   y_md = y_mm;

   g.Dispose();

  }

 }

}


private void Form1_MouseUp(object sender, MouseEventArgs e) {

 bPaint = false;

}


private void mnuClear_Click(object sender, EventArgs e) {

 g = CreateGraphics();

 g.Clear(this.BackColor);

 g.Dispose();

}


private void Form1_Load(object sender, EventArgs e) {

 erasePen = new Pen(this.BackColor);

}


private void mnuPaint_Click(object sender, EventArgs e) {

 mnuPaint.Checked = !mnuPaint.Checked;

 mnuLines.Checked = !mnuLines.Checked;

}


private void mnuGreenPen_Click(object sender, EventArgs e) {

 myPen.Color = Color.Green;

}


private void mnuRedPen_Click(object sender, EventArgs e) {

 myPen.Color = Color.Red;

}

На рис. 6.9 показано, как выглядит созданный графический редактор в работе.

Рис. 6.9. Простейший графический редактор

Дополнительные материалы

Если нужно ознакомиться с дополнительными материалами по программированию графики, то стоит обратиться к статьям документации MSDN. Например, в статье «How to: Display a Gradient Fill» рассказывается том, как раскрасить элемент градиентной заливкой. Также в документации MSDN имеется статья уже известного нам Алекса Яхнина «Creating a Microsoft .NET Compact Framework-based Animation Control», в которой рассказывается о создании элемента управления, способного воспроизводить анимированное изображение, создавая его на основе серии картинок. Тем, кто планирует писать приложения для устройств под управлением Windows Mobile 5.0, стоит обратить внимание на технологию Windows Mobile DirectX and Direct3D, которая дает дополнительные возможности для работы с графикой.

Глава 7 Разработка приложений

Активация и деактивация формы

Модель выполнения программ на карманном компьютере отличается от поведения программ, работающих на обычном персональном компьютере. Например, на мобильных компьютерах используется один экземпляр запущенной программы. Аналогом подобного поведения на настольных компьютерах является почтовая программа Outlook Express, которая всегда запускается в одном экземпляре. При попытке запуска программы она просто активируется (если уже была запущена). При этом вторая копия программы не запускается.

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

Учитывая подобное поведение, нужно писать программы, которые не занимают много ресурсов системы. Однажды запущенное приложение может находиться в памяти несколько дней, пока пользователь не перезагрузит компьютер или не закроет программу самостоятельно. Деактивированная программа закроется автоматически, если система обнаружит уменьшение свободной памяти при разрядке батареи. Но, тем не менее, иногда надо проследить, чтобы при закрытии программа освободила ресурсы, которые она использовала. Бывают ситуации, когда приложение поддерживает соединение с базой данных или осуществляет связь с СОМ-портами. В этом случае система может не освободить занимаемые программой ресурсы. Для отслеживания состояния формы используются события Form.Deactivate и Form.Activated. В листинге 7.1 приведен пример работы с этими событиями.

Листинг 7.1

private void Form1_Activated(object sender, EventArgs e) {

 // Здесь ваш код для восстановления связей с портами и т.д.

 lblInfo.Text = "Приложение активировано";

}


private void Form1_Deactivate(object sender, EventArgs e) {

 // Здесь ваш код для освобождения ресурсов

 lblInfo.Text = "Приложение деактивировано";

}

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

Закрыть или свернуть окно

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

Но бывают ли такие ситуации, когда действительно требуется принудительно закрывать программу? Такая необходимость возникает при отладке и тестировании программы в эмуляторе. При стандартной модели поведения довольно утомительно каждый раз вручную останавливать программу, запущенную в эмуляторе. Конечно, можно временно присвоить свойству MinimizeBox при отладке значение False, что поможет избавиться от этой проблемы. Но перед окончательным релизом программы надо все же поставить значение True. Однако полагаться на свою память не стоит. Гораздо проще воспользоваться условной компиляцией.

При создании приложения надо использовать несколько строчек кода в конструкторе формы сразу после вызова процедуры InitializeComponent(), как показано в листинге 7.2.

Листинг 7.2

#if DEBUG

 MinimizeBox = false;

#else

 MinimizeBox = true;

#endif

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

Рис. 7.1. Код условной компиляции на панели инструментов

Пиктограмма приложения

Любая серьезная программа должна иметь собственную пиктограмму. Чтобы указать используемую пиктограмму, надо при помощи команды меню Project►Properties открыть диалоговое окно Property Pages, выбрать раздел Application и указать путь к файлу с пиктограммой в свойстве Icon (рис. 7.2).

Рис. 7.2. Добавление пиктограммы для приложения

Создание собственных диалоговых окон

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

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

Предположим, что нужно создать специальное окно авторизации пользователя для доступа к программе. В состав проекта нужно включить новую форму, которая будет реализована как диалоговое окно проверки имени пользователя LogonForm. Это будет маленькое окно без четко очерченной границы. В нем надо разместить текстовое поле и две кнопки. Затем надо задать значения свойств FormBorderStyle, Size и Location. При загрузке основной формы и обработке события Load создается новый экземпляр объекта LogonForm и вызывается как диалоговое окно. Данное окно может вернуть значения DialogResult.OK, если пользователь ввел имя, или DialogResult.Cancel, если он просто закрыл форму. Если было введено правильное имя, то главная форма продолжает свою работу. В противном случае приложение следует закрыть. Соответствующий код приведен в листинге 7.3.

ВНИМАНИЕ

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

Листинг 7.3

private void Form1_Load(object sender, EventArgs e) {

 LogonForm LogonFrm = new LogonForm();

 if (LogonFrm.ShowDialog() == DialogResult.Cancel) {

  LogonFrm.Dispose();

  this.Close();

 } else {

  this.Text += " - " + LogonFrm.txtCheck.Text;

  LogonFrm.Dispose();

 }

}

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

Листинг 7.4

private void butOK_Click(object sender, EventArgs e) {

 if (txtCheck.Text == "Alex") {

  this.DialogResult = DialogResult.OK;

 } else {

  MessageBox.Show("В доступе отказано. Попробуйте еще раз",

   "Вход в программу");

 }

}

Если пользователь не знает имени для доступа к программе, то ему придется нажать кнопку Отмена. В этом случае обработчик события butCancel_Click, код которого приведен в листинге 7.5, возвращает значение DialogResult.Cancel в главную форму, которая закрывает приложение.

Листинг 7.5

private void butCancel_Click(object sender, System.EventArgs e) {

 this.DialogResult = DialogResult.Cancel;

}

Создание заставки Splash Screen

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

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

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

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

Листинг 7.6

protected override void OnPaint(PaintEventArgs e) {

 StringFormat sf = new StringFormat();

 sf.Alignment = StringAlignment.Center;

 sf.LineAlignment = StringAlignment.Center;

 Graphics g = e.Graphics;

 g.DrawString(".NET Compact Framework", this.Font,

 new SolidBrush(Color.Blue), Screen.PrimaryScreen.Bounds, sf);

}


private void timer1_Tick(object sender, EventArgs e) {

 this.Close();

}

В событии OnPaint формы AboutForm нужно установить свойства для вывода текста. При желании можно добавить отображение логотипа. Через заданный интервал таймер просто закроет это окно. Код для основной формы MainForm приведен в листинге 7.7.

Листинг 7.7

public MainForm() {

 InitializeComponent();

#if DEBUG

 MinimizeBox = false;

#else

 MinimizeBox = true;

#endif

 AboutForm about = new AboutForm();

 about.ShowDialog();

}


private void mnuAbout_Click(object sender, EventArgs e) {

 AboutForm about = new AboutForm();

 about.ShowDialog();

}

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

Поворот экрана

Устройства с операционной системой Pocket PC 2003 Second Edition и старше обрели долгожданную возможность поворачивать содержимое экрана. Раньше пользователям приходилось устанавливать дополнительные программы для достижения такого эффекта. А разработчики получили возможность управлять поворотами экрана управляемыми методами только в .NET Compact Framework 2.0. Но зато теперь это можно сделать буквально одной строкой кода. Тем, кто по ряду причин должен по-прежнему использовать .NET Compact Framework 1.0, придется задействовать сложный код с вызовами функций API, который приведен в листинге 7.8. Сначала надо установить ссылку на пространство имен Microsoft.WindowsCE.Forms. После этого следует просто использовать нужные свойства класса SystemSettings.

Листинг 7.8.

using Microsoft.WindowsCE.Forms;

// запоминаем настройки экрана

ScreenOrientation initialOrientation = SystemSettings.ScreenOrientation;


private void butRot90_Click(object sender, EventArgs e) {

 // поворачиваем экран на 90 градусов

 SystemSettings.ScreenOrientation = ScreenOrientation.Angle90;

}


private void butRestore_Click(object sender, EventArgs e) {

 // восстанавливаем старую ориентацию

 if (SystemSettings.ScreenOrientation != initialOrientation) {

  try {

   SystemSettings.ScreenOrientation = initialOrientation;

  } catch (Exception) {

   // Невозможно вернуться к старым настройкам

   MessageBox.Show("He могу восстановить " +

    "предыдущую ориентацию экрана.");

  }

 }

}

Рекомендации по дизайну форм

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

Рекомендуемые размеры кнопок для Pocket PC составляют 21×21 пикселов, если пользователь применяет стилус, и 38×38 пикселов, если он предпочитает нажимать кнопки пальцами. Также надо предусмотреть свободное пространство между элементами, чтобы избежать ошибочных нажатий. Если маленькие кнопки для копирования и удаления файлов находятся рядом, то пользователи не раз вспомнят вас недобрым словом при неаккуратном нажатии на кнопки.

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

Готовые приложения

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

Файловый менеджер для смартфона

Смартфоны под управлением Windows Mobile 2005 не имеют в составе системы приложения, которое позволяет просматривать содержимое папок и файлов. В этом разделе будет рассматриваться аналог Проводника для смартфона. Основой данного примера послужил великолепный проект с открытым исходным кодом, который находится на сайте www.businessanyplace.net/?p=spfileman. Автор проекта Кристиан Форсберг (Christian Forsberg) любезно разрешил использовать его программу в качестве учебного пособия для этой книги.

Интересна история создания этого приложения. Сам автор оригинальной версии писал программу еще на Visual Studio .NET 2003 для смартфонов под управлением системы Smartphone 2003. Когда я скачал исходный код и попытался запустить его, то среда разработки Visual Studio .NET 2005 предложила конвертировать проект. Я согласился, в результате получил новую версию проекта. Теперь, после переделки, проект запускался в Visual Studio 2005 и использовал эмулятор Smartphone 2003. Но мне захотелось использовать пример для смартфонов Windows Mobile 2005. Для этого достаточно было в свойствах проекта выбрать другую платформу. Снова несколько минут раздумий, и Visual Studio выдает еще раз переделанный проект. Но и этого мне мало. Проект по-прежнему использует .NET Compact Framework 1.0. После выбора нужных значений свойств проекта, он стал использовать .NET Compact Framework 2.0. Осталось лишь перевести некоторые команды на русский язык и ввести новые возможности .NET Compact Framework 2.0 вместо старых конструкций, которые применялись для .NET Compact Framework 1.0.

Зачем нужен файловый менеджер

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

Графический интерфейс программы

У создаваемого приложения будет своя пиктограмма. При запуске программа будет отображать содержимое папки My Documents. Сам графический интерфейс программы очень прост и понятен. Навигация по папкам осуществляется простым выделением нужной папки и нажатием кнопки Enter. Для перехода на один уровень вверх нужно выделить папку, обозначенную двумя точками. Пункт меню Выход закрывает файловый менеджер, а пункт Меню позволяет выбрать выполняемую операцию (рис. 7.3).

Рис. 7.3. Общий вид файлового менеджера

Меню содержит команды для всех стандартных файловых операций. Пользователь может удалять, копировать, добавлять и переименовывать файлы. Также имеется возможность работы с ярлыками. Чтобы использовать эту возможность, нужно сначала выбрать файл, выполнить команду Копировать, затем перейти в нужную папку и выполнить команду Вставить ярлык. При выборе команды Свойства появляется соответствующее окно (рис. 7.4).

Рис. 7.4. Окно свойств

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

Код программы

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

Листинг 7.9

ListViewHelper.SetGradient(listView);

string bs = Path.DirectorySeparatorChar.ToString();

// Устанавливаем начальную папку

this.path = bs + "My Documents" + bs;

// Заполняем список папок и файлов

fillList();

Сначала устанавливается внешний вид элемента listView с градиентной закраской фона. Затем устанавливается папка по умолчанию My Documents, которую программа открывает при загрузке. Метод fillList заполняет список ListView содержимым открываемой папки. Сам код метода приведен в листинге 7.10.

Листинг 7.10

/// <summary>

/// Заполнение ListView списком папок и файлов

/// </summary>

private void fillList() {

 Cursor.Current = Cursors.WaitCursor;

 // Заполняем ListView списком папок и файлов

 // в выбранной папке

 ListViewItem lvi;

 listView.BeginUpdate();

 listView.Items.Clear();

 // Если не корневая папка

 if (path.Length > 1) {

  // Добавляем папку "Вверх"

  lvi = new ListViewItem(UPDIR);

  lvi.ImageIndex = 0;

  listView.Items.Add(lvi);

 }


 // Добавляем папки

 string[] dirs = Directory.GetDirectories(path);

 ArrayList list = new ArrayList(dirs.Length);

 for(int i = 0; i < dirs.Length; i++)

  list.Add(dirs[i]);

 list.Sort(new SimpleComparer());

 foreach(string dir in list) {

  lvi = new ListViewItem(Path.GetFileName(dir));

  lvi.ImageIndex = 0;

  listView.Items.Add(lvi);

 }


 // Добавляем файлы

 string[] files = Directory.GetFiles(path);

 list = new ArrayList(files.Length);

 for(int i = 0; i < files.Length; i++)

  list.Add(files[i]);

 list.Sort(new SimpleComparer());

 foreach(string file in list) {

  lvi = new ListViewItem(Path.GetFileName(file));

  lvi.ImageIndex = 1;

  listView.Items.Add(lvi);

 }

 listView.EndUpdate();

 if (listView.Items.Count > 0) {

  // выделяем первый элемент

  listView.Items[0].Selected = true;

  listView.Items[0].Focused = true;

 }

 Cursor.Current = Cursors.Default;

}

Итак, посмотрим, что делает метод fillList. Перед заполнением элемента списком файлов надо очистить его содержимое от предыдущих записей при помощи метода Clear. После очистки списка надо проверить, является ли папка корневой. Если папка не корневая, то в список добавляется специальная папка «На один уровень выше». Затем в список добавляются все папки в отсортированном порядке.

После этого наступает очередь файлов. Они сортируются и заносятся в список. Наконец, первый элемент списка выделяется другим цветом. Заодно на первом элементе устанавливается фокус ввода. Навигация по папкам и файлам осуществляется с помощью кнопок и дополняется кнопкой Action. Код навигации приведен в листинге 7.11.

Листинг 7.11

/// <summary>

/// Навигация по папкам и файлам

/// </summary>

/// <param name="sender"></param>

/// <param name="e"></param>

private void listView_ItemActivate(object sender, System.EventArgs e) {

 Cursor.Current = Cursors.WaitCursor;

 ListViewItem lvi = listView.Items[listView.SelectedIndices[0]];

 bool isFolder = lvi.ImageIndex == 0;

 if (lvi.Text == UPDIR) {

  path = path.Substring(0,

   path.Substring(0,

   path.Length - 1).LastIndexOf(Path.DirectorySeparatorChar) + 1);

  fillList();

 } else if (isFolder) {

  path += lvi.Text + Path.DirectorySeparatorChar;

  fillList();

 } else

  ShellExecute.Start(path + lvi.Text);

 Cursor.Current = Cursors.Default;

}

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

Теперь разберем код для команд меню. Для команды Вырезать код приведен в листинге 7.12.

Листинг 7.12

private void cutMenuItem_Click(object sender, System.EventArgs e) {

 ListViewItem lvi =

  listView.Items[listView.SelectedIndices[0]];

 clipboardFileName = this.path + lvi.Text;

 clipboardAction = ClipboardAction.Cut;

}

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

Листинг 7.13

private void copyMenuItem_Click(object sender, System.EventArgs e) {

 ListViewItem lvi = listView.Items[listView.SelectedIndices[0]];

 clipboardFileName = path + lvi.Text;

 clipboardAction = ClipboardAction.Copy;

}

Для команды меню Вставить код немного усложняется. Он приведен в листинге 7.14.

Листинг 7.14

private void pasteMenuItem_Click(object sender, System.EventArgs e) {

 // Если файл существует

 string dest = path + Path.GetFileName(clipboardFileName);

 if (File.Exists(dest)) {

  if (MessageBox.Show("Файл уже существует, перезаписать?", this.Text,

   MessageBoxButtons.YesNo, MessageBoxIcon.Question,

   MessageBoxDefaultButton.Button2) == DialogResult.Yes)

   File.Delete(dest);

  else return;

 }

 // Перемещаем или копируем

 string s = path.Substring(0, path.Length - 1);

 switch(clipboardAction) {

 case ClipboardAction.Cut:

  File.Move(clipboardFileName, dest);

  break;

 case ClipboardAction.Copy:

  File.Copy(clipboardFileName, dest, false);

  break;

 }

 clipboardAction = ClipboardAction.None;

 clipboardFileName = string.Empty;

 fillList();

}

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

Листинг 7.15

private void pasteShortcutMenuItem_Click(object sender, System.EventArgs e) {

 int i = 2;

 string s = string.Empty;

 string dest;

 while(true) {

  dest = path + "Shortcut" + s + " to " +

   Path.GetFileName(Path.GetFileNameWithoutExtension(clipboardFileName) +

   ".lnk");

  if (!File.Exists(dest)) break;

  s = " (" + i.ToString() + ")";

  i++;

 }

 StreamWriter sw = new StreamWriter(dest);

 s = clipboardFileName;

 if(s.IndexOf(" ") > 0)

  s = "\"" + s + "\"";

 s = s. Length.ToString() + "#" + s;

 sw.WriteLine(s);

 sw.Close();

 fillList();

}

В этом коде создается уникальное имя ярлыка, которое затем записывается в виде файла с добавлением. К имени ярлыка добавляется расширение .LNK.

Код для команды Переименовать приведен в листинге 7.16.

Листинг 7.16

private void renameMenuItem_Click(object sender, System.EventArgs e) {

 Cursor.Current = Cursors.WaitCursor;

 istViewItem lvi = listView.Items[listView.SelectedIndices[0]];

 bool isFolder = lvi.ImageIndex = 0;

 string s;

 if (isFolder)

  s = "папку";

 else s = "файл";

 NameForm nameForm =

  new NameForm(this, "Переименовать " + s, lvi.Text,

   new SetNameDelegate(SetRename));

 if (nameForm.ShowDialog() = DialogResult.OK) fillList();

 listView.Focus();

}

Сначала обрабатывается текущий выделенный элемент. Если пользователь выделил папку, то для формы nameForm задается соответствующий заголовок Переименовать папку. Также из этой формы передается в основную форму новое имя папки или файла с помощью метода Set Rename, как это показано в листинге 7.17.

Листинг 7.17

/// <summary>

/// Метод для переименования папки или файла

/// </summary>

/// <param name="name">Имя папки или файла</param>

public void SetRename(string name) {

 ListViewItem lvi = listView.Items[listView.SelectedIndices[0]];

 bool isFolder = lvi.ImageIndex == 0;

 string itemName = path + lvi.Text;

 string destName =

  Path.GetDirectoryName(itemName) +

  Path.DirectorySeparatorChar.ToString() + name;

 if (isFolder)

  Directory.Move(itemName, destName);

 else

  File.Move(itemName, destName);

}

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

Листинг 7.18

private void deleteMenuItem_Click(object sender,

 System.EventArgs e) {

 ListViewItem lvi = listView.Items[listView.SelectedIndices[0]];

 bool isFolder = lvi.ImageIndex == 0;

 string s = "Are you sure you want to delete " + lvi.Text;

 if (isFolder)

  s += " and all its content";

 s += "?";

 if (MessageBox.Show(s, this.Text, MessageBoxButtons.YesNo,

  MessageBoxIcon.Question, MessageBoxDefaultButton.Button2) ==

  DialogResult.Yes) {

 if (isFolder)

  Directory.Delete(path + lvi.Text, true);

 else

  File.Delete(path + lvi.Text);

 fillList();

}

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

Листинг 7.19

private void newFolderMenuItem_Click(object sender, System.EventArgs e) {

 Cursor.Current = Cursors.WaitCursor;

 ListViewItem lvi = listView.Items[listView.SelectedIndices[0]];

 NameForm nameForm = new NameForm(this, "Новая папка", "",

  new SetNameDelegate(SetNewName));

 if (nameForm.ShowDialog() == DialogResult.OK) fillList();

 listView.Focus();

}

В результате действия этой функции отображается форма NameForm с заголовком Новая папка. Эта форма также передает информацию в главную форму при помощи метода SetNewName, который приведен в листинге 7.20.

Листинг 7.20

/// <summary>

/// Устанавливает новое имя для папки

/// </summary>

/// <param name="name">Имя для папки</name>

public void SetNewName(string name) {

 Directory.CreateDirectory(path + name);

}

Метод создает папку с заданным именем. Как видно, код его чрезвычайно прост.

Код для выполнения команды Свойства приведен в листинге 7.21.

Листинг 7.21

private void propertiesMenuItem_Click(object sender, System.EventArgs e) {

 Cursor.Current = Cursors.WaitCursor;

 ListViewItem lvi = listView.Items[listView.SelectedIndices[0]];

 FileInfo fi = new FileInfo(path + lvi.Text);

 PropertiesForm propertiesForm =

  new PropertiesForm(this, fi, new SetNameDelegate(SetRename),

  new SetAttributesDelegate(SetAttributes));

 if (propertiesForm.ShowDialog() == DialogResult.OK) fillList();

 listView.Focus();

}

Этот код вызывает форму PropertiesForm, которая отображает атрибуты выбранного файла или папки. Также в этой форме пользователь может изменять атрибуты файла при помощи метода SetAttributes, код которого приведен в листинге 7.22.

Листинг 7.22

public void SetAttributes(FileAttributes fileAttributes) {

 ListViewItem lvi = listView.Items[listView.SelectedIndices[0]];

 bool isFolder = lvi.ImageIndex = 0;

 if (isFolder) {

  DirectoryInfo di = new DirectoryInfo(path + lvi.Text);

  di.Attributes = fileAttributes;

 } else {

  FileInfo fi = new FileInfo(path + lvi.Text);

  fi.Attributes = fileAttributes;

 }

}

Для создания градиентной заливки соответствующего элемента интерфейса применяется метод, код которого приведен в листинге 7.23.

Листинг 7.23

public static void SetGradient(System.Windows.Forms.ListView listView) {

 // Новый вариант

 // Для .NET Compact Framework 2.0

 SendMessage(listView.Handle, LVM_SETEXTENDEDLISTVIEWSTYLE,

  LVS_EX_GRADIENT);

 listView.Refresh();

}

Итак, основные трудности реализации программы рассмотрены. Кроме того, в примере присутствуют вызовы функций Windows API для работы с табличным списком ListView. Эти примеры рассматривались в главе 4, поэтому не стоит повторять их разбор. На самом деле эту программу можно улучшать до бесконечности, добавляя новые функциональные возможности. Надеюсь, у вас это получится. Буду рад, если вы пришлете свои варианты примеров, которые, на ваш взгляд, украсят программу.

Диспетчер задач

Но мы с вами не расстаемся с программами, написанными Кристианом Форсбергом. На его сайте можно найти еще одну полезную программу, необходимую как разработчику, так и пользователю. Это Диспетчер задач (Task Manager). Программа подобного рода тоже отсутствует в стандартной поставке Windows Mobile. А ведь эта программа очень полезна в работе. Владелец смартфона под управлением системы Windows Mobile может узнать много нового о своей системе после запуска этой утилиты. Диспетчер задач покажет все программы, которые размещаются в памяти смартфона, отбирая системные ресурсы. Диспетчер задач также позволяет удалять из памяти ненужные программы и процессы. Не случайно, многие производители сами снабжают свои устройства программами подобного типа. Если вам не повезло и у вас нет такой программы, то вы можете сами написать Диспетчер задач.

Как и предыдущий пример, оригинальная версия программы была написана на Visual Studio 2003 для смартфонов под управлением Windows Mobile 2003 на платформе .NET Compact Framework 1.0. Следуя нашей традиции, я с согласия автора конвертировал проект для Visual Studio 2005 для целевой системы Windows Mobile 5.0 и с применением .NET Compact Framework 2.0.

Графический интерфейс программы

Диспетчер задач при запуске показывает список запущенных программ (рис. 7.5).

Рис. 7.5. Внешний вид программы

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

□ Обновить — обновляет список запущенных программ;

□ Процессы — показывает список запущенных процессов;

□ Остановить — останавливает выбранную программу;

□ Остановить все — останавливает все запущенные программы;

□ Вид — показывает информацию о процессе;

□ Убить — закрывает процесс;

□ О программе — выводит информацию об авторе программы;

□ Готово — закрывает программу. Внешний вид этого меню показан на рис. 7.6.

Рис. 7.6. Команды меню для правой кнопки

Код программы

При активации основной формы MainForm программа получает список запущенных программ при помощи процедуры fillTaskList, код которой приведен в листинге 7.24.

Листинг 7.24

private void fillTaskList() {

 Cursor.Current = Cursors.WaitCursor;

 // Получим список запущенных приложений

 windows = WindowHelper.EnumerateTopWindows();

 // Заполняем ListView

 ListViewItem lvi;

 listView.BeginUpdate();

 listView.Items.Clear();

 foreach(Window w in windows) {

  lvi = new ListViewItem(w.ToString());

  listView.Items.Add(lvi);

 }

 listView.EndUpdate();

 if (listView.Items.Count > 0) {

  listView.Items[0].Selected = true;

  listView.Items[0].Focused = true;

 }

 Cursor.Current = Cursors.Default;

}

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

Листинг 7.25

public static Window[] EnumerateTopWindows() {

 ArrayList windowList = new ArrayList();

 IntPtr hWnd = IntPtr.Zero;

 Window window = null;

 // Получим первое окно

 hWnd = GetActiveWindow();

 hWnd = GetWindow(hWnd, GW_HWNDFIRST);

 while(hWnd != IntPtr.Zero) {

  if (IsWindow(hWnd) && IsWindowVisible(hWnd)) {

   IntPtr parentWin = GetParent(hWnd);

   if ((parentWin == IntPtr.Zero)) {

    int length = GetWindowTextLength(hWnd);

    if (length > 0) {

     string s = new string('\0', length + 1);

     GetWindowText(hWnd, s.length + 1);

     s = s.Substring(0, s.IndexOf('\0'));

     if (s != "Tray" && s != "Start" && s != "Task Manager") {

      window = new Window();

      window.Handle = hWnd;

      window.Text = s;

      windowList.Add(window);

     }

    }

   }

  }

  hWnd = GetWindow(hWnd, GW_HWNDNEXT);

 }

 return (Window[])windowList.ToArray(typeof(Window));

}

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

Активация и закрытие приложения

Для активации запущенного приложения вызывается функция Windows API SetForegroundWindow, которая использует дескриптор окна. Для закрытия приложения используется функция SendMessage с соответствующим сообщением закрытия WM_CLOSE. Для закрытия сразу всех окон можно использовать функцию Windows API SHCloseApps, которая закрывает все запущенные программы, кроме самого Диспетчера задач. Код, выполняющий эти действия, приведен в листинге 7.26.

Листинг 7.26

public static void ActivateWindow(IntPtr hWnd) {

 // Активируем приложение

 SetForegroundWindow(hWnd);

}


public static void CloseWindow(IntPtr hWnd) {

 // Закрываем приложение

 SendMessage(hWnd, WM_CLOSE, 0, 0);

}


public static void CloseApps() {

 // Закрываем все приложения

 SHCloseApps(int.MaxValue);

}

Перечисление процессов

Для отображения списка процессов используется функция, код которой приведен в листинге 7.27.

Листинг 7.27

private void fillProcessList() {

 Cursor.Current = Cursors.WaitCursor;

 // Получаем список запущенных процессов

 processes = Process.GetProcesses();

 // Заполняем ListView

 ListViewItem lvi;

 listView.BeginUpdate();

 listView.Items.Clear();

 foreach (Process p in processes) {

  lvi = new ListViewItem(p.ProcessName);

  //lvi.SubItems.Add("ID");

  listView.Items.Add(lvi);

 }

 listView.EndUpdate();

 if (listView.Items.Count > 0) {

  listView.Items[0].Selected = true;

  listView.Items[0].Focused = true;

 }

 Cursor.Current = Cursors.Default;

}

Список активных процессов извлекается при помощи класса Process. Основой класса является метод GetProcesses, приведенный в листинге 7.28.

Листинг 7.28

public static Process[] GetProcesses() {

 ArrayList procList = new ArrayList();

 IntPtr handle = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);

 if ((int)handle > 0) {

  try {

   PROCESSENTRY32 peCurrent;

   PROCESSENTRY32 pe32 = new PROCESSENTRY32();

   byte[] peBytes = pe32.ToByteArray();

   int retval = Process32First(handle, peBytes);

   while(retval == 1) {

    peCurrent = new PROCESSENTRY32(peBytes);

    Process proc =

     new Process(new IntPtr((int)peCurrent.PID), peCurrent.Name,

     (int)peCurrent.ThreadCount, (int)peCurrent.BaseAddress);

     procList.Add(proc);

    retval = Process32Next(handle, peBytes);

   }

  } catch(Exception ex) {

   throw new Exception("Exception: " + ex.Message);

  }

  CloseToolhelp32Snapshot(handle);

  return (Process[])procList.ToArray(typeof(Process));

 } else {

  throw new Exception("Unable to get processes!");

 }

}

С помощью данного метода можно узнать детальную информацию о каждом процессе.

Закрытие процесса

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

Листинг 7.29

public void Kill() {

 IntPtr hProcess;

 hProcess = OpenProcess(PROCESS_TERMINATE, false, (int) processId);

 if (hProcess != (IntPtr) INVALID_HANDLE_VALUE) {

  bool bRet;

  bRet = TerminateProcess(hProcess, 0);

  CloseHandle(hProcess);

 }

}

Данный метод также использует вызовы функций Windows API. Функция OpenProcess получает дескриптор процесса, который затем передается функции TerminateProcess для уничтожения процесса.

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

Маленький блокнот

Однажды мой друг, далекий от программирования, попросил меня написать простенький текстовый редактор для карманного компьютера. Его не совсем устраивало приложение Word Mobile, которое используется для работы с текстовыми файлами в операционной системе Windows Mobile. Заказчик хотел получить только основные функции стандартного Блокнота из Windows XP, то есть копирование, вырезание, вставку и удаление текста. Также он хотел обойтись без установки .NET Compact Framework 2.0, так как устаревшая модель его карманного компьютера обладала малой емкостью памяти.

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

Единственная сложность при написании данного текстового редактора состояла в том, что библиотека .NET Compact Framework 1.0 не поддерживает работу с буфером обмена на уровне управляемого кода. Поэтому пришлось прибегать к вызовам функций Windows API.

Данный пример можно использовать в качестве основы для тех, кто хочет написать свой текстовый редактор для .NET Compact Framework 1.0. Надо заметить, что если бы я стал писать свой пример с использованием .NET Compact Framework 2.0, то справиться с задачей было бы гораздо легче, так как вторая версия библиотеки поддерживает буфер обмена, который так необходим при операциях с текстом.

Первые шаги

После запуска Visual Studio .NET 2005 надо создать новый проект. При выборе типа проекта надо указать, что будет использоваться .NET Compact Framework 1.0. Для начала на форме следует разместить текстовое поле с именем txtEditor. Для свойства Multiline надо задать значение True, а свойство ScrollBars получит значение Both.

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

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

Листинг 7.30

private void MainForm_Load(object sender, EventArgs e) {

 // устанавливаем позицию текстового поля

 txtEditor.Location = new Point(0, 0);

 // Приравниваем размеры текстового поля к размерам формы

 txtEditor.Width = this.Width;

 txtEditor.Height = this.Height;

 // Устанавливаем фокус

 txtEditor.Focus();

}

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

Листинг 7.31

private void MainForm_Load(object sender, EventArgs e) {

 ...

 // Высоту текстового поля устанавливаем в зависимости от SIP

 //txtEditor.Height = this.Height;

 SetTextBoxHeight();

}


// устанавливаем размеры текстового поля в зависимости от

// активности SIP

private void SetTextBoxHeight() {

 if (SIP.Enabled)

  txtEditor.Height = SIP.VisibleDesktop.Height + 2;

 else

  txtEditor.Height = this.Height;

}


private void SIP_EnabledChanged(object sender, EventArgs e) {

 SetTextBoxHeight();

}

Стандартные операции с текстом

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

Пользователь должен иметь возможность манипулировать текстом, то есть копировать часть текста, вырезать его, удалять и вставлять в нужную позицию. Для этого надо создать меню при помощи элемента mainMenu. В подменю Правка надо добавить стандартные команды редактирования текста — Отменить, Вырезать, Копировать, Вставить. Если бы приложение создавалось для среды исполнения .NET Compact Framework 2.0, то можно было бы использовать класс Clipboard. Но так как используется .NET Compact Framework 1.0, то придется обратиться к функциям Windows API и использовать неуправляемый код, что иллюстрирует листинг 7.32.

Листинг 7.32

// сообщения буфера обмена

public const int WM_CUT = 0x0300;

public const int WM_COPY = 0x0301;

public const int WM_PASTE = 0x0302;

public const int WM_CLEAR = 0x0303;

public const int WM_UNDO = 0x0304;


// функции API

[DllImport("coredll.dll", CharSet = CharSet.Unicode)]

public static extern IntPtr GetFocus();

[DllImport("coredll.dll")]

public static extern int SendMessage(IntPtr hWnd, uint Message,

 uint wParam, uint lParam);


private void mnuCut_Click(object sender, EventArgs e) {

 // Вырезаем текст

 SendMessage(hwndEditor, WM_CUT, 0, 0);

}


private void mnuUndo_Click(object sender, EventArgs e) {

 // Отменяем последнее действие

 SendMessage(hwndEditor, WM_UNDO, 0, 0);

}


private void mnuCopy_Click(object sender, EventArgs e) {

 // Копируем выделенный текст

 SendMessage(hwndEditor, WM_COPY, 0, 0);

}


private void mnuPaste_Click(object sender, EventArgs e) {

 // Вставляем текст из буфера обмена

 SendMessage(hwndEditor, WM_PASTE, 0, 0);

}


private void mnuDelete_Click(object sender, EventArgs e) {

 // Удаляем выделенный текст

 SendMessage(hwndEditor, WM_CLEAR, 0, 0);

}

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

Листинг 7.33

private void cmenuCopy_Click(object sender, EventArgs e) {

 // Копируем выделенный текст

 SendMessage(hwndEditor, WM_COPY, 0, 0);

}

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

Листинг 7.34

[DllImport("Coredll.dll")]

private static extern bool IsClipboardFormatAvailable(uint uFormat);


// константа для буфера обмена

private const uint CF_UNICODETEXT = 13;


public static bool IsText() {

 try {

  return IsClipboardFormatAvailable(CF_UNICODETEXT);

 } catch (Exception ex) {

  MessageBox.Show("He могу понять, что содержится в буфере обмена!");

  return false;

 }

}


private void mnuEdit_Popup(object sender, EventArgs e) {

 if (IsText())

  mnuPaste.Enabled = true;

 else

  mnuPaste.Enabled = false;

}

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

Листинг 7.35

//Если текст выделен

if (txtEditor.SelectionLength > 0) {

 mnuCut.Enabled = true;

 mnuCopy.Enabled = true;

 mnuDelete.Enabled = true;

} else {

 mnuCut.Enabled = false;

 mnuCopy.Enabled = false;

 mnuDelete.Enabled = false;

}

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

Листинг 7.36

private void mnuOpen_Click(object sender, EventArgs e) {

 dlgOpenFile.Filter = "Текстовые документы (*.txt)|*.txt|Все файлы |*.*";

 dlgOpenFile.ShowDialog();

 if (File.Exists(dlgOpenFile.FileName)) {

  fname = dlgOpenFile.FileName;

  StreamReader sr =

   new StreamReader(fname, System.Text.Encoding.GetEncoding("Windows-1251"), false);

  txtEditor.Text = sr.ReadToEnd();

  flag = false;

  sr.Close();

 }

}


private void mnuSaveAs_Click(object sender, EventArgs e) {

 SaveFileDialog dlgSaveFile = new SaveFileDialog();

 dlgSaveFile.Filter = "Текстовые документы (*.txt)|*.txt|Все файлы |*.*";

 dlgSaveFile.ShowDialog(); fname = dlgSaveFile.FileName;

 savedata();

}


private void savedata() {

 if (fname == "") {

  SaveFileDialog dlgSaveFile = new SaveFileDialog();

  dlgSaveFile.Filter = "Текстовые документы (*.txt)|*.txt|Все файлы|*.*";

  DialogResult res = dlgSaveFile.ShowDialog();

  if (res == DialogResult.Cancel) {

   return;

  }

  fname = dlgSaveFile.FileName;

  MessageBox.Show(fname);

 }

 StreamWriter sw =

  new StreamWriter(fname, false, System.Text.Encoding.GetEncoding("Windows-1251"));

 sw.WriteLine(txtEditor.Text);

 sw.Flush();

 sw.Close();

 flag = false;

}


private void mnuSave_Click(object sender, EventArgs e) {

 savedata();

}


private void txtEditor_TextChanged(object sender, EventArgs e) {

 flag = true;

}

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

Распространение приложений

Даже если вы написали очень полезную программу, она не сможет обрести всемирную известность, пока вы держите ее на своем компьютере. Нужно все же распространить программу и, если она не бесплатная, то и немного заработать на отпуск. Программы для настольных компьютеров распространять довольно просто. Нужно лишь создать специальный проект для создания установочного пакета, который сгенерирует специальный файл установки Microsoft Installer (MSI). К сожалению, для мобильных устройств процесс создания установочных файлов немного отличается. В процессе распространения программы участвуют три составляющие: настольный компьютер, программа синхронизации Microsoft ActiveSync и программа wceload.exe для извлечения файлов из cab-файлов.

Для пользователя процесс установки программы не сильно отличается от привычной схемы. Сначала он скачивает программу или находит ее на компакт-диске. Затем запускает установочный msi-файл. Программа Microsoft Installer с помощью специального мастера установки помогает пользователю установить программу с нужными настройками. После этого программа считается установленной, и пользователь может запускать ее.

Создание cab-файла

Прежде чем установочный пакет попадет в руки пользователя, нужно хорошенько поработать над его созданием. Устройства под управлением Windows Mobile не могут напрямую работать с файлами .msi. Вместо этого используются кабинетные файлы с расширением .cab. Таким образом, задача программиста заключается в том, чтобы составить список команд для программы синхронизации ActiveSync, которые позволят скопировать cab-файлы на устройство с учетом необходимых установок. Для создания удобного установочного пакета с интуитивно понятным интерфейсом вам необходимо выполнить нехитрую последовательность действий.

1. Создать cab-файл для устройства.

2. Добавить в cab-файл дополнительные файлы, используемые программой, например изображения или файлы с данными

3. Добавить в cab-файл инструкции для записи в реестр.

4. Зарегистрировать cab-файл с помощью ActiveSync, чтобы пользователь мог установить приложение с настольного компьютера.

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

6. Упаковать все необходимые файлы в один специальный файл установки с расширением .msi.

Вы, вероятно, знаете, что кабинетный файл является специальным файлом упаковки и компрессии, с помощью которого можно сжимать файлы, что приведет к уменьшению их размеров. Также в этом файле могут содержаться инструкции для внесения изменений в реестр системы. За обработку cab-файлов на устройстве отвечает утилита wceload.exe, входящая в состав Windows Mobile.

Создание проекта

Приступим к разработке проекта для создания установочного пакета. Прежде всего нужно запустить уже существующий проект, который планируется подготовить для распространения. В качестве примера будет использоваться проект SmallNotepad. Затем нужно выполнить команду меню File►Add►New Project. В открывшемся диалоговом окне надо перейти в раздел Other Project Types, выбрать тип Smart Device Cab Project и задать имя нового проекта DeployNotepadCab (рис. 7.7).

Рис. 7.7. Выбор нового проекта для распространения приложения

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

Затем надо запустить редактор File System Editor, нажав соответствующую кнопку в окне свойств. Нужно выбрать пункт Application Folder и в контекстном меню выбрать пункт Add►Project Output (рис. 7.8).

Рис. 7.8. Выбор параметров проекта

В результате этого будет открыто диалоговое окно Add Project Output Group (рис. 7.9).

Рис. 7.9. Диалоговое окно Add Project Output Group

С помощью данного окна можно выбрать различные типы файлов, необходимые для программы, такие как файлы документации или, например, локализированные ресурсы. Нужно выбрать пункт Primary Output и нажать кнопке OK. В правой части окна следует щелкнуть правой кнопкой мыши на единственном пункте Primary output from SmallNotepad_CS и в контекстном меню выбрать пункт Create Shortcut to Primary output from SmallNotepad_CS (рис. 7.10). Это позволит включить пиктограмму в список файлов для распространения.

Рис. 7.10. Создание пиктограммы приложения

Созданный ярлык надо переместить мышью в папку Program Files Folder. Теперь можно приступать к созданию установочного файла.

В меню надо выполнить пункт Build►Build DeployNotepadCab. После этого среда разработки создаст специальный файл с расширением .CAB. При помощи файлового менеджера его нужно найти и запомнить его расположение.

Теперь надо установить созданный файл на эмуляторе. Для этого выполняется команда меню Tools►Device Emulator Manager. В диалоговом окне надо выбрать эмулятор. Например, Pocket PC 2003 SE Emulator. В этом же окне следует выполнить команду меню Actions►Connect. При этом выбранный эмулятор будет активирован.

В окне эмулятора надо выполнить команду меню File►Configure. После этого откроется окно настроек эмулятора, в котором следует перейти в раздел Shared Folder. В этом разделе надо выбрать папку, в которой находится созданный cab-файл (рис. 7.11). Эмулятор будет считать, что данная папка является карточкой памяти.

Рис. 7.11. Активация и настройка эмулятора

Если открыть в эмуляторе программу File Explorer (Start►Programs►File Explorer) и найти папку Storage Card, то в ней можно будет увидеть ранее созданные установочные файлы.

Нужно выбрать файл DeployNotepadCab и запустить его. В результате начнется процесс установки программы на устройство. При установке автоматически будет создан файл деинсталляции. Он поможет корректно удалить приложение. Для этого в окне эмулятора надо выполнить команду меню Start►Settings►System►Remove Program. В списке установленных программ надо найти ранее установленное приложение, выделить его и нажать кнопку Remove (рис. 7.12).

Рис. 7.12. Деинсталляция приложения

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

Дополнительные материалы

На сайте MSDN есть очень подробная статья «Deploying .NET Compact Framework 2.0 Applications with .cab and .msi Files», в которой приведены дополнительные сведения о создании и распространении установочных файлов. Стоит ознакомиться с данным материалом, чтобы использовать все возможности установочных файлов.

Глава 8 Эмулятор и другие утилиты

Программы для отладки приложений

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

Эмулятор

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

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

Надо сказать, что качество и возможности эмулятора постоянно улучшаются и совершенствуются. Разработчики, которые программировали еще на eMbedded Visual Basic и Visual Studio 2003, без сомнения, обратят внимание на возросшую скорость работы эмулятора, его надежность и удобство. Эмулятор, поставляемый с Visual Studio 2005, имеет улучшенную поддержку общих папок, программы синхронизации ActiveSync и последовательных портов. Также эмулятор поддерживает альбомную и книжную ориентацию. Раньше об этом приходилось только мечтать. Особенно приятно отметить тот факт, что можно дополнительно скачать локализованные версии эмуляторов. Например, все примеры для Windows Mobile 5.0 тестировались исключительно на русской версии эмулятора.

Запуск эмулятора

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

Рассмотрим вариант запуска эмулятора и его настройки. Сначала требуется создать или открыть проект, предназначенный для мобильного устройства, например, первую программу «Здравствуй, мир», которая создавалась в главе 2. После выполнения команды меню Debug►Start Debugging среда разработки Visual Studio отображает диалоговое окно Deploy (рис. 8.1).

Рис. 8.1. Запуск эмулятора

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

Нужно выбрать любой эмулятор из списка. Стандартным выбором в данном случае является значение Pocket PC 2003 SE Emulator. Нужно выделить строку с выбранным эмулятором и нажать кнопку Deploy. Через несколько секунд на экране компьютера появится эмулятор карманного компьютера, в котором будет запущено выбранное приложение. Программист может работать с тестируемой программой так же, как и на реальном устройстве. Кроме того, можно оставить в покое программу и запустить любое приложение, которое есть на этом эмуляторе.

ПРИМЕЧАНИЕ

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

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

ПРИМЕЧАНИЕ

Если ваша программа имеет код для закрытия приложения this.Close(), то режим отладки автоматически остановится и выполнять команду меню Stop debugging не понадобится.

Настройка эмулятора

Попробуем теперь поработать с различными настройками эмулятора. Для начала следует выполнить команду меню Tools►Options. В открывшемся диалоговом окне Options надо выбрать строку Device Tools, а в ней активировать пункт Devices. Затем в списке Devices надо выбрать элемент Pocket PC 2003 SE и нажать кнопку Properties (рис. 8.2).

Рис. 8.2. Окно настроек эмулятора

На экране появится новое диалоговое окно Pocket PC 2003 SE Properties (рис. 8.3). Обратите внимание на то, что по умолчанию программа устанавливается в папку Program Files.

Рис. 8.3. Окно свойств эмулятора

После ознакомления со свойствами эмулятора нужно закрыть все диалоговые окна и вернуться в главное окно среды разработки. Там надо выполнить команду меню Tools►Device Emulator Manager. На экране откроется новое диалоговое окно, в котором будут перечислены все имеющиеся эмуляторы (рис. 8.4).

Рис. 8.4. Список установленных эмуляторов

Надо выбрать из списка элемент Pocket PC 2003 SE Emulator, а затем выполнить команду меню Actions►Connect. Менеджер эмуляторов загрузит выбранный эмулятор. На экране появится специальный значок, который сигнализирует об установленном соединении. Затем нужно выполнить команду меню Actions►Cradle. Если операция пройдет успешно, то значок состояния эмулятора изменится. Это означает, что эмулятор КПК соединен с виртуальной док-станцией. Теперь можно синхронизировать данные с помощью программы синхронизации ActiveSync. По завершении операции нужно выполнить команду меню Actions►Uncradle.


Эмуляция карточки памяти

Все модели карманных компьютеров и смартфонов имеют возможность увеличения объема памяти при помощи различных карточек памяти. Дополнительный объем дискового пространства используют для хранения фильмов, фотографий и других документов. Особенно это актуально для пользователей устройств под управлением Pocket PC 2003, так как после перезагрузки устройства все данные на устройстве стираются. Эмулятор позволяет использовать любую папку настольного компьютера в качестве карточки памяти. Для выбора подключаемой папки нужно в окне эмулятора выполнить команду меню File►Configure и на вкладке General указать соответствующую папку в пункте Shared Folder (рис. 8.5).

Рис. 8.5. Эмуляция карточки памяти

После того как соответствующая папка будет подключена, можно с помощью стандартной программы File Explorer, входящей в состав Windows Mobile, убедиться, что у устройства теперь имеется карточка памяти, которая представлена как папка Storage Card (рис. 8.6).

Рис. 8.6. Папка Storage Card

Изменение ориентации экрана

Эмулятор позволяет легко менять ориентацию экрана. Достаточно перейти на вкладку Display после выполнения команды меню File►Configure и выбрать нужный режим в разделе Orientation (рис. 8.7).

Рис. 8.7. Настройка ориентации экрана

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

Рис. 8.8. Вращение устройства

Выход в Интернет через эмулятор

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

1. Создать новый проект в Visual Studio 2005.

2. Запустить программу ActiveSync. Возможно, она неактивна, и ее пиктограмма располагается в области уведомлений. В этом случае надо щелкнуть правой кнопкой мыши на этом значке и выполнить команду контекстного меню Открыть Microsoft ActiveSync.

3. Вернуться в среду разработки Visual Studio 2005 и выполнить команду меню Tools►Device Emulator Manager. На экране появится диалоговое окно Device Emulator Manager.

4. Щелкнуть правой кнопкой мыши на соответствующем эмуляторе и выполнить команду контекстного меню Connect. На экране появится соответствующий эмулятор.

5. Вернуться в диалоговое окно Device Emulator Manager и снова щелкнуть правой кнопкой на выбранном ранее эмуляторе, а затем выполнить команду Cradle.

6. В диалоговом окне Device Emulator Manager у выбранного эмулятора появится значок, показывающий, что эмулятор теперь подключен к системе настольного компьютера.

7. Автоматически появится сообщение от Microsoft ActiveSync о том, что установлено соединение (рис. 8.9).

Рис. 8.9. Сообщение ActiveSync

8. В этом окне нужно нажать кнопку OK.

9. На экране появится окно Мастер синхронизации (рис. 8.10).

Рис. 8.10. Окно ActiveSync

10. Так как сейчас синхронизация не нужна, то следует нажать кнопку Cancel.

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

12. Закрыть окно программы Microsoft ActiveSync. Программа продолжает работать в фоновом режиме. В области уведомлений должна отображаться зеленая пиктограмма.

13. В очередной раз вернуться в окно программы Device Emulator Manager и закрыть его. Программа также продолжает работать в фоновом режиме, а ее пиктограмма тоже появится в области уведомлений.

14. Настало время настройки эмулятора для доступа в Интернет. Нужно щелкнуть правой кнопкой на зеленом значке ActiveSync и выполнить команду контекстного меню Открыть Microsoft ActiveSync. Затем надо выполнить команду меню File►Connection Settings и выбрать режим This computer is connected to The Internet, после чего останется только нажать кнопку OK.

15. В эмуляторе надо нажать кнопку Start и щелкнуть на пиктограмме Internet Explorer. В результате будет запущен стандартный браузер. В адресной строке можно указать URL любого существующего сайта. Эмулятор должен загрузить выбранный сайт.

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

Изменение внешнего вида эмуляторов

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

Эмулятор как отдельный продукт

Эмулятор поставляется вместе с Visual Studio 2005. Эмуляторы для тестирования программ на новых устройствах, таких как Windows Mobile 5.0, также интегрируются в оболочку Visual Studio. И чтобы установить эмулятор на новой машине, раньше приходилось устанавливать весь пакет Visual Studio 2005.

Разработчики на форумах часто спрашивали: можно ли установить эмулятор как отдельную программу на компьютере? До недавнего времени ответ был отрицательным. Но наконец-то Microsoft прислушалась к просьбам разработчиков и выпустила эмулятор в виде отдельного продукта. Более подробную информацию об этом можно найти на веб-странице www.microsoft.com/downloads/details.aspx?FamilyId=C62D54A5-183A-4A1E-A7E2-CC500ED1F19A&displaylang=en.

Новая версия эмулятора

Работы над улучшением эмулятора не прекращаются. На странице «Microsoft Device Emulator 2.0 Beta — Community Technology Preview», которая располагается по адресу http://www.microsoft.com/downloads/details.aspx?FamilyID=13f5de85-30cd-4506-9c5b-a2068fa1ee9e&DisplayLang=en, выложена бета-версия эмулятора, которая будет работать с будущей версией Windows СЕ 6.0. В новой версии обещана еще большая скорость работы эмулятора и реализованы дополнительные возможности.

Набор утилит Visual Studio Remote Tools

В состав Visual Studio 2005 входят несколько утилит, которые могут пригодиться разработчикам программ для мобильных устройств. Если открыть группу программ Visual Studio Remote Tools, то можно увидеть, что в ней расположены утилиты, перечисленные в следующем списке:

□ Remote File Viewer;

□ Remote Heap Walker;

□ Remote Process Viewer;

□ Remote Registry Editor;

□ Remote Spy;

□ Remote Zoom-in.

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

Remote Zoom-in

Утилита Remote Zoom-in позволяет получить снимок экрана устройства или эмулятора на компьютере разработчика. Большинство иллюстраций к данной книге были сделаны с помощью данной программы.

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

Рис. 8.11. Выбор устройства для получения снимка экрана

После нажатия кнопки OK программа автоматически установит связь с выбранным устройством и загрузит текущее изображение экрана. Если необходимо получить новое изображение с экрана устройства, то нужно выполнить команду меню File►New Bitmap.

Утилита Remote Zoom-in сохраняет экранные снимки в формате BMP-файлов. Функциональные возможности программы сильно урезаны, пользователь может вырезать часть изображения, изменить его размер или сделать копию. Но от этой программы и не требуется больших возможностей. Сохранив изображение в файле, при необходимости можно редактировать его в любом графическом редакторе.

Remote File Viewer

Утилита Remote File Viewer является аналогом стандартного Проводника, входящего в состав Windows XP. С помощью этой утилиты пользователь может просматривать содержимое папок устройства или эмулятора, а также копировать файлы из устройства на настольный компьютер и наоборот.

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

Remote Registry Editor

Еще одной полезной утилитой является редактор реестра Remote Registry Editor. С помощью данного редактора пользователь может изменять, удалять и создавать новые записи в реестре. В одной из следующих глав будет рассказано о программном изменении значений реестра с помощью функций Windows API. С помощью этой утилиты можно контролировать работу этих функций.

Глава 9 Программирование для смартфонов

Особенности программирования для смартфонов

В этой главе мы научимся создавать приложения для смартфонов под управлением системы Windows Mobile 5.0. Так получилось, что в России смартфоны под управлением Smartphone 2003 поначалу не получили широкого признания. Признанными лидерами на рынке «умных» телефонов были такие марки, как Nokia, Siemens и Sony Ericsson, которые использовали в телефонах операционную систему Symbian. И если на рынке КПК компании Microsoft удалось потеснить своего вечного конкурента PalmOs, то в сфере мобильной связи основная борьба еще впереди.

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

Если .NET Compact Framework можно считать подмножеством полной версии .NET Framework, то смартфоны можно считать подмножеством карманных компьютеров. Причем разница между ними стремительно стирается. Но, тем не менее, между двумя типами мобильных устройств есть существенные различия. Во-первых, смартфоны являются прежде всего мобильными телефонами, предназначенными для телефонных разговоров. Во-вторых, размер экрана у смартфонов меньше, чем у стандартных карманных компьютеров, и составляет 176×220 пикселов, тогда как у КПК размер экрана 240×320 пикселов.

ПРИМЕЧАНИЕ

В последнее время все чаще выпускаются смартфоны с разрешением 240×320 пикселов. А КПК стали все чаще стали делать с экраном 480×640 пикселов.

Еще одной отличительной и, пожалуй, главной чертой смартфонов является отсутствие стилуса. Следовательно, тип экрана также отличается от экрана карманного компьютера. Пользователь может взаимодействовать с приложением только при помощи кнопок телефона. И хотя «умные» телефоны используют такую же версию .NET Compact Framework, эти различия заставляют применять совсем иные приемы программирования.

В состав Visual Studio 2005 уже входят эмулятор для Smartphone 2003 и необходимые шаблоны проектов. Пора приступить к созданию приложения для смартфона. Самый первый пример будет сделан для устройства Smartphone 2003, а остальные — для Windows Mobile 5.0. И хотя речь о Windows Mobile 5.0 пойдет только в следующей главе, я решил сразу тестировать программы именно для этой платформы. В этом случае вам придется скачать дополнительный пакет Windows Mobile 5.0 SDK Smartphone, который содержит дополнительные эмуляторы для этого класса устройств.

Создание приложения для смартфона

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

Запустите Visual Studio 2005 для создания нового проекта. Надо выбрать тип проекта Smartphone 2003. Для этого типа применяется только .NET Compact Framework 1.0. Сразу после создания надо запустить эмулятор при помощи команды меню Debug►Start Debugging. На экране будет отображено окно Deploy со списком имеющихся эмуляторов. Нужно выбрать эмулятор и нажать кнопке Deploy. Если все прошло нормально, то эмулятор будет загружен с пустой формой. В первом упражнении надо лишь проверить возможности работы с эмулятором. Поэтому надо закрыть приложение (но не эмулятор!) и продолжить работу с приложением в режиме проектирования.

ПРИМЕЧАНИЕ

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

Создание меню

Практически все программы для смартфонов работают при помощи команд меню. Поэтому надо получить базовые навыки работы с этим элементом управления. В режиме проектирования формы следует щелкнуть мышью в левой части голубой полоски, которая расположена в нижней части экрана. Эта полоска является элементом меню, которое вызывается нажатием кнопки Soft Key1, находящейся под экраном. На форме появится текст Type Here (рис. 9.1).

Рис. 9.1. Создание меню

В этой области нужно ввести слово Привет и нажать клавишу Enter. Введенный текст появится в левой части формы, и будет активирована Soft Key 2 с той же надписью Type Here. В этой области нужно ввести слово Закрыть. Теперь можно вводить текст для подменю. Новый пункт меню получит заголовок Выход. Перед словом Выход появится единица. Среда разработки Visual Studio 2005 автоматически вставляет цифры в создаваемое меню. Эти цифры являются номерами кнопок-клавиш телефонов. С помощью этой подсказки пользователь может быстро активировать нужный пункт меню нажатием соответствующей кнопки (рис. 9.2).

Рис. 9.2. Создание подменю

Теперь нужно перейти на форму и дважды щелкнуть на пункте созданного меню Выход. В результате будет открыт редактор кода с заготовкой функции menuItem3_Click. Ее код приведен в листинге 9.1

Листинг 9.1

private void menuItem3_Click(object sender, EventArgs e) {

 this.Close();

}

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

В отношении меню приложения для смартфонов установлено специальное правило. Клавиша Left Softkey может иметь только один пункт меню, а клавиша Right Softkey может иметь разветвленное меню. Любопытно отметить, что при попытке создания подменю для левой клавиши предыдущая версия среды разработки Visual Studio 2003 выводила ошибку. Теперь такой ошибки не выводится, и, теоретически, ничто не мешает нарушить установившуюся традицию. Например, при использовании примеров для смартфонов под управлением Windows Mobile 5.0 программист может создавать вложенные меню для левой кнопки.

Элементы управления

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

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

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

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

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

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


Рис. 9.3. Окантовка у первого текстового поля, имеющего фокус

Чтобы не путать текстовые поля с элементами Label, в надписях используют более жирный текст. На форме надо расположить два элемента Label. На рис. 9.4 видно, что строки label1 и label2 выделяются более жирным начертанием текста. На этом различия не заканчиваются.

Рис. 9.4. Различия внешнего вида некоторых элементов управления

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

Если установить фокус ввода на этом текстовом поле и нажать кнопку Enter, то текст полностью будет показан в новом окне (рис. 9.5).

Рис. 9.5. Полный текст в текстовом поле

Пользователь может самостоятельно дописать слова песни в новом окне и выбрать команду Done или отказаться от подтверждения ввода с помощью команды Cancel.

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

Существует также альтернативный способ выбора элемента из ComboBox. Для этого нужно опять установить фокус на комбинированном окне и прокручивать имеющиеся записи при помощи кнопок навигации Влево или Вправо.

Режимы ввода

Первые модели сотовых телефонов для отправки сообщений имели только один режима ввода. Пользователь нажимал на кнопки телефона в определенном порядке, вводя тот или иной символ. Затем появились другие режимы. В частности, сейчас поддерживается числовой режим, так называемый режим T9 и символьный режим. Поначалу библиотека .NET Compact Framework не имела поддержки режимов ввода. Поэтому для установки необходимого режима программистам приходилось использовать механизм P/Invoke для вызова функций API, как показано в листинге 9.2.

Листинг 9.2

[DllImport("coredll.dll", EntryPoint = "SendMessage")]

private static extern uint SendMessage(IntPtr hWnd, uint msg,

 uint wParam, uint lParam);


// Сообщение для режима ввода

const uint EM_SETINPUTMODE = 0x00DE;


// Перечисление режимов ввода

public enum InputModeAPI {

 Spell = 0,

 T9 = 1,

 Numbers = 2,

 Text = 3

}


public static void SetInputMode(Control ctrl, InputModeAPI mode) {

 SendMessage(ctrl.Handle, EM_SETINPUTMODE, 0, (uint)mode);

}


private void mnuT9_Click(object sender, EventArgs e) {

 SetInputMode(textBox3, InputModeAPI.T9);

}


private void mnuSpell_Click(object sender, EventArgs e) {

 SetInputMode(textBox3, InputModeAPI.Spell);

}


private void mnuNumeric_Click(object sender, EventArgs e) {

 SetInputMode(textBox3, InputModeAPI.Numbers);

}


private void mnuText_Click(object sender, EventArgs e) {

 SetInputMode(textBox3, InputModeAPI.Text);

}

В данном примере нужный режим ввода указывается для текстового поля textBox3 с помощью системы меню (рис. 9.6).

Рис. 9.6. Выбираем режим ввода

ПРИМЕЧАНИЕ

Режим T9 в эмуляторе не работает, поэтому надо проверять код на реальном устройстве.

В библиотеке .NET Compact Framework 2.0 появилась возможность контролировать режим ввода текста с помощью класса InputModeEditor. Данный режим распространяется только на текстовые поля.

Предположим, что в программе есть два текстовых поля. В одном поле пользователь должен ввести свое имя, а во втором — номер телефона. В первом случае пользователь будет использовать буквы, а во втором случае ему необходимы только цифры. Поэтому можно заранее задать нужный режим ввода текста для разных текстовых полей. Для этого надо указать ссылку на сборку Microsoft.WindowsCE.Forms и задействовать класс InputModeEditor, как показано в листинге 9.3.

Листинг 9.3 Управление режимами ввода с помощью управляемого кода

private void Form1_Load(object sender, EventArgs e) {

 // Устанавливаем текстовый режим ввода текста

 InputModeEditor.SetInputMode(txtName, InputMode.AlphaCurrent);

 // Устанавливаем числовой режим ввода текста

 InputModeEditor.SetInputMode(txtPhone, InputMode.Numeric);

}

Переопределение клавиш Soft Key

На смартфонах клавиши Soft Key 1 и Soft Key 2 используются для управления меню. Если попробовать переопределить эти клавиши для других задач, то у вас ничего не получится. Дело в том, что события Key_Down не распознаются системой для этих клавиш, если на форме присутствует компонент MainMenu. Но если удалить этот компонент, устанавливаемый по умолчанию, то с этими кнопками можно будет связать собственные команды, как показано в листинге 9.4.

Листинг 9.4

private void Form1_KeyDown(object sender, KeyEventArgs e) {

if ((e.KeyCode == System.Windows.Forms.Keys.F1)) {

 // Soft Key 1

 lblTest.Text = "Вы нажали на клавишу Soft Key 1";

}

if ((e.KeyCode == System.Windows.Forms.Keys.F2)) {

 // Soft Key 2

 lblTest.Text = "Вы нажали на клавишу Soft Key 2";

}

Прокручивание формы

Если форма не умещается на экране целиком, то пользователь может прокрутить ее стилусом с помощью полос прокрутки. Особенно это полезно, если учесть, что .NET Compact Framework 2.0 теперь поддерживает свойство AutoScroll. Но смартфоны не имеют сенсорного экрана, реагирующего на стилус. Для прокрутки формы надо искать другой вариант.

Например, можно воспользоваться обработкой события KeyDown. В тестовом проекте надо растянуть форму так, чтобы нижнюю часть не было видно на экране смартфона. На форме надо разместить несколько надписей, причем одна из них должна располагаться в нижней части формы. Для свойства формы AutoScroll надо задать значение True. В листинге 9.5 приведен пример кода для прокрутки формы.

Листинг 9.5

private void Form1_KeyDown(object sender, KeyEventArgs e) {

 if ((e.KeyCode == System.Windows.Forms.Keys.Up)) {

  // Up

  this.AutoScrollPosition =

   new Point(-this.AutoScrollPosition.X, -this.AutoScrollPosition.Y - 16);

 }

 if ((e.KeyCode == System.Windows.Forms.Keys.Down)) {

  // Down

  this.AutoScrollPosition =

   new Point(-this.AutoScrollPosition.X, -this.AutoScrollPosition.Y + 16);

 }

 if ((e.KeyCode == System.Windows.Forms.Keys.Left)) {

  // Left

  this.AutoScrollPosition =

   new Point(-this.AutoScrollPosition.X - 16, -this.AutoScrollPosition.Y);

 }

 if ((e.KeyCode == System.Windows.Forms.Keys.Right)) {

  // Right

  this.AutoScrollPosition =

   new Point(-this.AutoScrollPosition.X + 16, -this.AutoScrollPosition.Y);

 }

}

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

Листинг 9.6

private void Form1_Load(object sender, EventArgs e) {

 pictureBox1.Focus();

 this.pictureBox1.KeyDown += new KeyEventHandler(Form1_KeyDown);

}

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

Глава 10 Windows Mobile 5.0

Первый взгляд

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

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

Компания Microsoft уделяет большое внимание данной платформе, предоставляя разработчикам подробнейшую документацию, примеры и инструменты разработки. Главная страница для Window Mobile 5.0 находится на сайте Windows Mobile по адресу msdn.microsoft.com/mobility/windowsmobile/default.aspx.

На сайте можно скачать необходимые пакеты SDK, позволяющие работать с устройствами под управлением Windows Mobile 5.0. В этой главе будут рассматриваться новые возможности, заложенные в систему Windows Mobile 5.0, которые будут интересны программистам.

Улучшенная продуктивность

В системе Windows Mobile 5.0 появились нововведения, которые увеличивают продуктивность труда программиста. Основные возможности перечислены в следующем списке.

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

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

□ Улучшена и добавлена поддержка технологий передачи данных, в том числе прием и посылка SMS и телефонных звонков.

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

□ Переработан эмулятор.

Поддержка мультимедиа

Теперь программисты могут использовать классы, взаимодействующие с фотокамерами. Это позволяет расширить область приложения камер и использовать их в работе с изображениями и видеозаписями в приложениях. Разработчики могут использовать возможности музыкального плеера Windows Media Player 10 Mobile в своих приложениях. Технология Direct3D позволяет разработчикам создавать более совершенные игры, а библиотека DirectDraw позволяет работать с графикой на более высоком уровне.

Поддержка управляемого кода

Система Windows Mobile 5.0 обеспечивает первоклассную поддержку программистов, работающих с управляемым кодом. Основные нововведения перечислены в следующем списке.

□ Все устройства под управлением Windows Mobile 5.0 поставляются с исполняемой средой .NET Compact Framework 1.0 Service Pack 3, которая записана в независимую память.

□ При помощи управляемого кода осуществляется работа с SMS-сообщениями, контактами Outlook Mobile и телефонными возможностями устройства.

Windows Mobile 5.0 API

Система Windows Mobile 5.0 обзавелась новыми функциями API. Программисты получили в свое распоряжение новое пространство имен Microsoft.WindowsMobile с множеством классов, перечислений и делегатов. Кроме того, появились такие пространства имен, как Configuration, Forms, PocketOutlook, PocketOutlook.MessageInterception, Status и Telephony.

Устройства под управлением Windows Mobile постоянно улучшаются. И разработчики требуют новых возможностей для написания красивых и сложных игр. Поэтому в состав системы включена библиотека Direct3D Mobile. Ее можно считать аналогом библиотеки Direct3D API, которая используется в настольных компьютерах.

Для доступа к памяти, улучшенной работе со сложной графикой и видеоматериалами система Windows Mobile 5.0 предлагает воспользоваться DirectDraw API. Эта библиотека также может быть востребована для разработки игр, она является аналогом библиотеки DirectDraw API настольного компьютера.

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

Кроме того, в устройствах все чаще стали использоваться приемники GPS. Раньше писать приложения, работающие с технологиями GPS, было довольно трудно. Нужно было использовать для работы serial API, что требовало хорошего знания основ сетевого программирования. Система Windows Mobile 5.0 во многом облегчила эту задачу при помощи технологии GPS Intermediate Driver. Эта технология предоставляет набор простых функций для доступа к данным GPS. В следующем списке приведены основные функции для работы с GPS Intermediate Driver:

□ GPSOpenDevice — соединение с GPS Intermediate Driver;

□ GPSCloseDevice — разрыв связи от GPS Intermediate Driver;

□ GPSGetPosition — получение текущих координат;

□ GPSGetDeviceState — получение информации о текущем состоянии устройства.

Взаимодействие с ActiveSync

Разработчики теперь могут запускать и останавливать процесс синхронизации ActiveSync, используя методы ActiveSyncStart и ActiveSyncStop.

Новые возможности системы

После выхода системы Windows Mobile 2005 разработчикам стали доступны многие системные возможности, что намного упростило разработку приложений с использованием передовых технологий.

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

Подготовка к работе

Прежде чем создавать приложения для устройств под управлением системы Windows Mobile 5.0, нужно установить необходимые пакеты SDK. Компания Microsoft предлагает заказать специальный диск с набором всех необходимых пакетов, сделав заказ на странице их сайта, которая располагается по адресу msdn.microsoft.com/mobility/windowsmobile/howto/resourcekit/default.aspx, или самостоятельно скачать эти пакеты с сайта (рис. 10.1).

Рис. 10.1. Веб-страница Windows Mobile 5.0

Следует обратить внимание на то, что существуют отдельные версии SDK для карманных компьютеров и смартфонов. После завершения установки пакеты автоматически интегрируются в среду разработки Visual Studio 2005. В результате разработчик получает новые эмуляторы под Windows Mobile 5.0, в систему будут добавлены новые классы, а справочная система пополнится новыми статьями и примерами.

Также можно скачать локализованные версии эмуляторов. К примеру, страница для загрузки локализованной версии Windows Mobile 5.0 Pocket PC Emulator Images находится по адресу www.microsoft.com/downloads/details.aspx?familyid=EEC33AE3-C129-4C25-ABAA-18E8E842178F&displaylang=en.

Чтобы воочию увидеть особенности Windows Mobile 5.0, надо разработать соответствующее приложение. Для этого следует запустить среду разработки Visual Studio 2005 и создать новый проект. При этом надо выбрать пункт Smart Device project, чтобы создать приложение для мобильного устройства. Затем надо выбрать платформу Pocket PC под управлением Windows Mobile 5.0 (рис. 10.2). После создания проекта Visual Studio 2005 отобразит пустую форму с установленными реальными размерами устройства.

Рис. 10.2. Выбор типа проекта для Windows Mobile 5.0

Система Windows Mobile 5.0 предоставляет разработчику множество новых пространств имен, классов, свойств и событий, с помощью которых он может получить доступ ко многим возможностям, которые ранее приходилось реализовывать только при помощи очень сложного и громоздкого кода на C++ с применением Windows API. Теперь разработчики могут для этих целей применять управляемый код .NET Compact Framework. Имеет смысл поближе познакомиться с этими возможностями.

Microsoft.WindowsMobile.PocketOutlook

С помощью пространства имен Microsoft.WindowsMobile.PocketOutlook разработчик получает доступ к модели Pocket Outlook Object Model (POOM). А имея доступ к POOM, можно легко получить данные из объектов Контакты, Встречи и Задачи. Также можно получить электронные адреса из адресной книги, номера отправки SMS и сообщения. В следующем списке указаны наиболее часто используемые классы.

□ OutlookSession — представляет собой объект Pocket Outlook для работы с контактами, встречами и задачами. Также можно получить доступ к учетным записям электронной почты и SMS.

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

□ Contact — класс для работы с контактами. Данный класс поддерживает более 60 свойств.

□ Task — класс для работы с задачами.

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

Встречи (Appointment)

При помощи объектной модели Pocket Outlook Object Model разработчик может добавить новую запись в список намечаемых встреч. Сначала надо создать тестовый проект. Чтобы получить доступ к объектам Pocket Outlook, нужно добавить ссылку на соответствующие сборки. Для этого следует выполнить команду Project►Add Reference. В диалоговом окне Add Reference нужно выбрать строки Microsoft.WindowsMobile.Forms и Microsoft.WindowsMobile.PocketOutlook (рис. 10.3).

Рис. 10.3. Подключение к проекту сборок

После нажатия кнопки OK выбранные ссылки должны появиться в списке ссылок Solution Explorer, как показано на рис. 10.4.

Рис. 10.4. Окно Solution Explorer

Теперь в редакторе кода следует добавить объявления для пространств имен Microsoft.WindowsMobile.Forms и Microsoft.WindowMobile.PocketOutlook сразу после существующих объявлений. В этом случае появляется возможность работы с различными классами Pocket Outlook. Например, чтобы получить доступ к настройкам для встреч, используется класс Appointment, как показано в листинге 10.1.

Листинг 10.1

using Microsoft.WindowsMobile.Forms;

using Microsoft.WindowsMobile.PocketOutlook;


private void button1_Click(object sender, EventArgs e) {

 // Создаем встречу и устанавливаем детали

 Appointment appt = new Appointment();

 // Тема для встречи

 appt.Subject = "Встреча с тещей";

 // Время встречи - 8 марта 2007 в 22 часа

 appt.Start = new DateTime(2007, 03, 08, 22, 00, 00);

 // Продолжительность встречи - 3 минуты

 appt.Duration = new TimeSpan(00, 03, 00);

 // Использовать виброзвонок для напоминания

 appt.ReminderVibrate = true;

 // Повторять напоминание, пока пользователь не отреагирует

 appt.ReminderRepeat = true;


 // Создаем сессию Outlook

 // добавляем встречу в папку встреч Outlook

 using (OutlookSession session = new OutlookSession()) {

  session.Appointments.Items.Add(appt);

  session.Dispose();

 }

}


Нужно запустить программу и нажать кнопку Добавить встречу. После этого можно закрыть приложение, так как свою работу оно закончило. Теперь следует открыть программу Календарь, которая встроена в систему. В календаре нужно найти дату, которая использовалась в программе. В текущем примере встреча была запланирована на 8 марта 2007 года. Если все сделано правильно, то в указанной дате должна присутствовать запись о новой встрече (рис. 10.5).

Рис. 10.5. Календарь с установленной записью встречи

Работа с адресной книгой

В этом разделе будет рассмотрен пример, в котором будет добавлена новая запись в объект Контакты. Для этого надо, как и прежде, добавить в проект ссылки на соответствующие сборки Miсrosoft.WindowsMobile.Forms и Microsoft.WindowsMobilе.PocketOutlook. А в редакторе кода надо добавить объявления для пространств имен Microsoft.WindowsMobilе.Forms и Microsoft.WindowsMobile.PocketOutlook сразу после существующих объявлений.

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

Листинг 10.2

private OutlookSession session;


public Form1() {

 InitializeComponent();

 // Создаем экземпляр сессии Pocket Outlook

 session = new OutlookSession();

}


private void butAddContact_Click(object sender, EventArgs e) {

 Contact contact = new Contact();

 contact.FirstName = "Билл";

 contact.LastName = "Гейтс";

 contact.Email1Address = "billgates@microsoft.com";

 contact.Birthday = new DateTime(1955,10,28);

 contact.CompanyName = "Microsoft";

 contact.WebPage = new Uri("http://www.microsoft.com");

 session.Contacts.Items.Add(contact);

}

Код очень прост и практически не требует комментариев. В начале работы создается переменная contact, в которой можно задавать самые различные параметры. В этом примере использовались только основные свойства. Были указаны имя, фамилия, электронный адрес, день рождения, имя компании и ее веб-страница. После того как новый контакт будет добавлен в список, нужно закрыть сессию при помощи метода Dispose().

После запуска приложения следует нажать кнопку Добавить в Контакты. В результате этого в списке Контакты появится новая запись (рис. 10.6)

Рис. 10.6. Просмотр списка контактов

Но разработчик может не только добавлять, но и получать информацию из имеющегося элемента списка. Для этого на форму надо поместить список lstContacts и кнопку butGetInfo. Прежде чем получить информацию о нужном нам человеке, нужно сначала получить сам список контактов. И только потом, выбрав из этого списка нужную запись, можно получить дополнительную информацию. Для получения полного списка контактов нужно добавить код в обработчик события Form_Load, как это показано в листинге 10.3.

Листинг 10.3

private void Form1_Load(object sender, EventArgs e) {

 // Получаем список контактов

 lstContacts.DataSource = session.Contacts.Items;

}

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

Листинг 10.4

private void butGetInfo_Click(object sender, EventArgs e) {

 // Получим информацию о выбранном контакте

 session.Contacts.Items[lstContacts.SelectedIndex].ShowDialog();

}

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

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

Листинг 10.5

private void butDelContactClick(object sender, EventArgs e) {

 // Удаляем выбранный контакт

 session.Contacts.Items[lstContacts.SelectedIndex].Delete();

}

Также из приложения можно вызвать стандартное окно выбора контакта, используемое программой Pocket Outlook. Теперь совсем не обязательно закрывать нашу программу и открывать окно контактов, как это было сделано при добавлении новой записи в список контактов.

Стандартное окно имеет некоторые дополнительные возможности, которые могут пригодиться разработчикам. Доступ к данному окну осуществляется через класс ChooseContactDialog, как показано в листинге 10.6.

Листинг 10.6

private void butShowContactsClick(object sender, EventArgs e) {

 ChooseContactDialog contactDialog = new ChooseContactDialog();

 // Прячем пункт меню Новый контакт

 contactDialog.HideNew = true;

 // Выводим диалоговое окна на экран

 contactDialog.ShowDialog();

 // Показываем выбранный контакт

 MessageBox.Show(contactDialog.SelectedContactName, "Выбранный контакт");

}

Электронная почта

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

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

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

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

Листинг 10.7

private void butSendEmail_Click(object sender, EventArgs e) {

 ChooseContactDialog contactDialog = new ChooseContactDialog();

 contactDialog.Title = "Выберите контакт для отправки email";

 if (contactDialog.ShowDialog() == DialogResult.OK) {

  EmailMessage message = new EmailMessage();

  message.To.Add(

   new Recipient(contactDialog.SelectedContact.Email1Address));

  message.Subject = "С днем рождения";

  message.BodyText =

   "Уважаемый Владимир Владимирович! Поздравляю вас с днем рождения!

   Посылаю вам открытку с видами Петербурга. Ваша Люда.";

  message.Attachments.Add(

   new Attachment(@"\My Documents\piter.jpg"));

  using (OutlookSession session = new OutlookSession()) {

   session.EmailAccounts[0].Send(message);

   session.Dispose();

  }

 }

}

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

Если надо отправить электронное письмо адресату, который не внесен в адресную книгу, то пример надо переработать. Новый код приведен в листинге 10.8.

Листинг 10.8

private void butSendEmail2_Click(object sender, EventArgs e) {

 Recipient recipient = new Recipient("alexander.klimoff@gmail.com");

 EmailMessage msg = new EmailMessage();


 // Кому письмо

 msg.To.Add(recipient);

 // Тема письма

 msg.Subject = "О вашей книге";

 // Текст письма

 msg.BodyText = "Спасибо за книгу";

 msg.Send("ActiveSync");

}

SMS-сообщения

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

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

Листинг 10.9.

private void butSendSMS_Click(object sender, EventArgs e) {

 ChooseContactDialog contactDialog = new ChooseContactDialog();

 contactDialog.Title = "Выберите получателя";

 if (contactDialog.ShowDialog() == DialogResult.OK) {

  // Создаем SMS-сообщение

  SmsMessage message = new SmsMessage(

   contactDialog.SelectedContact.MobileTelephoneNumber,

   "Купи хлеба. Жена");

  message.RequestDeliveryReport = true;

  // Посылаем сообщение

  message.Send();

 }

}

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

Здесь я хочу сделать небольшое отступление и открыть вам большой секрет. Разработчик может посылать SMS-сообщения самому себе при помощи эмулятора! Если послать SMS-сообщение из эмулятора на телефонный номер 4250010001, то оно вернется на эмулятор (рис. 10.7).

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

ПРИМЕЧАНИЕ

При отладке приложения в эмуляторе надо использовать целевое устройство типа «Phone Edition». Если проверять пример в обычном эмуляторе, то будет отображено сообщение об ошибке «Could not load sms.dll». Впрочем, это не удивительно. Если эмулятор не имеет телефонных функций, то как можно отправлять SMS-сообщение?

Листинг 10.10

private void butSendSMS2_Click(object sender, EventArgs e) {

 SmsMessage message = new SmsMessage();

 // Номер получателя

 message.To.Add(new Recipient("4250010001"));

 // Текст сообщения

 message.Body = "Позвони домой";

 // Посылаем сообщение

 message.Send();

}

Результат выполнения этого кода приведен на рис. 10.7.

Рис. 10.7. Прием SMS-сообщения

Прием и обработка SMS-сообщений

Итак, мы научились отправлять SMS-сообщения из своей программы. Но было бы неплохо научить приложения принимать подобные сообщения. Для приема сообщений существует пространство имен MessageInterception, которое находится в сборке Microsoft.WindowsMobilе.PocketOutlook.

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

С этой возможностью стоит познакомиться ближе. После создания нового проекта InterceptionSMS_CS, нужно добавить на форму кнопку для отсылки SMS-сообщения, флажок chkAlert для установки флага срочности и текстовое поле, в котором будет содержаться текст SMS-сообщения. Затем надо задать ссылки на уже применявшиеся ранее сборки Microsoft.WindowsMobile и Microsoft.WindowsMobile.PocketOutlook. Код, отвечающий за обработку принятых сообщений, приведен в листинге 10.11

Листинг 10.11

using Microsoft.WindowsMobile;

using Microsoft.WindowsMobile.PocketOutlook;

using Microsoft.WindowsMobile.PocketOutlook.MessageInterception;


// Объявляем переменную

private MessageInterceptor smsInterceptor;


private void smsInterceptor_MessageReceived(object sender,

 MessageInterceptorEventArgs e) {

 // Обработка входящего сообщения

 MessageBox.Show("К вам пришло срочное сообщение");

}


private void butSendSMS_Click(object sender, EventArgs e) {

 SmsMessage message = new SmsMessage();

 // Номер получателя

 message.To.Add(new Recipient("4250010001"));

 // Текст сообщения

 if (chkAlert.Checked) {

  // Если взведен флажок, то добавляем слово Срочно!

  message.Body = "Срочно! " + txtSMSText.Text;

 } else {

  message.Body = txtSMSText.Text;

 }

 // Посылаем сообщение

 message. Send();

}


private void Form1_Load(object sender, EventArgs e) {

 smsInterceptor =

  new MessageInterceptor(InterceptionAction.NotifyAndDelete, true);

 smsInterceptor.MessageCondition =

  new MessageCondition(MessageProperty.Body,

  MessagePropertyComparisonType.StartsWith, "Срочно", true);

 smsInterceptor.MessageReceived +=

  new MessageInterceptorEventHandler(smsInterceptorMessageReceived);

}

При помощи ключевого слова using было объявлено несколько пространств имен, также была добавлена переменная smsInterceptor, после чего можно было объявлять функцию обработки сообщения smsInterceptor_MessageReceived. При получении SMS-сообщения с определенным текстом эта функция выводит соответствующую строку.

Но самое интересное происходит в событии Form_Load. Как только устройство принимает SMS-сообщение, оно перехватывается приложением для дальнейшей обработки. Если сообщение начинается словом «Срочно», то пользователь предупреждается о прибытии важного сообщения, после чего это сообщение удаляется. Подобное поведение обеспечивает параметр NotifyAndDelete.

После запуска приложения на форме будут отображены текстовое поле и флажок. После ввода текста сообщения нужно нажать кнопку Послать SMS. Код отправки сообщения позаимствован из предыдущего примера. Система должна отреагировать на прибытие нового сообщения с помощью специального уведомления, которое мы видели при разборе предыдущего примера (см. рис. 10.7).

Теперь следует повторить операцию. Только на этот раз надо взвести флажок Пометить как срочное. В этом случае при отправке сообщения в начало текста вставляется дополнительное слово «Срочно». После нажатия кнопки приложение должно перехватить прибытие SMS-сообщения, так как теперь оно содержит ключевое слово, которое определялось в параметре StartWith. Как только это произойдет, сообщение будет удалено, а пользователь получит уведомление о прибытии срочного сообщения (рис. 10.8). Но следует помнить, что для перехвата сообщения приложение должно быть запущено.

Рис. 10.8. Прием срочного сообщения

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


ВНИМАНИЕ

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

Телефония

Разработчик может использовать возможности телефонии при помощи класса Miсrosoft.WindowsMobile.Telephony.Phone. Используя метод этого класса Talk, можно программно набрать нужный телефонный номер. При использовании класса Phone перед началом работы нужно установить ссылку на сборку Microsoft.WindowsMobile.Telephony. Пример использования этого метода приведен в листинге 10.12.

Листинг 10.12

using Microsoft.WindowsMobile.Telephony;


// Объявляем переменную Phone

phone = new Phone();


// Набираем номер

// Перед набором запрашиваем подтверждение

phone.Talk("4255551212", true);

Обратите внимание на набираемый номер. С помощью данного номера разработчик может делать звонок на эмуляторе. Эмулятор сначала запросит подтверждение набора номера (рис. 10.9) и затем будет звонить по указанному номеру.

Рис. 10.9. Запрос набора указанного номера

После подтверждения будет установлено соединение с неизвестным абонентом 4255551212 (рис. 10.10).

Рис. 10.10. Соединение с абонентом

State and Notifications Broker

В Windows Mobile 5.0 появилась новая технология, получившая название State and Notifications Broker. Использование данной технологии позволяет управлять состоянием устройства. Раньше для доступа к системным настройкам приходилось использовать неуправляемый код. Но теперь можно использовать возможности технологии State and Notification Broker.

При помощи этой технологии можно обрабатывать информацию о различных состояниях устройства и постоянно отслеживать изменения этих состояний. Если будут обнаружены какие-либо изменения, то система сообщит об этом приложению. Использование данных технологий открывает широкие возможности для увеличения функциональности программ. Например, разработчик сможет определять силу сигнала от сотовой станции, значение текущего заряда батареи, узнать, подключен ли крэдл, отслеживать состояние ActiveSync, определять наличие подключаемой клавиатуры, фотокамеры и гарнитуры. Также с помощью этой технологии можно определять число Bluetooth-соединений, отображать список текущих сетевых соединений, получать информацию об ориентации экрана. Разработчик может получать информацию о следующей назначенной встрече (Appointment), обрабатывать информацию о проигрываемом музыкальном файле, получать информацию о контактах и количестве не прочитанных электронных писем, SMS-сообщений и пропущенных телефонных звонков.

Чтобы использовать возможности State and Notifications Broker в приложениях, надо добавить ссылку на сборку Microsoft.WindowsMobile.Status. Также необходимо добавить ссылку на сборку Microsoft.WindowsMobile. После этого программа готова использовать классы пространства имен Microsoft.WindowsMobile.Status.

Конечно, без наглядного примера обойтись просто нельзя. Предположим, что нас интересует информация о владельце устройства и необходимо отслеживать изменение этой информации. Для этого надо создать новый проект и добавить на форму элемент Label. Этого вполне достаточно для работы примера. Также необходимо добавить ссылки на сборки Microsoft.WindowsMobile и Microsoft.WindowsMobile.Status при помощи команды меню Project►Add Reference. Нас интересует изменение электронного адреса владельца устройства. Для этого используется код, приведенный в листинге 10.13.

Листинг 10.13

using Microsoft.WindowsMobile.Status;

private SystemState sysState;


sysState = new SystemState(SystemProperty.OwnerEmail, true);

sysState.Changed += new ChangeEventHandler(sysStateChanged);

private void sysState_Changed(object sender, ChangeEventArgs args) {

 lblOwnerEmail.Text = SystemState.OwnerEmail;

}

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

Листинг 10.14

private void butGetEmail_Click(object sender, EventArgs e) {

 //Получим email владельца устройства

 lblOwnerEmail.Text = SystemState.OwnerEmail;

}

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

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

sysState = new SystemState(SystemProperty.OwnerEmail, true);

Затем нужно присоединить делегат к новому экземпляру события Changed:

sysState.Changed += new ChangeEventHandler(sysState_Changed);

А уже после этого можно перехватывать изменение состояния нужных параметров:

private void sysState_Changed(object sender, ChangeEventArgs args) {

 lblOwnerEmail.Text = SystemState.OwnerEmail;

}

Пример с электронным адресом был приведен лишь для ознакомления. На самом деле, с помощью соответствующих свойств можно получить доступ более чем к ста системным настройкам. Наиболее внимательные читатели могут заметить, что State и Notifications Broker порой дублируют функциональность, которую можно воспроизвести при помощи других средств. Например, текущую ориентацию экрана можно узнать с помощью функции API GetSystemMetrics или с помощью вызова Screen.PrimaryScreen.Bounds. А информацию о заряде батареи можно узнать с помощью функции GetSystemPowerStatusEx.

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

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

Листинг 10.15

private void butGetInfo_Click(object sender, EventArgs e) {

 lstInfo.Items.Add("Название оператора: " + SystemState.PhoneOperatorName);

 lstInfo.Items.Add("Наличие радио: " + SystemState.PhoneRadioPresent);

 lstInfo.Items.Add("Наличие камеры: " + SystemState.CameraPresent);

 lstInfo.Items.Add("Ориентация экрана " + SystemState.DisplayRotation);

}


private void butBattery_Click(object sender, EventArgs e) {

 // Уровень заряда батареи

 BatteryLevel batteryLevel = SystemState.PowerBatteryStrength;

 BatteryState batteryState = SystemState.PowerBatteryState;

 string strBatteryLevel = "Уровень заряда";

 switch (batteryLevel) {

 case BatteryLevel.VeryLow:

  strBatteryLevel = "Уровень заряда: Очень низкий (0-20%)";

  break;

 case BatteryLevel.Low:

  strBatteryLevel = "Уровень заряда: Низкий (21-40%)";

  break;

 case BatteryLevel.Medium:

  strBatteryLevel = "Уровень заряда: Средний (41-60%)";

  break:

 case BatteryLevel.High:

  strBatteryLevel = "Уровень заряда: Высокий (61-80%)";

  break;

 case BatteryLevel.VeryHigh:

  strBatteryLevel = "Уровень заряда: Очень высокий (81-100%)";

  break;

 }


 // Состояние батареи

 string strBatteryState = "Состояние батареи: ";

 if ((batteryState & BatteryState.Normal) == BatteryState.Normal)

  strBatteryState += "Нормальное";

 if ((batteryState & BatteryState.NotPresent) == BatteryState.NotPresent)

  strBatteryState += "Батарея отсутствует ";

 if ((batteryState & BatteryState.Charging) == BatteryState.Charging)

  strBatteryState += "Заряжается ";

 if ((batteryState & BatteryState.Low) == BatteryState.Low)

  strBatteryState += "Низкий заряд ";

 if ((batteryState & BatteryState.Critical) == BatteryState.Critical)

  strBatteryState += "Критическое";

 MessageBox.Show(strBatteryLevel + "\n" + strBatteryState);

}

Мультимедиа

Система Windows Mobile 5.0 обеспечивает еще более глубокую поддержку мультимедиа, чем предыдущие версии операционных систем. Теперь разработчики имеют возможность напрямую работать с фотокамерой, встраивая в свои программы взаимодействие с камерой и обработку картинок и видеороликов. Технология Microsoft DirectShow дает возможность управлять потоковыми мультимедийными материалами. Программа Microsoft Windows Media Player 10 Mobile позволяет интегрировать функциональность музыкального плеера в собственные приложения. Технология Microsoft DirectDraw предоставляет доступ к графической системе на более высоком уровне, а библиотека Microsoft Direct3D позволяет создавать очень сложные динамические игры, используя управляемый код. Эти возможности стоит рассмотреть подробнее.

Выбор изображения

В операционной системе Windows Mobile 5.0 стало поразительно легко работать с коллекцией фотографий и рисунков. При помощи стандартного диалогового окна выбора рисунка можно легко выбрать нужный рисунок. Доступ к стандартному окну выбора рисунка осуществляется при помощи класса Microsoft.WindowsMobile.Forms.SelectPictureDialog.

Но лучше работу с диалоговым окном выбора картинки рассмотреть на примере. На форме надо разместить метку lblSelectedPicture и графическое поле picSelectImage. Не забудьте перед началом создания приложения установить ссылку на пространство имен Microsoft.WindowsMobile.Forms. Соответствующий код приведен в листинге 10.16.

Листинг 10.16

private void butSelectPicture_Click(object sender, EventArgs e) {

 SelectPictureDialog selectPictureDialog = new SelectPictureDialog();

 // Задаем фильтр

 selectPictureDialog.Filter = "Рисунки(*.BMP;*.JPG)|*.BMP;*.JPG";

 // Задаем папку для обзора

 selectPictureDialog.InitialDirectory = Windows";

 // Заголовок для диалогового окна

 selectPictureDialog.Title = "Выберите рисунок";

 if (selectPictureDialog.ShowDialog() = DialogResult.OK &&

  selectPictureDialog.FileName.Length > 0) {

  // Получим расширение выбранного файла

  string fileExtension = Path.GetExtension(selectPictureDialog.FileName);

  // Выводим путь выбранного файла

  lblSelectedPicture.Text = "Выбранный файл: " +

   selectPictureDialog.FileName;

  // Если выбран файл JPG, то выводим на экран

  if (fileExtension.ToLower() == ".jpg")

   picSelectedImage.Image = new Bitmap(selectPictureDialog.FileName);

 }

}

В начале работы создается объект SelectPictureDialog, а затем для него задаются нужные свойства. С помощью свойства Filter ограничивается выбор файлов. Пользователь может загружать изображения с расширениями .BMP и .JPG. Затем указывается стартовая папка. Строго говоря, в Windows Mobile для хранения картинок используется папка Мои картинки. Но приложение, работающее с изображениями, может использовать свою собственную папку.

Рис. 10.11. Выбор изображения

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

Если пользователь выбрал картинку и нажал на кнопку OK, то надо распознать выбранный файл. С помощью метода Path.GetExtension можно получить расширение файла. В текстовой метке lblSelectedPicture отображается полный путь к выбранному файлу, а в графическом поле picSelectedImage размещается сама картинка. Но для этого она должна иметь расширение .JPG (рис. 10.11).

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

Работа с фотокамерой

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

Диалоговое окно захвата изображения позволяет интегрировать фотографии и видеоматериал в приложения. При этом разработчик получает возможность управлять поведением камеры. Доступ к возможностям камеры осуществляется при помощи класса Microsoft.WindowsMobile.Forms.CameraCaptureDialog. Класс CameraCaptureDialog очень похож на класс SelectPictureDialog.

Свойство Mode позволяет управлять режимом съемки. Камера может работать, как обычный фотоаппарат, что задается значением CameraCaptureMode.Still, или записывать видеоролик. Диалоговое окно вызывается методом ShowDialog, который возвращает значение, показывающее, как было закрыто окно. Если пользователь выбрал кнопку OK, то возвращается значение DialogResult.OK. Имя выбранной картинки записывается в свойство FileName. В листинге 10.17 приведен пример работы с фотокамерой.

Листинг 10.17

private void butPhotoMake_Click(object sender, EventArgs e) {

 CameraCaptureDialog cameraCaptureDialog = new CameraCaptureDialog();

 cameraCaptureDialog.Owner = this;

 cameraCaptureDialog.Title = "Фотограф";

 cameraCaptureDialog.Mode = CameraCaptureMode.Still;

 if (cameraCaptureDialog.ShowDialog() == DialogResult.OK &&

  cameraCaptureDialog.FileName.Length > 0) {

  PictureBox.Image = new Bitmap(cameraCaptureDialog.FileName);

  MessageBox.Show("Снято!");

 }

}

Для записи видеоролика используется аналогичный способ, но надо поменять режим съемки. Так, для записи видеоматериала вместе со звуком используется режим VideoWithAudio. Пример записи видеоролика приведен в листинге 10.18.

Листинг 10.18

private void butCaptureClick(object sender, EventArgs e) {

 CameraCaptureDialog cameraCapture = new CameraCaptureDialog();

 cameraCapture.Owner = null;

 cameraCapture.InitialDirectory = @"\My Documents":

 cameraCapture.DefaultFileName = @"test.3gp";

 cameraCapture.Title = "Камера - Демонстрация";

 cameraCapture.VideoTypes = CameraCaptureVideoTypes.Messaging;

 cameraCapture.Resolution = new Size(176, 144);

 // Лимит в 10 секунд для видео

 cameraCapture.VideoTimeLimit = new TimeSpan(0, 0, 10);

 cameraCapture.Mode = CameraCaptureMode.VideoWithAudio;

 if (DialogResult.OK == cameraCapture.ShowDialog()) {

  MessageBox.Show("Картинка или видео успешно записаны в:\n{0}",

  cameraCapture.FileName);

 }

}

Легко заметить, что эти два примера практически идентичны. Существует еще режим записи видео без звукового сопровождения. В этом случае для свойства Mode задается значение CameraCaptureMode.VideoOnly. Если перед вызовом метода ShowDialog использовать свойство DefaultFileName, то указанное имя будет использоваться как имя файла для записи новых фотографий или видеоматериала. Свойство InitialDirectory позволяет указать папку, в которой будут сохраняться отснятые материалы. Свойство Resolution позволяет задать разрешение снимаемого материала, что иллюстрирует следующая строка кода:

cameraCaptureDialog.Resolution = new Size(320, 240);

Свойство StillQuality позволяет установить качество сжатия для фотографий при помощи перечисления CameraCaptureStillQuality. Используемые значения перечислены в следующем списке:

□ High — указывает на наилучшее качество картинки с минимальным сжатием;

□ Normal — среднее качество картинки;

□ Low — высокая степень сжатия, плохое качество.

Свойство VideoTimeLimit позволяет установить максимальную продолжительность записи видеоматериала. По умолчанию используется нулевое значение, что означает отсутствие временного ограничения. В этом случае запись съемки будет вестись до тех пор, пока позволяют ресурсы системы. Свойство VideoTypes позволяет выбрать тип видеоматериала. На устройствах под управлением Windows Mobile 5.0 используется видеоматериал двух типов — Multimedia Messaging Service (MMS) и Windows Media Video (WMV).

Повторение пройденного

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

Встречи

Сначала рассмотрим пример с использованием объекта Pocket Outlook. На этот раз надо получить доступ к списку встреч (Appointment). Перед началом изучения примера вам нужно убедиться, что список событий имеет хотя бы одну запись. Если там ничего нет, то следует создать несколько записей самостоятельно.

После создания нового проекта на форме надо разместить элемент ListView. Свойство View должно получить значение Details. В коллекции Columns надо задать заголовки Дата, Время и Тема (рис. 10.12). Прежде всего потребуется задать переменную для экземпляра сессии Outlook. Сразу же после вызова метода InitializeComponent в конструкторе формы объявляем экземпляр для сессии PocketOutlook, как показано в листинге 10.19.

Рис. 10.12. Внешний вид приложения

Листинг 10.19

private OutlookSession session;

public Form1() {

 InitializeComponent();

 // Создаем экземпляр сессии Pocket Outlook

 session = new OutlookSession();

}

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

Листинг 10.20

private void menuAppointments_Click(object sender, EventArgs e) {

 AppAppts = session.Appointments.Items;

 // Проходим через все элементы коллекции

 foreach (Appointment appt in AppAppts) {

  // Создаем объект ListViewItem

  lvItems = new ListViewItem();

  // Разделяем полученные результаты по колонкам

  lvItems.Text = appt.Start.ToShortDateString();

  lvItems.SubItems.Add(appt.Start.ToShortTimeString());

  lvItems.SubItems.Add(appt.Subject);

  // Добавляем в ListView

  lvContacts.Items.Add(lvItems);

 }

 // He забываем закрыть сессию PocketOutlook

 session.Dispose();

}

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

Отсылка письма

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

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

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

Также потребуется изменить код из предыдущего примера. Нужно переместить код из обработчика события menuSoftKey1_Click в отдельный метод SelectContact(). Это делается для того, чтобы можно было более гибко настраивать программу под свои нужды. Соответствующий код приведен в листинге 10.21.

Листинг 10.21

private void SelectContact() {

 // Создаем экземпляр окна выбора контактов

 ChooseContactDialog contactDial = new ChooseContactDialog();

 // а также убираем возможность создания новых контактов

 contactDial.HideNew = true;

 // выводим диалоговое окно на экран

 if (contactDial.ShowDialog() == DialogResult.OK) {

  selContact = contactDial.SelectedContact;

  txtContact.Text = selContact.FileAs;

  menuSoftKey1.Text = Послать;

 }

}

Следует обратить особое внимание на строку

menuSoftKey1.Text = "Послать";

Когда пользователь выберет пункт Контакты, а затем нужный контакт, то текст в пункте меню menuSoftKey1 меняется на строчку Послать. Также надо добавить новый пункт меню для очистки текстовых полей. Это позволит пользователю выбрать новый контакт для отправки письма. Надо открыть файл Form1.cs в дизайнере формы. На правой стороне меню к уже имеющемуся пункту Выход следует добавить новый пункт меню Очистить. Созданный пункт получит имя mnuClear. Код для метода mnuClear_Click приведен в листинге 10.22.

Листинг 10.22

private void mnuClear_Click(object sender, EventArgs e) {

 txtContact.Text = string.Empty;

 menuSoftKey1.Text = "Контакты";

}

Это позволить очистить текстовое поле и в пункте меню menuSoftKey1 отобразить строку Контакты.

Теперь можно писать функцию, отправляющую электронное письмо. В примере сообщение будет отправляться с вложенными файлами. Для примера можно использовать одну из картинок, входящих в состав Windows Mobile 5.0.

Для отправки письма используется класс EmailMessage. Чтобы использовать этот класс в нашем примере, надо сначала установить ссылку на пространство имен System.Messaging, выполнив команду меню Project►Add Reference. После этого можно пользоваться данным пространством имен при помощи ключевого слова using:

using System.Messaging;

Код метода SendEmail(), который будет отвечать за отправку письма, приведен в листинге 10.23.

Листинг 10.23

private void SendEmail() {

 // Создаем экземпляр класса EmailMessage

 EmailMessage message = new EmailMessage();

 // Тема письма

 message.Subject = "Поздравление";

 // Текст письма

 message.BodyText = "Поздравляю с Днем Варенья!";

 // Выбираем адресата

 Recipient client = new Recipient(selContact.Email1Address);

 message.To.Add(client);

 // добавляем в письмо вложенный файл

 Attachment image = new Attachment(@"\My Documents\My Pictures\Flower.jpg");

 message.Attachments.Add(image);

 message.Send("ActiveSync");

 txtContact.Text = string.Empty;

 menuSoftKey1.Text = "Контакты";

}

Итак, в методе SendEmail объявляется и создается экземпляр класса EmailMessage. В свойствах Subject и BodyText задаются тема и текст письма. Электронный адрес из выбранного контакта записывается в свойстве EmailMessage.То. Для этого создается экземпляр класса Recipient и передается свойство selContact.Email1Address.

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

Теперь для отправки письма все готово. Следует вызвать метод message.Send и очистить текстовое поле. Также надо восстановить в меню строку Контакты. Так как для menuSoftKey1 используются два метода, SendEmail и SelectContact, то нужно определиться, когда какой метод следует использовать. Для этого нужно получить значение свойства menuSoftKey1.Text, как показано в листинге 10.24.

Листинг 10.24

private void menuSoftKey1Click(object sender, EventArgs e) {

 if (menuSoftKey1.Text == "Послать")

  SendEmail();

 else

  SelectContact();

}

Настало время проверить нашу программу. После запуска приложения надо выбрать адресата, которому предназначено письмо. Для отображения окна выбора контакта следует нажать кнопку Soft Key 1. Можно выбрать любой контакт из имеющегося списка. После этого в текстовом поле появится выбранный контакт. При этом пункт меню обретет название Послать.

Затем надо снова нажать кнопку Soft Key 1. Кнопка Soft Key 1 примет первоначальный вид, в меню будет отображаться строка Контакт, а текстовое поле будет очищено. Выходим из программы. Но нам надо убедиться, что письмо было отправлено. Поэтому следует перейти на экран Сегодня и нажать кнопку Пуск, после чего активировать пиктограмму Сообщения. В появившемся списке надо выбрать пункт Эл.п. Outlook, а из пункта Меню перейти в подменю Папки. Затем осталось перейти в папку Исходящие. В ней должно находиться новое сообщение.

Мелочь, а приятно

В блоге blogs.msdn.com/anthonywong/, который ведет Энтони Вонг (Anthony Wong), я нашел несколько интересных заметок, рассказывающих об исправленных ошибках или улучшенных возможностях, которые стали доступны в Windows Mobile 5.0.

Метод Directory.Exists

На устройствах под управлением Windows СЕ 4.X метод Directory.Exists() по-разному обрабатывал имена путей, которые заканчивались обратным слэшем. В качестве примера можно рассмотреть следующее выражение:

Directory.Exists("\\temp");

Это выражение возвращает значение True, если папка temp существует. Добавим в предыдущее выражение символ обратной черты.

Directory.Exists("\\temp\\")

Теперь данный метод возвратит False, даже если папка существует. На устройствах под управлением Windows Mobile 5.0 платформа .NET Compact Framework исправила это противоречие, и теперь метод Directory.Exists() возвращает True вне зависимости от наличия замыкающего обратного слэша.

Метод Bitmap.Save()

На старых устройствах также отсутствовали конвертеры графических изображений, что не позволяло сохранять изображения в форматах GIF, JPG или PNG. Разработчикам приходилось довольствоваться только форматом BMP. Причем при написании программы среда разработки позволяла писать неправильный код, выводя соответствующие подсказки. Однако при вызове этого метода программа выводила сообщение об ошибке. В Windows Mobile 5.0 теперь поддерживаются все четыре формата.

Глава 11 Создание игр

Игры на мобильных устройствах

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

Рис. 11.1. Раздел MSDN, посвященный играм

Если в вашей коллекции уже есть игры для настольных компьютеров, написанные с использованием .NET Framework, то в большинстве случаев вам не составит труда портировать их для мобильных устройств. Я хочу познакомить вас с играми, которые уже написаны для КПК и смартфонов. Надо сказать, что существует определенная категория программистов, которые не читают документацию и ищут материалы по заданной теме в книгах и на сайтах. Но это не самое правильное поведение. Компания Microsoft очень часто размещает примеры написания игр в своих справочных системах. Очень много статей на тему разработки игр можно найти в MSDN. В этой коллекции статей и документации есть целый раздел, посвященный созданию игр, под названием «Graphics, Audio and Gaming» (рис. 11.1).

Продуктовая аркада

Для начала имеет смысл рассмотреть игру Bouncer, которую можно найти на веб-странице по адресу msdn.microsoft.com/library/default.asp?url=/library/en-us/dnnetcomp/html/gamesprogwithcheese.asp. Автор игры Роб Майлз (Rob Miles) написал четыре большие статьи об этой игре, которая использует в качестве игровых объектов кусочки сыра, батон хлеба и яблоки. Интересно, что сначала статьи писались о версии игры для .NET Compact Framework 1.0 для смартфонов под управлением Windows Mobile 2003 с использованием Visual Studio .NET 2003. Но к настоящему моменту игра была переписана для смартфонов под управлением Windows Mobile 5.0.

ПРИМЕЧАНИЕ

К слову сказать, когда я читал эти статьи в 2004 году, у меня еще не было смартфона. И тогда я переписал игру для своего карманного компьютера, чтобы поиграть в аркаду на настоящем устройстве.

Автор шаг за шагом раскрывает перед программистом тонкости процесса разработки игры, начиная с создания пустого проекта и заканчивая написанием полноценной игровой модели. Роб Майлз любезно разрешил использовать исходный код игры на страницах книги, а в архиве программ вы найдете установочный файл, содержащий исходные коды игры. Когда вы запустите установочный файл, то программа установки скопирует файлы с примерами в папку C:\Program Files\Windows Mobile Developer Samples\Games Programming With Cheese Part 1. В этом каталоге будут расположены еще семь папок с проектами, которые шаг за шагом ведут программиста к написанию игры.

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

Начало работы

Итак, прежде всего нужно создать новый проект для смартфона под управлением Windows Mobile 5.0 с использованием платформы .NET Compact Framework 2.0. Этот проект должен получить имя Bouncer.

Добавление изображения в программу

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

Возьмем, к примеру, изображение кусочка сыра. Файл с изображением сыра надо скопировать в папку, в которой хранятся файлы проекта. Затем следует щелкнуть правой кнопкой мыши на названии проекта Bouncer в окне Solution Explorer, выбрать пункт контекстного меню Add, а затем перейти к пункту подменю Add Existing Item. В диалоговом окне Add Existing Item надо выбрать файл cheese.gif. После этого остается нажать кнопку Add. Картинка теперь добавлена в проект, но еще не является частью программы.

Необходимо указать, что графический файл будет храниться в виде встроенного ресурса. Нужно щелкнуть правой кнопкой мыши на значке графического файла в окне Solution Explorer и выполнить команду контекстного меню Properties. В разделе Build Action по умолчанию используется пункт Content. Но в данном случае нужно указать пункт Embedded Resource.

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

Использование встроенных ресурсов

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

Листинг 11.1

// Получим ссылку на сборку

System.Reflection.Assembly execAssem =

 System.Reflection.Assembly.GetExecutingAssembly();

Метод System.Reflection.Assembly.GetExecutingAssembly возвращает сборку, из которой выполняется текущий код. Получив в программе ссылку на сборку, можно получить доступ к встроенным ресурсам, в том числе к изображению сыра. Метод GetManifestResourceStream позволяет извлекать указанный ресурс из сборки. Для этого нам надо указать имя файла и название пространства имен. В нашем случае это будет Bouncer.cheese.gif, как показано в листинге 11.2.

Листинг 11.2

/// <summary>

/// Изображение сыра

/// </summary>

private Image cheeseImage = null;


public Form1() {

 InitializeComponent();


 // Получим ссылку на сборку

 System.Reflection.Assembly execAssem =

 System.Reflection.Assembly.GetExecutingAssemblу();


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

 cheeseImage = new System.Drawing.Bitmap(

  execAssem.GetManifestResourceStream(@"Bouncer.cheese.gif");

}

Вывод картинки на экран

При запуске программа загружает из ресурсов картинку. Теперь надо вывести изображение на экран. Для этого нужно воспользоваться событием Paint, как показано в листинге 11.3.

Листинг 11.3

private void Form1_Paint(object sender, PaintEventArgs e) {

 e.Graphics.DrawImage(cheeseImage, 0, 0);

}

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

Рис. 11.2. Вывод изображения на экран

Создание анимации

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

Листинг 11.4

/// <summary>

/// Координата X для рисования сыра

/// </summary>

private int cx = 0;


/// <summary>

/// Координата Y для рисования сыра

/// </summary>

private int cy = 0;


private void updatePositions() {

 cx++;

 cy++;

}

Переменные cx и cy содержат текущие координаты кусочка сыра. Меняя значения этих координат, можно управлять расположением изображения на экране. Теперь нужно переписать код для события Form1_Paint, как это показано в листинге 11.5.

Листинг 11.5

private void Form1_Paint(object sender,

 System.Windows.Forms.PaintEventArgs e) {

 // Текущая позиция сыра

 e.Graphics.DrawImage(cheeseImage, cx, cy);

}

Теперь при каждом вызове метода Paint программа перерисовывает изображение сыра в указанном месте. Но программа должна самостоятельно перемещать изображение через определенные промежутки времени. Также нужно иметь возможность управлять скоростью перемещения картинки. Для этой задачи подойдет объект Timer. Соответствующий элемент нужно добавить на форму.

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

Но вернемся к настройкам таймера. Интервал срабатывания таймера должен составлять 50 миллисекунд, а свойство Enabled должно получить значение False. Когда таймер будет включен, код в методе Tick будет срабатывать 20 раз в секунду. При создании таймера нельзя для свойства Enable устанавливать значение True, так как метод timer1_Tick попытается отобразить изображения до того, как они будут загружены. Включать таймер можно только тогда, когда все необходимые картинки будут загружены, иначе программа выдаст сообщение об ошибке. В нашем примере таймер активируется в конструкторе формы после загрузки изображения сыра, как это показано в листинге 11.6.

Листинг 11.6

public Form1() {

 //

 // Required for Windows Form Designer support.

 //

 InitializeComponent();


 // Получим ссылку на сборку

 System.Reflection.Assembly execAssem =

  System.Reflection.Assembly.GetExecutingAssemblу();


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

 cheeseImage = new System.Drawing.Bitmap

  (execAssem.GetManifestResourceStream(@"Bouncer.cheese.gif"));


 // Включаем таймер

 this.timer1.Enabled = true;

}

Теперь при запуске программы конструктор загружает картинку и включает таймер.

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

Листинг 11.7

private void timer1_Tick(object sender, System.EventArgs e) {

 updatePositions();

 Invalidate();

}

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

Отражения

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

Листинг 11.8

/// <summary>

/// Направление движения по оси X

/// </summary>

private bool goingRight = true;

/// <summary>

/// Направление движения по оси Y

/// </summary>

private bool goingDown = true;


private void updatePositions() {

 if (goingRight) {

  cx++;

 } else {

  cx--;

 }

 if ((cx + cheeseImage.Width) >= this.Width) {

  goingRight = false;

 }

 if (cx <= 0) {

  goingRight = true;

 }

 if (goingDown) {

  cy++;

 } else {

  cy--;

 }

 if ((cy + cheeseImage.Height ) >= this.Height) {

  goingDown = false;

 }

 if (cy <= 0) {

  goingDown = true;

 }

}

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

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

Управление скоростью движения объекта

Рассматривая поведение программы, вам, вероятно, хотелось бы ускорить процесс движения объекта. Чтобы игра была динамичной и увлекательной, нужно постепенно увеличивать сложность игрового процесса для пользователя. Одним из таких способов является ускорение движения. На данный момент кусочек сыра проходит расстояние от одного угла до другого за 5 секунд. Увеличить скорость перемещения картинки очень просто. Достаточно увеличивать значение текущей позиции объекта не на один пиксел, а на несколько. Нужно объявить новые переменные xSpeed и ySpeed, которые будут отвечать за увеличение или уменьшение скорости движения объекта. Соответствующий код приведен в листинге 11.9.

Листинг 11.9

/// <summary>

/// Скорость движения сыра по горизонтали

/// </summary>

private int xSpeed = 1;

/// <summary>

/// Скорость движения сыра по вертикали

/// </summary>

private int ySpeed = 1;


private void updatePositions() {

 if (goingRight) {

  cx += xSpeed;

 } else {

  cx -= xSpeed;

 }

 if ((cx + cheeseImage.Width) >= this.Width) {

  goingRight = false;

 }

 if (cx <= 0) {

  goingRight = true;

 }

 if (goingDown) {

  cy += ySpeed;

 } else {

  cy -= ySpeed;

 }

 if ((cy + cheeseImage.Height) >= this.Height) {

  goingDown = false;

 }

 if (cy <= 0) {

  goingDown = true;

 }

}

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

Листинг 11.10

private void changeSpeed(int change) {

 xSpeed += change;

 ySpeed += change;

}

Теперь можно вызывать этот метод для изменения скорости движения изображения. Для уменьшения скорости надо передавать в функцию отрицательные значения. Чтобы управлять скоростью во время игры, можно использовать клавиши Soft Key, расположенные под экраном.

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

Листинг 11.11

private void menuItem1_Click(object sender, System.EventArgs e) {

 changeSpeed(1);

}


private void menuItem2_Click(object sender, System.EventArgs e) {

 changeSpeed(-1);

}

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

Добавляем новый объект

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

□ Добавляем графический файл в проект в виде ресурса.

□ Получаем в коде ссылку на файл из сборки

□ Объявляем две переменные, содержащие координаты батона хлеба.

Соответствующий код приведен в листинге 11.12.

Листинг 11.12

/// <summary>

/// Изображение, содержащее батон хлеба

/// </summary>

private Image breadImage = null;


// Получаем изображение батона хлеба

breadImage = new System.Drawing.Bitmap(

 execAssem.GetManifestResourceStream(@"Bouncer.bread.gif"));


/// <summary>

/// Координата X для батона хлеба

/// </summary>

private int bx = 0;


/// <summary>

/// Координата Y для батона хлеба

/// </summary>

private int by = 0;

На рис. 11.3 показан внешний вид программы на этом этапе.

Рис. 11.3. Изображения хлеба и сыра

Устранение мерцания

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

Решение проблемы лежит в использовании специальной техники, называемой двойной буферизацией. Двойная буферизация обеспечивает плавную смену кадров. Технология позволяет рисовать необходимые изображения в специальном буфере, который находится в памяти компьютера. Когда все необходимые изображения будут выведены в буфере, то готовое окончательное изображение копируется на экран. Процесс копирования идет очень быстро, и эффект мерцания пропадет. Для реализации этой идеи надо создать новый объект Bitmap. Именно на нем будут отображаться все рисунки, а потом останется только скопировать объект в нужную позицию. Также потребуется переписать метод Form1_Paint, как показано в листинге 11.13.

Листинг 11.13

/// <summary>

/// картинка-буфер

/// </summary>

private Bitmap backBuffer = null;


private void Form1_Paint(object sender,

 System.Windows.Forms.PaintEventArgs e) {

 // Создаем новый буфер

 if (backBuffer == null) {

  backBuffer = new Bitmap(this.ClientSize.Width, this.ClientSize.Height);

 }

 using (Graphics g = Graphics.FromImage(backBuffer)) {

  g.Clear(Color.White);

  g.DrawImage(breadImage, bx, by);

  g.DrawImage(cheeseImage, cx, cy);

 }

 e.Graphics.DrawImage(backBuffer, 0, 0);

}

При первом вызове метода Form1_Paint создается буфер для приема изображений, который объявлен как переменная backBuffer. Затем данный буфер использует контекст устройства для вывода изображений. И, наконец, метод DrawImage из графического контекста формы копирует изображение из буфера и выводит его на экран.

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

Нужно сделать так, чтобы система Windows не перерисовывала экран. Для этого следует переопределить метод OnPaintBackground, отвечающий за перерисовку экрана, причем новая версия метода вообще ничего не будет делать, что иллюстрирует листинг 11.14.

Листинг 11.14

protected override void OnPaintBackground(PaintEventArgs pevent) {

 // He разрешаем перерисовывать фон

}

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

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

Хлеб — всему голова

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

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

Обработчики событий используют перечисления Keys, показывающие конкретные кнопки навигации. Соответствующий код приведен в листинге 11.15.

Листинг 11.15

/// <summary>

/// Используем keyArgs в качестве флага

/// </summary>

private System.Windows.Forms.KeyEventArgs keyArgs = null;


private void Form1_KeyDown(object sender,

 System.Windows.Forms.KeyEventArgs e) {

 keyArgs = e;

}


private void Form1_KeyUp(object sender, System.Windows.Forms.KeyEventArgs e) {

 keyArgs = null;

}

Когда программа получает вызов события Form1_KeyDown, флаг keyArgs ссылается на класс KeyEventArgs. При наступлении события Form1_KeyUp флаг keyArgs сбрасывается в null, и код нажатых клавиш игнорируется. Теперь надо переписать метод updatePositions, как показано в листинге 11.16.

Листинг 11.16

private void updatePositions() {

 // Код для кусочка сыра остался прежним

 ...


 // Для батона хлеба

 if (keyArgs != null) {

  switch (keyArgs.KeyCode) {

  case Keys.Up:

   by-=ySpeed;

   break;

  case Keys.Down:

   by+=ySpeed;

   break;

  case Keys.Left:

   bx-=xSpeed;

   break;

  case Keys.Right:

   bx+=xSpeed;

   break;

  }

 }

}

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

Обнаружение столкновений

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

Рис. 11.4. Ограничивающий прямоугольник для объекта

Две точки позволяют оперировать координатами верхнего левого и нижнего правого углов прямоугольника. В .NET Compact Framework существует структура RECTANGLE, использующая эти координаты для реализации прямоугольника. Несколько методов используют эту структуру для обнаружения пересечения двух прямоугольников. С их помощью и можно обнаружить столкновение объектов. Ранее использовавшиеся переменные надо заменить структурой RECTANGLE, в которой будет содержаться информация о местонахождении объекта. Соответствующий код приведен в листинге 11.17.

Листинг 11.17

/// <summary>

/// Позиция и ограничивающий прямоугольник для сыра

/// </summary>

private Rectangle cheeseRectangle;


/// <summary>

/// Позиция и ограничивающий прямоугольник для батона хлеба

/// </summary>

private Rectangle breadRectangle;

Сразу после загрузки изображений надо ввести код, приведенный в листинге 11.18.

Листинг 11.18

// Получим координаты и ограничивающие прямоугольники

cheeseRectangle = new Rectangle(0, 0, cheeseImage.Width.cheeseImage.Height);

breadRectangle = new Rectangle(0, 0, breadImage.Width, breadImage.Height);

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

Листинг 11.19

g.DrawImage(breadImage, breadRectangle.X, breadRectangle.Y);

g.DrawImage(cheeseImage, cheeseRectangle.X, cheeseRectangle.Y);

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

Листинг 11.20

private void updatePositions() {

 // Движение кусочка сыра

 if (goingRight) {

  cheeseRectangle.X += xSpeed;

 } else {

  cheeseRectangle.X -= xSpeed;

 }

 if ((cheeseRectangle.X + cheeseImage.Width) >= this.Width) {

  goingRight = false;

 }

 if (cheeseRectangle.X <= 0) {

  goingRight = true;

 }

 if (goingDown) {

  cheeseRectangle.Y += ySpeed;

 } else {

  cheeseRectangle.Y -= ySpeed;

 }

 if ((cheeseRectangle.Y + cheeseImage.Height) >= this.Height) {

  goingDown = false;

 }

 if (cheeseRectangle.Y <= 0) {

  goingDown = true;

 }


 // Управление батоном

 if (keyArgs != null) {

  switch (keyArgs.KeyCode) {

  case Keys.Up:

   breadRectangle.Y -= ySpeed;

   break;

  case Keys.Down:

   breadRectangle.Y += ySpeed;

   break;

  case Keys.Left:

   breadRectangle.X -= xSpeed;

   break;

  case Keys.Right:

   breadRectangle.X += xSpeed;

   break;

  }

 }

 /// и далее...

Когда сыр ударяется о батон хлеба, он должен отскочить. Этого эффекта можно добиться, просто изменив направления движения по оси Y в методе updatePosition, как показано в листинге 11.21.

Листинг 11.21

// Проверка на столкновение

if (cheeseRectangle.IntersectsWith(breadRectangle)) {

 goingDown = !goingDown;

}

Метод IntersectsWith принимает параметры прямоугольников. Если они пересекаются, то возвращается значение True, после чего меняется направление движения сыра.

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

Столкновения батона и мяча

Хотя код вполне нормально работает, все-таки хочется больше реализма. Отвлечемся на минутку и рассмотрим пример столкновений мячей с круглым предметом (рис. 11.5).

Рис. 11.5. Столкновение круглых объектов

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

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

Рис. 11.6. Виды столкновений

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

Листинг 11.22

if (goingDown) {

 // если сыр движется вниз

 if (cheeseRectangle.IntersectsWith(breadRectangle)) {

  // столкновение

  bool rightIn =

   breadRectangle.Contains(cheeseRectangle.Right, cheeseRectangle.Bottom);

  bool leftIn =

   breadRectangle.Contains(cheeseRectangle.Left, cheeseRectangle.Bottom);

  // способ отражения

  if (rightIn & leftIn) {

   // отражается вверх

   goingDown = false;

  } else {

   // отражается вверх

   goingDown = false;

   // в зависимости от вида столкновений

   if (rightIn) {

    goingRight = false;

   }

   if (leftIn) {

    goingRight = true;

   }

  }

 }

}

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

Новые объекты

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

Листинг 11.23

/// <summary>

/// Изображение, содержащее помидор

/// </summary>

private Image tomatoImage = null;


// Получаем изображение помидора

tomatoImage = new System.Drawing.Bitmap(

 execAssem.GetManifestResourceStream(@"Bouncer.tomato.gif"));

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

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

Листинг 11.24

/// <summary>

/// Позиция и состояние помидора

/// </summary>

struct tomato {

 public Rectangle rectangle;

 public bool visible;

}

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

Размещение помидоров

Нужно создать массив помидоров для размещения на экране, как показано в листинге 11.25.

Листинг 11.25

/// <summary>

/// Расстояние между помидорами.

/// Устанавливаем один раз для игры

/// </summary>

private int tomatoSpacing = 4;


/// <summary>

/// Высота, на которой рисуется помидор

/// Высота может меняться в процессе игры

/// Начинаем с верхней части экрана

/// </summary>

private int tomatoDrawHeight = 4;


/// <summary>

/// Количество помидоров на экране.

/// Устанавливается при старте игры

/// методом initialiseTomatoes.

/// </summary>

private int noOfTomatoes;


/// <summary>

/// Позиции всех помидоров на экране

/// </summary>

private tomato[] tomatoes;

При усложнении игры помидоры должны отображаться все ниже и ниже, заставляя пользователя действовать интуитивно. Переменная tomatoDrawHeight будет отвечать за эту задачу. Для инициализации местоположения помидоров нужно создать функцию initialiseTomatos, которая использует размеры помидоров и экрана. Ее код приведен в листинге 11.26.

Листинг 11.26

/// <summary>

/// Вызывается один раз для установки всех помидоров

/// </summary>

private void initialiseTomatoes() {

 noOfTomatoes =

  (this.ClientSize.Width - tomatoSpacing) /

  (tomatoImage.Width + tomatoSpacing);

 // создаем массив, содержащий позиции помидоров

 tomatoes = new tomato[noOfTomatoes];

 // Координата x каждого помидора

 int tomatoX = tomatoSpacing / 2;

 for (int i = 0; i < tomatoes.Length; i++) {

  tomatoes[i].rectangle =

   new Rectangle(tomatoX, tomatoDrawHeight,

   tomatoImage.Width, tomatoImage.Height);

   tomatoX = tomatoX + tomatoImage.Width + tomatoSpacing;

 }

}

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

Листинг 11.27

/// <summary>

/// Вызывается для создания ряда помидоров.

/// </summary>

private void placeTomatoes() {

 for (int i = 0; i < tomatoes.Length; i++) {

  tomatoes[i].rectangle.Y = tomatoDrawHeight;

  tomatoes[i].visible = true;

 }

}

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

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

Листинг 11.28

for (int i = 0; i < tomatoes.Length; i++) {

 if (tomatoes[i].visible) {

  g.DrawImage(tomatoImage, tomatoes[i].rectangle.X, tomatoes[i].rectangle.Y);

 }

}

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

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

Листинг 11.29

breadRectangle = new Rectanglе(

 (this.ClientSize.Width - breadImage.Width) / 2,

 this.ClientSize.Height — breadImage.Height,

 breadImage.Width, breadImage.Height);

Теперь игра выглядит так, как показано на рис. 11.7

Рис. 11.7. Внешний вид игры

Уничтожение томатов

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

Листинг 11.30

// Уничтожаем помидоры при столкновении с сыром

for (int i = 0; i < tomatoes.Length; i++) {

 if (!tomatoes[i].visible) {

  continue;

 }

 if (cheeseRectangle.IntersectsWith(tomatoes[i].rectangle)) {

  // прячем томат

  tomatoes[i].visible = false;

  // отражаемся вниз

  goingDown = true;

  // только удаляем помидор

  break;

 }

}

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

Счет игры

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

Листинг 11.31

/// <summary>

/// Шрифт для вывода счета

/// </summary>

private Font messageFont = null;


// Создадим шрифт для показа набранных очков

messageFont = new Font(FontFamily.GenericSansSerif, 10, FontStyle.Regular);

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

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

Листинг 11.32

/// <summary>

/// Прямоугольник, в котором будет отображаться счет игры

/// </summary>

private Rectangle messageRectangle;


/// <summary>

/// Высота панели для счета.

/// </summary>

private int scoreHeight = 15;


// Устанавливаем размеры прямоугольника для счета

messageRectangle = new Rectanglе(0, 0, this.ClientSize.Width, scoreHeight);

Если прямоугольник будет слишком мал для текста, то текст будет обрезаться при отображении.

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

Листинг 11.33

/// <summary>

/// Кисть, используемая для отображения сообщений

/// </summary>

private SolidBrush messageBrush;


// Выбираем красную кисть

messageBrush = new SolidBrush(Color.Red);

Текст счета игры на экране будет отображаться красным цветом. Чтобы вывести сообщение на экран, понадобится вызвать метод DrawString в событии Form1_Paint, как показано в листинге 11.34.

Листинг 11.34

/// <summary>

/// Строка для вывода сообщений

/// </summary>

private string messageString = "Нажмите Старт для начала игры";

g.DrawString(messageString, messageFont, messageBrush, messageRectangle);

Созданная переменная messageString применяется для вывода сообщений на экран во время игры.

Ведение счета

Теперь нужно научиться обновлять счетчик столкновения томатов в методе updatePosition. Код для этого приведен в листинге 11.35.

Листинг 11.35

/// <summary>

/// Счет в игре

/// </summary>

private int scoreValue = 0;


private void updatePositions() {

 if (cheeseRectangle.IntersectsWith(tomatoes[i].rectangle)) {

  // прячем томат

  tomatoes[i].visible = false;

  // отражаемся вниз

  goingDown = true;

  // обновляем счет

  scoreValue = scoreValue + 10;

  messageString = "Счет: " + scoreValue;

  break;

 }

}

За каждый уничтоженный томат начисляется 10 очков. Эти данные постоянно обновляются и выводятся на экран.

Звуковые эффекты

Неплохо бы добавить в игру звуковые эффекты. К сожалению, библиотека .NET Compact Framework пока не поддерживает воспроизведение звуковых файлов при помощи управляемого кода. Поэтому придется воспользоваться механизмом Platform Invoke (P/Invoke). В главе, посвященной вызовам функций Windows API, эта тема будет освещаться подробнее

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

В этом проекте требуется создать отдельный класс для воспроизведения звуков. Нужно щелкнуть правой кнопкой мыши на проекте Bouncer в окне Solution Explorer и выполнить команду контекстного меню Add►New Item... В открывшемся окне нужно выбрать элемент Class и задать имя Sound.cs. После нажатия кнопки Add новый класс будет добавлен в проект.

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

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

Листинг 11.36

using System.Runtime.InteropServices;

using System.IO;

Наш пример со звуком просто хранит в памяти байтовый массив с аудиоматериалом. Для обращения к этому блоку используется функция операционной системы, способная производить звуки. В классе Sound блок памяти объявляется так, как показано в листинге 11.37.

Листинг 11.37

/// <summary>

/// массив байтов, содержащий данные о звуке

/// </summary>

private byte[] soundBytes;

Эта конструкция не создает массив, а только объявляет его. Массив будет создан при конструировании экземпляра класса, ведь изначально размер звукового файла неизвестен.

Код конструктора приведен в листинге 11.38.

Листинг 11.38

/// <summary>

/// Создание экземпляра sound и хранение данных о звуке

/// </summary>

/// <param name="soundStream">поток для чтения звука</param>

public Sound(Stream soundStream) {

 // создаем массив байтов для приема данных

 soundBytes = new byte[soundStream.Length];

 // читаем данные из потока

 soundStream.Read(soundBytes, 0, (int)soundStream.Length);

}

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

В проект надо добавить звуковые файлы click.wav и burp.wav и для их свойства Build Action задать значение Embedded Resources. Теперь доступ к звуковым файлам получить очень просто, что иллюстрирует код, приведенный в листинге 11.39.

Листинг 11.39

/// <summary>

/// Звук, воспроизводимый при столкновении с батоном хлеба

/// </summary>

private Sound batHitSound;


/// <summary>

/// Звук, воспроизводимый при столкновении с помидором

/// </summary>

private Sound tomatoHitSound;


// Получим звук при столкновении с батоном хлеба

batHitSound = new Sound

 (execAssem.GetManifestResourceStream(@"Bouncer.click.wav"));


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

tomatoHitSound = new Sound

 (execAssem.GetManifestResourceStream(@"Bouncer.burp.wav"));

Для воспроизведения звука в класс Sound надо добавить метод Play, как показано в листинге 11.40.

Листинг 11.40

/// <summary>

/// Управление звуком в игре (Включать или выключать)

/// </summary>

public static bool Enabled = true;


/// <summary>

/// Проигрываем звук

/// </summary>

public void Play() {

 if (Sound.Enabled) {

  WCE_PlaySoundBytes(soundBytes, IntPtr.Zero,

   (int)(Flags.SND_ASYNC | Flags.SND_MEMORY));

 }

}

Метод Play проверяет флаг переменной Enabled. С его помощью можно легко включать или выключать звук в игре. Воспроизведение звука обеспечивается вызовом функции Windows API WCE_PlaySoundBytes, что иллюстрирует код, приведенный в листинге 11.41.

Листинг 11.41

private enum Flags {

 SND_SYNC = 0x0000,

 SND_ASYNC = 0x0001,

 SND_NODEFAULT = 0x0002,

 SND_MEMORY = 0x0004,

 SND_LOOP = 0x0008,

 SND_NOSTOP = 0x0010,

 SND_NOWAIT = 0x00002000,

 SND_ALIAS = 0x00010000,

 SND_ALIASID = 0x00110000,

 SND_FILENAME = 0x00020000,

 SND_RESOURCE = 0x00040004

}


/// <summary>

/// Функция Windows API для воспроизведения звука.

/// </summary>

/// <param name="szSound">Массив байтов, содержащих данные /// </param>

/// <param name="hMod">Дескриптор к модулю, содержащему звуковой

/// ресурс</param>

/// <param name="flags">Флаги для управления звуком</param>

/// <returns></returns>

[DllImport("CoreDll.DLL", EntryPoint = "PlaySound", SetLastError = true)]

private extern static int WCE_PlaySoundBytes( byte[] szSound,

 IntPtr hMod, int flags);

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

Листинг 11.42

// если сыр движется вниз

if (cheeseRectangle.IntersectsWith(breadRectangle)) {

 // столкновение

 // воспроизводим удар

 batHitSound.Play();

}

Можете запустить проект, чтобы проверить работу звука. Также можно добавить звук при столкновении сыра с помидорами. Этот код приведен в листинге 11.43.

Листинг 11.43

if (cheeseRectangle.IntersectsWith(tomatoes[i].rectangle)) {

 // воспроизводим звук столкновения сыра с помидором

 tomatoHitSound.Play();

}

Дальнейшие улучшения

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

□ Режим «attract», включающийся, когда пользователь не играет.

□ Потеря жизни, если сыр ударился о нижнюю границу экрана.

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

□ Добавление в игру случайных элементов.

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

Для этого потребуется изменить метод, выполняющийся при старте игры. Новая версия приведена в листинге 11.44.

Листинг 11.44

/// <summary>

/// True, если игра запущена на экране.

/// </summary>

private bool gameLive = false;


/// <summary>

/// Число оставшихся жизней.

/// </summary>

private int livesLeft;


/// <summary>

/// Число жизней, доступных для игрока.

/// </summary>

private int startLives = 3;


private void startGame() {

 // Устанавливаем число жизней, счет и сообщения

 livesLeft = startLives;

 scoreValue = 0;

 messageString = "Счет: 0 Жизнь: " + livesLeft;


 // Располагаем помидоры наверху экрана

 tomatoDrawHeight = tomatoLevelStartHeight;

 placeTomatoes();


 // Поместим батон в центре экрана

 breadRectangle.X = (this.ClientSize.Width - breadRectangle.Width) / 2;

 breadRectangle.Y = this.ClientSize.Height / 2;


 // Поместим сыр над батоном в центре экрана

 cheeseRectangle.X = (this.ClientSize.Width - cheeseRectanglе.Width) / 2;

 cheeseRectangle.Y = breadRectangle.Y — cheeseRectangle.Height;


 // Установим начальную скорость

 xSpeed = 1;

 ySpeed = 1;


 // Установим флаг, позволяющий начать игру

 gameLive = true;

}

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

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

Соответствующий код приведен в листинге 11.45.

Листинг 11.45

if ((cheeseRectangle.Y + cheeseImage.Height) >= this.Height) {

 // сыр достиг нижней границы экрана

 loseLife();

 goingDown = false;

}

Метод loseLife подсчитывает количество оставшихся жизней и заканчивает игру, если все жизни были израсходованы. Также метод может показывать лучший достигнутый счет игры. Его код приведен в листинге 11.46.

Листинг 11.46

private void loseLife() {

 if (!gameLive) {

  return;

 }

 // Потеряли еще одну жизнь

 livesLeft--;

 if (livesLeft > 0) {

  // обновим сообщение на экране

  messageString = "Счет: " + scoreValue + " Жизнь: " + livesLeft;

 } else {

  // Останавливаем игру

  gameLive = false;

  // сравниваем с лучшим результатом

  if (scoreValue > highScoreValue) {

   highScoreValue = scoreValue;

  }

  // меняем сообщение на экране

  messageString = "Лучший результат: " + highScoreValue;

 }

}

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

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

Листинг 11.47

bool gotTomato = false;

for (int i = 0; i < tomatoes.Length; i++) {

 if (tomatoes[i].visible) {

  gotTomato = true;

  g.DrawImage(tomatoImage, tomatoes[i].rectangle.X, tomatoes[i].rectangle.Y);

 }

}

if (!gotTomato) {

 newLevel();

}

Если пользователь выбил все томаты, то вызывается метод newLevel. Метод просто перерисовывает томаты и увеличивает скорость, как показано в листинге 11.48.

Листинг 11.48

private void newLevel() {

 if (!gameLive) {

  return;

 }

 // Рисуем помидоры чуть ниже

 tomatoDrawHeight += tomatoSpacing;

 if (tomatoDrawHeight >

  (ClientSize.Height - (breadRectangle.Height+tomatoImage.Height))) {

  // Рисуем помидоры снова в верхней части экрана

  tomatoDrawHeight = tomatoLevelStartHeight;

 }

 placeTomatoes(); // Увеличиваем скорость

 if (xSpeed < maxSpeed) {

  xSpeed++;

  ySpeed++;

 }

}

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

Тестирование

Игра практически готова. Теперь нужно протестировать ее. Чтобы не играть самому несколько часов, надо поручить эту работу компьютеру. Достаточно лишь изменить метод updatePosition, как показано в листинге 11.49.

Листинг 11.49 Тестирование программы в автоматическом режиме

/// <summary>

/// Тестирование программы. Батон автоматически отслеживает

/// движение сыра

/// </summary>

private bool testingGame = true;

if (testingGame) {

 breadRectangle.X = cheeseRectangle.X;

 breadRectangle.Y = ClientSize.Height - breadRectangle.Height;

}

Булева переменная testingGame может принять значение True. В этом случае позиция батона всегда будет соответствовать позиции сыра. В этом состоянии игра будет действовать сама, без участия пользователя и без потери жизней. Можно откинуться на спинку кресла и отдыхать.

И опять добавляем новые объекты

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

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

Листинг 11.50

/// <summary>

/// Изображение ветчины

/// </summary>

private Image bonusHamImage = null;


/// <summary>

/// Позиция и ограничивающий прямоугольник для ветчины

/// </summary>

private Rectangle bonusHamRectangle;


/// <summary>

/// Звук, воспроизводимый при столкновении с ветчиной

/// </summary>

private Sound bonusHamSound;


// Получим изображение ветчины

bonusHamImage = new System.Drawing.Bitmap(

 execAssem.GetManifestResourceStream(@"Bouncer.ham.gif"));


// Создадим прямоугольник для ветчины

bonusHamRectanglе =

 new Rectanglе(0, 0, bonusHamImage.Width, bonusHamImage.Height);


// Получим звук при столкновении с ветчиной

bonusHamSound = new

 Sound(execAssem.GetManifestResourceStream((@"Bouncer.pig.wav"));

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

Листинг 11.51

/// <summary>

/// True, если ветчина на экране

/// </summary>

private bool hamPresent = false;


/// <summary>

/// Интервал от 0 до 10. Чем выше значение,

/// тем чаще ветчина появляется на экране

/// </summary>

private int hamLikelihood = 5;


/// <summary>

/// Отчет времени перед исчезновением ветчины.

/// Устанавливаем случайное число при появлении ветчины.

/// </summary>

private int hamTimerCount;


/// <summary>

/// Случайное число.

/// </summary>

private Random randomNumbers;


/// <summary>

/// Вызывается для активизации ветчины

/// </summary>

private void startHam() {

 // не продолжать, если ветчина уже есть на экране

 if (hamPresent) {

  return;

 }

 // решаем, как часто выводить ветчину на экран

 if (randomNumbers.Next(10) > hamLikelihood) {

  // не выводить ветчину на экран

  return;

 }

 // позиция ветчины в случайной позиции на экране

 bonusHamRectangle.X =

  randomNumbers.Next(ClientSize.Width — bonusHamRectangle.Width);

 bonusHamRectangle.Y =

  randomNumbers.Next(ClientSize.Height - bonusHamRectangle.Height);

 // как долго держится изображение ветчины на экране

 // (по крайне мере 50 тиков)

 hamTimerCount = 50 + randomNumbers.Next(100);

 // делаем ветчину видимой

 hamPresent = true;

}

На первый взгляд код кажется сложным. Но все очень просто. Метод вызывается каждый раз при столкновении сыра с томатом. Если ветчина уже отображается на экране, то метод ничего не делает. Если ветчины на экране нет, то программа использует случайное число для принятия решения, нужно ли показывать на экране изображение. Генерируется случайное число в промежутке от 0 до 10. Ветчина не выводится, если это число больше, чем заданная переменная.

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

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

Листинг 11.52

/// <summary>

/// Обновляем состояние ветчины

/// </summary>

private void hamTick() {

 // ничего не делаем, если ветчина невидима

 if (!hamPresent) {

  return;

 }

 if (breadRectangle.IntersectsWith(bonusHamRectangle)) {

  // при касании игроком куска ветчины

  // прибавляем 100 очков

  scoreValue = scoreValue + 100;

  messageString = "Счет: " + scoreValue + " Жизнь: " + livesLeft;

  // звук касания ветчины

  bonusHamSound.Play();

  // прячем ветчину с экрана

  hamPresent = false;

 } else {

  // Отчитываем время назад

  hamTimerCount--;

  if (hamTimerCount == 0) {

   // время вышло - удаляем ветчину

   hamPresent = false;

  }

 }

}

Также надо изменить код методов Form1_Paint и updatePosition. Если изображения батона и ветчины пересекаются, то нужно увеличить счет и удалить изображение ветчины. В ином случае надо уменьшить время отображения ветчины или удалить это изображение, если соответствующий период времени уже закончился. Соответствующий код приведен в листинге 11.53.

Листинг 11.53

//(Form1_Paint)

// Выводим на экран кусок ветчины

if (hamPresent) {

 g.DrawImage(bonusHamImage, bonusHamRectangle.X, bonusHamRectangle.Y);

}

//(updatePosition)

// Активизируем ветчину

startHam();

//(timerTick)

hamTick();

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

Управление таблицей результатов

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

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

Новую форму надо добавить в проект и задать для нее имя HighScore.cs. На созданной форме следует разместить текстовое поле для ввода имени и меню, которое сигнализирует об окончании ввода. Созданная форма будет отображаться при достижении высокого результата. В этом случае игрок-рекордсмен вводит свое имя и нажимает на пункт меню OK для закрытия формы и сохранения имени.

Переключение между формами

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

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

При старте программы создается экземпляр формы HighScore. Данный экземпляр имеет ссылку на родительскую форму. При достижении высокого результата форма HighScore выводится на экран. При этом выполняется метод HighScore_Load, который скрывает родительскую форму. На экране появляется форма, отображающая лучшие результаты, игрок вводит свое имя и выполняет команду меню OK. При этом срабатывает обработчик события для меню OK, которое закрывает форму HighScore. При закрытии формы выполняется метод HighScore_Closing. Основное окно формы снова появляется на экране. Код главной формы извлекает имя игрока из формы HighScore.

Итак, метод HighScore_Load должен скрыть родительскую форму. Для этого метод должен использовать ссылку на главное окно. Ссылка на родительское окно передается в форму HighScore при ее создании, как показано в листинге 11.54.

Листинг 11.54

/// <summary>

/// Родительское окно, из которого вызывается данное окно.

/// Используется при закрытии данного окна.

/// </summary>

private Form parentForm;


public HighScore(Form inParentForm) {

 // Сохраняем родительское окно при закрытии окна лучших

 // результатов.

 parentForm = inParentForm;

 InitializeComponent();

}

Этот код является конструктором формы HighScore. Когда идет создание формы, то передается ссылка на родительскую форму.

Код метода HighScore_Load приведен в листинге 11.55.

Листинг 11.55

private void HighScore_Load(object sender, System.EventArgs e) {

 parentForm.Hide();

}

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

Листинг 11.56

private void HighScore_Closing(object sender,

 System.ComponentModel.CancelEventArgs e) {

 parentForm.Show();

}

После ввода имени игрок выполняет команду меню OK для закрытия формы. Обработчик этого события приведен в листинге 11.57.

Листинг 11.57

private void doneMenuItem_Click(object sender, System.EventArgs e) {

 Close();

}

После закрытия окна вызывается обработчик события, который выводит главное окно на экран.

Отображение дочернего окна

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

Листинг 11.58

/// <summary>

/// Форма для ввода имени игрока с лучшим результатом.

/// </summary>

private HighScore highScore;

// Создаем форму для лучших результатов

highScore = new HighScore(this);

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

Листинг 11.59

if (scoreValue > highScoreValue) {

 timer1.Enabled=false;

 // Показываем форму для лучших результатов

 highScore.ShowDialog();

 timer1.Enabled=true;

}

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

Получение имени игрока

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

Листинг 11.60

/// <summary>

/// Имя игрока, введенное в текстовом поле.

/// </summary>

public string PlayerName {

 get {

  return nameTextBox.Text;

 }

}

Свойство Name извлекает имя из текстового поля nameTextBox и возвращает его тому, кто вызывал данное свойство. Это свойство используется в программе, как показано в листинге 11.61.

Листинг 11.61

/// <summary>

/// Имя игрока, достигшего лучшего результата.

/// </summary>

private string highScorePlayer = "Rob";


if (scoreValue > highScoreValue) {

 highScoreValue = scoreValue;

 timer1.Enabled = false;

 highScore.ShowDialog();

 timer1.Enabled = true;

 highScorePlayer = highScore.PlayerName;

}

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

Хранение лучших результатов

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

Листинг 11.62

/// <summary>

/// Папка, в которой находится программа.

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

/// </summary>

private string applicationDirectory;


// Получим имя файла программы из текущей сборки

string appFilePath =

 execAssem.GetModules()[0].FullyQualifiedName;

// Выделяем из полного пути имени файла только путь к файлу

applicationDirectory =

 System.IO.Path.GetDirectoryName(appFilePath);

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

if (!applicationDirectory.EndsWith(@"\")) {

 applicationDirectory += @"\";

}

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

Листинг 11.63

/// <summary>

/// Имя файла для хранения лучших результатов.

/// </summary>

private string highScoreFile = "highscore.bin";


/// <summary>

/// Сохраняем лучший результат в файле.

/// </summary>

public void SaveHighScore() {

 System.IO.TextWriter writer = null;

 try {

  writer = new System.IO.StreamWriter(

   applicationDirectory + highScoreFile);

  writer.WriteLine(highScorePlayer);

  writer.WriteLine(highScoreValue);

 } catch {}

 finally {

  if (writer != null) {

   writer.Close();

  }

 }

}

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

Листинг 11.64

/// <summary>

/// Загружаем лучший результат из файла.

/// </summary>

public void LoadHighScore() {

 System.IO.TextReader reader = null;

 try {

  reader = new System.IO.StreamReader(applicationDirectory + highScoreFile);

  highScorePlayer = reader.ReadLine();

  string highScoreString = reader.ReadLine();

  highScoreValue = int.Parse(highScoreString);

 } catch {}

 finally {

  if (reader != null) {

   reader.Close();

  }

 }

}

Улучшение графики

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

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

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

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

Листинг 11.65

/// <summary>

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

/// </summary>

private System.Drawing.Imaging.ImageAttributes transparentWhite;


// Задаем белую маску.

transparentWhite = new System.Drawing.Imaging.ImageAttributes();

transparentWhite.SetColorKey(Color.White, Color.White);

Напомню, что в .NET Framework метод SetColorKey принимает ряд цветов, а в .NET Compact Framework один и тот же цвет дается дважды. Этот цвет будет прозрачным для всех картинок, отображаемых с помощью класса ImageAttribute. Если в игре понадобятся белые цвета, то они не должны быть совершенно белыми.

Объекты игры были созданы так, чтобы их фон был абсолютно белым. Значения атрибутов, используемых при рисовании кусочка сыра, реализованы так, как показано в листинге 11.66. Для других объектов код будет абсолютно таким же.

Листинг 11.66

// Выводим на экран кусочек сыра

g.DrawImage(

 cheeseImage,            // Image

 cheeseRectangle,        // Dest.rect

 0,                      // srcX

 0,                      // srcY

 cheeseRectangle.Width,  // srcWidth

 cheeseRectangle.Height, // srcHeight

 GraphicsUnit.Pixel,     // srcUnit

 transparentWhite);      // ImageAttributes

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

Итак, мы рисуем прозрачные области для батона, куска сыра и ветчины. Мы обошли вниманием помидоры, которые пока не перекрываются. Этот недостаток будет исправлен чуть позже. В качестве украшения надо добавить фоновую картинку в виде красочной скатерти (рис. 11.8).

Рис. 11.8. Фон для игры

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

Добавить фон не так уж и трудно. Вместо заливки экрана белым цветом в каждом кадре надо просто отрисовать этот узор. Следует объявить новую переменную backgroundImage для картинки-фона, загрузить изображение из ресурсов и изменить код в методе Form1_Paint, как показано в листинге 11.67.

Листинг 11.67

/// <summary>

/// Изображение, содержащее фон игры.

/// </summary>

private Image backgroundImage = null;


// Получим изображение фона игры

backgroundImage = new System.Drawing.Bitmap(

 execAssem.GetManifestResourceStream(@"Bouncer.tablecloth.gif"));


g.DrawImage(backgroundImage, 0, 0);

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

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

Спрайты

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

Рис. 11.9. Структура экрана

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

Средний слой — это спрайты, которые неподвижны. Их не нужно постоянно перерисовывать. Они меняют свое состояние только при ударах кусочка сыра или при запуске нового уровня. За них отвечает класс BackSprite.

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

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

Основной движок игры просто управляет движением передних спрайтов, а также отслеживает состояние и позицию фоновых спрайтов. Данная версия библиотеки спрайтов немного отличается от прежней версии игры. Сыр теперь уничтожает томаты при движении вниз к нижней части экрана. Сыр может застрять позади линии томатов, набирая тем самым призовые очки. Автор игры автор Роб Майлз предлагает изучить применение спрайтов на примере другой игры, «Salad Rescue». Вам придется самостоятельно изучить эту игру.

Версия игры, использующая спрайты, располагается в папке BouncerSprite, которая входит в состав материалов для книги, расположенных на сайте издательства «Питер».

Другие игры

Как уже говорилось ранее, в документации MSDN имеется множество примеров различных игр. Если вы проявите настойчивость, то самостоятельно найдете эти примеры и сможете разобрать их. Также стоит посетить сайт CodeProject, где по адресу www.codeproject.com/netcf/#Games расположился специальный подраздел, посвященный играм для .NET Compact Framework (рис. 11.10).

Рис. 11.10. Сайт CodeProject, посвященный играм для .NET Compact Framework

Глава 12 Связь

Инфракрасное соединение

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

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

История и теория

Основанная в 1993 году как некоммерческая организация, Ассоциация инфракрасной передачи данных (Infrared Data Association, или сокращенно IrDA) является международной ассоциацией (www.irda.org), создающей и продвигающей стандарты инфракрасной связи, позволяющие пользователям соединять устройства для передачи данных. Стандарты Infrared Data Association поддерживают огромное число устройств. На данный момент существует несколько версий технологии IrDA, которые различаются скоростью передачи данных.

Протокол IrDA позволяет соединяться с другим устройством без проводов при помощи ИК-излучения. Порт IrDA позволяет устанавливать связь на расстоянии до 1-2 метров. Интерфейс IrDA предполагает малую мощность потребления, что позволяет создавать недорогую продукцию.

Класс IrDAClient

Практически все устройства под управлением Windows Mobile имеют встроенные инфракрасные порты. Библиотека .NET Compact Framework имеет в своем составе классы, позволяющие работать с инфракрасной связью.

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

За инфракрасное соединение отвечает специальный класс IrDAClient, который может выступать и в роли сервера, и в роли клиента. Данный класс входит в библиотеку System.Net.IrDA.dll. Таким образом, при использовании класса IrDAClient необходимо добавить в проект ссылку на указанную библиотеку.

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

1. Создать новый экземпляр класса IrDAClient.

2. Получить список доступных устройств с помощью метода IrDAClient.DiscoverDevices. Можно ограничить количество опрашиваемых устройств при помощи параметра maxDevices. Метод DiscoverDevices возвращает массив объектов IrDADeviceInfo.

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

4. Если подобное устройство найдено, то при помощи метода IrDAClient.Connect производится соединение. При этом необходимо указать имя службы

Создание программы для работы с ИК-связью

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

Кнопка butFindDevs предназначена для поиска устройств, кнопка butSend — для отправки текстового сообщения, а кнопка butReceive служит для приема сообщения. В списке listBox1 будет отображаться информация об обнаруженных устройствах, а в строке состояния будут отображаться сообщения о производимых операциях. Для передачи данных и работы с файлами нам необходимо импортировать несколько пространств имен, как это показано в листинге 12.1.

Листинг 12.1

Imports System.Net

Imports System.IO

Imports System.Net.Sockets

Для работы с инфракрасной связью необходимо подключить к проекту класс IrDAClient. Для этого выполним команду меню Project►Add Reference и в диалоговом окне выберем пункт System.Net.IrDa.

Теперь нужно объявить переменные на уровне класса, как показано в листинге 12.2

Листинг 12.2

private IrDAListener irListen;

private IrDAClient irClient;

private IrDAEndPoint irEndP;

private IrDADeviceInfo[] irDevices;


string fileSend;

string fileReceive;

string irServiceName;


int buffersize;

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

Листинг 12.3

public Form1() {

 InitializeComponent();

 irClient = new IrDAClient();


 // Файлы, предназначенные для отправки и приема

 fileSend = ".\\My Documents\\send.txt";

 fileReceive = ".\\My Documents\\receive.txt";

 // Задаем имя для службы IrDA

 // Это может быть любое слово

 // Другие устройства для примера должны использовать это же

 // слово

 irServiceName = "IrDAFtp";


 // Устанавливаем максимальный размер буфера для передаваемого

 // файла

 buffersize = 256;


 // Делаем недоступными кнопки отправки и посылки сообщений

 // до тех пор, пока не будут обнаружены устройства

 butSend.Enabled = false;

 butReceive.Enabled = false;

}

Обнаружение устройств

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

Листинг 12.4

private void butFindDevs_Click(object sender, EventArgs e) {

 // Ищем доступные устройства с инфракрасной связью

 // и помещаем их в список

 // Поиск не более трех доступных устройств

 irDevices = irClient.DiscoverDevices(2);


 // Если устройства не найдены, то выводим сообщение

 if (irDevices.Length == 0) {

  MessageBox.Show("Устройства с ИК-портами не обнаружены!");

  return;

 }


 // Перечисляем массив IrDADeviceInfo

 // и выводим информацию о каждом устройстве в список

 string device;

 int ID;

 listBox1.Items.Clear();

 foreach (IrDADeviceInfo irDevice in irDevices) {

  ID = BitConverter.ToInt32(irDevice.DeviceID, 0);

  device =

   ID.ToString() + " " + irDevice.DeviceName + " " + irDevice.CharacterSet +

   " " + irDevice.Hints;

  listBox1.Items.Add(device);

 }


 listBox1.SelectedIndex = 0;

 if (irDevices.Length > 0)

  statusBar1.Text = irDevices.Length.ToString() + " устройств(а)";


 // Делаем доступными кнопки для отправки и посылки сообщения

 butSend.Enabled = true;

 butReceive.Enabled = true;

}

Передача данных

Код для отправки и посылки файлов приведен в листинге 12.5.

Листинг 12.5

private void butSend_Click(object sender, EventArgs e) {

 // Открываем файл для отправки и получаем его поток

 Stream fileStream;

 try {

  fileStream = new FileStream(fileSend, FileMode.Open);

 } catch (Exception exFile) {

  MessageBox.Show("Не могу открыть " + exFile.ToString());

  return;

 }


 // Создаем IrDA-клиент с установленным именем службы.

 // которое должно совпадать с именем службы на другом

 // IrDA-клиенте

 try {

  irClient = new IrDAClient(irServiceName);

 } catch (SocketException exS) {

  MessageBox.Show("Ошибка сокета: " + exS.Message +

   " - Вы щелкнули на кнопке Получить на другом устройстве?");

  return;

 }


 // Получим поток

 Stream baseStream = irClient.GetStream();


 // Получим размер отправляемого файла

 // и запишем это значение в поток

 byte[] length = BitConverter.GetBytes((int)fileStream.Length);

 baseStream.Write(length, 0, length.Length);


 // Создаем буфер для чтения файла

 byte[] buffer = new byte[buffersize];


 // Показываем число отправленных байт

 int fileLength = (int)fileStream.Length;

 statusBar1.Text = "Отправлено " + fileLength + " байт";


 // Читаем файловый поток в базовом потоке

 while (fileLength > 0) {

  int numRead = fileStream.Read(buffer, 0, buffer.Length);

  baseStream.Write(buffer, 0, numRead);

  fileLength -= numRead;

 }


 fileStream.Close();

 baseStream.Close();

 irClient.Close();

 statusBar1.Text = "Файл отправлен";

}


private void butReceive_Click(object sender, EventArgs e) {

 // Создаем поток для записи файла

 Stream writeStream;

 try {

  writeStream = new FileStream(fileReceive, FileMode.OpenOrCreate);

 } catch (Exception) {

  MessageBox.Show("Не могу открыть "+ fileReceive + " для записи");

  return;

 }


 // Создаем соединение с помощью класса IrDAEndPoint

 // для выбранного устройства из списка

 // Начинаем прослушку входящих сообщений

 // из устройства с объектом IrDAListener

 try {

  int i = listBox1.SelectedIndex;

  irEndP = new IrDAEndPoint(irDevices[i].DeviceID, irServiceName);

  irListen = new IrDAListener(irEndP);

  irListen.Start();

 } catch (SocketException exSoc) {

  MessageBox.Show("Не могу прослушивать на службе " + irServiceName + ": " +

   exSoc.ErrorCode);

 }


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

 statusBar1.Text = "Прослушка " + listBox1.SelectedItem.ToString();


 // Создаем соединение

 // для службы, обнаруженной прослушкой

 IrDAClient irClient;

 try {

  irClient = irListen.AcceptIrDAClient();

 } catch (SocketException exp) {

  MessageBox.Show("Не могу принять сокет "+ exp.ErrorCode);

  return;

 }


 // Показываем, идет ли передача файла

 if (irListen.Pending() == true)

  statusBar1.Text = "Передача из " + irClient.RemoteMachineName;

 else

  statusBar1.Text = "Нет передачи из " + irClient.RemoteMachineName;


 // Получим поток из клиента

 Stream baseStream = irClient.GetStream();

 int numToRead;

 // Создаем буфер для чтения файла

 byte[] buffer = new byte[buffersize];

 // Читаем поток данных, который содержит

 // данные из передающего устройства

 numToRead = 4;

 while (numToRead > 0) {

  int numRead = baseStream.Read(buffer, 0, numToRead);

  numToRead -= numRead;

 }


 // Получим размер буфера для показа

 // числа байт для записи в файл

 numToRead = BitConverter.ToInt32(buffer, 0);

 statusBar1.Text = "Записываем "+ numToRead + " байт";

 // Записываем поток в файл до тех пор,

 // пока не будут прочитаны все байты

 while (numToRead > 0) {

  int numRead = baseStream.Read(buffer, 0, buffer.Length);

  numToRead -= numRead;

  writeStream.Write(buffer, 0, numRead);

 }

 // Сообщаем, что файл получен

 statusBar1.Text = "Файл получен";

 baseStream.Close();

 writeStream.Close();

 irListen.Stop();

 irClient.Close();

}

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

Затем на втором устройстве надо нажать кнопку Принять, а на первом устройстве нажать кнопку Отправить. В результате ваших действий текст сообщения из файла send.txt должен быть передан на другое устройство и сохранен в файле receive.txt.

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

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

Технология Bluetooth

Несмотря на свою дешевизну и простоту, инфракрасное соединение имеет несколько существенных недостатков. К ним относятся маленький радиус действия и возможность связи в пределах прямой видимости. Этих недостатков лишено Bluetooth-соединение.

Но и тут не обошлось без ложки дегтя в бочке меда. Во-первых, существует два различных подхода к реализации Bluetooth-соединений, которые не совместимы друг с другом. Во-вторых, пока не существует поддержки этой технологии в управляемом коде .NET Compact Framework. Примеры с Bluetooth-связью мы будем приводить для устройств под управлением Windows Mobile 5.0, так как они гарантированно используют одну и ту же реализацию Bluetooth-технологии. Так как библиотека .NET Compact Framework не имеет в своем составе классов, работающих с Bluetooth, то придется воспользоваться вызовами функций Windows API, как показано в листинге 12.6.

Листинг 12.6

public enum RadioMode {

 Off = 0,

 Connectable = 1,

 Discoverable = 2

}


/// <summary>

/// Получает текущий статус bluetooth

/// </summary>

/// <param name="dwMode">флаги</param>

/// <returns></returns>

[DllImport("BthUtil.dll")]

public static extern int BthGetMode(out RadioMode dwMode);


/// <summary>

/// Устанавливает новый режим bluetooth

/// </summary>

/// <param name="dwMode">флаги для установки режима</param>

/// <returns></returns>

[DllImport("BthUtil.dll")]

public static extern int BthSetMode(RadioMode dwMode);


private void mnuOn_Click(object sender, EventArgs e) {

 BthSetMode(RadioMode.Connectable);

 lblStatus.Text = RadioMode.Connectable.ToString();

}


private void Form1_Load(object sender, EventArgs e) {

 RadioMode mode;

 int ret = BthGetMode(out mode);

 lblStatus.Text = mode.ToString();

}


private void mnuOff_Click(object sender, EventArgs e) {

 ВthSetMode(RadioMode.Off);

 lblStatus.Text = RadioMode.Off.ToString();

}

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

Несколько слов о связи

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

Глава 13 Использование неуправляемого кода

Несмотря на то что библиотека .NET Compact Framework имеет множество классов для выполнения самых разных задач, во многих случаях приходится прибегать к вызовам функций Windows API. А в некоторых случаях использование функций Windows API даже предпочтительнее, чем использование аналогичных методов управляемого кода, так как они позволяют оптимизировать и повысить производительность приложения.

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

Вызов функций Windows API

Для вызовов функций Windows API используется механизм P/Invoke. Большинство часто вызываемых функций находится в библиотеке coredll.dll.

Разработчики, которые пользовались функциями API в настольной версии Windows, наверняка обратят внимание на то, что эта библиотека coredll.dll содержит множество знакомых функций из библиотек kernel32.dll, gdi32.dll и user32.dll. Поэтому во многих случаях довольно легко будет перенести свои наработки из программ для настольного компьютера в приложения для мобильных устройств.

Определение платформы

Если нужно определить, на какой платформе запущено ваше приложение, то здесь вам не обойтись без вызова функции Windows API SystemParametersInfo.

Для начала нужно создать новый класс PlatformDetector, в котором следует объявить функцию SystemParametersInfo и методы определения платформы. А в обработчике события Load основной формы надо вызвать метод GetPlatform, чтобы узнать платформу сразу же после загрузки приложения, как это показано в листинге 13.1.

Листинг 13.1

using System;

using System.Collections.Generic;

using System.Text;

using System.Runtime.InteropServices;


namespace PlatformDetector_CS {

 class PlatformDetector {

  [DllImport("coredll.dll")]

  private static extern bool SystemParametersInfo(int uiAction, int uiParam,

   StringBuilder pvParam, int fWinIni);


  private static int SPI_GETPLATFORMTYPE = 257;


  public static Platform GetPlatform() {

   Platform plat = Platform.Unknown;

   switch (System.Environment.OSVersion.Platform) {

   case PlatformID.Win32NT:

    plat = Platform.Win32NT;

    break;

   case PlatformID.WinCE:

    plat = CheckWinCEPlatform();

    break;

   }

   return plat;

  }


  static Platform CheckWinCEPlatform() {

   Platform plat = Platform.WindowsCE;

   StringBuilder strbuild = new StringBuilder(200);

   SystemParametersInfо(SPI_GETPLATFORMTYPE, 200, strbuild, 0);

   string str = strbuild.ToString();

   switch (str) {

   case "PocketPC":

    plat = Platform.PocketPC;

    break;

   case "SmartPhone":

    // Note that the strbuild parameter from the

    // PInvoke returns "SmartPhone" with an

    // upper case P. The correct casing is

    // "Smartphone" with a lower case p.

    plat = Platform.Smartphone;

    break;

   }

   return plat;

  }

 }


 public enum Platform {

  PocketPC, WindowsCE, Smartphone, Win32NT, Unknown

 }

}


using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Drawing;

using System.Text;

using System.Windows.Forms;


namespace PlatformDetector_CS {

 public partial class Form1 : Form {

  public Form1() {

   InitializeComponent();

  }


  private void Form1_Load(object sender, EventArgs e) {

   try {

    MessageBox.Show("Платформа: " + PlatformDetector.GetPlatform());

   } catch (Exception ex) {

    MessageBox.Show(ex.Message.ToString());

   }

  }

 }

}

Особое внимание следует обратить на комментарий. Параметр strbuild после вызова функции возвращает значение SmartPhone с большой буквой «P», хотя более правильным вариантом считается слово с маленькой буквой «p».

Пароли

Как вы, вероятно, знаете, пользователь может установить пароль на свой карманный компьютер. Для этого ему нужно зайти в раздел Password при помощи последовательности команд Start►Settings►Password и указать четырехсимвольный пароль. С помощью четырех функций API можно получить сведения о пароле и даже попытаться угадать его!

Для тестирования этой возможности на форме надо разместить четыре кнопки и текстовое поле. Соответствующий код приведен в листинге 13.2.

Листинг 13.2

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

[DllImport("coredll.dll")]

private static extern bool SetPassword(string lpszOldpassword,

 string lspzNewPassword);


// Функция для активации или блокировки текущего пароля

[DllImport("coredll.dll")]

private static extern bool SetPasswordActive(bool bActive,

 string lpszPassword);


// Функция для определения текущего состояния пароля

[DllImport("coredll.dll")]

private static extern bool GetPasswordActive();


// Функция для проверки пароля [DllImport("coredll.dll")]

private static extern bool CheckPassword(string lpszPassword);


private void butCheckPass_Click(object sender, EventArgs e) {

 txtInfo.Text ="Активность пароля: " + GetPasswordActive().ToString();

}


private void butNewPass_Click(object sender, EventArgs e) {

 MessageBox.Show("Установка нового пароля " +

 SetPassword("Активность пароля: False", txtInfо.Text).ToString());

}


private void butSetState_Click(object sender, EventArgs e) {

 MessageBox.Show("Отключение пароля: " +

 SetPasswordActive(false, txtInfo.Text).ToString());

}


private void butFindPass_Click(object sender, EventArgs e) {

 MessageBox.Show("Угадали пароль? " + CheckPassword(txtInfo.Text).ToString());

}

ВНИМАНИЕ

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

Перезагрузка КПК

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

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

Листинг 13.3

public const uint FILE_DEVICE_HAL = 0x00000101;

public const uint METHOD_BUFFERED = 0;

public const uint FILE_ANY_ACCESS = 0;


public uint CTL_CODE(uint DeviceType, uint Function,

 uint Method, uint Access) {

 return

  ((DeviceType << 16) | (Access << 14) | (Function << 2) | Method);

}


[DllImport("Coredll.dll")]

public extern static uint KernelIoControl(

 uint dwIoControlCode, IntPtr lpInBuf, uint nInBufSize, IntPtr lpOutBuf,

 uint nOutBufSize, ref uint lpBytesReturned);


private void butReset_Click(object sender, EventArgs e) {

 uint bytesReturned = 0;

 uint IOCTL_HAL_REBOOT =

  CTL_CODE(FILE_DEVICE_HAL, 15, METHOD_BUFFERED, FILE ANY ACCESS);

 KernelIoControl(IOCTL_HAL_REBOOT, IntPtr.Zero, 0, IntPtr.Zero,

  0, ref bytesReturned);

}

Еще раз о перезагрузке

Для устройств, работающих под управлением Windows Mobile 5.0, существует более удобный способ перезагрузки. Он очень похож на код перезагрузки настольных компьютеров с использованием функции ExitWindowsEx. При этом надо обратить внимание на различия карманных компьютеров и смартфонов. Если КПК можно только перезагрузить, то смартфон можно и перезагрузить, и выключить. Соответствующий код приведен в листинге 13.4.

Листинг 13.4

[DllImport("aygshell.dll")]

public static extern System.Boolean ExitWindowsEx(int uFlags,

 int dwReserved);


const int EWX_REBOOT = 2; // перезагрузка

private void butReboot_Click(object sender, EventArgs e) {

 ExitWindowsEx(EWX_REBOOT, 0);

}

Поворот экрана

Начиная с версии операционной системы PocketPC 2003 Second Edition, карманные компьютеры научились изменять ориентацию экрана на системном уровне. Эту возможность часто используют при создании игр, просмотре видеоматериалов или отображении текстов. Если вы планируете писать программу с учетом поворота экрана, то будет нужно проверить, поддерживает ли целевое устройство данную функциональность. Ведь многие пользователи еще владеют КПК на базе PocketPC 2000, PocketPC 2002 и PocketPC 2003.

Для поворота экрана, а также для проверки возможности такого поворота используется функция API ChangeDisplaySettingsEx. Данная функция использует структуру DEVMODE. В первую очередь, в этой структуре нас интересует поле Fields, в котором хранится значение DisplayQueryOrientation. Этот флаг отвечает за поддержку смены ориентации экрана и передает значение в поле lpDevMode.dmDisplayOrientation. Например, значение DMO_0 говорит о том, что поворот экрана не поддерживается.

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

Листинг 13.5

// Флаг, определяющий поддержку поворота экрана

private static Int32 DisplayQueryOrientation = 0x01000000;


private static Int32 CDS_TEST = 2;


// запоминаем настройки экрана

ScreenOrientation initialOrientation = SystemSettings.ScreenOrientation;

[DllImport("coredll.dll", SetLastError = true)]

private extern static Int32 ChangeDisplaySettingsEx(

 String deviceName, ref DeviceMode deviceMode, IntPtr hwnd,

 Int32 flags, IntPtr param);


struct DeviceMode {

 [MarshalAs(UnmanagedType.ByValTStr, SizeConst - 32)]

 public String DeviceName;

 public Int16 SpecVersion;

 public Int16 DriverVersion;

 public Int16 Size;

 public Int16 DriverExtra;

 public Int32 Fields;

 public Int16 Orientation;

 public Int16 PaperSize;

 public Int16 PaperLength;

 public Int16 PaperWidth;

 public Int16 Scale;

 public Int16 Copies;

 public Int16 DefaultSource;

 public Int16 PrintQuality;

 public Int16 Color;

 public Int16 Duplex;

 public Int16 Yresolution;

 public Int16 TTOption;

 public Int16 Collate;

 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]

 public String FormName;

 public Int16 LogPixels;

 public Int32 BitsPerPel;

 public Int32 PelsWidth;

 public Int32 PelsHeight;

 public Int32 DisplayFlags;

 public Int32 DisplayFrequency;

 public Int32 DisplayOrientation;

}


private void butCheckRotate_Click(object sender, EventArgs e) {

 // подготавливаем структуру DeviceMode

 DeviceMode devMode = new DeviceMode();

 devMode.Size = (Int16)Marshal.SizeOf(devMode);

 devMode.Fields = DisplayQueryOrientation;

 // Проверяем, поддерживает ли система поворот экрана

 Int32 result =

  ChangeDisplaySettingsEx(null, ref devMode, IntPtr.Zero, CDS_TEST,

   IntPtr.Zero);

 if (result == 0) {

  // Если вызов функции прошел успешно.

  // то проверяем поддержку поворота экрана

  // Если параметр DisplayOrientation имеет ненулевое

  // значение то поворот экрана возможен

  if (devMode.DisplayOrientation != 0) {

   MessageBox.Show("Поворот экрана поддерживается");

  }

 } else {

  MessageBox.Show("Поворот экрана не поддерживается");

 }

}


private void butRot90_Click(object sender, EventArgs e) {

 SystemSettings.ScreenOrientation = ScreenOrientation.Angle90;

}


private void butRestore_Click(object sender, EventArgs e) {

 if (SystemSettings.ScreenOrientation != initialOrientation) {

  try {

   SystemSettings.ScreenOrientation = initialOrientation;

  } catch (Exception) {

   // Unable to change the orientation back

   // to the original configuration.

   MessageBox.Show("This sample was unable to set the " +

    "orientation back to the original state.");

  }

 }

}

Прячем кнопку Start

Функция SHFullScreen позволяет прятать и показывать кнопку Start и пиктограмму виртуальной клавиатуры SIP. Соответствующий код приведен в листинге 13.6.

Листинг 13.6

/// <summary>

/// Функция используется для изменения вида экрана.

/// Вы можете модифицировать панель задач, панель ввода, значок

/// Пуск

/// </summary>

/// <param name="hwndRequester">Дескриптор окна</param>

/// <param name="dwState">Определяет состояние окна</param>

/// <returns>B успешном случае возвращается True, иначе -

/// False</returns>

[DllImport("aygshell.dll")]

static extern uint SHFullScreen(IntPtr hwndRequester, uint dwState);


const uint SHFS_SHOWTASKBAR = 0x0001;

const uint SHFS_HIDETASKBAR = 0x0002;

const uint SHFS_SHOWSIPBUTTON = 0x0004;

const uint SHFS_HIDESIPBUTTON = 0x0008;

const uint SHFS_SHOWSTARTICON = 0x0010;

const uint SHFS_HIDESTARTICON = 0x0020;


private void butHideStart_Click(object sender, EventArgs e) {

 IntPtr hwnd = this.Handle;

 //прячем кнопку Start

 SHFullScreen(hwnd, SHFS_HIDESTARTICON);

 //прячем SIP

 //SHFullScreen(hwnd, SHFS_HIDESIPBUTTON);

}


private void butShowStart_Click(object sender, EventArgs e) {

 //показываем кнопку Start

 IntPtr hwnd = this.Handle;

 SHFullScreen(hwnd, SHFS_SHOWSTARTICON);

 //показываем SIP

 //SHFullScreen(hwnd, SHFS_SHOWSIPBUTTON);

}

В примере показано, как прятать кнопку Start. Если нужно спрятать пиктограмму SIP, то надо убрать комментарии при втором вызове функции. На рис. 13.1 показан внешний вид экрана со спрятанной кнопкой Start.

Рис. 13.1. Скрытие кнопки Start

Панель задач

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

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

Листинг 13.7

/// <summary>

/// Скрывает одно окно и активирует другое

/// </summary>

private const int SW_HIDE = 0;


/// <summary>

/// Активирует окно

/// </summary>

private const int SW_SHOW = 5;


[DllImport("coredll.dll")]

private static extern IntPtr FindWindow(string ClassName, string WindowName);


[DllImport("coredll.dll")]

private static extern bool ShowWindow(IntPtr hwnd, int nCmdShow);


/// <summary>

/// Прячем панель задач, чтобы пользователь не мог

/// нажать кнопку Start

/// </summary>

public static void HideTaskbar() {

 IntPtr h = FindWindow("HHTaskBar", "");

 ShowWindow(h, SW_HIDE);

}


/// <summary>

/// Показывает панель задач

/// </summary>

public static void ShowTaskBar() {

 IntPtr h = FindWindow("HHTaskBar", "");

 ShowWindow(h, SW_SHOW);

}


private void butHideTaskbar_Click(object sender, EventArgs e) {

 HideTaskbar();

}


private void butShowTaskbar_Click(object sender, EventArgs e) {

 ShowTaskBar();

}

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

Запуск других приложений

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

Листинг 13.8

public class ProcessInfo {

 public IntPtr hProcess;

 public IntPtr hThread;

 public Int32 ProcessId;

 public Int32 ThreadId;

}


[DllImport("CoreDll.DLL", SetLastError = true)]

private extern static int CreateProcess(

 String imageName, String cmdLine, IntPtr lpProcessAttributes,

 IntPtr lpThreadAttributes, Int32 boolInheritHandles,

 Int32 dwCreationFlags, IntPtr lpEnvironment, IntPtr lpszCurrentDir,

 byte[] si, ProcessInfo pi);


private void butCalc_Click(object sender, EventArgs e) {

 //Запускаем калькулятор

 ProcessInfo pi = new ProcessInfo();

 CreateProcess(

  "calc.exe", "", IntPtr.Zero, IntPtr.Zero, 0, 0, IntPtr.Zero, IntPtr.Zero,

  new Byte[128], pi);

}


private void butCalendar_Click(object sender, EventArgs e) {

 //Запускаем календарь

 ProcessInfo pi = new ProcessInfo();

 CreateProcess(

  "calendar.exe", "", IntPtr.Zero, IntPtr.Zero, 0, 0, IntPtr.Zero,

  IntPtr.Zero, new Byte[128], pi);

}


private void butInfra_Click(object sender, EventArgs e) {

 //Посылаем файл через инфракрасное соединение

 ProcessInfo pi = new ProcessInfo();

 CreateProcess(

  "Beam.exe", "\\windows\\Alarm1.wav", IntPtr.Zero, IntPtr.Zero, 0, 0,

  IntPtr.Zero, IntPtr.Zero, new Byte[128], pi);

}

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

Названия специальных файлов

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

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

Листинг 13.9

// Константы

/// <summary>

/// Папка, содержащая файлы и папки, которые появляются на

/// экране Сегодня

/// </summary>

const int CSIDL_DESKTOPDIRECTORY = 0x0010;


/// <summary>

/// Папка Избранное

/// </summary>

const int CSIDL_FAVORITES = 0x0006;


/// <summary>

/// Папка \Мои документы

/// </summary>

const int CSIDL_PERSONAL = 0x0005;


/// <summary>

/// Папка Программы в папке Главное меню

/// (\Windows\Start Menu\Programs)

/// </summary>

const int CSIDL_PROGRAMS = 0x0002;


/// <summary>

/// Папка Recent (содержит последние из открывавшихся

/// документов)

/// </summary>

const int CSIDL_RECENT = 0x0008;


/// <summary>

/// Папка Главное меню

/// (\Windows\Start Menu)

/// </summary>

const int CSIDL_STARTMENU = 0x000b;


/// <summary>

/// Папка Автозагрузка для программ,

/// которые автоматически загружаются при запуске Windows

/// \Windows\StartUp

/// </summary>

const int CSIDL_STARTUP = 0x0007;


/// <summary>

/// Папка, в которой хранятся шаблоны документов

/// </summary>

const int CSIDL_TEMPLATES = 0x0015;


/// <summary>

/// Функция получения имен специальных папок

/// </summary>

[DllImport("Coredll.dll")]

static extern int SHGetSpecialFolderPath

 (IntPtr hwndOwner, StringBuilder lpszPath, int nFolder, int fCreate);


const int MAX_PATH = 260;


private void Form1_Load(object sender, EventArgs e) {

 // Папка Избранное

 StringBuilder strFavorites = new StringBuilder(MAX_PATH);

 SHGetSpecialFolderPath(this.Handle, strFavorites, CSIDL_FAVORITES, 0);

 MessageBox.Show("Избранное: " + strFavorites.ToString());


 // Папка Программы

 StringBuilder strPrograms = new StringBuilder(MAX_PATH);

 SHGetSpecialFolderPath(this.Handle, strPrograms, CSIDL_PROGRAMS, 0);

 MessageBox.Show("Программы: " + strPrograms.ToString());


 // Мои документы

 StringBuilder strMyDocs = new StringBuilder(MAX_PATH);

 SHGetSpecialFolderPath(this.Handle, strMyDocs, CSIDL_PERSONAL, 0);

 MessageBox.Show("Мои документы: " + strMyDocs.ToString());

}

Использование звуковых файлов

Мир современных компьютеров трудно представить без мультимедийных возможностей; однако проигрывание звуковых файлов не поддерживалось в библиотеке .NET Framework 1.0. Подобный подход Microsoft удивил многих программистов. В этом случае приходилось использовать неуправляемый код с вызовом функции PlaySound.

С выходом .NET Framework 2.0 ситуация изменилась в лучшую сторону. Но легкая поддержка звуковых файлов остается прерогативой настольных систем. В библиотеке .NET Compact Framework по-прежнему отсутствует поддержка проигрывания звуковых файлов. А ведь для разработки игры наличие звуковых эффектов является обязательным условием, иначе игра будет просто неинтересна!

Поэтому нужно устранить недоработку разработчиков из Microsoft. В новом примере будут использоваться два способа воспроизведения звуков. В первом случае программа будет извлекать звуковой фрагмент из ресурсов. Во втором случае программа будет проигрывать звук из обычного WAV-файла.

Итак, нужно создать новый проект с именем PlaySound_CS. К проекту надо добавить новый класс с именем Sound. Объявление функции PlaySound, необходимой для проигрывания звуков, нужно поместить в класс Sound, как показано в листинге 13.10.

Листинг 13.10

private enum Flags {

 SND_SYNC = 0x0000,

 SND_ASYNC = 0x0001,

 SND_NODEFAULT = 0x0002,

 SND_MEMORY = 0x0004,

 SND_LOOP = 0x0008,

 SND_NOSTOP = 0x0010,

 SND_NOWAIT = 0x00002000,

 SND_ALIAS = 0x00010000,

 SND_ALIAS_ID = 0x00110000,

 SND_FILENAME = 0x00020000,

 SND_RESOURCE = 0x00040004

}


[DllImport("CoreDll.DLL", EntryPoint = "PlaySound", SetLastError = true)]

private extern static int PlaySound(string szSound, IntPtr hMod, int flags);


[DllImport("CoreDll.DLL", EntryPoint = "PlaySound", SetLastError = true)]

private extern static int PlaySoundBytes(byte[] szSound, IntPtr hMod,

 int flags);

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

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

Для того чтобы пример работал, понадобятся два звуковых файлов. В состав Windows XP входит несколько звуковых файлов. Для данного примера использовался файл chimes.wav. Его нужно добавить в проект. Чтобы включить файл chimes.wav в проект как ресурс, надо в свойствах файла выбрать пункт Build Action и установить значение Embedded Resource.

В качестве внешнего аудиофайла будет использоваться файл alarm3.wav, входящий в состав Windows Mobile. Этот файл находится в папке Windows. При желании можно использовать свой файл, но при этом надо в коде указать путь к нему. Теперь достаточно прописать код для обработки события Click созданных кнопок, как показано в листинге 13.11, — и приложение готово.

Листинг 13.11

using System;

using System.Collections.Generic;

using System.Text;

using System.IO;

using System.Runtime.InteropServices;


namespace PlaySound_CS {

 public class Sound {

  private byte[] m_soundBytes;

  private string m_fileName;

  private enum Flags {

   SND_SYNC = 0x0000,

   SND_ASYNC = 0x0001,

   SND_NODEFAULT = 0x0002,

   SND_MEMORY = 0x0004,

   SND_LOOP = 0x0008,

   SND_NOSTOP = 0x0010,

   SND_NOWAIT = 0x00002000,

   SND_ALIAS = 0x00010000,

   SND_ALIAS_ID = 0x00110000,

   SND_FILENAME = 0x00020000,

   SND_RESOURCE = 0x00040004

  }


  [DllImport("CoreDll.DLL", EntryPoint = "PlaySound", SetLastError = true)]

  private extern static int PlaySound(string szSound, IntPtr hMod, int flags);


  [DllImport("CoreDll.DLL", EntryPoint = "PlaySound", SetLastError = true)]

  private extern static int PlaySoundBytes(byte[] szSound, IntPtr hMod,

   int flags);


  /// <summary>

  /// Конструктор объекта Sound, который проигрывает звук из

  /// указанного файла

  /// </summary>

  public Sound(string fileName) {

   m_fileName = fileName;

  }


  /// <summary>

  /// Конструктор объекта Sound, который проигрывает звук из

  /// ресурсов

  /// </summary>

  public Sound(Stream stream) {

   // читаем данные из потока

   m_soundBytes = new byte[stream.Length];

   stream.Read(m_soundBytes, 0, (int)stream.Length);

  }


  /// <summary>

  /// Воспроизводим звук

  /// </summary>

  public void Play() {

   // Если из файла, то вызываем PlaySound.

   // если из ресурсов, то PlaySoundBytes.

   if (m_fileName != null)

    PlaySound(m_fileName, IntPtr.Zero,

     (int)(Flags.SND_ASYNC | Flags.SND_FILENAME));

   else

    PlaySoundBytes(m_soundBytes, IntPtr.Zero,

     (int)(Flags.SND_ASYNC | Flags.SND_MEMORY));

  }

 }

}

Теперь нужно перейти к самой форме. Код для нее приведен в листинге 13.12.

Листинг 13.12

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Drawing;

using System.Text;

using System.Windows.Forms;

using System.Reflection;


namespace PlaySound_CS {

 public partial class Form1 : Form {

  public Form1() {

   InitializeComponent();

   InitializeComponent();

#if DEBUG

   MinimizeBox = false;

#else

   MinimizeBox = true;

#endif

  }


  private void butResource_Click(object sender, EventArgs e) {

   Sound sound =

    new Sound(Assembly.GetExecutingAssembly().GetManifestResourceStream(

     "PlaySound_CS.chimes.wav"));

   sound.Play();

  }


  private void butFile_Click(object sender, EventArgs e) {

   Sound sound = new Sound("Windows\\alarm3.wav");

   sound.Play();

  }

 }

}

Системные звуки

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

Листинг 13.13

[DllImport("coredll.dll")]

extern static void MessageBeep(uint BeepType);


private void butBeep_Click(object sender, EventArgs e) {

 MessageBeep(0);

}

Системное время

Чтобы получить или установить системное время на устройстве, нужно использовать функции GetSystemTime и SetSystemTime. Следует учитывать, что функция GetSystemTime возвращает время по Гринвичу, а не местное время. Код, иллюстрирующий применение этих функций, приведен в листинге 13.14.

Листинг 13.14

using System.Runtime.InteropServices;


[DllImport("coredll.dll")]

private extern static void GetSystemTime(ref SYSTEMTIME lpSystemTime);


[DllImport("coredll.dll")]

private extern static uint SetSystemTime(ref SYSTEMTIME lpSystemTime);


private struct SYSTEMTIME {

 public ushort wYear;

 public ushort wMonth;

 public ushort wDayOfWeek;

 public ushort wDay;

 public ushort wHour;

 public ushort wMinute;

 public ushort wSecond;

 public ushort wMilliseconds;

}


private void GetTime() {

 // Получим системное время

 SYSTEMTIME st = new SYSTEMTIME();

 GetSystemTime(ref st);

 DateTime dt = DateTime.UtcNow.ToLocalTime();

 // Выводим сообщение

 MessageBox.Show("Текущее время: " + st.wHour.ToString() + ":" +

  st.wMinute.ToString());

}


private void SetTime() {

 // Сначала получим системное время

 SYSTEMTIME st = new SYSTEMTIME();

 GetSystemTime(ref st);

 // А теперь прибавим один час

 st.wHour = (ushort)(st.wHour + 1 % 24);

 SetSystemTime(ref st);

 MessageBox.Show("Новое время: " + st.wHour.ToString() + ":" +

  st.wMinute.ToString());

}


private void butGetTime_Click(object sender, EventArgs e) {

 GetTime();

}


private void butSetTime_Click(object sender, EventArgs e) {

 SetTime();

}

Создание ярлыка

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

Листинг 13.15

/// <summary>

/// Функция для создания ярлыка

/// </summary>

/// <param name="szShortcut">Строка, содержащая

/// путь и имя создаваемого ярлыка.

///</param>

/// <param name="szTarget">Строка, содержащая

/// путь и аргументы для ярлыка.

/// Размер строки ограничен 256 символами.

/// </param>

/// <returns>B успешном случае возвращается TRUE,

/// в случае ошибки возвращается FALSE

/// </returns>

[DllImport("coredll.dll", EntryPoint = "SHCreateShortcut")]

private static extern bool SHCreateShortcut(string szShortcut,

 string szTarget);


private void butCreateShortcut_Click(object sender, EventArgs e) {

 // Создадим ярлык к калькулятору

 bool success = SHCreateShortcut("\\My Documents\\Shortcut.lnk",

  "\\Windows\\calс.exe\"");

}

В этом примере создается ярлык Shortcut.lnk для стандартного калькулятора, чей исполняемый файл носит имя windows\calc.exe.

Количество строк в текстовом поле

Если у текстового поля свойство Multiline имеет значение True, то свойство Lines возвращает массив строк в текстовом поле. Но у данного свойства есть два недостатка. Во-первых, свойство Lines не поддерживается библиотекой .NET Compact Framework, а во-вторых, это свойство не учитывает перенос слов. Для подсчета количества строк в многострочном текстовом поле можно использовать сообщение EM_GETLINECOUNT. Соответствующий код приведен в листинге 13.16.

Листинг 13.16

[DllImport("coredll.dll")]

static extern int SendMessage(IntPtr hwnd, int msg, int wParam, int lParam);


const int EM_GETLINECOUNT = 0x00BA;

private void butGetNumber_Click(object sender, EventArgs e) {

 // Узнаем число строк в текстовом поле

 int numberOfLines = SendMessage(textBox1.Handle, EM_GETLINECOUNT, 0, 0);

 sbInfo.Text = "Число строк: " + numberOfLines.ToString();

}

Реестр

Реестр является важной частью любой операционной системы семейства Windows. Не является исключением и система Windows Mobile, в которой тоже имеется собственный реестр. Однако разработчики компании Microsoft не стали включать редактор реестра в состав Windows Mobile. Поэтому для доступа к разделам реестра приходится устанавливать программы от сторонних производителей.

Однако любой программист может написать свой редактор реестра, используя возможности .NET Compact Framework. При этом следует учитывать, что в библиотеке .NET Compact Framework 2.0 появились классы для работы с разделами реестра. Если же вы продолжаете писать программы с использованием .NET Compact Framework 1.0, то придется вызывать функции Windows API.

В листинге 13.17 приведен код, который будет работать в любой версии .NET Compact Framework.

Листинг 13.17

using System;

using System.Collections.Generic;

using System.Text;

using System.Runtime.InteropServices;


namespace Registry_CS {

 class Registry {

  /// <summary>

  /// Создает ключ

  /// </summary>

  /// <param name="keyName">Имя создаваемого ключа</param>

  /// <returns>B успешном случае возвращается

  /// ERROR_SUCCESS</ returns>

  public static int CreateKey(UIntPtr root, string keyName) {

   UIntPtr hkey = UintPtr.Zero;

   uint disposition = 0;

   try {

    return

     RegCreateKeyEx(root, keyName, 0, null, 0, KeyAccess.None, IntPtr.Zero,

      ref hkey, ref disposition);

   } finally {

    if (UIntPtr.Zero != hkey) {

     RegCloseKey(hkey);

    }

   }

  }


  /// <summary>

  /// Удаляет ключ

  /// </summary>

  /// <param name="keyName">Имя ключа</param>

  /// <returns>B успешном случае возвращается

  /// ERROR_SUCCESS</returns>

  public static int DeleteKey(UIntPtr root, string keyName) {

   return RegDeleteKey(root, keyName);

  }


  /// <summary>

  /// Создает строковой параметр в заданном ключе

  /// </summary>

  /// <param name="keyName">Имя ключа</param>

  /// <param name="valueName">Имя параметра</param>

  /// <param name="stringData">Значение параметра</param>

  /// <returns>В успешном случае возвращается

  /// ERROR_SUCCESS</returns>

  public static int CreateValueString(string keyName, string valueName,

   string stringData) {

   UIntPtr hkey = UintPtr.Zero;

   try {

    int result = RegOpenKeyEx(root, keyName, 0, KeyAccess.None, ref hkey);

    if (ERROR_SUCCESS != result) return result;

    byte[] bytes = Encoding.Unicode.GetBytes(stringData);

    return RegSetValueEx(hkey, valueName, 0, KeyType.String, bytes,

     (uint)bytes.Length);

   } finally {

    if (UIntPtr.Zero != hkey) {

     RegCloseKey(hkey);

    }

   }

  }


  /// <summary>

  /// Создает параметр типа DWORD в заданном ключе

  /// </summary>

  /// <param name="keyName">Имя ключа</param>

  /// <param name="valueName">Имя параметра</param>

  /// <param name="dwordData">Значение параметра</param>

  /// <returns>В успешном случае возвращается

  /// ERROR_SUCCESS</returns>

  public static int CreateValueDWORD(UIntPtr root, string keyName,

   string valueName, uint dwordData) {

   UIntPtr hkey = UintPtr.Zero;

   try {

    int result = RegOpenKeyEx(root, keyName, 0, KeyAccess.None, ref hkey);

    if (ERROR_SUCCESS != result) return result;

    byte[] bytes = BitConverter.GetBytes(dwordData);

    return RegSetValueEx(hkey, valueName, 0, KeyType.Dword, bytes,

     (uint)bytes.Length);

   } finally {

    if (UIntPtr.Zero != hkey) {

     RegCloseKey(hkey);

    }

   }

  }


  /// <summary>

  /// Создает двоичный параметр в заданном ключе

  /// </summary>

  /// <param name="keyName">Имя ключа</param>

  /// <param name="valueName">Имя параметра</param>

  /// <param name="dwordData">Значение параметра</param>

  /// <returns>B успешном случае возвращается

  /// ERROR_SUCCESS</returns>

  public static int CreateValueBinary(UIntPtr root, string keyName,

   string valueName, uint binData) {

   UIntPtr hkey = UintPtr.Zero;

   try {

    int result = RegOpenKeyEx(root, keyName, 0, KeyAccess.None, ref hkey);

    if (ERROR_SUCCESS != result) return result;

    byte[] data = BitConverter.GetBytes(binData);

    return RegSetValueEx(hkey, valueName, 0, KeyType.Binary, data,

     (uint)data.Length);

   } finally {

    if (UIntPtr.Zero != hkey) {

     RegCloseKey(hkey);

    }

   }

  }


  /// <summary>

  /// Получает значение строкового параметра

  /// </summary>

  /// <param name="keyName">Имя ключа</param>

  /// <param name="valueName">Имя параметра</param>

  /// <param name="stringResult">строковые данные</param>

  /// <returns>В успешном случае возвращается

  /// ERROR_SUCCESS</returns>

  public static int GetStringValue(UIntPtr root, string keyName,

   string valueName, ref string stringResult) {

   UIntPtr hkey = UintPtr.Zero;

   try {

    int result = RegOpenKeyEx(root, keyName, 0, KeyAccess.None, ref hkey);

    if (ERROR_SUCCESS != result) return result;

    byte[] bytes = null;

    uint length = 0;

    KeyType keyType = KeyType.None;

    result = RegQueryValueEx(hkey, valueName, IntPtr.Zero, ref keyType, null,

     ref length);

    if (ERROR_SUCCESS != result) return result;

    keyType = KeyType.None;

    bytes = new byte[length];

    result = RegQueryValueEx(hkey, valueName, IntPtr.Zero, ref keyType, bytes,

     ref length);

    if (ERROR SUCCESS != result) return result;

     stringResult = Encoding.Unicode.GetString(bytes, 0, bytes.Length);

    return ERROR_SUCCESS;

   } finally {

    if (UIntPtr.Zero != hkey) {

     RegCloseKey(hkey);

    }

   }

  }


  /// <summary>

  /// Получает заданное значение типа DWORD

  /// </summary>

  /// <param name="keyName">Имя ключа</param>

  /// <param name="valueName">Имя параметра</param>

  /// <param name="dwordResult">Значение параметра</param>

  /// <returns>B успешной случае возвращается

  /// ERROR_SUCCESS</returns>

  public static int GetDWORDValue(UIntPtr root, string keyName,

   string valueName, ref uint dwordResult) {

   UIntPtr hkey = UintPtr.Zero;

   try {

    int result = RegOpenKeyEx(root, keyName, 0, KeyAccess.None, ref hkey);

    if (ERROR_SUCCESS != result) return result;

    byte[] bytes = null;

    uint length = 0;

    KeyType keyType = KeyType.None;

    result = RegQueryValueEx(hkey, valueName, IntPtr.Zero, ref keyType, null,

     ref length);

    bytes = new byte[Marshal.SizeOf(typeof(uint))];

    length = (uint)bytes.Length;

    keyType = KeyType.None;

    result = RegQueryValueEx(hkey, valueName, IntPtr.Zero, ref keyType, bytes,

     ref length);

    if (ERROR_SUCCESS != result) return result;

    dwordResult = BitConverter.ToUInt32(bytes, 0);

    return ERROR_SUCCESS;

   } finally {

    if (UIntPtr.Zero != hkey) {

     RegCloseKey(hkey);

    }

   }

  }


  /// <summary>

  /// Удаляет заданный параметр из раздела реестра

  /// </summary>

  /// <param name="keyName">Имя ключа</param>

  /// <param name="valueName">Имя параметра</param>

  /// <returns>В успешном случае возвращается

  /// ERROR_SUCCESS</returns>

  public static int DeleteValue(UIntPtr root, string keyName,

   string valueName) {

   UIntPtr hkey = UIntPtr.Zero;

   try {

    int result = RegOpenKeyEx(root, keyName, 0, KeyAccess.None, ref hkey);

    if (ERROR_SUCCESS != result) return result;

    return RegDeleteValue(hkey, valueName);

   } finally {

    if (UIntPtr.Zero != hkey) {

     RegCloseKey(hkey);

    }

   }

  }


  /// <summary>

  /// Типы ключей

  /// </summary>

  public enum KeyType : uint {

   None = 0,

   String = 1,

   Binary = 3,

   Dword = 4,

  }


  /// <summary>

  /// Тип доступа

  /// </summary>

  public enum KeyAccess : uint {

   None = 0x0000,

   QueryValue = 0x0001,

   SetValue = 0x0002,

   CreateSubKey = 0x0004,

   EnumerateSubKeys = 0x0008,

   Notify = 0x0010,

   CreateLink = 0x0020

  }


  /// <summary>

  /// HKEY_CLASSES_ROOT

  /// </summary>

  public static UIntPtr HKCR = new UintPtr(0x80000000);

  /// <summary>

  /// HKEY_CURRENT_USER

  /// </summary>

  public static UIntPtr HKCU = new UIntPtr(0x80000001);

  /// <summary>

  /// HKEY_LOCAL_MACHINE

  /// </summary>

  public static UIntPtr HKLM = new UIntPtr(0x80000002);

  /// <summary>

  /// HKEY_USERS

  /// </summary>

  public static UIntPtr HKU = new UintPtr(0x80000003);


  /// <summary>

  /// Возвращаемое значение в случае успеха

  /// </summary>

  public const int ERROR_SUCCESS = 0;


  /// <summary>

  /// Функция для создания заданного раздела реестра. Если раздел

  /// уже существует, то функция открывает его.

  /// </summary>

  /// <param name="hkey">[in] Дескриптор к открываемому разделу

  /// или одна из ветвей реестра:

  /// HKCR, HKCU, HKLM.</param>

  /// <param name="lpSubKey">[in] Имя для нового раздела. Данный

  /// раздел должен быть подразделом раздела, определенного в

  /// параметре hKey.

  /// </param>

  /// <param name="Reserved">[in] Зарезервированный параметр.

  /// Установлен равным 0</param>

  /// <param name="lpClass">[in] Имя класса или типа объекта

  /// Данный параметр игнорируется, если раздел уже существует

  /// </param>

  /// <param name="dwOptions">[in] Игнорируется; установите

  /// равным 0

  /// </param>

  /// <param name="samDesired">[in] Игнорируется; установите

  /// равным 0

  /// </param>

  /// <param name="lpSecurityAttributes">[in] Установите в NULL.

  /// </param>

  /// <param name="phkResult">[out] Переменная, получаемая от

  /// дескриптора нового или открытого раздела

  /// Если вы больше не нуждаетесь в дескрипторе, то вызовите

  /// функцию RegCloseKey для его закрытия. </param>

  /// <param name="lpdwDisposition">[out] Переменная, которая

  /// получает значение 1 (REG_CREATED_NEW_KEY),

  /// если раздел был создан

  /// и значение 2 (REG_OPENED_EXISTING_KEY), если был открыт уже

  /// существующий раздел

  /// </param>

  /// <returns>ERROR_SUCCESS сообщает об успешном вызове функции.

  /// В случае ошибки возвращается ненулевое значение

  /// </returns>

  [DllImport("coredll.dll", SetLastError = true)]

  public static extern int RegCreateKeyEx(

   UIntPtr hkey, String lpSubKey, uint Reserved, StringBuilder lpClass,

   uint dwOptions, KeyAccess samDesired, IntPtr lpSecurityAttributes,

   ref UIntPtr phkResult, ref uint lpdwDisposition);


  /// <summary>

  /// Функция для удаления раздела реестра

  /// </summary>

  /// <param name="hkey">[in] Дескриптор к удаляемому разделу или

  /// одна из ветвей реестра: HKCR, HKCU, HKLM.

  /// </param>

  /// <param name="subkeyName">[in] Имя удаляемого раздела.

  /// Нельзя использовать NULL

  /// </param>

  /// <returns>ERROR_SUCCESS сообщает об успешном вызове функции

  /// В случае ошибки возвращается ненулевое значение

  /// </returns>

  [DllImport("coredll.dll", SetLastError = true)]

  public static extern int RegDeleteKey(UIntPtr hkey, string subkeyName );


  /// <summary>

  /// Функция для открытия заданного раздела реестра.

  /// </summary>

  /// <param name="hkey">[in] Дескриптор к открываемому разделу

  /// или одна из ветвей реестра HKCR, HKCU, HKLM.</param>

  /// <param name="lpSubKey">[in] Имя открываемого раздела

  /// </param>

  /// <param name="ulOptions">[in] Зарезервированный параметр.

  /// Установлен равным 0</param>

  /// <param name="samDesired">[in] He поддерживается. Установите

  /// в 0.</param>

  /// <param name="phkResult">[out] Переменная, получаемая от

  /// дескриптора открытого раздела. Если вы больше не нуждаетесь

  /// в дескрипторе, то вызовите функцию RegCloseKey для его

  /// закрытия</param>

  /// <returns>ERROR_SUCCESS сообщает об успешном вызове функции.

  /// В случае ошибки возвращается ненулевое значение

  /// </returns>

  [DllImport("coredll.dll", SetLastError = true)]

  public static extern int RegOpenKeyEx(

   UIntPtr hkey, String lpSubKey, uint ulOptions, KeyAccess samDesired,

   ref UIntPtr phkResult);


  /// <summary>

  /// Функция получает тип и данные из заданного раздела реестра

  /// </summary>

  /// <param name="hkey">[in] Дескриптор к открываемому разделу

  /// или одна из ветвей реестра: HKCR, HKCU, HKLM.</param>

  /// <param name="lpValueName">[in] Значение параметра.

  /// </param>

  /// <param name="lpReserved">[in] Зарезервированный параметр.

  /// Установите в NULL.</param>

  /// <param name="lpType">[out] Тип данных

  /// </param>

  /// <param name="lpData">[out] Буфер, получающий данные.

  /// Данный параметр может быть NULL, если данные не требуются.

  /// </param>

  /// <param name="lpcbData">[in/out] Размер буфера в байтах

  /// </param>

  /// <returns>ERROR_SUCCESS сообщает об успешном вызове функции.

  /// В случае ошибки возвращается ненулевое значение

  /// </returns>

  [DllImport("coredll.dll", SetLastError = true)]

  public static extern int RegQueryValueEx(

   UIntPtr hkey, String lpValueName, IntPtr lpReserved, ref KeyType lpType,

   byte[] lpData, ref uint lpcbData);


  /// <summary>

  /// Функция создает параметр в разделе реестра.

  /// </summary>

  [DllImport("coredll.dll", SetLastError = true)]

  public static extern int RegSetValueEx(

   UIntPtr hkey, String lpValueName, uint Reserved, KeyType dwType,

   byte[] lpData, uint cbData);


  [DllImport("coredll.dll", SetLastError = true)]

  public static extern int RegDeleteValue(UIntPtr hkey, string valueName);


  [DllImport("coredll.dll", SetLastError = true)]

  public static extern int RegCloseKey(UIntPtr hkey);

 }

}

Наличие внешней клавиатуры

С помощью класса Registry разработчик может получать или устанавливать значения параметров в реестре. Предположим, что нужно узнать, подключена ли к устройству внешняя клавиатура. За данную функцию отвечает параметр HasKeyboard в разделе HKEY_CURRENT_USER\Software\Microsoft\Shell. Если данный параметр имеет единичное значение, то система работает с подключенной внешней клавиатурой. Если значение равно нулю, то клавиатуры нет. В листинге 13.18 приведен код, показывающий, как можно извлечь значение интересующего параметра.

Листинг 13.18

private void butCheckKeyboard_Click(object sender, EventArgs e) {

 uint check = 0;

 Registry.GetDWORDValue(Registry.HKCU, "SOFTWARE\\Microsoft\\Shell",

  "HasKeyboard", ref check);

 lblInfo.Text = Convert.ToBoolean(check).ToString();

}

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

Листинг 13.19

private static bool IsKeyboard() {

 uint dwordResult;

 UIntPtr hkey = UIntPtr.Zero;

 try {

  int result =

   Registry.RegOpenKeyEx(Registry.HKCU, "SOFTWARE\\Microsoft\\Shell", 0,

   Registry.KeyAccess.None, ref hkey);

  if (Registry.ERROR_SUCCESS != result) return false;

  byte[] bytes = null;

  uint length = 0;

  Registry.KeyType keyType = Registry.KeyType.None;

  result =

   Registry.RegQueryValueEx(hkey, "HasKeyboard", IntPtr.Zero, ref keyType,

   null, ref length);

  if (Registry.ERROR_SUCCESS != result) return false;

  bytes = new byte[Marshal.SizeOf(typeof(uint))];

  length = (uint)bytes.Length;

  keyType = Registry.KeyType.None;

  result =

   Registry.RegQueryValueEx(hkey, "HasKeyboard", IntPtr.Zero, ref keyType,

   bytes, ref length);

  if (Registry.ERROR_SUCCESS != result) return false;

  dwordResult = BitConverter.ToUInt32(bytes, 0);

  return (dwordResult == 1);

 } finally {

  if (UIntPtr.Zero != hkey) {

   Registry.RegCloseKey(hkey);

  }

 }

}

Теперь эту функцию можно вызвать в любом месте программы, как показано в листинге 13.20.

Листинг 13.20

// Определяем наличие внешней клавиатуры

lblInfo.Text = IsKeyboard().ToString();

ВНИМАНИЕ

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

Информация о пользователе

Также с помощью реестра можно узнать информацию о пользователе устройства. За эту информацию отвечает параметр Owner в разделе HKEY_CURRENT_USER\ControlPanel\Owner. В листинге 13.21 приведен код, который получает эту информацию.

Листинг 13.21

private void butOwner_Click(object sender, EventArgs e) {

 string strOwner = "";

 Registry.GetStringValue(Registry.HKCU, "\\ControlPanel\\Owner", "Owner",

  ref strOwner);

 lblInfo.Text = strOwner;

}

Наличие дополнительной клавиатуры

Узнать о наличии в системе подключаемой клавиатуры можно с помощью функции API или просмотрев значение соответствующего ключа в реестре. Использование реестра рассматривалось несколько раньше. В листинге 13.22 приведен код, который показывает, как можно узнать о присутствии подключенной клавиатуры с помощью функции API GetKeyboardStatus.

Листинг 13.22

/// <summary>

/// Функция возвращает статус подключаемой клавиатуры и ее

/// возможности.

/// </summary>

/// <returns>Функция возвращает битовую маску,

/// показывающую присутствие клавиатуры и ее возможности

/// </returns>

[DllImport("coredll.dll")]

public static extern uint GetKeyboardStatus();


/// <summary>

/// Показывает присутствие клавиатуры в системе

/// </summary>

public const uint KBDI_KEYBOARD_PRESENT = 0x0001;


/// <summary>

/// Показывает доступность клавиатуры.

/// Данный бит может быть изменен функцией

/// EnableHardwareKeyboard

/// </summary>

public const uint KBDI_KEYBOARD_ENABLED = 0x0002;


/// <summary>

/// Показывает наличие на клавиатуре клавиш ENTER и ESC

/// </summary>

public const uint KBDI_KEYBOARD_ENTER_ESC = 0x0004;


/// <summary>

/// Показывает наличие клавиш с буквами и цифрами

/// </summary>

public const uint KBDI_KEYBOARD_ALPHA_NUM = 0x0008;


private void Form1_Load(object sender, EventArgs e) {

 MessageBox.Show("Наличие и доступность клавиатуры: " +

  IsKeyboard().ToString());

}


private static bool IsKeyboard() {

 uint flags = KBDI_KEYBOARD_ENABLED | KBDI_KEYBOARD_PRESENT;

 return ((GetKeyboardStatus() & flags) == flags);

}

Виброзвонок

Как правило, практически все современные модели мобильных телефонов и смартфонов поддерживают функцию виброзвонка. Следовательно, должны существовать функции для его включения и выключения. Для использования виброзвонка на смартфоне применяются функции Vibrate, VibrateStop и VibrateGetDeviceCaps.

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

Листинг 13.23

/// <summary>

/// Включает виброзвонок

/// </summary>

/// <returns>S_OK сообщает об успешном вызове функции. В случае

/// ошибки возвращается E_FAIL

///</returns>

[DllImport("aygshell")]

private static extern int Vibrate(int cvn, IntPtr rgvn, uint fRepeat,

 uint dwTimeout);


/// <summary>

/// Останавливает виброзвонок

/// </summary>

/// <returns>S_OK сообщает об остановке виброзвонка. В случае

/// ошибки возвращается EFAIL

/// </returns>

[DllImport("aygshell")]

private static extern int VibrateStop();


/// <summary>

/// Получает сведения о возможности использования виброзвонка

/// </summary>

/// <param name="caps">Перечисление VIBRATEDEVICECAPS,

/// определяющее возможности воспроизведения виброзвонка

/// устройством.

///</param>

[DllImport("aygshell")]

private static extern int VibrateGetDeviceCaps(VibrationCapabilities caps);


/// <summary>

/// Используется функцией VibrateGetDeviceCaps для определения

/// возможности воспроизведения виброзвонка.

/// </summary>

public enum VibrationCapabilities : int {

 VDC_Amplitude,

 VDC_Frequency,

}


private void mnuStopVibrate_Click(object sender, EventArgs e) {

 StopVibrate();

}


private void mnuVibrate_Click(object sender, EventArgs e) {

 StartVibrate();

}


/// <summary>

/// Включаем виброзвонок

/// </summary>

/// <returns>В успешном случае возвращается TRUE, в случае

/// ошибки - FALSE.</returns>

public static bool StartVibrate() {

 int result = Vibrate(0, IntPtr.Zero, 0xffffffff, 0xffffffff);

 if (result != 0) {

  return false;

 }

 return true;

}


/// <summary>

/// Останавливаем виброзвонок

/// </summary>

/// <returns>В успешном случае возвращается TRUE, в случае

/// ошибки - FALSE.</returns>

public static bool StopVibrate() {

 int result = VibrateStop();

 if (result != 0) {

  return false;

 }

 return true;

}

ВНИМАНИЕ

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

Глава 14 Кирпичики .NET Compact Framework

Итак, изучение .NET Compact Framework подходит к концу. Мы с вами рассмотрели различные аспекты программирования для карманных компьютеров и смартфонов. Напоследок я хочу предложить вам несколько маленьких советов-кирпичиков, с помощью которых вы сможете построить свое новое приложение. Часть этих советов уже встречалась вам на страницах этой книги. Но, может быть, вы не обратили на них внимания или не помните, где искать нужный вам кусок кода. Поэтому я отобрал часть этих советов и поместил их в отдельную главу. Эту главу можно рассматривать как справочный материал

Узнать версию .NET Compact Framework

В папке Windows есть утилита CGACUTIL.EXE, которая выводит номер версии установленной .NET Compact Framework. Если нужно программно узнать номер версии, то следует воспользоваться кодом, приведенным в листинге 14.1.

Листинг 14.1

// Узнаем версию установленной .NET Compact Framework

txtAppDir.Text = Environment.Version.ToString();

Узнать версию операционной системы

Для получения версии операционной системы нужно вызвать уже свойство OSVersion, как показано в листинге 14.2.

Листинг 14.2

// Узнаем версию операционной системы

txtInfo.Text = Environment.OSVersion.ToString();

Получаемые значения приведены в следующем списке.

□ 3.0 — соответствует Pocket PC 2000/2002.

□ 4.20 — соответствует Pocket PC 2003.

□ 4.21 — соответствует Pocket PC 2003 SE.

□ 5.01 — соответствует Windows Mobile 5.0.

Путь к запущенному приложению

Иногда требуется узнать путь к файлу запущенного приложения. Для этого можно воспользоваться кодом из листинга 14.3.

Листинг 14.3

using System.IO;

using System.Reflection;


txtAppDir.Text =

 Path.GetDirectoryName(Assembly.GetExecutingAssemblу().GetModule()[0].

  FullyQuelifiedName).ToString();

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

Специальные папки

В главе, посвященной функциям Windows API, путь к специальным папкам отыскивался с помощью функции SHGetSpecialFolderPath. Сторонники управляемого кода могут воспользоваться методом GetFolderPath, который появился в .NET Compact Framework 2.0. С помощью перечисления Environment.SpecialFolder можно получить пути к некоторым специальным папкам системы. Например, чтобы получить путь к папке Start Up, можно воспользоваться кодом, приведенным в листинге 14.4.

Листинг 14.4

txtInfo.Text =

 Environment.GetFolderPath(Environment.SpecialFolder.Startup).ToString();

Узнать имя устройства

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

Листинг 14.5

txtInfo.Text = System.Net.Dns.GetHostName().ToString();

Узнать ориентацию экрана

Чтобы узнать, какой режим экрана установлен на данный момент, достаточно получить свойство Bounds, как показано в листинге 14.6.

Листинг 14.6

txtInfo.Text =

 Screen.PrimaryScreen.Bounds.Width + ":" + Screen.PrimaryScreen.Bounds.Height;

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

Открытие файлов по умолчанию

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

Листинг 14.7

System.Diagnostics.Process.Start("\\My Music\\myfile.mp3");

ВНИМАНИЕ

Класс System.Diagnostics.Process появился в .NET Compact Framework 2.0. Для версии .NET Compact Framework 1.0 нужно использовать функцию API ShellExecuteEx.

Создание и отправка письма

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

Листинг 14.8

private void butSendMail_Сlick(object sender, EventArgs e) {

 System.Diagnostics.Process.Start

  ("mailto:alexander.klimoff@gmail.com?subject=About Book", null);

}

Кнопки навигации

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

Чтобы узнать, на какую кнопку нажал пользователь, нужно переопределить событие OnKeyDown. Для создания тестового приложения нужно разместить на форме строку состояния, в которой будет отображаться название нажатой кнопки. Соответствующий код приведен в листинге 14.9.

Листинг 14.9

protected override void OnKeyDown(KeyEventArgs keyg) {

 switch (keyg.KeyData) {

 case Keys.Left:

  sbaKeys.Text = "Left";

  break;

 case Keys.Right:

  sbaKeys.Text = "Right";

  break:

 case Keys.Down:

  sbaKeys.Text = "Down";

  break;

 case Keys.Up:

  sbaKeys.Text = "Up";

  break;

 case Keys.Return:

  sbaKeys.Text = "Return";

  break:

 default:

  break;

 }

}

Послесловие

Что дальше?

Вот и подошла к концу книга о программировании для мобильных устройств с помощью .NET Compact Framework. Надеюсь, я смог рассказать об основных особенностях программирования в этой среде, и вам будет легко продолжить изучение этой технологии. Жизнь не стоит на месте, и постоянно выпускаются новые релизы эмуляторов, обновлений SDK и новых утилит. Компания Microsoft уже работает над новой мобильной версией Windows, которая должна прийти на смену Windows Mobile 5.0, и обещает выпустить ее в конце 2006 года. Новая операционная система называется Crossbow. По заявлениям разработчиков, в ней будут представлены расширенные средства синхронизации с программами Office 2007 и Exchange 12.

Также в состав операционной системы войдет новая программа Office Communicator, обладающая широкими возможностями обмена информацией через мгновенные сообщения, голосовую связь и видео. Также появилась информация, что после Crossbow будет выпущена еще одна новая платформа под кодовым названием Photon. Главная особенность этой системы заключается в том, что ее можно будет использовать как на смартфонах, так и на карманных компьютерах. На сегодняшний день, по оценкам экспертов, компания Microsoft удерживает примерно 16% рынка мобильных операционных систем. Лидером в этом сегменте является операционная система Symbian, на долю которой приходится 63%. Но есть все предпосылки, что в ближайшем будущем эти цифры могут измениться в сторону увеличения доли Windows Mobile.

Полезные ресурсы

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

.NET Compact Framework 2.0 Redistributable

Если вы пишете программы с использованием .NET Compact Framework 2.0, то при распространении программы надо либо включать в состав вашего установочного файла все необходимые библиотеки, либо предложить пользователю самостоятельно установить .NET Compact Framework 2 0. В этом случае достаточно будет выкладывать на сайте только сам исполняемый файл программы. Загрузить последнюю версию .NET Compact Framework 2.0 можно по адресу www.microsoft.com/downloads/details.aspx?familyid=9655156b-356b-4a2c-857c-e62f50ae9a55&displaylang=en.

Microsoft ActiveSync 4.1

Программа синхронизации ActiveSync используется для передачи файлов между настольным и карманным компьютерами. Последнюю версию программы можно скачать по адресу www.microsoft.com/ downloads/details.aspx?FamilyId=3926A1E0-CABD-4A45-8E5B-F938D9A69D8D&displaylang=ru.

Русская версия эмулятора для Windows Mobile 5.0 Smartphone

Помимо стандартного эмулятора для смартфона под управлением системы Windows Mobile 5.0 на английском языке, вы можете скачать и локализованную версию, которая располагается по адресу www.microsoft.com/downloads/details.aspx?familyid=52FED581-8F8D-4C46-9966-4832098191B7&displaylang=ru.

Русская версия эмулятора для КПК под управлением Windows Mobile 5.0 Pocket PC

Также можно использовать русскую версию эмулятора для КПК под управлением операционной системы Windows Mobile 5.0, которую можно найти по адресу www.microsoft.com/downloads/details.aspx?FamilyID=eec33ae3-c129-4c25-abaa-18e8e842178f&displaylang=en&Hash=S3HN6BD.

Сайт Роба Майлза

На страницах книги я использовал примеры разработчика Роба Майлза (Rob Miles). Он является автором многих статей, которые можно найти в документации MSDN. Также у него есть свой сайт www.robmiles.com, который стоит посетить.

Сайт Кристиана Форсберга

Кристиан Форсберг (Christian Forsberg), чьи примеры я использовал в этой книге, тоже ведет свой сайт www.businessanyplace.net, на котором можно найти много полезной информации.

OpenNETCF.org

Один из самых популярных сайтов, посвященных программированию при помощи .NET Compact Framework, расположился по адресу www.opennetcf.org. Особый интерес вызывают представленные на сайте статьи и исходные коды приложений. Также на сайте находятся очень интересные блоги опытных программистов, которые делятся своими мыслями, разработками и примерами. Например, я частенько заглядываю на блог Алекса Яхнина по адресу blog.opennetcf.org/ayakhnin, на котором не раз находил интересные примеры. Часть этих примеров я также использовал в книге с разрешения автора. Кстати, Алексу можно задать вопрос на русском языке!

Google

К сожалению, я не могу упомянуть все сайты, которые посвящены программированию с помощью .NET Compact Framework. Для поиска новой информации можно воспользоваться услугами любой поисковой системы. Я рекомендую вам для этих целей использовать поисковую службу Google (www.google.com), которая осуществляет поиск не только по сайтам, но и по группам новостей.


Оглавление

  • Введение
  •   На кого рассчитана эта книга
  •   Требования
  •   Примеры к книге
  •   Благодарности
  •   Отзывы и предложения
  •   От издательства
  • Глава 1 Знакомство с .NET Compact Framework
  •   Мобильные устройства
  •   Общие сведения
  •   Развитие .NET Compact Framework
  •   Что нового в .NET Compact Framework 2.0
  •   Что нового в Visual Studio .NET 2005
  • Глава 2 Первое приложение для .NET Compact Framework
  •   Первые шаги
  •   Кнопки минимизации и закрытия формы
  •   Размеры и позиция формы
  •   Меню
  •   Панель ввода SIP
  •   Стилус вместо мыши
  • Глава 3 Элементы управления
  •   Сходство и различия
  •   Урезанная функциональность элементов управления
  •   Элемент Form
  •     Свойство FormBorderStyle
  •     Свойство ControlBox
  •     Свойства MinimizeBox и MaximizeBox
  •     Свойство WindowsState
  •     Размеры и расположение формы
  •   Элементы управления
  •     Элемент Button
  •     Элемент TextBox
  •     Элемент Label
  •     Элемент RadioButton
  •     Элемент Panel
  •     Элемент CheckBox
  •     Элемент ComboBox
  •     Элемент ListBox
  •     Элемент NumericUpDown
  •     Элемент DomainUpDown
  •     Элемент ProgressBar
  •     Элемент StatusBar
  •     Элемент TrackBar
  •     Элемент ToolBar
  •     Элемент MainMenu
  •     Элемент ContextMenu
  •     Элемент Timer
  •     Элементы OpenFileDialog и SaveFileDialog
  •     Элементы HScrollBar и VScrollBar
  •     Список рисунков (ImageList)
  •     Элемент PictureBox
  •     Элемент ListView
  •     Элемент TabControl
  •     Элемент TreeView
  •     Элемент InputPanel
  •     Элемент управления DataGrid
  •     Элемент Splitter
  •     Элемент MonthCalendar
  •     Элемент DateTimePicker
  •     Элемент DocumentList
  •     Элемент Notification
  •     Элемент HardwareButton
  • Глава 4 Улучшаем элементы управления
  •   Текстовые поля
  •   Управление полосой прокрутки
  •   Многострочный текст в кнопке
  •   Увеличение ширины выпадающего списка ComboBox
  •   ListBox
  •   ListView
  •   Создание кнопки, содержащей изображение
  •   Список с расширенными возможностями
  •   Текстовое поле для ввода чисел
  •   Сортировка элементов ListView
  •   Использование элемента DateTimePicker
  • Глава 5 Мышь и клавиатура
  •   Мышь и стилус
  •   Курсоры
  •   Песочные часы
  •   Обработка события Tap-and-Hold
  •   Клавиатура
  •   Клавиши навигации
  •   Выключение устройства
  •   Дополнительные материалы
  • Глава 6 Графика
  •   Классы для программирования графики
  •   Класс Pen
  •   Класс Brush
  •   Класс SolidBrush
  •   Класс TextureBrush
  •   Класс Color
  •   Класс Font
  •   Класс Icon
  •   Класс Bitmap
  •   Структура Point
  •   Структура Rectangle
  •   Графические методы
  •   Создание собственных методов DrawPie и FillPie
  •   Создание фонового рисунка для формы
  •   Копирование рисунка
  •   Поддержка прозрачности
  •   Округленные прямоугольники
  •   Создание экранных снимков
  •   Метод Lockbits
  •   Графический редактор
  •   Дополнительные материалы
  • Глава 7 Разработка приложений
  •   Активация и деактивация формы
  •   Закрыть или свернуть окно
  •   Пиктограмма приложения
  •   Создание собственных диалоговых окон
  •   Создание заставки Splash Screen
  •   Поворот экрана
  •   Рекомендации по дизайну форм
  •   Готовые приложения
  •     Файловый менеджер для смартфона
  •     Зачем нужен файловый менеджер
  •     Графический интерфейс программы
  •     Код программы
  •   Диспетчер задач
  •     Графический интерфейс программы
  •     Код программы
  •     Активация и закрытие приложения
  •     Перечисление процессов
  •     Закрытие процесса
  •   Маленький блокнот
  •     Первые шаги
  •     Стандартные операции с текстом
  •   Распространение приложений
  •     Создание cab-файла
  •     Создание проекта
  •   Дополнительные материалы
  • Глава 8 Эмулятор и другие утилиты
  •   Программы для отладки приложений
  •   Эмулятор
  •   Запуск эмулятора
  •   Настройка эмулятора
  •   Эмуляция карточки памяти
  •   Изменение ориентации экрана
  •   Выход в Интернет через эмулятор
  •   Изменение внешнего вида эмуляторов
  •   Эмулятор как отдельный продукт
  •   Новая версия эмулятора
  •   Набор утилит Visual Studio Remote Tools
  •     Remote Zoom-in
  •     Remote File Viewer
  •     Remote Registry Editor
  • Глава 9 Программирование для смартфонов
  •   Особенности программирования для смартфонов
  •   Создание приложения для смартфона
  •   Создание меню
  •   Элементы управления
  •   Режимы ввода
  •   Переопределение клавиш Soft Key
  •   Прокручивание формы
  • Глава 10 Windows Mobile 5.0
  •   Первый взгляд
  •     Улучшенная продуктивность
  •     Поддержка мультимедиа
  •     Поддержка управляемого кода
  •     Windows Mobile 5.0 API
  •     Взаимодействие с ActiveSync
  •     Новые возможности системы
  •   Подготовка к работе
  •   Microsoft.WindowsMobile.PocketOutlook
  •   Встречи (Appointment)
  •   Работа с адресной книгой
  •   Электронная почта
  •   SMS-сообщения
  •   Прием и обработка SMS-сообщений
  •   Телефония
  •   State and Notifications Broker
  •   Мультимедиа
  •   Выбор изображения
  •   Работа с фотокамерой
  •   Повторение пройденного
  •   Встречи
  •   Отсылка письма
  •   Мелочь, а приятно
  •     Метод Directory.Exists
  •     Метод Bitmap.Save()
  • Глава 11 Создание игр
  •   Игры на мобильных устройствах
  •   Продуктовая аркада
  •     Начало работы
  •     Добавление изображения в программу
  •     Использование встроенных ресурсов
  •     Вывод картинки на экран
  •     Создание анимации
  •     Отражения
  •     Управление скоростью движения объекта
  •     Добавляем новый объект
  •     Устранение мерцания
  •     Хлеб — всему голова
  •     Обнаружение столкновений
  •     Столкновения батона и мяча
  •     Новые объекты
  •     Размещение помидоров
  •     Уничтожение томатов
  •     Счет игры
  •     Ведение счета
  •     Звуковые эффекты
  •     Дальнейшие улучшения
  •     И опять добавляем новые объекты
  •     Управление таблицей результатов
  •     Переключение между формами
  •     Отображение дочернего окна
  •     Получение имени игрока
  •     Хранение лучших результатов
  •     Улучшение графики
  •     Спрайты
  •   Другие игры
  • Глава 12 Связь
  •   Инфракрасное соединение
  •     История и теория
  •   Класс IrDAClient
  •   Создание программы для работы с ИК-связью
  •     Обнаружение устройств
  •     Передача данных
  •   Технология Bluetooth
  •   Несколько слов о связи
  • Глава 13 Использование неуправляемого кода
  •   Вызов функций Windows API
  •   Определение платформы
  •   Пароли
  •   Перезагрузка КПК
  •   Еще раз о перезагрузке
  •   Поворот экрана
  •   Прячем кнопку Start
  •   Панель задач
  •   Запуск других приложений
  •   Названия специальных файлов
  •   Использование звуковых файлов
  •     Системные звуки
  •   Системное время
  •   Создание ярлыка
  •   Количество строк в текстовом поле
  •   Реестр
  •     Наличие внешней клавиатуры
  •     Информация о пользователе
  •   Наличие дополнительной клавиатуры
  •   Виброзвонок
  • Глава 14 Кирпичики .NET Compact Framework
  •   Узнать версию .NET Compact Framework
  •   Узнать версию операционной системы
  •   Путь к запущенному приложению
  •   Специальные папки
  •   Узнать имя устройства
  •   Узнать ориентацию экрана
  •   Открытие файлов по умолчанию
  •   Создание и отправка письма
  •   Кнопки навигации
  • Послесловие
  •   Что дальше?
  •   Полезные ресурсы
  •     .NET Compact Framework 2.0 Redistributable
  •     Microsoft ActiveSync 4.1
  •     Русская версия эмулятора для Windows Mobile 5.0 Smartphone
  •     Русская версия эмулятора для КПК под управлением Windows Mobile 5.0 Pocket PC
  •     Сайт Роба Майлза
  •     Сайт Кристиана Форсберга
  •     OpenNETCF.org
  •     Google




  • MyBook - читай и слушай по одной подписке