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

Обладая поддержкой популярных входов, протоколов и устройств, таких как WM_Pen, WM_Touch, Mtdev, TUIO, Linux Kernel HID и других, Kivy также интегрирует симулятор мыши с несколькими касаниями. Кроме того, вам может быть интересно узнать, что его графический движок основан на OpenGL ES 2.

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

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

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

Системные требования

• Cython
• Python 2.x
• Другие дополнительные библиотеки (взаимозаменяемые):
• OpenCV 2.0 — Вход камеры.
• PIL — Отображение изображений и текста.
• PyCairo — Отображение текста.
• PyEnchant — Коррекция орфографии.
• PyGST — Воспроизведение аудио / видео и вход камеры.

Подано в соответствии с

Фреймворк NUI Разработка приложений NUI Разработка NUI Новый фреймворк разработки пользовательского интерфейса NUI

Как разделить переменную между модулями в Python или Kivy

Раньше я отвечал на несколько вопросов по Stackoverflow.com о том, как разделить ценности между разными Киви. Фактически, вы можете справиться с этим способом Python, вообще не используя фреймворк kivy. Здесь я подведу итог как киви, так и к питону.

1. Глобальная переменная

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

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

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
 12 
 

 def create_new_number (): 
 global wow 
 wow = 3 
 
 def read_new_number () : 
 global wow 
 print (wow) 
 
 create_new_number () 
 read_new_number () 
 
 
 

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

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

2.1 Пример Python выглядит так:

Первый файл, которому нужна эта переменная

 1 
 2 
 3 
 4 
 5 
 

 
 import Global 
 
 def change_number (): 
 Global.MY_NUMBER = 888 
 

Теперь прочтите окончательный результат из третьего файла

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 

 
 import Global 
 import first 
 
 first.change_number () 
 print (Global.MY_NUMBER) 
 
 
 
 

2.2 Пример Kivy

Вот файл, в котором хранится переменная, которую необходимо передать:

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

На каждом экране по 3 кнопки

