|
как использовать Подключаемые модули исследовательская работа Карманное руководство пользователя с пояснительными рисунками и схемами Автор: bokzy, 2003
|
|
Итак, вы опробовали MMB, приобрели его через пару дней, потратили несколько недель на изучение языка скриптов, и вот, когда вы уже думали, что все веревочки в ваших руках - тут появился ваш сосед, обескуражив вас следующими словами: "Джон, не мог бы ты мне одолжить молоток, несколько гвоздей и копию подключаемого модуля Tweak с парой примеров для него?" Молоток и гвозди лежат где-то в гараже, но что за подключаемый модуль, о чем он говорит? Вы пытаетесь импровизировать. Несколько ржавых гвоздей, молоток со сломанной рукояткой - не беда, он починит - и модуль? Скорее всего, ему нужен блок питания, решаете вы, и отдаете ему один из них, и все в порядке. За исключением улыбки на лице вашего соседа. Наверно, это потому что гвозди ржавые. Так? Хм, не угадали. Да, он взял и молоток, и гвозди, но почему он отбросил блок питания, который вы ему дали? Неужели он не работает? Спустя несколько дней вы заглянули к соседу. Войдя в его дом, вы начали болтать с кружкой пива в руках... одним глазом поглядывая на экран компьютера... надо же, он что-то делает в MMB... и даже использует редактор скриптов (именно поэтому он не спал предыдущие 10 ночей). Так... Команды скриптов повсюду - Show, Hide, есть даже MoveObject... Volume Up, VolumeDown, Plugin... ммм... что это? Plugin... Set? Что это? Вы так удачно игнорировали эту команду! До этого момента. Некий фильм стал прокручиваться у вас в голове. Ему не нужен блок питания! Это была уловка, чтобы проверить, насколько далеко вы продвинулись в изучении MMB! Допив вторую кружку пива, вы побежали домой, захлопнули дверь, включили компьютер... вам предстоит несколько серьезных разговоров с MMB! Пришло время провести несколько ночей не рядом со своей любимой, а с MMB и подключаемыми модулями! Подключаемые модули везде. Давайте пропустим слова: "Все началось 200 лет назад..." ...потому что это не так ;) Большинство сегодняшних пользователей имеют возможность экспериментировать с подключающимися модулями, иногда даже не подозревая об этом. Долгое время дополнительные возможности осуществлялись различными дополнительными функциями, реализованными в основной программе. Поэтому, чтобы почувствовать разницу, необходимо было изменить всю программу. Однажды кто-то подумал о новом подходе - почему бы не создать дополнительные внешние модули, которые могли бы добавляться или заменяться как кирпичики? И почему бы людям со всего света не начать создавать подобные кирпичики? И они сделали это - как только были достигнуты соглашения, созданы стандарты, документация и обучающие статьи стали доступны всему миру, подключаемым модулям не пришлось долго дожидаться, чтобы получить немного внимания! Значит ли это, что мы должны были дожидаться стандартов, чтобы воспользоваться подключаемыми модулями? Да! Стандартизации на множестве уровней. Сегодня вы можете найти подключаемые модули (или плагины) везде - в графических редакторах, в приложениях для обработки видео, мультимедийных проигрывателях, почтовых клиентах... Но как они работают? В чем суть? Орбитальная станция - набор подключаемых модулей. Конечно же, вы хотя бы один раз видели орбитальную станцию. Они летают не так уж высоко над нами, падают туда и сюда, и внешне далеки от вещей, которые мы видим в научно-фантастических фильмах. Теперь представьте себе, что MMB является центральной частью орбитальной станции:
Да, без солнечных батарей это не слишком похоже на орбитальную станцию. Больше напоминает несколько пушек соединенных вместе ;) Но это не важно. Вот орбитальная станция MMB, представляющая саму программу MMB. Вы можете жить на этой орбитальной станции. Но спустя некоторое время, вы почувствуете необходимость в новых предметах. И для этих вещей потребуется больше места. В конце концов, и вам необходимо несколько акров свободного пространства, чтобы сбросить обувь и наслаждаться свежим воздухом. Благодаря шлюзам станции вы можете это сделать! Вам только нужно заглянуть в магазин дополнительных ресурсов и купить то, что вам нужно! Кому-то станет свободнее, а кто-то получит небольшое вознаграждение! Платите и уносите, и не волнуйтесь, установка не вызовет затруднений!
* Пивной модуль находится в стадии разработки Теперь у вас настоящая орбитальная станция! Больше пространства, больше возможностей, и она выглядит намного лучше, чем у соседа! Шлюзы орбитальной станции Давайте посмотрим правде в глаза - для установки первого плагина/модуля для вашей орбитальной станции вам придется вызвать специалиста. Не хотите? Тогда добро пожаловать: Краткое руководство Самостоятельного Установщика Подключаемых Модулей Поскольку орбитальная станция MMB сама заботится о своих шлюзах, то ваша часть работы по установке модулей будет несложной, если вы будете следовать данному руководству. Да, такое вот различие между сложностью установки и использования! Компоненты:
Это такой же файл, как и любой другой, но с необычным расширением - DLL. Вот несколько примеров имен файлов подключаемых модулей: tweak.dll Обычно имя файла отражает основную функцию подключаемого модуля. Очень трудно найти подключаемый модуль с таким именем: 3ksvow843beer.dll Чашечку кофе? Отлично! Где вы сможете найти подключаемые модули для MMB? Есть много мест, с которых можно начать, но чтобы сделать ответ на этот вопрос кратким, Руководство Пользователя рекомендует вам следующие:
Посетите сайты, посвященные MMB: Со временем ссылки могут измениться, поэтому воспользуйтесь поисковой машиной, если запрошенная страница не найдена. Вернемся к нашим делам! Вы создали отличную коллекцию подключаемых модулей и вернулись к этому руководству. Что дальше? Взгляните на окно MMB. Давайте посмотрим, что здесь можно найти...
Неееет... Продолжайте искать. Пробуем снова и... УРА!
Щелкните на пункте "Plug-In" и ваш курсор изменит свой вид, сигнализируя вам о том, что вы должны очертить прямоугольную область, которая впоследствии будет окном подключаемого модуля (если это визуальный модуль). Вы можете изменить размер и положение прямоугольника подключаемого модуля позже, поэтому не уделяйте этому много внимания сейчас.
Эй! Он плоский и совсем не похож на 3D-модуль для космической станции! Что ж, это так... вы же знаете, это как с подарками Деда Мороза... Всю правду о них узнаешь позже... По крайней мере, у вас есть прямоугольник подключаемого модуля! Щелкните по нему дважды. Появится новое диалоговое окно, оно очень простое:
Опции Имя (Label), Скрыть (Hide) и Зафиксировать положение (Lock Position) доступны для любого объекта. Вам требуется только запомнить имя объекта. Ниже этих стандартных опций находится поле, над которым написано "Подключаемый модуль" ("Plug In"). Справа от этого поля находится кнопка "...", говорящая о том, что вы можете поискать подключаемые модули на своих жестких дисках. Нажмите ее! Появилось хорошо знакомое окно выбора файла, позволяющее вам выбрать файл DLL - подключаемый модуль для MMB. Если вы создали коллекцию подключаемых модулей, загрузив их с сайтов разработчиков, то вы откроете соответствующую директорию и выберете файл. Ваша коллекция пуста? Откройте папку, в которую вы установили MMB и найдите каталог Plugins. Там вы обнаружите небольшой подключаемый модуль, разработанный компанией Mediachance и входящий в инсталляционный пакет MMB, с именем TenBlobs.dll Как только вы выберете файл и нажмете кнопку "Открыть", MMB спросит вас о том, что он должен сделать с файлом: "Хотите поместить подключаемый модуль в список вложенных файлов?" Да. В этом случае, подключаемый модуль будет вложен (прикреплен) в ваш проект. Фанаты Star Trek использовали бы выражение "ассимилирован" ;) Если подключаемый модуль вложен в проект, то вы уже не должны беспокоиться о его размещении при завершении проекта. MMB скомпилирует все вместе. Небольшое замечание - здесь есть свой недостаток, но об этом позже. После того, как вы вложите подключаемый модуль, диалоговое окно будет выглядеть следующим образом:
Путь к DLL-файлу содержит префикс <Embedded>\ Его называют макропутем, в нашем случае он говорит о том, что Tweak.dll вложен в ваш проект. Дополнительная информация о макропутях находится в разделе Константы. Ниже находится текстовое поле с комментариями - место, где разработчики подключаемых модулей помещают важную информацию: авторские права, имя автора, URL страницы поддержки и e-mail и так далее. Нажмите кнопку OK и вот! Если вы точно следовали Инструкции Установщика, то ваша работа по установке подключаемого модуля завершена! Сохраните ваш проект, закройте все и возвращайтесь завтра. Доброе утро. У вас есть 1 подключаемый модуль. Возможно, после добавления в проект подключаемого модуля вам показалось, что кое-что отсутствует. Где все диалоговые окна и панели настроек, которые так хорошо вам известны по подключаемым модулям для других программ? Хм. Подход к изменению настроек подключаемых модулей для MMB несколько иной. Если вы попробуете воспользоваться подключаемым модулем TenBlobs, поставляемым с MMB, то вы заметите возможность изменения некоторых параметров через диалоговое окно свойств. Другие подключаемые модули используют команды, чтобы сделать это. Почему это так? Используя язык скриптов MMB и просматривая некоторые примеры, предоставленные сообществом MMB, вы наверняка заметили, что он может использоваться для создания более широкого диапазона приложений, чем меню автозапуска или инсталляционные заставки. Начиная с этого момента, подключаемые модули для MMB предлагают вам возможность управлять ими из вашего приложения. В любое время, где угодно - используя язык скриптов MMB. Это огромное преимущество! Вы можете загружать, сохранять и задавать различные параметры, выполнять изменения через циклы и во время выполнения приложения... все это без необходимости взаимодействия с конечным пользователем. Представьте, насколько раздражительными для пользователя были бы выскакивающие каждую минуту диалоговые окна, требующие взаимодействия... ;) Правильно! Давайте признаем это - использование подключаемых модулей и языка скриптов является программированием. Таким образом, здесь у нас серьезное дело. За кулисами Давайте скажем несколько слов для тех пользователей, которые хотят знать больше о технической стороне вопроса. Вы угадали, сейчас пойдут сложные словечки, читайте внимательнее. Подключаемые модули MMB являются DLL - динамически подключаемыми библиотеками. Это означает, что они устроены подобно коллекции команд/функций. Помните шлюзы космической станции MMB? Разработчики подключаемых модулей используют их для взаимодействия с MMB. :) Таким образом, мы говорим о неких каналах взаимодействия. Некоторые из них используются для внутренних целей, но в данном руководстве мы рассмотрим те, что интересны пользователям подключаемых модулей:
Вот другой порядок взаимодействия подключаемых модулей и MMB:
Типы подключаемых модулей для MMB Существует два (2) типа подключаемых модулей: 1 тип подключаемых модулей: 98% подключаемых модулей относятся к этому типу. Они отличаются от обычных приложений тем, что они являются библиотеками DLL, взаимодействующими с родительским (MMB) приложением через команды ("каналы"), и их визуальные компоненты отображаются в окне объекта-плагина MMB-приложения. Все остальное практически независимо от родительского (MMB) приложения - вся обработка команд происходит внутри подключаемого модуля. Результат выполненной команды либо изменяет объекты внутри модуля, либо сохраняется в числовой/строковой переменной. И все эти возможности скрыты в подключаемом модуле. Больше никакого взаимодействия с MMB, а? Это очень важно понять - подключаемые модули 1 типа работают почти независимо в своих окнах, поэтому они не могут влиять на другие объекты - но эта неполнота взаимодействия также не позволяет другим объектам MMB перекрывать окно подключаемого модуля. Это именно то, что вы заметите, используя видимые подключаемые модули - такие как EditBox PlugIn, SlideShow PlugIn и т.д.
Также при использовании подключаемых модулей первого типа важно помнить то, что они не могут отображаться в нескольких объектах, если используется один dll-файл. Ресурсы нельзя разделить, поэтому, если вы хотите использовать два поля редактируемого текста с помощью модуля EditBox PlugIn, то вам необходимы два dll-файла. Вы должны переименовать их, например, так: EditBoxPlugIn1.dll EditBoxPlugIn2.dll Что бы получить два подключаемых модуля, работающих одновременно, вы дважды выполните действия, которые описаны в Руководстве Установщика Подключаемых Модулей.
Теперь у вас два подключаемых модуля. Первый называется "PlugIn1", а второй "PlugIn2". Имена важны при использовании команд, управляющих подключаемыми модулями, они используются в качестве ссылок на объекты. Также как при отправке почты - вы должны знать адрес получателя. В нашем случае вам требуется имя объекта-плагина. А как же использовать управляющие команды? Это самая важная часть данного руководства и скоро мы к ней приступим! Читайте дальше ;) 2 тип подключаемых модулей: подключаемые модули этого типа позволяют использовать несколько объектов для одновременного отображения, а также могут перекрываться другими объектами. Но они менее стабильны, поэтому эти модули используются редко. MMB предлагает вам ознакомиться с таким подключаемым модулем, он называется TenBlobs.dll
Вернемся в зрительный зал Уф! Предыдущая глава была слишком серьезной. Что мы успели узнать?
Не будем терять время на теорию! Мы должны переходить к практике! Как можно скорее! После установки подключаемых модулей, возможно, кто-нибудь спросит: Что же теперь получается? Они не похожи на модули космической станции (и вы можете пережить это), но и не похожи на аудиобиблиотеки для WinAmp, графические библиотеки для Photoshop и совсем не похожи на видеобиблиотеки для Premiere! Открыв свойства подключаемого модуля для WinAmp, вы увидите что-нибудь вроде этого:
...но если вы откроете окно свойств объекта-плагина для MMB...
...в 98% случаев:
вы НЕ УВИДИТЕ НИКАКИХ СВОЙСТВ! Что теперь? - Хм. Кажется, что мы должны будем изменять свойства подключаемого модуля где-то в другом месте. Где? - В редакторе скриптов, используя язык скриптов MMB! Посетим другую планету
Если вашим первым впечатлением при взгляде на это изображение было выражение "Что это такое!?", то, к сожалению, вы должны оставить руководство пользователя по подключаемым модулям и начать изучение языка скриптов MMB. Язык скриптов MMB Это основа использования подключаемых модулей для MMB - без понимания того, как работают переменные и где их использовать, вы потеряете половину своих волос, пытаясь понять, о чем идет речь в данном руководстве. Конечно же, вы не должны быть экспертом в языке скриптов, чтобы начать использовать подключаемые модули! Важнейшими элементами программирования в MMB являются:
Отправимся в логово ужасного чудовища-модуля? Пристегните ремни безопасности.
ЗАКОНЫ И КОНСТИТУЦИЯ ПОДКЛЮЧАЕМЫХ МОДУЛЕЙ В языке скриптов MMB существует три команды, управляющие подключаемыми модулями и используемые для организации взаимодействия с ними. Вы будете использовать эти команды в редакторе скриптов. Итак, мы говорим о СОДРУЖЕСТВЕ 3 КОМАНД
Фидо - собака-модуль Лучше один раз увидеть, чем сто раз услышать, поэтому давайте посмотрим, как старый добрый Фидо работает с командами!
Хотя, выполняя команды, наш Фидо не выглядит счастливым, в одном вы можете быть уверены - подключаемые модули не будут жаловаться и бросать на вас странные взгляды, независимо от того, насколько часто вы повторяете эти три команды, независимо от того, сколько костей вы бросите ;) Использование команд в скриптах Вы наверняка подумали: "Не может быть, чтобы эти команды работали просто так, без дополнительных параметров". И вы правы - как и большинство команд MMB, эти команды также используют скобки и кавычки, чтобы вы могли задавать параметры.
Команда PluginRun не отличается по структуре. Единственное заметное изменение - третья часть команды, где вы указываете не переменные, а требуемые команды модуля:
Подобно команде PluginSet, эта команда также использует переменные в третьей части, но на этот раз для того, чтобы получить значение - из подключаемого модуля!
Поместите, встряхните, получите - вуаля! Виртуальный пример номер 1! Теперь мы извлечем самые важные строки из предыдущих таблиц, поместим их друг за другом и получим что-то вроде... PluginSet("PlugIn","var$") Вот так! Первый блок кода для подключаемого модуля закончен! Совсем не больно, и все же, что делает этот код? Это пример. Некий виртуальный подключаемый модуль (объект назван так же, как был бы назван по умолчанию - "PlugIn"), к которому относится вышеприведенный код, выполняющий следующие действия:
Давайте дополним этот код несколькими строками: var$='Добро пожаловать домой, Тимон' Теперь у нас целая программа! Она помещает в переменную var$ текст "Добро пожаловать домой, Тимон", передает этот текст в подключаемый модуль (с помощью PluginSet), выполняет команду подключаемого модуля UpperCase (с помощью PluginRun), получает результат в выходную переменную text$ (с помощью PluginGet) и, наконец, отображает обработанный текст в окне сообщения MMB! Сейчас самое время обсудить, что именно делает команда UpperCase этого модуля - она приводит входной текст к верхнему регистру и возвращает его обратно в MMB. Живым и в верхнем регистре :) Таким образом, текст "Добро пожаловать домой, Тимон" превращается в кричащее "ДОБРО ПОЖАЛОВАТЬ ДОМОЙ, ТИМОН" :) Виртуальный пример 2 - без выходных данных Мы возьмем наш виртуальный, несуществующий подключаемый модуль еще раз и посмотрим, какие строки кода потребуются, если используются входные данные, но нет никаких выходных данных (подключаемый модуль молчит после выполнения команды PluginRun). Когда нам это необходимо? Обычно, когда входная переменная является всего лишь параметром, который будет "поглощен" подключаемым модулем - например, для изменения цвета, увеличения/уменьшения размера шрифта, запуска какой-либо важной команды в модуле (например, Connect (Подключиться), EncryptFile (Зашифровать файл), SetMute (Отключить звук)) или даже отправки сообщения через Интернет, или указания параметра для другой команды подключаемого модуля (например, указание исходного файла может выполняться командой SetSourceFile, указание конечного файла командой SetDestinationFile, и после указания обеих команд вы можете использовать третью - CopyAllFiles). Входные данные необходимы, а выходных мы не дождемся (точнее говоря, выходных данных в виде строковых/текстовых переменных). Командами, которые будут использоваться для этого, являются:
Поиск в документации приводит нас к описанию кое-чего, что могло бы служить для этой цели:
Хмм... что ж, эта команда может кое-что, но окно сообщения не появится :) Продолжим изучение непривычных джунглей документации подключаемого модуля...
Да, похоже, это то, что нужно! Как вы можете видеть из этих таблиц - документация имеет заголовок (Документация виртуального подключаемого модуля), подзаголовок, определяющий категорию команд (в нашем случае - Основные команды) и список команд с описанием и примерами. Большинство инструкций по подключаемым модулям предполагает, что объект-плагин в MMB будет иметь имя "PlugIn". Поэтому вы должны проверить имя объекта и скорректировать либо его, либо строки кода.
После прочтения описания команды ShowMessageBox вы решили использовать предложенный пример. Просто скопировав код из документации и вставив его в окно редактора скриптов, вы получили следующее: var$ ='Я не люблю кофе, клянусь!' Давайте познакомимся с этими строками поближе... Первая строка назначает текст строковой переменной var$ var$ ='Я не люблю кофе, клянусь!' Вторая использует команду PluginSet, чтобы передать текст подключаемому модулю PluginSet("PlugIn","var$") И, наконец, - мы вызовем команду PluginRun, чтобы сказать подключаемому модулю: "Эй, модуль, все параметры заданы, и теперь тебе пора выполнить команду ShowMessageBox." PluginRun("PlugIn","ShowMessageBox") А результат? Мы увидим его на экране!
Обратите внимание: вы не всегда сможете просто копировать/вставлять примеры из документации без корректировки кода. Она может зависеть от других команд и скриптов, у вас могут быть другие имена объектов, команды могут потребоваться вам для иных целей - примеры обычно демонстрируют основные возможности команд подключаемых модулей, и вы можете найти им лучшее применение (например, вышеприведенный код можно улучшить путем добавления возможности вводить текст сообщения в поле редактируемого текста и отображать сообщение по нажатию кнопки). Виртуальный пример 3 - без входных данных Исследуя сотни команд в описаниях различных подключаемых модулей, вы наткнетесь на команды этого типа - они не требуют входных данных ни в форме строковых переменных, ни в форме числовых - но они выполняются с помощью команды PluginRun, и вы можете получить результат их работы с помощью команды PluginGet. Для чего предназначены команды этого типа? В основном для получения:
В большинстве случаев вы будете использовать их для получения информации, такой как системная дата и время, чтения INI-файлов, определения объема свободной оперативной памяти, положения курсора и получения сведений о нажатых клавишах, чтения данных из реестра, информации из мультимедийного файла и так далее... Давайте определим системную дату! Вернемся к документации!
Мы, конечно же, скопируем этот пример в редактор скриптов: PluginRun("PlugIn","GetSystemDate") Заметьте разницу - здесь больше нет входной переменной - мы сразу воспользуемся командой PluginRun, чтобы сказать модулю: "Модуль, привет, извини за беспокойство, но не мог бы ты получить текущую дату из этой системы с помощью команды GetSystemDate, которая у тебя имеется?" С помощью команды PluginGet приходит другая инструкция, говорящая модулю: "Да, чуть не забыл - помести дату в переменную date$, чтобы я мог использовать ее в моем прекрасном проекте!" Конечно же, вы должны немного улучшить этот код, например, чтобы полученная дата отображалась в окне сообщения: PluginRun("PlugIn","GetSystemDate") Давайте посмотрим результат:
Пример подобный этому может использовать команду GetSystemYear, чтобы получить значение текущего года в числовую переменную: PluginRun("PlugIn","GetSystemYear") В этом примере результат выполнения команды PluginRun, которая в свою очередь вызывает команду GetSystemYear, будет помещен в числовую переменную year. Получив значение в числовую переменную, вы можете выполнить с ним математические операции, доступные в языке скриптов MMB. Виртуальный пример 4 - без входных и выходных данных? Да, вы найдете и такие команды! Странный вид команд... они ничего не требуют... они ничего не возвращают. Тогда для чего же они? Что ж, для задач, которые не требуют вспомогательных параметров и не возвращают никаких данных! И их много - Play, Stop, Show, Clear... Заглянем в документацию еще раз, на этот раз мы будем искать команду, которая отображает окно подключаемого модуля (давайте предположим, что это визуальный подключаемый модуль, имеющий такие визуальные эффекты, что было бы стыдно не показать их в приложении).
Снова скопируем пример в редактор скриптов: PluginRun("PlugIn","Show") Теперь это легко! Никакой возни с переменными, вы просто вызываете команду PluginRun, и она запускает команду подключаемого модуля Show! Обычно наряду с командой Show в подключаемом модуле присутствует команда Hide, которая выполняет противоположное действие - она скрывает окно подключаемого модуля. Она также не требует переменных, вы просто используете эту строку: PluginRun("PlugIn","Hide") Объединение примеров 1 и 2 Мы переходим к более сложному примеру, который объединяет команды 1 и 2 типа, а именно: мы будем
var$ ='Мой компьютер пристрастился к кофе!' Посмотрите! Вся последовательность команд, которая начинается с var$ ='Мой компьютер пристрастился к кофе!' ...заканчивается...
Нет никаких ограничений по числу последовательностей, которые вы можете выполнять подобным образом - и очень удобно выполнять их в циклах. Подключаемые модули и переменные Давайте потратим некоторое время на примеры, которые подготовят вас к встрече с различными входными/выходными переменными, используемыми с подключаемыми модулями. Пример с обычной строковой входной переменной Посмотрим в действии уже знакомую команду виртуального подключаемого модуля, которая называется ShowMessageBox. С помощью строковой переменной var$ вы задаете текст, который будет отображен в окне сообщения подключаемого модуля: var$='Живите долго и процветайте!' С помощью команды PluginSet содержимое переменной будет передано подключаемому модулю: PluginSet("PlugIn","var$") И с помощью команды PluginRun будет отображено окно сообщения: PluginRun("PlugIn","ShowMessageBox") Результат видно на экране:
Примеры с более сложными строковыми входными переменными С помощью обычных строк вы задаете текст в словесной форме или в форме предложений. Тогда что представляют собой более сложные строковые переменные? Это разновидность входных переменных, которые требуются подключаемому модулю для указания свойств/параметров. Фактически, есть два вида входных строковых переменных, задающих свойства/параметры подключаемого модуля...
Строки в верхнем регистре Как вы предположили, это имеет некоторое отношение к словам, набранным в верхнем регистре. Для чего вы будете их использовать? Чтобы задать такие свойства подключаемого модуля, как стиль границы окна или, чтобы определить события по нажатию кнопки мыши. Им требуются аргументы (обычно один аргумент) в виде слов, которые установят свойства подключаемого модуля после выполнения определенной команды. И употребление слов в верхнем регистре является соглашением, используемым для подключаемых модулей MMB. Этот пример задает стиль границы окна подключаемого модуля, используя слово SINGLE в качестве входного параметра для команды SetBorder. var$ ='SINGLE' Авторы подключаемых модулей приводят список допустимых параметров в документации, таким образом, вам не придется их отгадывать ;) Строки с запятой-разделителем Строка с запятой-разделителем представляет собой более сложную строку, которая использует запятую в качестве границы между двумя словами. Строка параметров относится к роду строк, которые изменяют параметры подключаемого модуля. Двумя основными (и важными) случаями, где вы будете использовать строки с запятыми-разделителями, являются:
Об обработчиках событий и цветах читайте далее. Эти понятия весьма важны для удобного обращения с подключаемыми модулями, поэтому рекомендуется пропустить примеры и ознакомиться с ними прямо сейчас. Пример строки с запятой-разделителем, которая служит для указания цвета фона с помощью команды виртуального подключаемого модуля SetBackColor: var$ ='10,201,20' После выполнения этого примера, цвет фона в окне виртуального подключаемого модуля выглядел бы так: Пока мы здесь, давайте посмотрим пример строки с запятой-разделителем, которая служит для назначения обработчика события с помощью команды виртуального подключаемого модуля SetHandler: var$ ='CTRL,SHIFT,ALT,U' Результат назначения обработчика события этой комбинации клавиш будет продемонстрирован, когда событие произойдет - нажатие клавиш CTRL, SHIFT, ALT и U будет сымитировано и передано вашему приложению. Примеры с целочисленной входной переменной Другой часто используемый тип входных переменных - целочисленный - существуют многочисленные команды подключаемых модулей, которые будут использовать именно этот тип переменных, чтобы задать громкость, размер шрифта, позицию медиафайла, количество секунд и т. д. Чтобы разобраться с этим, посмотрим пример, который устанавливает размер шрифта. С помощью входной целочисленной переменной вы задаете размер шрифта: var=18 С помощью команды PluginSet значение переменной будет передано подключаемому модулю: PluginSet("PlugIn","var") И с помощью команды PluginRun размер шрифта будет задан вызовом команды виртуального подключаемого модуля SetFontSize: PluginRun("PlugIn","SetFontSize") Вот как выглядит код в полном виде: var=18 И результатом будет изменение размера шрифта в подключаемом модуле:
Еще одним стандартным примером использования целочисленной входной переменной является указание громкости для подключаемого модуля. Допустимые значения в этом случае находятся в диапазоне 0-100, и подключаемые модули игнорируют любые меньшие или большие значения. Для нашего примера будет использована команда виртуального подключаемого модуля SetVolume для указания значения с помощью целочисленной переменной и изменения громкости подключаемого модуля. var=18 (колонки и медиаплееры не поставляются с данным руководством, поэтому просто попытаемся представить себе результат этого кода) Пример с обычной строковой выходной переменной Почти все команды подключаемых модулей, которые возвращают результат в виде строк, используют для этого обычные строковые переменные. Результатом будет слово, несколько слов, предложение и т. д. Вы уже ознакомились с выходными переменными строкового типа, используя команды UpperCase и GetSystemDate. Сразу после использования команды PluginRun вы вызовете команду PluginGet, чтобы получить строку - результат работы подключаемого модуля. С помощью команды виртуального подключаемого модуля GetComputerName: PluginRun("PlugIn","GetComputerName") ...команда PluginGet получит имя компьютера в строковую переменную var$: PluginGet("PlugIn","var$") Как только вы получили значение, вы можете делать с ним все, что захотите. В этом примере имя компьютера будет отображено в окне сообщения MMB: Message("Имя компьютера:","var$") Весь код выглядит так: PluginRun("PlugIn","GetComputerName") Вот результат, отраженный в окне сообщения MMB:
Примеры с более сложными строковыми выходными переменными Этот вид выходных строковых переменных используется в двух случаях:
Давайте познакомимся с: Уведомления о событиях В одном из разделов этого руководства вам предлагалось ознакомиться с назначением обработчиков событий и параметрами цвета. Вы прочитали их, прежде чем возвращаться к руководству? Хорошо! Тогда вы знаете, что подключаемые модули возвращают уведомления в виде строковых или целочисленных переменных, информируя вас о том, какое именно событие произошло. Как только событие произошло, объект-скрипт, назначенный для обработки комбинации клавиш, нажатие которой симулирует подключаемый модуль, получит выходную переменную с помощью команды PluginGet. Этот раздел посвящен строковым выходным переменным, поэтому в нашем случае будет получена строковая выходная переменная: PluginGet("PlugIn","var$") Что будет содержать переменная var$? Подключаемый модуль возвращает уведомление о событии, поэтому, если он выпил свое пиво, строка может выглядеть так: Я только что допил третью кружку пива. Ик. Как только это уведомление передано в выходную переменную var$, вы либо отобразите его в каком-либо текстовом объекте, либо воспользуетесь условным оператором, чтобы указать, что делать, если выпита третья кружка пива: If (var$='Я только что допил третью кружку пива. Ик.') Then Важно соблюдать все пробелы и регистр букв - MMB чувствителен к регистру, поэтому условие должно в точности соответствовать уведомлению подключаемого модуля. Пример не будет работать, если в условии вы укажете: If (var$ ='я только что допил третью кружку пива.ик.') Then ...потому что отсутствуют заглавные буквы и один пробел. Строки с разделителем Не беспокойтесь, этот тип используется редко. Подключаемый модуль вернет выходную строковую переменную, которая состоит из нескольких строк, разделенных определенным символом (заданным автором подключаемого модуля). С помощью строк этого типа подключаемый модуль может вернуть несколько значений, не выполняя команду PluginRun снова и снова, но чтобы получить отдельные строки вам понадобится дополнительный код, поэтому такой тип выходных переменных используется редко. Как только выполнена команда PluginRun, вы воспользуетесь командой PluginGet, чтобы получить выходную строковую переменную: PluginGet("PlugIn","var$") Что будет содержать переменная var$ в этом случае? Строку с разделителем, которая будет выглядеть так: собака|кошка|лошадь|змея|кролик|мышь Этот пример использует в качестве разделителя символ "|". Конечно, это может быть и другой символ: собака*кошка*лошадь*змея*кролик*мышь ...а чтобы узнать, какой символ используется подключаемым модулем (в некоторых случаях вы даже можете задать собственный разделитель), обратитесь к его документации. Примеры с целочисленной выходной переменной Подключаемые модули будут часто выдавать вам результат, используя переменные целочисленного типа. Начиная с подсчета результатов и заканчивая координатами и размером в байтах - все числовые результаты отправляются в целочисленные выходные переменные. До этого вы познакомились с выходными переменными целочисленного типа, используя команду GetSystemYear. Сразу после использования PluginRun вы вызовете команду PluginGet, чтобы получить число - результат работы подключаемого модуля. Обычный пример целочисленного результата С помощью команды виртуального подключаемого модуля GetRamCapacity: PluginRun("PlugIn","GetRamCapacity") ...команда PluginGet получит объем оперативной памяти в числовую переменную var: PluginGet("PlugIn","var") Как только вы получили значение, вы можете делать с ним все, что захотите. В этом примере объем оперативной памяти будет отображен в окне сообщения MMB: Message("Объем оперативной памяти (в байтах):","var") Весь код выглядит так: PluginRun("PlugIn","GetRamCapacity") Вот результат, отраженный в окне сообщения MMB:
Это был сырой пример, автоматически отображенный в MMB. Вы можете воспользоваться преимуществом числовых переменных, чтобы выполнить математические операции над результатом, полученным от подключаемого модуля. Вышеприведенный пример, дополненный математическими операциями, может выглядеть так: PluginRun("PlugIn","GetRamCapacity") Результаты будут отображены в MMB:
Пример уведомления о событии целочисленного типа Также как и при использовании строковых выходных переменных, подключаемый модуль может передать вам уведомление о событии, выраженное в виде переменной целочисленного типа. Когда вы можете столкнуться с этим? Если что-либо находится в процессе (например, воспроизведение медиафайла, передача файла по сети или локально) и подключаемый модуль может передать вам текущее значение прогресса выполнения, то это значение будет передано как уведомление о событии в выходную целочисленную переменную. Вероятно, вы будете использовать это значение для создания индикаторов выполнения, которые будут изменяться в зависимости от уведомлений о выполнении процесса, приходящих от подключаемого модуля. До сих пор не прочитали об обработке событий? Отправляйтесь в раздел, расположенный после раздела примеров, и читайте об этом! Вот пример использования уведомлений целочисленного типа, а именно уведомлений о ходе передачи файла. Как только событие произошло, объект-скрипт, назначенный для обработки комбинации клавиш, нажатие которой симулирует подключаемый модуль, получит выходную переменную с помощью команды PluginGet. Этот раздел посвящен целочисленным выходным переменным, поэтому в нашем случае будет получена целочисленная выходная переменная: PluginGet("PlugIn","var") Что будет содержать переменная var? Подключаемый модуль возвращает уведомление о передаче файла, поэтому, если процесс выполнен на 50%, значение будет таким: 50 Вы не и не ждали, что оно будет другим, верно? Как только это уведомление передано в выходную переменную var, вы либо отобразите его в каком-либо текстовом объекте, либо измените размер какого-нибудь объекта (например, прямоугольника, используемого в качестве индикатора прогресса), либо воспользуетесь условным оператором, чтобы задать поведение приложения (например, если процесс завершен). Этот код получает целочисленный результат (процент выполнения) и изменяет размер объекта Rectangle: PluginGet("PlugIn","var") Чтобы выполнить какое-либо действие после передачи файла, вы воспользуетесь кодом, подобным этому: PluginGet("PlugIn","var") Некоторые подключаемые модули MMB могут содержать перемещаемые компоненты. Поэтому, если подключаемый модуль передает уведомление об изменении положения объекта, то код может выглядеть так: PluginGet("PlugIn","var") Обработка событий События возникают в подключаемых модулях MMB, и ваше приложение получает уведомления о них: Через обработчики событий - объекты-скрипты, которые служат своего рода "сетью", перехватывающей события, генерируемые подключаемым модулем. Как все это работает? Как вы видели из примеров в этом руководстве, вы можете получить выходные данные, используя команды управления подключаемыми модулями. Но в некоторых случаях подключаемый модуль не может вернуть результат сразу после выполнения команды PluginRun. Это такие задачи, как:
Так как подключаемый модуль будет реагировать, когда задержанное событие произойдет? Он симулирует нажатие клавиш (отдельных клавиш или их комбинаций) и передаст его вашему приложению!
Вот так! Комбинация клавиш, переданная подключаемым модулем, активирует объект-скрипт, который настроен именно на эту комбинацию клавиш:
Теперь вы знаете, что такое Обработчики Событий - объекты-скрипты, реагирующие на определенную комбинацию клавиш (как видно на изображении выше). Они будут активированы, когда произойдет событие, таким образом, весь код внутри объекта-скрипта будет выполнен. Конечно, вы можете делать все, что угодно, используя этот код, но обычно первым действием является получение выходных данных от подключаемого модуля: PluginGet("PlugIn","var") - для целочисленного результата PluginGet("PlugIn","var$") - для результата строкового типа Обычно именно эти строки указываются первыми в обработчике события. Почему? Выходные значения могут измениться, если вы выполните другие команды подключаемого модуля перед тем, как получить выходные (целочисленные или строковые) данные, поэтому предпочтительно сделать это, как только событие произошло. Схема, приведенная выше, использует комбинацию клавиш CTRL+SHIFT+ALT+D. Подключаемые модули позволяют вам задавать свои собственные комбинации, используя команды управления подключаемыми модулями со сложными строковыми переменными качестве входного параметра. Помните раздел, который описывает использование подключаемых модулей с различными входными и выходными переменными? Верно, мы будем использовать строки с запятой-разделителем, чтобы задать комбинацию клавиш для обработки события! Конечно же, вы должны обратиться к документации и посмотреть точное имя команды, которая выполняет эту задачу. В нашем примере мы воспользуемся (в который раз) виртуальным подключаемым модулем с еще более виртуальной командой SetHandler: Прежде всего, используем строковую переменную var$, чтобы задать клавиши, которые будут активировать обработчик события. Являясь строкой с разделителем, она будет содержать запятые для разделения элементов-клавиш. Первые три клавиши являются системными (CTRL, SHIFT, ALT), четвертая может быть любой алфавитно-цифровой клавишей. Верхний регистр должен использоваться для всех клавиш, особенно для четвертой клавиши - объекты-скрипты позволяют задавать и реагируют только на буквы в верхнем регистре. Итак, первая строка кода задаст комбинацию клавиш: var$='CTRL,SHIFT,ALT,U' Может быть, вы не хотите использовать все системные клавиши? Просто оставьте запятые там, где системная клавиша пропущена: var$='CTRL,,ALT,U' Предыдущая строка не использует клавишу SHIFT. var$=',SHIFT,ALT,U' А эта строка не использует клавишу CTRL. var$=',,,U' С таким параметром подключаемый модуль вообще не будет использовать системные клавиши! Просто символ 'U'. Но использования только алфавитно-цифровых клавиш следует избегать - иначе пользователь может случайно нажать эту клавишу, ведь клавиша 'U' может быть очень популярной в вашем приложении ;) Примечание 1: Использование алфавитно-цифровой клавиши обязательно. Примечание 2: Заданные комбинации клавиш не должны быть занятыми различными планировщиками задач, инструментами автоматизации и тому подобным - эти инструменты могут регистрировать комбинации клавиш для глобального использования в системе, поэтому автор руководства рекомендует вам использовать необычные комбинации, такие как: var$='CTRL,SHIFT,ALT,]' или var$='CTRL,SHIFT,ALT,0' Хватит о комбинациях! Давайте лучше передадим значение var$ подключаемому модулю с помощью команды PluginSet: PluginSet("PlugIn","var$") Теперь, когда входная переменная задана, осталось только вызвать команду PluginRun и выполнить команду подключаемого модуля, которая задает комбинацию клавиш для обработки события (виртуальный модуль использует команду SetHandler). PluginRun("PlugIn","SetHandler") Строки кода разбросаны повсюду, давайте соберем их вместе! var$='CTRL,SHIFT,ALT,]' С помощью этих трех строк вы задаете комбинацию клавиш для обработчика событий. Это еще не все, вы не забыли? Вспомните, кое-что должно быть настроено на использование этой комбинации! - Фидо? Нет. - Кофе? Нет. - Сосед? Это было бы интересно, но в нашем случае - нет. - Может быть объект-скрипт, также известный как Обработчик События? ДА!
Как видно на изображении, первая строка в объекте-скрипте получает значение выходной переменной: PluginGet("PlugIn","item$") В зависимости от подключаемого модуля и рода события, произошедшее событие передаст в качестве выходных данных либо целочисленную, либо строковую переменную. Вы должны почитать документацию подключаемого модуля и посмотреть тип возвращаемой переменной. Обычно подключаемые модули используют строковые переменные, чтобы обозначить такие важные события, как: CONNECTED - установлено соединение (Поскольку язык скриптов MMB чувствителен к регистру, убедитесь, что вы используете верный регистр при написании условных операторов с использованием уведомлений о событиях) Подключаемые модули возвращают целочисленные результаты чаще всего для указания текущей позиции медиафайла - либо в процентах, либо в обычном формате: 12 Повторим, на практике в обработчике событий вы будете использовать: PluginGet("PlugIn","event$") ...чтобы получить от произошедшего события выходные данные (уведомления) строкового типа, и PluginGet("PlugIn","event") ...чтобы получить от произошедшего события выходные данные (уведомления) целочисленного типа. Как только в переменную помещено уведомление о событии, вы можете отобразить его в текстовом объекте: LoadText("Text","event$") LoadText("SoundPosition","event") ...или воспользоваться условным оператором, чтобы определить действия вашего приложения, когда произойдет какое-либо событие. Этот пример использует уведомление о виртуальном событии, полученное от виртуального подключаемого модуля, которое информирует ваше приложение о подключении к Интернет: PluginGet("PlugIn","event$") Еще раз! Этот код помещается в объект-скрипт, или обработчик события, который настроен на получение от подключаемого модуля нажатия комбинации клавиш. Важное замечание, касающееся Обработки Событий Получение уведомлений обработчиками событий возможно не всегда - если окно вашего приложения не активно в момент передачи комбинации клавиш от подключаемого модуля, то эта комбинация может быть передана -> какому-либо другому приложению! <- Также, использование диалоговых окон в приложении может привести к трудностям, если события происходят повторно с некоторым интервалом, потому что подключаемый модуль пытается сфокусироваться на основном окне приложения. Чтобы избежать дефокусировки диалогового окна, временно отключите передачу комбинаций клавиш и уведомлений (если подключаемый модуль позволяет это) на тот период, пока отображается диалоговое окно, и включите снова, когда пользователь завершит работу с диалоговым окном. Частые, повторяющиеся передачи комбинаций клавиш могут перекрываться нажатиями системных клавиш самим пользователем (если они используются). Будущие версии MMB должны предоставить более простой подход к этой теме, поэтому, мы надеемся, что работа с событиями будет легче как для разработчиков подключаемых модулей, так и для пользователей. Цветовые свойства Визуальные подключаемые модули имеют еще одну удобную особенность - цвет их объектов может изменяться динамически, во время выполнения приложения. Это очень важная особенность, дающая конечным пользователям возможность изменять визуальные свойства приложения в соответствии с их предпочтениями. Обычно вы можете задавать два цветовых свойства:
Изменение цветовых свойств происходит посредством команды подключаемого модуля, использующей строку с разделителем в качестве входного параметра. Опять, как и в случае с обработкой событий, мы будем использовать усложненные строковые входные переменные, на этот раз, чтобы задать цветовые свойства. Чтобы задать цвет через входной параметр, подключаемые модули MMB используют систему RGB, как мониторы, телевизоры и, конечно же, программы. RGB означает: Red (Красный)
Эти три компонента представляют основные цвета. Если вы смешаете их в различных пропорциях, то сможете получить другие цвета:
Задание пропорций, конечно же, происходит в определенном диапазоне значений. Подключаемые модули MMB используют тот же диапазон значений, который хорошо вам известен по стандартной цветовой палитре Windows: 0-255 Меньшее значение указывает на меньшую интенсивность компонента в RGB-цвете:
Входная строка с разделителем, с помощью которой задают цветовые свойства, содержит запятую в качестве разделителя между компонентами цвета: красный, зеленый, синий Значения выглядят так: 255,150,50 ...а на практике так: var$='255,150,50' Комбинация этих значений компонентов даст такой цвет:
Это значит, что передний план или фон подключаемого модуля станет оранжевым после выполнения команды, задающей цветовые свойства. Как обычно, вы обратитесь к документации подключаемого модуля, чтобы узнать точное имя команды. В рамках данного руководства воспользуемся командой виртуального подключаемого модуля SetBackColor: Прежде всего, воспользуемся переменной var$, чтобы задать три цветовых компонента в виде строки с разделителем: var$='170,40,170' С помощью команды PluginSet цветовые значения будут переданы подключаемому модулю: PluginSet("PlugIn","var$") Как только значения заданы, вызовем команду PluginRun, чтобы выполнить команду подключаемого модуля SetBackColor: PluginRun("PlugIn","SetBackColor") Результатом будет такой цвет фона подключаемого модуля:
Похожий скрипт можно было бы использовать для изменения цвета шрифта. Давайте воспользуемся командой виртуального подключаемого модуля SetFontColor, которая задает цвет шрифта: var$='102,102,153' В результате цвет шрифта станет серо-голубым:
Возможность изменять цвета во время выполнения приложения позволяет симулировать анимацию цвета с помощью циклов: For i=1 To 255 Для приложений с различными темами интерфейса вы наверняка будете использовать возможности подключаемого модуля по управлению цветами, чтобы изменить их в соответствии с загруженной темой. Цветовые настройки должны сохраняться, например, с помощью команд MMB, позволяющими работать с реестром: SaveVariable("BackColor","var$") Подключаемые модули: Подведение итогов Читая руководство, вы узнали о подключаемых модулях следующее:
Конец уже близко, приготовьтесь! ...чтобы заняться более серьезными делами, конечно! ;) Как любое руководство пользователя, данное руководство было бы всего лишь подшивкой страниц с изображениями и схемами, если бы его содержание не применялось на практике! Теперь отправляйтесь в (более-менее) реальный мир MMB - возьмите с собой подключаемые модули, на загрузку которых вы потратили столько часов - и широко откройте эти новые окна, впустите свежий воздух в ваш проект! Учитесь. Зарабатывайте. Наслаждайтесь. И еще несколько слов от автора этого руководства... Я думаю, что здесь нужно привести ответы на часто задаваемые вопросы, которые касаются подключаемых модулей. Разработчики подключаемых модулей высоко оценят, если пользователи проведут достаточно времени с этим руководством и ознакомятся с подключаемыми модулями, тем самым оставляя больше свободного времени для разработчиков. А кто они - разработчики подключаемых модулей? - несколько обычных парней, занимающиеся подключаемыми модулями как хобби, скорее на добровольной, чем на коммерческой основе Являются ли они частью команды Mediachance? - нет, разработчики подключаемых модулей не связаны с разработчиками Mediachance Как насчет поддержки пользователей подключаемых модулей? - если разработчик подключаемого модуля не располагает своей собственной системой поддержки, вы можете задать вопросы, поделиться советом и сообщить о неисправностях на MMB Forums. Пожалуйста, не забывайте о том, что разработчики подключаемых модулей тоже люди, имеющие обычную работу и жизнь, и ожидать от них поддержки 24 часа в сутки и 7 дней в неделю было бы очень трудно, особенно это касается старых бесплатных подключаемых модулей. Конечно, коммерческие продукты обычно имеют хорошую поддержку; что же касается вопросов о бесплатных подключаемых модулях, то на MMB Forums всегда найдутся добрые души, готовые помочь (за исключением случаев с ошибками в модулях) :) Поставляются ли демонстрационные mbd-файлы с подключаемыми модулями? - да, подключаемые модули обычно поставляются с демо-проектами, показывающими, как команды, описанные в документации, работают на практике. Обратите внимание на то, что в некоторых демонстрационных проектах пути в объекте-плагине будут указывать на <SrcDir> - это делается для того, чтобы уменьшить избыточность пакета (пакет содержит только одну копию DLL). В этом случае вы просто скорректируете пути в соответствии с расположением DLL. Другой случай, когда DLL находится в списке вложенных файлов <Embedded>: если вы не можете отыскать DLL в установочном пакете, то запустите демонстрационный проект и отправляйтесь в каталог временных файлов - там вы найдете требуемый файл DLL и сможете скопировать его, куда вам угодно. Что насчет легальности использования подключаемых модулей в коммерческих продуктах? - если вопросы легальности и связанные с ними ограничения не отмечены в документации особо, то подключаемый модуль может использоваться в любом проекте, независимо от того, коммерческий он или нет. Подключаемые модули прекрасны тем, что их покупка является незначительной тратой денег, в то время как их особенности дают вам широкие возможности и иногда они выполняют самые сложные функции вашего приложения, сохраняя ваше время и гарантируя хороший сон, не требуя выплаты отчислений. Вернемся к нашей истории - теперь вашему соседу есть о чем подумать! Пока он борется с переменными, вы уже перешли к обработке событий! Пока он добирается до событий - ваш проект уже вышел, поражая потребителей по всей планете! Только удостоверьтесь, что у него нет копии этого руководства...
Контактная информация: Это руководство бесплатно для персонального использования. Если вы нашли его полезным в процессе создания коммерческих продуктов, пожалуйста, поддержите развитие и поддержку данного руководства либо посредством покупки подключаемого модуля, созданного автором руководства, либо с помощью платежа, согласованного с автором руководства. Подключаемые модули: Руководство Пользователя (V1 01.06.2003) Ни одна часть этого руководства не может быть воспроизведена или скопирована каким-либо образом (электронным, механическим, фотокопированием, в виде записи или иначе) в коммерческих целях без разрешения автора. Руководство может использоваться только в личных образовательных целях. Автор не предусматривает ответственности относительно использования информации, содержащейся здесь. Хотя при подготовке руководства были предприняты соответствующие меры, автор не предполагает никакой ответственности за ошибки или упущения. Также не предусмотрена ответственность за ущерб, причиненный в результате использования информации, содержащейся в данном руководстве. Все термины, упомянутые в этом руководстве, которые являются известными торговыми марками, были соответственно выделены заглавными буквами. Однако автор не может с уверенностью гарантировать это. Использование терминов в этом руководстве не должно расцениваться как посягательство на торговую марку. Каждое усилие было направлено на то, чтобы сделать это руководство столь полным и настолько точным, насколько это возможно, но никакой гарантии не дается. Информация предоставляется по принципу "как есть". Автор не несет ответственности ни перед физическими, ни перед юридическими лицами относительно любой потери или убытков, связанных с использованием информации, содержащейся в данном руководстве. | |||||||||||||||||||||||||||||||||||||||||||||||||||||||