• Чтение: чтение значения MY_NUMBER
• Изменение: добавить MY_NUMBER на 1
• Перейти: перейти к следующему экрану

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

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
 12 
 13 
 14 
 15 
 16 
 17 
 18 
 19 
 20 
 21 
 22 
 23 
 24 
 25 
 26 
 27 
 28 
 29 
 30 
 31 
 32 
 33 
 34 
 35 
 36 
 37 
 38 
 39 
 40 
 41 
 42 
 43 
 44 
 45 
 46 
 47 
 48 
 49 
 50 
 51 
 52 
 53 
 54 
 55 
 56 
 57 
 58 
 59 
 60 
 61 
 62 
 63 
 64 
 65 
 66 
 67 
 68 
 69 
 70 
 71 
 

 
 импортирует GlobalShared 
 из kivy.app import App 
 from kivy.lang.builder import Builder 
 from kivy.uix.screenmanager import Screen, ScreenManager 
 
 Builder.load_string ("" "
 : 
 BoxLayout: 
 ориентация: 'вертикальная' 
 Ярлык: 
 текст: «Я ScreenOne» 
 Метка: 
 id: lbl1 
 Кнопка: 
 текст: «Прочитать» 
 on_press: root.press_read () 
 Кнопка: 
 текст: «Изменить» 
 on_press: root.press_change () 
 Button: 
 text: 'Go to ScreenTwo' 
 on_press: app.sm.current = "screen_2" 
 : 
 BoxLayout: 
 ориентация: 'вертикальный' 
 Label: 
 text: 'I am ScreenTwo '
 Label: 
 id: lbl2 
 Button: 
 text:' Read '
 on_press: root.press_read () 
 Button: 
 text:' Change '
 on_press: root.press_change () 
 Button: 
 text: 'Go to ScreenOne' 
 on_press: app.sm.current = "screen_1" 
 "" ") 
 
 
 class ScreenOne (Screen): 
 def press_read (self): 
 self. ids.lbl1.text = "SharedVar is" + str (GlobalShared.MY_NUMBER) 
 
 def press_change (self): 
 GlobalShared.MY_NUMBER = GlobalShared.MY_NUMBER + 1 
 self.ids.lbl1.text = "SharedVar is now" + str (GlobalShared.MY_NUMBER) 
 
 
 class ScreenTwo (Screen): 
 def press_read (self): 
 self.ids.lbl2.text = "SharedVar сейчас" + str (GlobalShared.MY_NUMBER) 
 
 def press_change (self): 
 GlobalShared.MY_NUMBER = GlobalShared.MY_NUMBER + 1 
 self.ids.lbl2.text = "SharedVar is" + str (GlobalShared.MY_NUMBER) 
 
 
 class ScreenApp (App): 
 sm = ScreenManager () 
 
 def build (self): 
 ScreenApp.sm.add_widget (ScreenOne (name = 'screen_1')) 
 ScreenApp.sm. add_widget (ScreenTwo (name = 'screen_2')) 
 вернуть ScreenApp.sm 
 
 
 if __name__ == '__main__': 
 ScreenApp (). run () 
 

3. Путь Kivy

Самый простой способ — путь Kivy:

• объявить переменную уровня класса в приложении class
• Затем вы можете получить значение с помощью app.get_running_app (). Your_class_variable_name
• Не забудьте из приложения импорта kivy.app

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

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

На каждом экране по 3 кнопки

• Чтение: чтение значения MY_NUMBER
• Изменение: добавить MY_NUMBER на 1
• Перейти: перейти к следующему экрану

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

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

И я показываю здесь два способа доступа к общей переменной:

• как получить к нему доступ в файле .kv .
  • используйте приложение .XXXX для доступа к экземпляру приложения из .kv
• , как получить к нему доступ в файле .py .
  • используйте App.get_running_app (). XXXX для доступа к переменной

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
 12 
 13 
 14 
 15 
 16 
 17 
 18 
 19 
 20 
 21 
 22 
 23 
 24 
 25 
 26 
 27 
 28 
 29 
 30 
 31 
 32 
 33 
 34 
 35 
 36 
 37 
 38 
 39 
 40 
 41 
 42 
 43 
 44 
 45 
 46 
 47 
 48 
 49 
 50 
 51 
 52 
 53 
 54 
 55 
 56 
 57 
 58 
 59 
 60 
 61 
 62 
 63 
 64 
 

 из Киви.app import App 
 from kivy.lang.builder import Builder 
 from kivy.uix.screenmanager import Screen, ScreenManager 
 
 Builder.load_string ("" "
 : 
 BoxLayout: 
 ориентация: 'вертикальная' 
 Ярлык: 
 текст: «Я LoginScreen» 
 Метка: 
 id: lbl1 
 Кнопка: 
 текст: «Прочитать» 
 on_press: root.press_read () 
 Кнопка: 
 текст: «Изменить» 
 on_press: 
 app.MY_NUMBER = app.MY_NUMBER + 1 
 root.ids.lbl1.text = 'SharedVar is' + str (app.MY_NUMBER) 
 Button: 
 text: 'Go to ScreenTwo' 
 on_press: app.sm.current = "screen_2" 
 : 
 BoxLayout: 
 ориентация: 'вертикальная' 
 Метка: 
 текст: 'Я MenuScreen' 
 Метка: 
 id: lbl2 
 Кнопка: 
 текст: 'Читать' 
 on_press: root.press_read () 
 Кнопка: 
 текст: «Изменить» 
 on_press: 
 app.MY_NUMBER = app.MY_NUMBER + 1 
 root.ids.lbl2.text = 'SharedVar is' + str (app.MY_NUMBER) 
 Button: 
 text: 'Go to ScreenOne' 
 on_press: app.sm.current = "screen_1" 
 "" ") 
 
 class LoginScreen (Screen): 
 def press_read (self): 
 app = App.get_running_app () 
 self.ids.lbl1.text =" SharedVar is "+ str (app.MY_NUMBER) 
 
 класс MenuScreen (Экран): 
 def press_read (self): 
 app = App.get_running_app () 
 self.ids.lbl2.text = "SharedVar is now" + str (app.MY_NUMBER) 
 
 class HandSetApp (App): 
 MY_NUMBER = 0 
 sm = ScreenManager () 
 
 def build (self): 
 HandSetApp.sm.add_widget (ScreenOne (name = 'screen_1')) 
 HandSetApp.sm.add_widget (ScreenTwo (name = 'screen_2')) 
 вернуть HandSetApp.sm 
 
 if __name__ == '__main__': 
 HandSetApp ( ) .run () 
 

4. End

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

Спасибо за чтение!

Следуй за мной (albertgao) в твиттере, если хочешь услышать больше о моих интересных идеях.

1. Знакомство с Kivy — создание приложений в Kivy [Книга]

Глава 1. Знакомство с Kivy

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

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

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

Независимо от того, кто вы, если вы заинтересованы в создании рабочего приложения в Kivy, вы попали в нужное место! Я покажу вам шаг за шагом, как разработать погодное приложение. Вы начнете с настройки среды разработки Kivy и в конечном итоге получите приложение, работающее на вашем устройстве Android или iPhone.

Зависимости: сложная часть

Прискорбная правда в мире программирования заключается в том, что самое интересное приходит после долгой работы. Наладить и запустить Kivy — не слишком сложный процесс, но я бы не назвал его приятным. «Я установил библиотеку программирования после получаса усилий» просто не звучит так же, как «Я сделал всплывающее окно программы через 20 секунд!» Итак, чтобы поднять вам настроение, позвольте мне сказать вам, что через 20 секунд после того, как вы настроите все эти зависимости, вы напишете и запустите небольшое приложение Kivy.Готовы? Пошли!

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

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

Хотя я использую и рекомендую операционную систему Linux (весь код в этой книге был сначала написан и протестирован на Linux), я не предоставляю инструкций по установке Linux. Установка зависимостей в Linux обычно намного проще, чем в других операционных системах. Однако инструкции для этого полностью различаются в зависимости от того, какой дистрибутив Linux вы используете, и как пользователь Linux вы, вероятно, лучше меня знаете, как получить их для выбранного вами дистрибутива (если вы не используете Arch Linux, для которого Я написал тонну документации).У Kivy есть потрясающие инструкции для большинства популярных дистрибутивов Linux на странице загрузок.

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

Чтобы установить его, просто загрузите последнюю версию (версия 1.8 или выше) .dmg файл со страницы загрузки Kivy.Дважды щелкните файл в папке загрузок или стопке, чтобы открыть его. Затем перетащите файл Kivy.app в ярлык папки Applications внутри тома.

Перед тем, как закрыть том .dmg , также дважды щелкните файл Make Symlinks . Это позволит вам запускать Kivy как скрипт на терминале. Этот скрипт является своего рода оболочкой для исполняемого файла Python. После запуска Make Symlinks вы можете открыть терминал и ввести kivy .Вам будет представлено стандартное приглашение Python, как если бы вы выполнили команду python напрямую.

Совет

В Mac OS Mavericks (10.9) Apple представила новую функцию защиты от разработчиков, которая предотвращает запуск «нелицензионных» программ. Появится предупреждение о том, что вы не можете запустить сценарий, загруженный из Интернета, и не дает вам очевидного способа участвовать в дискуссии.

Однако есть скрытый обходной путь (я думаю, Apple просто хочет, чтобы вы доказали, что знаете, что делаете).В Finder откройте папку, содержащую сценарий. Затем щелкните значок, удерживая нажатой клавишу Control, и выберите в контекстном меню команду «Открыть». Это переопределит настройки безопасности и позволит запускать скрипт.

Это приглашение — ваш системный Python с некоторыми измененными путями, чтобы гарантировать, что все необходимые библиотеки установлены. Если вы опытный программист на Python, вам, вероятно, интересно, почему бы вам просто не использовать virtualenv . Виртуальные среды великолепны, когда ваши зависимости представляют собой библиотеки Python, которые вы можете установить из репозиториев pypi или Git.Однако многие зависимости Kivy представляют собой библиотеки C, которые имеют сложные взаимозависимости. Они включены в Kivy.app как набор динамических библиотек, которые загружаются при запуске сценария kivy .

Обратите внимание, что Kivy.app использует Python по умолчанию, который поставляется с Mac OS. Это означает, что вы будете использовать Python 2 вместо Python 3. Чтобы заставить их работать, вам придется адаптировать пару примеров из этой книги, но я выделил их, чтобы у вас не было никаких проблем.

По большей части вы будете использовать Kivy из терминала в этой книге. Ваш файл будет называться main.py . Я могу посоветовать вам запустить python main.py , но если вы используете Mac OS Kivy.app , вместо этого вы захотите запустить kivy main.py .

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

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

Загрузите ZIP-файл Kivy для Windows со страницы загрузки Kivy. Извлеките (щелкните файл правой кнопкой мыши и выберите «Извлечь все») ZIP-файл в известный каталог в вашей системе; Я рекомендую папку C: \ utils \ kivy .

Теперь вы можете открыть командную строку Windows. Введите команду cd C: \ utils \ kivy , а затем просто kivy . Это активирует среду Kivy, которая включает в себя нужные вам библиотеки. Он также включает в себя исполняемый файл Python (вы можете выбрать между Python 2 и Python 3 на странице загрузок). Вам придется выполнять этот шаг активации каждый раз, когда вы открываете новый терминал.

Обратите внимание, что вы также можете установить msysgit, чтобы получить удобный для программиста интерфейс командной строки (та же командная оболочка, которая используется по умолчанию в Linux и Mac OS).Если вы используете этот пакет, вам необходимо запустить исходный код kivyenv.sh вместо сценария kivy . Я рекомендую использовать этот установщик, так как у вас также будет доступ к системе контроля версий Git для управления исходным кодом, и он установит некоторые зависимости, которые вам понадобятся в главе 9.

Написание кода: The Easy Part

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

Начальный модуль Python для всех приложений Kivy должен называться main.py , поскольку инструменты сборки, которые вы будете использовать позже для автоматизации развертывания на мобильных устройствах, будут искать этот файл. Теперь добавьте пару строк кода в этот новый файл, как показано в примере 1-1.

Пример 1-1. Самое простое приложение Kivy

  из   kivy.app   import   App 


  Приложение   ()  .   запустить   ()  

Вот и все: самый простой код Kivy, который вы могли бы написать.Он импортирует класс App , создает его экземпляр, а затем вызывает метод run . Запустите этот код, активировав среду Kivy в терминале и набрав python main.py (или kivy main.py в Mac OS). Появится пустое окно с черным фоном. Закрой его.

Объект Kivy App выполняет внушительный объем работы от вашего имени. В этом прелесть объектно-ориентированного программирования. Этот объект что-то делает, и все, что вам нужно сделать, это приказать ему выполнить свою работу, вызвав метод run .Он заботится обо всем: взаимодействии с аппаратным обеспечением экрана; общение с устройствами ввода, такими как мультитач-дисплеи, клавиатуры и акселерометры; планирование задач; и больше. Мы поговорим об этом позже, а пока просто знайте, что если у вас нет объекта App , вы не получите окно.

Если вы не знакомы с основами объектно-ориентированного программирования, возможно, вы захотите просмотреть соответствующий раздел Руководства по Python. Если вы хотите более подробно осветить эту тему, см. Мою книгу Python 3 Object Oriented Programming (Packt, 2010).

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

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

Лично мне хочется чего-нибудь поинтереснее. Так что давай попробуем еще раз. Отредактируйте файл, чтобы он выглядел как в Примере 1-2.

Пример 1-2. Немного менее простое приложение Kivy

  из   kivy.app   import   App 


  класс   WeatherApp   (  приложение  ): 
      проезд 

 , если   __name__   ==   '__main__'  : 
          WeatherApp   ()  .  запустить   ()  

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

Введение в язык KV

Язык KV, часто называемый kvlang , представляет собой простой синтаксис разметки, который я думаю как «как бы выглядел HTML, если бы HTML выглядел как Python». Это очень чистый синтаксис, который делает дизайн интерфейса Kivy гораздо более приятным, чем любой другой набор инструментов, с которым я работал, включая Интернет.,

Вы будете создавать новый файл для хранения языка KV.Назовите его weather.kv и сохраните в том же каталоге, что и main.py . Ваш файл .kv всегда должен иметь то же имя, что и ваш класс приложения, но со словом App , удаленным с конца и преобразованным в нижний регистр. Таким образом, WeatherApp всегда будет искать информацию о макете в файле с именем weather.kv .

Я буду больше рассказывать о языке KV на протяжении всей книги. Для начала поместите Пример 1-3 в погоду .kv файл.

Пример 1-3. Языковой файл Simple KV

  Этикетка  : 
      text  :   «Hello World»  

Это очень простой языковой файл KV, который создает новый объект Label и устанавливает его текст в печально известную строку Hello World . Если вы сейчас запустите команду python main.py , вы увидите всплывающее окно, все еще с черным фоном, но также с текстом, отображаемым в его центре, как показано на рисунке 1-1.

Рисунок 1-1. Ярлык Hello World

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

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

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

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

• Форма для добавления новых локаций
• Список мест, которые ранее искали
• Экран текущих условий
• Экран прогноза
• Экран настроек

Они, конечно, будут состоять из других компонентов интерфейса. Я представлю вам нужные виджеты по мере их появления. Остальная часть этой главы будет посвящена форме для добавления нового местоположения.Эта форма довольно проста и требует только текстового поля для ввода названия города и кнопки для поиска этого местоположения (см. Рисунок 1-2 для макета).

Рисунок 1-2. Макет формы «Добавить местоположение»

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

Kivy использует слово widget для описания любого элемента пользовательского интерфейса.Вот лишь несколько примеров виджетов:

• Метка, которую вы создали в примере 1-3.
• Поле ввода текста и кнопки, которые вы скоро создадите
• Классы макета, которые составляют другие виджеты и определяют, где они должны отображаться.
• Сложные древовидные представления, такие как средства выбора файлов
• Рендеры фильмов и фото
• Поля с вкладками, которые отображают разные виджеты в зависимости от выбранной вкладки

Мне удобно думать о виджете как о некоем блоке, который имеет поведение и может содержать другие блоки.Класс Widget — самый простой из таких блоков. Пусто. Однако все другие виджеты расширяют этот класс в красивой иерархии наследования. Виджет Label — очень простой виджет, отображающий текст. Виджет Button более интерактивен и реагирует на события касания или щелчка. Виджет TextInput знает, как работать с событиями клавиатуры.

Более сложные виджеты, такие как TabbedPanel или FileChooser , состоят из множества других виджетов.На самом деле нет никакой концептуальной разницы между продвинутым и примитивным виджетами, кроме сложности их рисования на экране. Расширенные виджеты обычно состоят из виджетов Layout , которые, по сути, представляют собой блоки, которые знают достаточно о виджетах внутри них, чтобы определить, как они должны быть размером и позиционированы относительно друг друга. Существует несколько различных подклассов Layout . Я лично использую BoxLayout , если у меня нет особых потребностей, требующих GridLayout или FloatLayout . BoxLayout , который отображает виджеты в вертикальной или горизонтальной линии, как правило, лучше подходит для адаптации своего размера к дисплею, на котором он в настоящее время отображается.

Наконец, вы можете создавать собственные пользовательские виджеты, расширяя класс Widget (или, часто, подкласс Layout ) и применяя правила языка KV для описания того, как должен выглядеть виджет. Есть два способа сделать это. Один из них — создание пользовательских команд рисования для визуализации графики непосредственно на холсте виджета.Другой — составить несколько примитивных виджетов во что-то более сложное; именно этим вы и будете заниматься в этой главе.

Корневой виджет языка KV

Язык KV — это специальный предметно-ориентированный язык, который идеально подходит для создания пользовательских интерфейсов. Он имеет синтаксис в стиле Pythonesque и во многом заимствует идеи Python о простоте и элегантности. В языковом файле KV используется отступ, чтобы указать, какие «блоки» помещаются внутри других блоков.

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

Ниже спецификатора Label: корневого виджета находится блок с отступом. Внутри этого блока вы можете определить другие дочерние виджеты (кроме Label , как правило, не имеет дочерних элементов), и вы можете указать свойства этого виджета.Я расскажу вам больше о свойствах в главе 2, в том числе о том, как создавать собственные настраиваемые свойства для настраиваемых виджетов. А пока имейте в виду, что виджет Label имеет свойство text . Это свойство принимает строковое значение. Как строковое значение в Python, оно заключено в кавычки. Двоеточие отделяет имя свойства от значения, так же, как спецификатор ключа / значения в словаре Python.

Вы, наверное, догадались, что корневой виджет прикреплен непосредственно к окну Kivy и отображается.Если бы это был виджет-контейнер, содержащий несколько дочерних виджетов, он бы их тоже отобразил. Попробуйте изменить файл weather.kv , чтобы он выглядел как в Примере 1-4.

Пример 1-4. Базовый виджет контейнера

  BoxLayout  : 
      Этикетка  : 
          текст  :   «Привет» 
      Этикетка  : 
          текст  :   «Красивый» 
      Этикетка  : 
          текст  :   «Мир»  

В данном случае корневой виджет — это объект BoxLayout .Как я упоминал ранее, виджеты Layout по сути являются контейнерами, которые умеют удерживать другие виджеты и каким-либо образом их позиционировать. Поставляются три метки с отступом как дочерние по отношению к BoxLayout . Каждый из этих Label s имеет собственный блок с отступом, в котором настраиваются свойства этого виджета; в этом примере для каждого из них предоставляется свое значение , текст .

По умолчанию BoxLayout размещает каждый из своих дочерних виджетов рядом, слева направо, предоставляя каждому из них равное количество места.Поскольку вы ничего не сделали для изменения значений по умолчанию, вот что происходит при рендеринге файла KV. Если вы сейчас запустите python main.py , он отобразит три метки, как показано на рисунке 1-3.

Рисунок 1-3. Отрисовка базового виджета контейнера

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

Вместо этого создайте пользовательский виджет AddLocationForm , который инкапсулирует текстовый ввод, кнопку поиска, кнопку местоположения и результаты поиска в один виджет. Затем установите корневой виджет как экземпляр этого настраиваемого виджета. Пример 1-5 делает все это.

Пример 1-5. Пользовательский виджет AddLocationForm

  AddLocationForm  :   #   <  AddLocationForm   @BoxLayout  >  :   #   ориентация  :   "вертикальный"   BoxLout  : 
          TextInput  : 
          Кнопка  : 
              текст  :   «Искать» 
          Кнопка  : 
              текст  :   «Текущее местоположение» 
      ListView  : 
          item_strings  :   [  «Пало-Альто, MX»  ,   «Пало-Альто, США»  ]   #  

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

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

AddLocationForm - это BoxLayout , как и в предыдущем примере, но вы устанавливаете его свойство ориентации на вертикальное. Это заставит его дочерние элементы появиться один над другим. Дочерними элементами в этом случае являются еще один BoxLayout (этот горизонтальный) и ListView .

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

Отрисовка этого кода показана на рисунке 1-4. Он уже выглядит так, как я хочу, но пропорции виджета шаткие.

Есть пара проблем с пропорциями при рендеринге на Рисунке 1-4. Во-первых, текстовое поле и две кнопки слишком высокие. Во-вторых, текстовое поле не занимает достаточно доступной ширины.Об этом довольно легко позаботиться с точки зрения строк кода. Однако я считаю, что установка пропорций в виджетах Kivy сбивает с толку. Я надеюсь избавить вас от этого разочарования, предоставив подробные объяснения в этом разделе!

Объект Layout определяет, какого размера должны быть его дочерние виджеты. Допускается получение двух советов от своих детей, если дети захотят их дать, но также можно игнорировать этот совет. Например, горизонтальный виджет BoxLayout всегда будет делать его дочерние элементы той же высоты, что и он сам, независимо от того, что дочерний виджет запрашивает (это может вызвать серьезные проблемы, если дочерний виджет находится в подростковом возрасте).

Рисунок 1-4. Отрисовка AddLocationForm

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

• size_hint_x
• size_hint_y
• size_hint (кортеж из size_hint_x , size_hint_y )
• ширина
• высота
• размер (кортеж из ширина , высота )

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

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

Главное помнить, что размер виджета рассчитывается на основе суммы значений size_hint для всех виджетов. Одиночный виджет, имеющий size_hint из 1 , не имеет смысла, если вы также не знаете, что его родственный виджет имеет size_hint из 2 (первый виджет будет меньше второго) или 0.5 (первый виджет будет больше). Взгляните на пример 1-6, представленный на рисунке 1-5.

Пример 1-6. Подсказки по размеру

  BoxLayout  : 
      ориентация  :   "вертикальная" 
      BoxLayout  : 
          Кнопка  : 
              size_hint_x  :   1 
          Кнопка  : 
              size_hint_x  :   1 
          Кнопка  : 
              size_hint_x  :   1 
      BoxLayout  : 
          Кнопка  : 
              size_hint_x  :   1 
          Кнопка  : 
              size_hint_x  :   2 
          Кнопка  : 
              size_hint_x  :   3 
      BoxLayout  : 
          Кнопка  : 
              size_hint_x  :   1 
          Кнопка  : 
              size_hint_x  :   0.75 
          Кнопка  : 
              size_hint_x  :   0,25  

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

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

Совет

Одна из самых неприятных проблем с компоновкой для новичков Kivy заключается в том, что свойства размера (включая ширину и высоту ) игнорируются, если только соответствующий size_hint свойства установлены на Нет . Значение по умолчанию для size_hint - 1.0 .

Таким образом, как показывает практика, каждый раз, когда вы выбираете для виджета высоту , вы также должны установить size_hint_y на None .Точно так же каждый раз, когда вы устанавливаете ширину , вы должны установить size_hint_x на None , если хотите получить ожидаемые результаты. И, конечно же, если вместо этого вы установите свойство size , вы должны установить size_hint на (None, None) .

Сами значения ширины и высоты довольно легко интерпретировать. Они могут быть целыми числами, и в этом случае они относятся к размеру виджета на экране в пикселях.Однако вы также можете передавать строковые значения, такие как "1см" , "0,75 дюйма" или "100dp" , чтобы отобразить виджет относительно разрешения дисплея. Это почти всегда хорошая идея, потому что современные устройства могут иметь чрезвычайно широкий диапазон плотности пикселей. Пиксель на дешевом ноутбуке может быть в три раза больше пикселя на смартфоне высокого класса, а разница даже больше для так называемых дисплеев Retina.

Лично я, если у меня нет веской причины поступить иначе, я всегда использую концепцию Киви о пикселях дисплея , передав суффикс dp моим свойствам height и width .Пиксель дисплея - это величина, не зависящая от разрешения, которая примерно соответствует «размеру пикселя на типичном ноутбуке при 72 точках на дюйм». На экране нижнего уровня 1 пиксель дисплея эквивалентен 1 пикселю. На топовых дисплеях ширина пикселя может составлять 3 или 4 реальных пикселя. Пиксель дисплея будет примерно одинакового размера на всех устройствах; сами пиксели меньше. Это не гарантируется, но я считаю, что пиксель дисплея на мобильных устройствах немного больше, чем на настольных компьютерах и ноутбуках. Это полезно, поскольку сенсорные интерфейсы должны предоставлять немного больше места для виджетов, чтобы приспособиться к неуклюжему размеру человеческого пальца.

Помните, что данный макет может игнорировать свойства width и height , если он того пожелает. Также помните, что большинство макетов Layout игнорируют эти свойства, несмотря ни на что, если для size_hint не установлено значение None в этом измерении. Держите эти знания под рукой, и вам (я надеюсь) никогда не придется пережить травму, которую я нанес, чтобы выяснить размеры Киви! Это действительно довольно элегантно; Не знаю, почему мне когда-то было так сложно.

После всего этого чтения вы, вероятно, захотите увидеть код языка KV. Надеюсь, пример 1-7 вас удовлетворит.

Пример 1-7. Настройка размеров виджета в AddLocationForm

Обратите особое внимание на отступ, чтобы вы могли сказать, какое свойство размера установлено для какого виджета. Помните, что есть два объекта BoxLayout . Внешний вид AddLocationForm , тип BoxLayout , является вертикальным. Вы устанавливаете внутренний (по умолчанию горизонтальный) BoxLayout , чтобы иметь явную высоту 40 пикселей дисплея.Это означает, что TextInput и две кнопки внутри будут ограничены этой высотой, так как они расширяются, чтобы заполнить всю высоту родительского элемента. Обратите внимание на явную установку size_hint_y от до None !

TextInput дается size_hint_x из 50 , чтобы он занимал половину ширины окна, поскольку родительский виджет занимает весь размер окна.

Двум объектам Button назначается size_hint_x из 25 , поэтому каждый из них занимает четверть ширины.Значения size_hint_x для трех виджетов в сумме составляют 100 , что позволяет нам легко думать о них как о процентах.