Все, что вы хотели знать о написании скриптов для JFW,
                  но не знали, кого спросить

                        ВВедение

Что такое скрипты? Давайте начнем с некоторых определений. Что
такое скрипт вообще? Когда вы выполняете на компьютере какую-либо
работу, она обычно включает некоторое количество шагов. Возможно,
вам приходится нажать несколько клавиш, чтобы попасть в нужную
часть программы, чтобы выполнить некоторую работу, или возможно
вам приходится нажимать несколько клавиш, чтобы открыть
программу, с которой вы хотите поработать. Затем, после того, как вы
оказались там, где хотели, вам возможно придется нажать еще
несколько клавиш, чтобы ввести нужные данные. Например, вы
находитесь в текстовом редакторе, и хотите ввести в верхней части
письма свой обратный адрес. Это может оказаться утомительным
занятием, если вам часто приходится это делать. Поэтому разве не
замечательно было бы набирать обратный адрес с помощью одной
единственной клавиши? Это как раз то, что делает скрипт. Скрипт
(ранее известный как макрос) - это небольшая компьютерная
программа, которая объединяет несколько шагов или комбинаций
клавиш в одну операцию, которую вы можете активизировать быстро и
просто. Ну, по крайней мере это один из типов скриптов. Jaws и
другие компьютерные приложения все время используют скрипты, и
очевидно, делают это не для того, чтобы набирать обратный адрес.
Поэтому, более глобально, скрипты - это последовательности отдельных
шагов, которые можно использовать для активизации и управления
широким диапазоном компьютерных процессов, начиная от таких
простых шагов, как повторение повторяющихся строк данных, и кончая
сложными вещами, которые ваш компьютер делает на постоянной
основе в качестве части своей деятельности. Именно такого рода
функциями мы и намерены озаботиться в данном руководстве. Хотя то,
что вы здесь узнаете, вы спокойно сможете использовать для
написания обратных адресов, вы также научитесь контролировать Jaws
таким образом, что он будет вести себя в большем соответствии с
вашими желаниями. Многие аспекты управления компьютером, которые
мы считае само собой разумеющимися, фактически находятся под
контролем скриптов. Мы, конечно, не считаем их скриптами, поскольку
они закодированы внутри приложения. Например, когда мы пользуемся
клавишами управления курсором, или вызываем в Microsoft Word
диалог с помощью горячей клавиши, на самом деле мы вызываем часть
программы, которая выполняет ряд операций или шагов. Согласно
нашему определению, это и есть скрипт. Jaws использует много
различных видов скриптов, которые сообщают ему, что делать в
определенных ситуациях или когда вы нажимаете определенные
клавиши. Jaws потому и стал такой чрезвычайно мощной программой,
что разработчики не стали прятать эти скрипты как часть главной
программы, таким образом сделав их недоступными для пользователя.
Если бы они так поступили, то Jaws был бы куда менее гибким
инструментом и был бы куда менее приспособляемым к нуждам
необычных приложений. Разработчики Jaws приняли сознательное
решение, позволить вам писать собственные скрипты для конкретных
целей и и дать вам возможность видеть и модифицировать отдельные
скрипты по умолчанию, которые контролируют многие аспекты работы
программы. Модифицированные или заново написанные скрипты затем
группируются в файлы скриптов, которые имеют то же имя, что и
приложение, для которого они созданы, но имеют другое расширение.
Доступ к скриптам, которые контролируют наиболее фундаментальное
поведение Jaws был обеспечен по двум веским причинам. Во-первых,
каждый пользователь хочет иметь возможность настроить поведение
программы так, как он или она хочет. Во-вторых, хотя разработчики
Jaws предусмотрели многие ситуации, возникающие при чтении экрана
в разных приложениях, невозможно предвидеть любую странную или
нестандартную установку экрана, которую могут придумать
программисты всего мира. В вашем распоряжении находится мощный
арсенал команд скриптов, которые вы можете применять по запросам
таких необычным образом разработанных программ. Вам остается
только научиться пользоваться ими. Кстати, чтобы настроить Jaws,
далеко не всегда следует пользоваться скриптами. Например,
определенные части экрана можно заставить озвучивать, или
игнорировать посредством использования фреймов (frames), которые
можно создать при помощи диспетчера фреймов. Со временем,
несомненно появятся дополнительные режимы, которые дадут вам
возможность настраивать Jaws не обращаясь к скриптам. Но всегда
будут необычные или запутанные ситуации, с которыми сможет
справиться только хорошо написанный скрипт. Помните, что после
того, как вы научитесь пользоваться языком скриптов Jaws, у вас в
руках окажется мощный инструмент, гораздо более мощный, чем
любой встроенный режим. Поэтому вы, вероятно, спрашиваете себя, в
чем же разница между макросом и скриптом? В общем-то никакой.
Скрипт - это макрос, и так оно и есть. Не позволяйте жаргону вас
запутать. Теперь мы будем называть их скриптами.

                   Скрипты против функций

Скрипты Jaws можно разделить на две главных категории. Те, которые
вызываются нажатием клавиш, называются скриптами, а те, которые
нет - функциями. Давайте сначала поговорим о клавишных скриптах.
Откуда Jaws знает, что он должен прочитать новую строку текста,
если вы находитесь в текстовом редакторе и нажимаете клавишу
"Стрелка вниз"? Ну, он узнает это, поскольку в главном файле
скриптов Jaws, который называется файл скриптов по умолчанию, есть
скрипт, который "Привязан" к клавише "Стрелка вниз" и этот скрипт
сообщает Jaws, что он должен прочитать новую строку. Этот
конкретный скрипт носит название "SayNexnLine" и он активизируется,
когда вы нажимаете клавишу "Стрелка вниз". Этот скрипт довольно
сложен, потому что он должен проанализировать, где вы находитесь, и
что вы собираетесь сделать, когда нажимаете "Стрелку вниз". Он
проверит, в каком типе окна вы находитесь, когда нажимаете стрелку
вниз, и, если вы находитесь в текстовом окне текстового редактора, он
озвучит строку, на которую вы переместились. В этом файле скриптов
есть строка, которая звучит как "SayLine ()", и она активизируется
после того, как ваш курсор перемещается на следующую строку. Это
строка скрипта, которая фактически выполняет функцию, которая
читает строку. Существует аналогичный скрипт, который называется
"SayPriorLine" (Прочитать предыдущую строку), который
активизируется, когда вы нажимаете клавишу "Стрелка вверх". Этот
скрипт использует аналогичную функцию "SayLine", в качестве части
своего кода. Когда вы нажимаете клавиши "Стрелка влево" и "Стрелка
вправо", активизируются два других скрипта, "SayNextCharacter"
(Прочитать следующий символ) и "SayPriorCharacter" (Прочитать
предыдущий символ). Эти скрипты используют как часть своего кода
функцию "SayCharacter", чтобы озвучить новый символ после того, как
курсор на него переместился. Есть и другие скрипты, прикрепленные к
клавишам,предназначенные для того, чтобы оперировать, когда вы
нажимаете на вашей клавиатуре другие клавиши. Эти скрипты
анализируют текущую ситуацию и пытаются выполнить действие,
соответствующее этой ситуации. Если ситуация очень необычная и не
была предусмотрена разработчиками Jaws, то вы можете сделать
некоторые модификации, чтобы команды выполнялись как положено.
Скрипты, которые не связаны с клавишами, или которые не
активизируются клавишами, называются функциями. Поскольку эти
функции нельзя активизировать при помощи клавиш, их нужно
использовать другим способом. Функции также отличаются от
скриптов, закрепленных за клавишами, еще и тем, что завершая
выполнение, они возвращают некоторую информацию, тогда как
закрепленные за клавишами скрипты этого не делают. Повторим еще
раз: не позволяйте жаргону вас запутать. Функция - это просто
скрипт, который не закреплен за конкретной клавишей и который при
выполнении возвращает некоторую информацию.

                   Почему это так сделано?

Есть два очень веских основания. Во-первых, некоторые функции
отрабатывают автоматически, когда происходят определенные события.
А значит, нет необходимости закреплять эти функции за
определенными клавишами, поскольку их активизирует не клавиша.
Во-вторых, иногда набор скриптовых утверждений применим ко
многим ситуациям, и может быть использован снова и снова. Вместо
того, чтобы выписываать этот набор утверждений для каждого скрипта,
который в нем нуждается, он может быть помещен в функцию,
которая может быть использована, или "вызвана" любым другим
скриптом, которому это может понадобиться. Таким образом, функции
подразделяются на две категории, на те, которые срабатывают
автоматически, когда происходят определенные события, и на те,
которые нужно запускать, или "вызывать" из другого скрипта. Первый
тип называется функциями событий, поскольку они запускаются
автоматически, когда происходит некоторое системное событие.
Например, функция NewTextEvent вызывается, когда на экране
пишется новый текст, а функция BottomEdgeEvent вызывается, когда
курсор достигает нижней строки окна. Без функции NewTextEvent
Jaws вообще не смог бы ничего озвучивать автоматически, когда
информация появлялась бы на экране, а без функции BottomEdgeEvent
ваш системный курсор никогда бы не подавал звуковой сигнал, и не
выдавал бы предупреждение, когда Jaws курсор достигал бы нижней
строки окна. Второй тип функций, который не вызывается
автоматически определенными событиями Windows, не имеет
сипциального названия (верите вы в это, или нет), поэтому мы просто
будем называть их функциями. Эти плоские функции действуют
только в том случае, когда они вызываются другими скриптами или
функциями. Это делается путем помещения имени функции внутри
другого скрипта или функции. Если вы именно так и делаете, то, когда
скрипт доходит до строки, на которой написано имя этой функции, он
приводит к выполнению именно этой функции. Этот процесс
называется "Вызовом" функции. Да, я знаю еще много жаргонных слов,
но вам придется к ним просто привыкнуть. Под вызовом функции
имеется в виду просто помещение имени функции в другой скрипт,
чтобы она была выполнена в нужное время. Например, функция
NewTextEvent, упомянутая выше, имеет строку, в которой написано
"SayNonHighlightedText ()". Если функция NewTextEvent
проанализировала новый текст, написанный на экране, и решила, что
он будет должным образом обработан функцией SayNonHighlightedText,
она передаст работу этой функции, вызвав ее и позволив ей
озвучивать текст для вас. С другой стороны, если функция
NewTextEvent решает, что информация на экране является выделенным
текстом, то она вместо этой вызовет другую функцию, которая
называется SayHighlightedText, и даст возможность этой функции
озвучивать текст. Решения, решения, решения... Ну, скрипты как раз
этим и занимаются. Они анализируют, что происходит на экране и
принимают решение относительно того, как озвучить экран. Если они
делают это неправильно, ваша задача - модифицировать
соответствующий скрипт таким образом, чтобы все было сделано
правильно. Кстати, вы наверное заметили, что после упомянутой выше
функции SayNonHighlightedText стоят открывающая и закрывающая
скобки. Эти скобки всегда требуются при вызове функции из скрипта.
Иногда внутри этих скобок помещается некоторая информация, но об
этом мы поговорим чуть позже.

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

                   Константы и переменные

Нам придется ввести еще два понятия, прежде чем мы на деле
займемся написанием скриптов. Это "Переменная" и "Константа".
Переменная - это слово из одной или нескольких букв, которое можно
использовать для сохранения значения, которое определяется в процессе
работы скрипта. Это значение часто неизвестно заранее, и во время
работы скрипта оно может меняться несколько раз. Значение, которое
определяется, приписывается переменной в ходе выполнения скрипта, и
переменная сохраняет это значение, пока оно не изменится, или если
оно не изменится другой операцией скрипта. Значение этой
переменной можно использовать для принятия решений этим, или
другим скриптом. Например, в утверждении "Пусть X = 1" X - это
переменная, и мы приписываем ей значение 1. X будет иметь значение
1 до тех пор, пока мы не изменим его на нечто другое, или пока
выполнение скрипта не сделает это за нас. Кстати, это есть вид
утверждения скрипта, которое мы используем, чтобы вручную
присвоить значение переменной. При выполнении конкретного скрипта
мы можем иметь утверждения, которые делают одно если X = 1, но
если X имеет другое значение, они делают что-то другое. Чтобы
продолжить наш пример, значение, хранящееся в переменной X, может
представлять тип окна, в котором мы сейчас находимся, скажем,
Кнопка (Button), поле редактирования (Edit field), или список (List box).
X будет иметь различное значение для каждого из разных типов окон,
а нашему скрипту может понадобиться выполнить различные оперкции
в зависимости от того, в каком окне мы сейчас находимся, и
следовательно от того, какое значение было присвоено переменной X.
Если бы наш скрипт имел возможность заглянуть в операционную
систему Windows и определить тип окна, в котором мы сейчас
находимся, скрипт мог бы присвоить X соответствующее значение,
после чего скрипт мог бы продолжить выполнение, приняв решение
относительно того, какой из вариантов действий выбрать, основываясь
на значении (т.е. типе окна), хранящемся в переменной. К счастью,
Jaws имеет возможность заглянуть в операционную систему Windows,
и такой тип решений, основанный на типе окна, это в точности та
работа по принятию решений, которую непрерывно выполняет Jaws. В
следующий раз, при запуске того же самого скрипта, мы можем
оказаться в другом типе окна, и, следовательно, в переменной будет
храниться другое значение. Поэтому скрипт может предпринять
совершенно другое действие, соответствующее данному типу окна. Еще
раз повторим, что скриптам часто приходится принимать решения, и
значение, хранящееся в переменной, это один из способов решить, что
делать дальше.

Константы - это совершенно другое дело, поскольку, как явствует из
их названия, они по ходу дела не изменяют своего значения. Если
константе присвоено значение, оно остается постоянным. Это может
показаться просто пустой тратой времени, но на самом деле это очень
удобно. Константы - это способ использования легко запоминающихся
имен для хранения труднозапоминаемых строк символов или чисел.
Предположим, например, что наш друг Джо имеет номер социальной
безопасности 589-43-3894. Далее, предположим, что нам нужно
работать с десятью человеками, и у каждого, или у каждой, будет свой
номер социальной безопасности. Мы можем просто задать константу,
присвоив ей имя JoeSecNum, а затем поместить его номер социальной
безопасности в эту константу, воспользовавшись равенством
JoeSocSecNum=589433894. С другими лицами и их номерами
социальной безопасности можно проделать нечто аналогичное. Затем,
когда нам понадобится отпечатать номер социальной безопасности, все
что нам нужно сделать, это запросить у программы отпечатать
константы номера социальной безопасности для каждого из десяти
человек. Поскольку JoeSocSecNum запомнить гораздо легче, чем
589-43-3894, мы можем изрядно облегчить себе жизнь,
воспользовавшись константой, вместо того, чтобы пытаться запомнить
длинный ряд чисел. Jaws очень часто выполняет такую работу, и вот о
чем мы говорим, когда говорим о константах применительно к языку
скриптов Jaws.

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

                    Структура руководства

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

              Часть I: начало работы со скриптами

                    Скрипты: краткий обзор

Предположим, вы работаете в приложении, которое выводит на нижней
строке окна описание каждого пункта меню. Если для зрячего
пользователя назначение данного конкретного пункта меню будет
неясным, он просто взглянет вниз, и прочитает, что написано на
нижней строке. Можно, конечно, включить Jaws курсор, переместиться
в нижнюю строку окна и прочитать ее, но не проще ли было бы
просто нажать горячую клавишу, чтобы прочитать текст подсказки? А
как насчет того, чтобы Jaws озвучивал эту информацию
автоматически? И, конечно, вам захочется иметь возможность включать
и выключать такое автоматическое чтение. Что ж, если для
приложения, с которым вы работаете, был бы написан файл скриптов,
и если бы в этом файле был скрипт, выполняющий эту работу за вас,
вы могли бы иметь такой вид удобного доступа. Если никто не создал
для вас такого особенного скрипта, вы могли бы создать его сами,
имея в виду, что вы узнали, как пользоваться языком скриптов Jaws
для построения своих собственных скриптов. Такой улучшенный
доступ помог бы увеличить эффективность работы с этой программой
до степени зрячего пользователя и это увеличило бы вашу
производительность.

                  Что такое файлы скриптов?

Jaws всегда находится под управлением скриптов. Как мы уже
обсуждали, скрипт - это небольшая компьютерная программа, которая
видоизменяет работу Jaws для каждой конкретной ситуации. Файлы
скриптов Jaws - это наборы отдельных скриптов, которые загружаются
для работы с данным конкретным приложением Windows. Jaws
автоматически загружает эти файлы скриптов всякий раз, когда вы
открываете новое приложение. Очень важно понять, что есть два типа
файлов скриптов: Default (по умолчанию) и Application (для
приложений). Файлы скриптов можно представить в виде стога сена,
при чем файл скриптов по умолчанию (default) находится в основании.
Файл скриптов по умолчанию загружается при запуске Jaws и
является активным во всех сессиях. Файл скриптов для приложения
размещается поверх файла скриптов по умолчанию, когда приложение
загружается. Jaws знает, какой файл скриптов приложения загружать,
потому что главная часть имени файла скриптов для приложения (т.е.
его часть без расширения) является той же, что и имя самого
приложения. Таким образом, наш файл скриптов по умолчанию
называется default.jss, а приложение spreadsheet.exe будет иметь файл
скриптов spreadsheet.jss. Когда вы закроете данное конкретное
приложение, конкретный файл скриптов, который с ним использовался,
будет выгружен и активными станут все настройки по умолчанию,
пока не будет загружен другой файл скриптов приложения. Файл
скриптов по умолчанию, который загружается, когда вы впервые
запускаете Jaws, содержит сотни скриптов. Эти скрипты предоставляют
Jaws всю информацию, в которой он нуждается для обеспечения
речевого вывода в большинстве ситуаций. Этот файл сообщает Jaws,
что говорить и когда говорить в большинстве обстоятельств, когда вы
работаете с приложениями, которые ведут себя хорошо. Однако, во
многих приложениях часто возникают ситуации, которые отклоняются
от нормы. Также могут возникать конкретные случаи, когда чтение
экрана требуется настраивать. Если такое происходит, то может
возникнуть необходимость создать файл скриптов только для данного
приложения. Если такой файл скриптов был создан и он находится в
подкаталоге, в котором находятся все файлы конфигурации Jaws, тогда
при запуске этого приложения будет загружаться и файл скриптов.
Именно этот файл скриптов Jaws будет искать в первую очередь, когда
вы воспользуетесь какой-либо комбинацией клавиш, или когда
возникнет ситуация, которая потребует вызова событийных функций,
описанных выше. Если файл скриптов приложения не содержит
скрипта, соответствующего ситуации, тогда Jaws будет обращаться к
файлу по умолчанию. Если в одном из этих мест скрипт будет найден,
он будет выполнен, как только будет найден, и никакой другой
обработки не потребуется. Если ни там, ни там не будет найдено
соответствующего скрипта, тогда Jaws передаст нажатие клавиш
приложению, и эта комбинация клавиш будет выполнена таким
образом, как если бы JaWS ВООБЩЕ НЕ БЫЛ ЗАГРУЖЕН. Эта
иерархия является очень важной. Если конкретный скрипт,
существующий в файле скриптов по умолчанию, для используемого
приложения не подходит, пользователь может поместить собственную
версию этого скрипта в файл скриптов приложения, и эта версия будет
иметь приоритет перед той, которая имеется в файле скриптов по
умолчанию. Поскольку скрипты, расположенные выше в нашем стоге
сена, имеют приоритет, скрипт в файле скриптов приложения будет
выполняться вместо того, который имеется в файле скриптов по
умолчанию, если они оба закреплены за одной и той же комбинацией
клавиш, и функция в файле скриптов приложения будет вызываться,
имея приоритет перед той, которая вызывается в файле скриптов по
умолчанию, если обе они имеют одно и то же имя. Например, это
означает, что если у вас есть в файле скриптов приложения скрипт,
закрепленный за клавишей Ctrl+G, а в файле скриптов по умолчанию
у вас также есть скрипт, прикрепленный к Ctrl+G, то когда вы
нажмете Ctrl+G, будет выполнен тот, который находится в файле
скриптов приложения. Не имеет значения даже и то, что оба эти
скрипта могут иметь разные имена. Определение того, какой скрипт
будет выполняться, зависит от привязке к клавишам. Если вы
попытаетесь закрепить скрипт за клавишей, которая уже используется
в файле скриптов по умолчанию, пользуясь редактором скриптов Jaws,
больше известным как диспетчер скриптов (Script manager), то вы
получите предупреждение, и у вас будет две возможности: продолжить
закрепление, или закрепить свой скрипт за другой клавишей. Это
сделано для того, чтобы предотвратить случайное отключение скриптов
в файле скриптов по умолчанию, без осознания того, что вы наделали.

Есть несколько важных соображений по поводу того, как следует
называть скрипты и за какими клавишами их закреплять. Если, с
одной стороны, пользователь присваивает своему скрипту имя,
отличное от того, которое использовано в файле скриптов по
умолчанию, тогда пользователь также может закрепить скрипт в файле
скриптов приложения за той же клавишей, что и в файле скриптов по
умолчанию, без особых противоречивых последствий. С другой стороны,
если пользователь присваивает скрипту в файле приложения то же
имя, что и в файле по умолчанию, то даже нет необходимости
закреплять этот скрипт приложения за определенной клавишей. В
обоих случаях Jaws выполнит скрипт, имеющийся в файле скриптов
приложения, и проигнорирует тот, который имеется в файле скриптов
по умолчанию. Это происходит потому, что Jaws ищет и файл
раскладки клавиатуры по умолчанию default.jrm, и файл раскладки
клавиатуры приложения application.jkm чтобы узнать, не закреплен ли
скрипт с конкретным именем за клавишей, когда эта клавиша
нажимается. Jaws будет всегда выполнять скрипт из файла скриптов
приложения, предпочитая его скрипту из файла скриптов по
умолчанию, даже если закрепление за клавишей сделано в файле
default.jkm. Другими словами, если в обоих файлах скриптов имеется
скрипт с одним и тем же именем, а закрепление за клавишей сделано
в файле скриптов по умолчанию, Jaws все равно будет знать, что ему
полагается выполнить скрипт из файла скриптов приложения.

                          Функции

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

Ранее уже было упомянуто, что если для конкретного приложения
имеется файл скриптов приложения, этот файл скриптов будет
автоматически загружен при загрузке данного приложения. Jaws умеет
это делать, поскольку главная часть имени файла скриптов
приложения та же, что и имя самого приложения. Начиная с версии
3.3 в Jaws for Windows появилась возможность загружать файлы
скриптов по выбору в любое время. Этот файл скриптов может иметь
любое имя, и это имя необязательно должно уподобляться имени
текущего приложения. Если загружается такой файл, он заменяет
обычный файл скриптов приложения в стоге, если такой файл имеется.
Но этот специальный файл скриптов будет, в свою очередь,
автоматически заменен, если пользователь переключится на новое
приложение, которое загрузит свой собственный файл скриптов. Эта
новая возможность позволяет пользователю загружать самопальные
файлы скриптов, чтобы справиться с необычными ситуациями в
приложении, где требования очень уж отличаются от остальной части
приложения. Специальный файл скриптов можно загружать вручную, с
помощью горячей клавиши, или автоматически, когда на экране
появляются определенные окна или объекты. Функция, используемая
для загрузки специальных файлов скриптов, называется
SwitchToScriptFile (Переключитьсянафайлскриптов). Ее можно вызвать
вручную, или автоматически, с помощью методов, описанных в
оставшейся части этого руководства.

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

                 Что такое диспетчер скриптов?

Jaws предоставляет вам все инструменты, необходимые для
редактирования и создания скриптов. Эти инструменты представлены в
программе, которая называется диспетчер скриптов (Script Manager).
Диспетчер скриптов - это полноценный текстовый редактор. Кроме
обычных режимов, имеющихся в большинстве текстовых редакторов, в
нем встроены возможности, призванные помочь вам создавать скрипты,
вставлять функции в ваши скрипты, выводить справочную информацию
об этих функциях и скриптах, которые уже написаны, проверять на
наличие ошибок, нарушающих правила корректного написания скриптов
и сохранять и компилировать файлы скриптов. Кроме того, имеются
три горячих клавиши, которые позволяют более эффективно
просматривать скрипты в вашем файле скриптов. Функциональную
клавишу F2 можно использовать для перепрыгивания на следующий
скрипт, а клавишу Shift+F2 можно использовать для перескакивания со
скрипта на скрипт в обратном направлении. Комбинацию клавиш
Ctrl+L можно использовать для вызова диалога, который который
перечисляет все скрипты в текущем файле в алфавитном порядке в
отдельном окне. Это облегчает поиск конкретного скрипта в большом
файле, если вы помните его имя, но не помните, в какой части файла
он находится.

Диспетчер скриптов можно использовать для сохранения и компиляции
ваших файлов скриптов. В предыдущем абзаце мы сказали, что
диспетчер скриптов можно использовать для сохранения и компиляции
ваших файлов скриптов. А что мы имеем в виду под словом
"Компиляция?" Когда вы пишете скрипты для Jaws в диспетчере
скриптов, вы пишете его обычным текстом. Однако, Jaws в этом виде
его использовать не может, поскольку он не понимает плоский текст.
Когда вы сохраняете ваш файл скриптов в диспетчере скриптов, он
автоматически выполняет дополнительный шаг, который другие
текстовые редакторы и обработчики текста не делают. Он создает
дополнительный файл, который был преобразован из плоского текста в
двоичный формат, который Jaws может понимать и использовать.
Оригинальный текст сохраняется в файле с расширением .jss (Jaws
script source), а скомпилированная, или двоичная версия сохраняется в
файле с расширением .jsb (Jaws script binary). Вот почему так важно
всегда создавать и сохранять свои файлы скриптов при помощи
диспетчера скриптов. Если вы отредактируете свой файл скриптов в
каком-нибудь другом текстовом редакторе, например в Блокноте
(Notepad), при сохранении они не будут скомпилированы, и Jaws
останется в полном неведении относительно тех изменений, которые вы
сделали.

Есть три способа запустить диспетчер скриптов. Можно из любого
приложения нажать Insert+0. Можно нажать Insert+F2, чтобы
запустить диалог Jaws Выполнить, после чего нажать букву S и
клавишу Enter. Наконец, можно выбрать диспетчер скриптов из меню
Utilities в окне Jaws. Когда вы запускаете диспетчер скриптов из
приложения первым или вторым способом, он автоматически открывает
файл сккриптов для этого приложения. Если файла не существует,
диспетчер скриптов его создает. Когда вы запускаете диспетчер
скриптов из меню Utilities, он никаких файлов не открывает.

                      Анатомия скрипта

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

Script ScriptName ()
Function FunctionName ()

Если скрипт привязан к клавише, его первая строка будет выглядеть
как первая из двух вышеприведенных строк. Если это функция, и
следовательно, не привязана к клавише, первая строка будет выглядеть
как вторая из двух вышеприведенных строк. Иногда перед словом
Function (функция) есть дополнительное слово, но это будет описано
позже. В обоих случаях, вторым словом будет имя функции или
скрипта. Имя может быть произвольным, но было бы очень полезно,
если имя будет описывать то, что делает скрипт или функция. Если вы
соединяете вместе несколько слов, начинайте каждое новое слово с
большой буквы, чтобы Jaws мог произносить их как положено.
Пробелы в именах скриптов не допускаются. В качестве типичных
примеров имен скриптов можно привести следующие: SayNextLine,
SayPriorCharacter, SayWindowTitle и NextDocumentWindow .Обратите
внимание, что из такого названия очень хорошо видно, для чего эти
скрипты предназначены. Наконец, в конце строки будут открывающая
и закрывающая скобки. Иногда внутри этих скобок будет содержаться
некоторая информация, но об этом будет сказано позже.

Далее идет тело скрипта. Оно состоит из всех инструкций, которые вы
добавляете во время написания скрипта, таких как объявлений
переменных, команд, утверждений контроля переполнения, вызовов
функций, утверждений типа PerformScript (ВыполнитьСкрипт) и
арифметических операций. По мере нашего продвижения по
руководству, вы узнаете обо всех этих типах инструкций.

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

EndScript
EndFunction

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

                    Наши первые скрипты

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

Если Jaws for Windows у вас еще не запущен, запустите его.
Откройте Блокнот (Notepad), главное
меню/программы/стандартные/блокнот. Запустите диспетчер скриптов,
нажав Insert+0 или Insert+F2, после чего нажмите букву S и клавишу
Enter.
Jaws сообщит вам, что вы находитесь в файле notepad.jss, т.е. в
исходном файле скриптов для Notepad. Вы обратите внимание, что в
этом файле скриптов нет. Блокноту скрипты не нужны, поэтому
открытие диспетчера скриптов из Блокнота начнется с создания нового
исходного файла. В меню Script выберите New Script (Новый скрипт),
или воспользуйтесь горячей клавишей Ctrl+E. Появится диалог New
Script (Новый скрипт), поэтому мы можем присвоить нашему скрипту
имя и написать его документацию. Пока просто делайте как написано.
Более подробно мы расскажем о присвоении имени и написании
документации позже.

Когда появляется диалог New Script, курсор помещается в поле Script
Name (Имя скрипта).

Наберите SayName.

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

Нажмите Tab, чтобы переместиться к блоку проверки Can Be Attached
To Key (может быть прикреплен к клавише), и нажмите Пробел, чтобы
включить его. На этом шаге диспетчеру скриптов сообщается, что мы
пишем скрипт, а не функцию. Включив этот блок проверки, мы делаем
возможным привязку скрипта к клавише.

Нажмите Tab, чтобы переместиться к полю Synopsis и наберите слова
"Say our name".

Нажмите Tab, чтобы переместиться в поле Description (Описание) и
наберите "The name of the person who wrote this script" (Имя того, кто
написал этот скрипт).

Нажмите Tab, чтобы переместиться в поле Category (Категория) и
наберите слово "Test".

Поле Category - это комбобокс, поэтому категорию можно выбрать,
набрав ее вручную, или перемещаясь стрелками по списку чтобы найти
ту, которая лучше всего подходит. Нажмите Tab, чтобы переместиться
к полю Assign to (Закрепить за), и нажмите Ctrl+Shift+n чтобы
прикрепить эту комбинацию клавиш к нашему скрипту.

Больше для нашего скрипта никаких полей заполнять не надо, поэтому
нажмите Enter чтобы закрыть диалог New Script и вставить наш новый
пустой скрипт в область редактирования.

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

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

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

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

SayString ("My name is XXX")

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

Script SayName()
SayString ("My name is XXX")
EndScript

Теперь мы должны сохранить и скомпилировать файл скниптов для
NotePad. Нажмите Ctrl+S, и вы должны услышать сообщение "Compile
complete" (Компиляцию завершил). Если этого не произошло, вернитесь
обратно и вновь проделайте все шаги.

Закройте диспетчер скриптов. Вы должны вновь оказаться в Блокноте.
Проверьте свою работу, нажав Ctrl+Shift+n. Ну и как? Вот он, ваш
первый скрипт. Перейдите в другое приложение, и попробуйте нажать
ту же комбинацию клавиш. Обратите внимание, что на этот раз скрипт
не работает. Это потому, что мы поместили наш скрипт в файл
скриптов редактора Блокнот, и когда мы закрыли Блокнот, этот файл
был выгружен из памяти. Если бы мы поместили наш скрипт в файл
скриптов по умолчанию, этот скрипт работал бы в любом приложении,
если только в файле скриптов для этого приложения не нашелся бы
скрипт, прикрепленный к той же самой горячей клавише.

Давайте теперь вернемся в блокнот и попробуем что-нибудь еще.
Нажмите Insert+1 (1 на верхнем ряду, а не на цифровой клавиатуре) и
Jaws скажет "Keyboard help On" (Помощь по клавишам включена). Это
режим помощи, которым можно пользоваться для изучения
клавиатуры,на самом деле не активизируя ни одной из клавиш. (Выйти
из режима помощи по клавишам можно, нажав Insert+1 во второй раз).

Теперь нажмите свою горячую клавишу. На этот раз горячая клавиша
не произносит вашего имени, она говорит, что делает горячая клавиша.
Быстро нажмите комбинацию клавиш два раза, и вы услышите еще
более подробную информацию относительно того, что делает горячая
клавиша. Эти фрагменты информации - это поля синопсис и Описание,
которые вы заполняли при создании скрипта. Теперь вы понимаете,
почему так важно корректно заполнять эти поля.

Для нашего следующего скрипта, давайте сделаем что-нибудь более
практическое.

Откройте текстовый редактор WordPad, открыв главное
меню/Программы/стандартные/Текстовый редактор WordPad. Теперь
откройте меню Файл, нажав Alt+F. Нажмите клавишу Стрелка вниз 7
раз, и вы услышите имя файла, который вы в последний раз открывали
в WordPad. (Если вы еще ничего в этой программе не открывали,
сделайте это сейчас, чтобы у вас была эта строка в меню).

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

Давайте для этого напишем скрипт. Как и в предыдущем случае, в
точности выполняйте все шаги, как это написано ниже.

Откройте диспетчер скриптов, нажав Insert+0, или Insert+F2, после чего
нажмите букву S, а после нее клавишу Enter. Как и прежде, вы
должны оказаться в пустом файле скриптов Wordpad.jss. Начните
новый скрипт, выбрав New script в меню Script, или нажмите горячую
клавишу Ctrl+E. Вы окажетесь в поле Имя скрипта (Script name).

Наберите LastOpenedFile (ПоследнийОткрытыйФайл) без пробелов, как
было показано выше. (Прим. переводчика: русские варианты названий
скриптов и функций приводятся просто для иллюстрации, и не могут
быть использованы в исходных текстах скриптов).

Клавишей Tab переместитесь к блоку проверки Can Be Attached to key
(может быть закреплен за клавишей) и включите его.

Клавишей Tab переместитесь к полю Synopsis и наберите "Says last
opened File". (Не включайте символы кавычек, здесь они просто для
того, чтобы показать, что набирать. Этот комментарий относится ко
всем знакам кавычек, которые использованы просто для того, чтобы
показать вам, что набирать).

Клавишей Tab перейдите в поле Description (Описание) и наберите
"Says the name of the last file opened in WordPad"
(Сообщает имя последнего файла, открытого в WordPad).

Перейдите в редактируемый комбобокс Category и
клавишами-стрелками спускайтесь до тех пор, пока не дойдете до
категории Say (сказать).

Перейдите в поле Assign to Hot Key и нажмите Ctrl+Shift+l, чтобы
сделать эту клавишу горячей для данного скрипта.

Перейдите к кнопке OK и нажмите Enter.

Теперь мы снова находимся в области редактирования диспетчера
скриптов, и у нас есть пустой скрипт, в первой строке которого
написано Script LastOpenedFile ()", а в последней строке написано
"EndScript". Мы находимся между двумя этими строками.

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

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

Script LastFile ()
SpeechOff ()
{Alt+F}
Pause ()
NextLine ()
NextLine ()
NextLine ()
NextLine ()
NextLine ()
NextLine ()
NextLine ()
SpeechOn ()
SayLine ()
SpeechOff ()
{escape}
{escape}
Pause ()
SpeechOn ()
EndScript

Итак, ради всех святых, что же выполняют все эти утверждения?

Вы вероятно заметили, что когда вы нажали Alt+f в Wordpad чтобы
открыть меню Файл, Jaws сообщил: "menu active, file, new, CTRL+N".
Мы не хотим выслушивать всю эту болтовню во время выполнения
скрипта, поэтому мы во второй строке нашего скрипта отключаем речь
с помощью функции SpeechOff() , до тех пор, пока она нам снова не
понадобится. Затем утверждение {Alt+F} посылает в WordPad команду
Alt+F, точно так же, как если бы мы ввели эту команду с клавиатуры.
Как вы узнаете позже, мы всегда помещаем комбинации клавиш,
которые хотим послать в приложение, между фигурными скобками.
Затем дается команда сделать паузу, чтобы приложение имело
возможность вывести меню, прежде чем скрипт продолжит свою
работу. Это делается очень часто, когда нам нужно, чтобы приложение
выполнило какое-либо действие. Без этого наш скрипт может забежать
вперед приложения, и отработать прежде, чем приложение выполнит
то, что мы от него хотим. Затем мы спускаемся по меню на семь
пунктов с помощью семи утверждений NextLine. Таким образом мы
помещаемся в пункт, где приведено имя последнего открытого файла.
Прежде, чем мы сможем услышать, что там написано, мы должны
снова включить речь командой SpeechOn. Далее находится утверждение
SayLine, которое и озвучит нам содержание текущей строки. Теперь
нам лучше снова отключить речь, чтобы не выслушивать все то, что
Jaws обычно говорит при выходе из меню. Теперь два утверждения
Escape выведут нас из меню. Обратите внимание, что эти утверждения
должны быть помещены в фигурные скобки. Затем нам придется снова
поместить паузу, чтобы меню исчезло, и наконец, мы снова включаем
речь последней командой SpeechOn. Теперь нужно сохранить и
скомпилировать наш скрипт нажав Ctrl+s.

Вернитесь в WordPad и нажмите свою новую горячую клавишу,
Ctrl+Shift+l. Вы должны быть вознаграждены тем, что Jaws сообщит
вам имя последнего открытого файла. Если вы думаете, что это
здорово, подождите немного. Вы только начинаете знакомиться с тем,
что можно делать с помощью этого замечательного языка скриптов. Вы
больше не будете находиться в зависимости от глупого программиста,
который не соблюдал правила и написал приложение, которое
невозможно озвучить с легкостью. Вам больше не придется нажимать
дюжины клавиш, чтобы получить с экрана фрагмент информации,
который ваши зрячие друзья могут получить, просто взглянув на
экран. Вам больше не надо ждать кого-нибудь, кто сконфигурирует для
вас приложение. Изучение этого языка может потребовать некоторой
работы, но вы будете вознаграждены умением заставить ваши
приложения говорить и вести себя в большем соответствии с вашими
желаниями. Хорошенько изучите весь этот материал, и вы сможете
получать доступ к своим приложениям гораздо лучше и эффективнее,
чем вы даже могли себе когда-либо представить.

Прежде чем окунуться в бодягу языка скрипетов, необходимо еще одно
слово поощрения. Иногда бывает обескураживающе видеть завершенный
скрипт, как например вышеприведеннный, который работает в точности
так, как ему положено. Новоявленный автор скриптов посмотрит на
этот скрипт и скажет: "Ради всего святого, как они узнали, какие
утверждения использовать и в каком порядке их расположить?"
Необходимо понимать, что скрипты не появляются из воздуха как
правильно и без единой ошибки подготовленный продукт. Автор
испробовал многие конфигурации этого скрипта, прежде чем пришел к
той, которая работает лучше всего, и которая показана выше. Первая
версия не содержала никаких утверждений типа SpeechOn или
SpeechOff, и в результате скрипт озвучивал слишком много
информации. Поэтому и были добавлены эти утверждения. Но
потребовалось несколько попыток, пока было найдено их наилучшее
расположение. Но и после этого скрипт по-прежнему не работал как
положено, пока в нужных местах не были поставлены утверждения
Pause, и этот процесс потребовал дополнительных попыток и ошибок.
Суть в том, что вам придется делать свои догадки и кое-что пробовать.
Если ваша догадка не сработала, попробуйте что-нибудь другое. По
мере приобретения опыта вы будете делать это гораздо быстрее. Но
единственный способ выучить этот новый язык - путь проб и ошибок,
и этим путем можно идти, только пытаясь писать свои собственные
скрипты. Не бойтесь пробовать. Худшее, что может произойти - это то,
что скрипт не будет делать то, что вы от него хотите, и вам придется
попробовать что-нибудь другое. Вы будете совершать ошибки, но они
являются частью процесса. Чем больше у вас будет опыта, тем легче и
быстрее вам будет писать скрипты. Но если вы не будете пытаться
писать скрипты, вы никогда не научитесь этого делать. К этому
моменту вы должны получить мысленную картину, для чего нам
нужны скрипты, как Jaws использует их для повышения
эффективности, и как файлы скриптов по умолчанию и файлы
скриптов приложений работают совместно.

                    Домашнее задание # 1.

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

                     Диспетчер скриптов

Использование диспетчера скриптов, диалог создания скрипта и другие
инструменты, создания скриптов и файлов скриптов будут описаны в
этом разделе. Как уже упоминалось выше, диспетчер скриптов - это
более чем текстовый редактор. Он предоставляет пользователю набор
инструментов, облегчающих процесс создания скриптов и файлов
скриптов. Мы разделим процесс описания диспетчера скриптов на 5
частей: 1) меню; 2)различные типы файлов диспетчера скриптов; 3)
утверждения Include (Включить); ;) Диалоги Новый скрипт и
Информация о скрипте, и 5) диалоги InsertFunction (вставить функцию)
и PerformScript )Выполнить скрипт).

                           Меню

               Типы файлов диспетчера скриптов

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

JSS - как уже описывалось выше, это исходный файл скрипта для
Jaws, который создается пользователем для создания файлов скриптов
для конкретных приложений.
JSb - это бинарный файлскриптов Jaws, который создается диспетчером
при сохранении и компиляции файла типа JSS. Этот файл не должен
ни непосредственно создаваться, ни редактироваться пользователем.
JSM - это файл сообщений скриптов Jaws, которые озвучиваются при
выполнении функции SayString. Когда вы создаете продвинутые файлы
скриптов, которые подлежат распространению по всему миру,
предпочтительно использовать номера сообщений в функциях SayString,
а не помещать туда реальный текст. Таким образом можно переводить
сообщения на другие языки. JSM файл содержит утверждения, которые
сообщают файлу скриптов что говорить по конкретному номеру
сообщений. Эти номера сообщений на самом деле являются
константами, которые приравниваются к сообщениям, которые вы
хотите озвучить. Если вы посмотрите на структуру файла default.jsm,
вы увидите, что номера сообщений задаются точно также, как и все
прочие константы. Например, файл сообщений по умолчанию
default.jsm содержит утверждения типа MSG1 = "End" или MSG2 = "home".
Вы обратите внимание, что утверждения записаны по одному на
строке, и в конце каждого утверждения стоит запятая, за исключением
последнего утверждения в файле. Если скрипт в default.jss встречает
строку SayString (MSG1), он скажет End, а если ему встретится строка
SayString (MSG2), он скажет Home.

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

JSH - это файл заголовка скриптов Jaws, и в немосодержится другая
информация, необходимая для ассоциированного с ним файла типа JSS,
например задаются константы или глобальные переменные. Мы уже
вкратце обсуждали константы и переменные, и поговорим о них ниже
более подробно. Глобальные переменные - это такие переменные,
которые могут использоваться более чем в одном скрипте. Необходимо
сообщить Jaws, каково значение константы, иначе он этой информации
не узнает. Аналогичным образом, что вы будете использовать
определенную переменную с определенным именем, иначе Jaws не
узнает, что данную конкретную строку символов следует воспринимать
как переменную. Этот процесс сообщения Jaws о константах и
переменных, которыми мы будем пользоваться, называется объявлением.
Если у вас только несколько констант или глобальных переменных, вы
можете прямо поместить их в начало JSS файла, который вы создаете.
Более подробно эта процедура будет описана ниже. Регулярные, или
локальные переменные, всегда объявляются внутри самого скрипта.
Однако, если вы используете большое количество констант или
глобальных переменных, лучше поместить их в отдельный JSH файл.
Исследуйте файлы hjglobal.jsh и hjconst.jsh в качестве примеров
файлов, содержащих глобальные переменные и константы.

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

                     Утверждения Include

Предположим, вы решили использовать jsm и/или jsh файл в качестве
части набора файла скриптов, который вы пишете для нового
приложения. Поэтому вы забегаете вперед и создаете эти файлы. Ну, а
дальше что? Как главный jss файл узнает, что эти файлы существуют
и являются частью набора скриптов? Взгляните на первые строки файла
default.jss и вы увидите примерно такие строки:

Include "hjglobal.jsh" ; глобальные переменные по умолчанию.
Include "HJCONST.JSH" ; константы по умолчанию
Include "default.jsm" ; файл сообщений.
Эти утверждения называются утверждениями Include, и их назначение
состоит в том, чтобы сообщить jss файлу, что вся информация во
вкоюченных файлах является частью набора. Когда вы сохраняете jss
файл и создаете jsb файл, вся информация во включенных файлах
также будет скомпилирована в результирующий jsb файл. Таким
образом, скрипты в jss файле узнают об определениях, содержащихся
во включенных файлах. Синтакс этих утверждений типа include
необходимо соблюдать в точности как показано. Обратите внимание,
что имя файла приводится вместе с расширением и заключается в
кавычки. Все, что записано после точки с запятой, считается
комментарием, и имеет целью просто дать читателю информацию. Все,
что записано в данной строке после точки с запятой, игнорируется
компилятором. Эти комментарии являются опциональными.

             Диалоги New script и Script information

Диалог New Script находится в меню Script, а диалог Script information
находится в меню View, как опция Documentanion. Эти два диалога
являются одинаковыми, за исключением того, что диалог New script
выводится при создании нового скрипта, а диалог Script Information
выводится в том случае, если вы хотите просмотреть документацию к
скрипту, который уже существует. Клавишами быстрого запуска для
этих диалогов являются Ctrl+e и Ctrl+D соответственно. Большинство
пунктов в меню диспетчера скриптов имеют горячие клавиши быстрого
запуска, и пользователь может легко познакомиться с ними, изучив
пункты меню.

В этих многостраничных диалогах имеется две вкладки: вкладка
General (Общие) и вкладка Parameters (параметры). Каждая из этих
вкладок описана ниже.

                       Вкладка General

Во вкладке General мы находим следующие строки ввода:

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

Can Be Attached to Key (может быть прикреплен к клавише) - это
блок проверки. Если вы его включаете - вы создаете скрипт, если нет -
то функцию. Помните, что скрипты могут быть прикреплены к
клавишам, а функции - нет.

Synopsis - в этом поле должно содержаться краткое описание того, что
делает скрипт. Он используется, если вы входите в режим помощи по
клавиатуре (Insert!1) или в помощь по ключевому слову (Shift+F1) в
диспетчере скриптов. Доступ к полю Synopsis осуществляется путем
нажатия комбинации клавиш6 которая вас интересует, после того, как
вы вошли в режим помощи по клавиатуре.

Description - в этом поле должно содержаться более подробное
описание того,. что делает скрипт. Это описание используется, если вы
входите в режим помощи по клавиатуре (Insert+1) или в помощь по
ключевому слову (Shift+F1) в диспетчере скриптов. Доступ к полю
Description (Описание) осуществляется, если вы входите в режим
помощи по клавиатуре и дважды быстро нажимаете интересующую вас
комбинацию клавиш.

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

Assign to Hot Key (Закрепить за горячей клавишей) - это поле
доступно только в том случае, если вы включили блок проверки "Can
be attached to key". Нажмите комбинацию клавиш, на которую вы
хотите повесить ваш скрипт. Если горячая клавиша закреплена за
другим скриптом, вы услышите предупреждающее сообщение, и вам
будет дана возможность продолжить определение или выбрать другую
горячую клавишу.

Function Returns (функция возвращает) - этот пункт доступен только в
том случае, если вы отключили блок проверки "Can be attached to key".
Возможны 5 вариантов: Int (Целое число), Handle (рукоятка), Object
(Объект), string (строка) и Void (пустая). Выберите один из первых
четырех опций, если ваша функция предназначена для вывода одного
из этих четырех типов данных в вызывающий ее скрипт. Выберите
Void, если вам не нужно, чтобы ваша функция возвращала какое-либо
значение. То, что вы выберете, появится в первой строке скрипта перед
словом Function. Более подробное описание возвращаемых значений
будет дано позже.

Return Description (описание возврата) - доступно только в том случае,
если вы не включили блок проверки "Can be attached to key". В этом
поле должно содержаться краткое описание того, какая информация
возвращается функцией и как эту информацию имеется в виду
использовать.

                      Вкладка Parameters

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

Existing Parameters (существующие параметры) - в этом списке будут
показаны уже существующие параметры, если таковые существуют. Он
также будет показывать параметры по мере их добавления. Вы можете
перемещаться по списку с помощью клавиш-стрелок вверх и вниз,
чтобы выбрать параметры для последующего удаления.
New Parameter (новый параметр) - если вы хотите добавить параметр,
наберите его имя в этом поле.

By Reference (по ссылке) - чтобы понять этот пункт, вы должны
понять, что параметры используются для передачи данных из
вызывающего скрипта на функцию. Обычно такая передача - это улица
с односторонним движением. Эта ситуация по умолчанию известна как
передача параметров "по значению". Таким образом, когда вы вызываете
функцию из скрипта, текущее значение параметра, коль скоро оно
существует в скрипте, будет скопировано и передано функции. Во
время выполнения функции значение параметра может измениться.
Поскольку обмен информацией о параметре обычно улица с
односторонним движением, когда данные передаются по значению,
скрипт не будет знать о том, что значение параметра изменилось.
Когда функция выполнится и вернет управление скрипту, скрипт
продолжит работу с первоначальным значением параметра. Включение
блока проверки By reference изменит улицу с односторонним
движением на улицу с двухсторонним движением. Если этот блок
проверки был включен, изменения в значении параметра, происшедшие
во время выполнения функции, будут известны вызывающему скрипту.
Это делает возможным изменение значения параметра при выполнении
функции, с тем чтобы затем скрипт мог использовать это
изменившееся значение. Происходит это потому, что передача по
ссылке передает функции адрес памяти, в котором находятся данные, а
не значение. Если функция изменяет значение по этому адресу,
вызывающий скрипт или функция,использующая значение, хранящееся
в том же адресе, будет использовать изменившееся значение.

Description (описание) - это поле должно содержать очень краткое
описание того, для чего предназначен параметр.

Available Types - вы должны выбрать Handle, Int, Object или String в
этом списке, в зависимости от типа информации, который должен
передавать этот параметр. Как будет описано ниже, Handle - это
рукоятка окна.

Add (Добавить) - эта кнопка будет доступна, если вы заполнили
предшествующие поля. Воспользуйтесь клавишей Enter или пробел,
чтобы добавить свой новый параметр к существующему списку
параметров.

Remove (убрать) - эта кнопка будет доступна, если вы выделили
строку в списке существующих параметров. Выбор этой кнопки с
помощью клавиши Пробел или Enter удалит выделенный параметр из
списка.

           Диалоги Insert Function (вставить функцию)
               и Perform Script (выполнить скрипт)

В меню Скрипт есть два пункта, Insert Function Call (вставить вызов
функции) и Insert Performscript (вставить выполнение скрипта). Они
используются для вставки функций и для вызова из скрипта других
скриптов. Использование двух этих инструментов описано ниже.

Insert Function Call - выводит диалог вставки функции, который
является списком более чем двухсот функций, которые вы можете
использовать при создании скрипта. Вы услышите заголовок Insert
Function 1". Термин "function 1" означает, что вы находитесь на первом
уровне этого диалога. Первое поле в этом диалоге является полем
редактирования. Следующий раздел - алфавитный список всех
доступных функций. Если вам посчастливится знать имя нужной вам
функции, вы можете начать набирать ее имя в поле редактирования, и
выделение в алфавитном списке будет автоматически перемещаться к
букве, которую вы только что набрали. Вы также заметите, что
читается описание новой функции, всякий раз когда выделение
перемещается к другой функции. Как только вы введете достаточно
букв, чтобы услышать имя функции, которую вы только что искали,
просто нажмите Enter, чтобы выбрать эту функцию. Если вы точно не
помните имени функции, просто наберите достаточно букв, чтобы
попасть в нужную часть списка, затем переместитесь к списку, и
перемещайтесь вверх и вниз по списку, пока не не найдете нужную
функцию. Вы также можете набирать имена функций, прямо находясь
в списке, и диспетчер скриптов будет перемещать вас к нужной
функции.

Вы также услышите описания функций, когда будете перемещаться
вверх и вниз по списку. Когда вы нажмете клавишу Enter, чтобы
выбрать функцию, произойдет одно из двух: если эта функция не
требует никаких параметров, вы вернетесь в главное окно редактора
диспетчера скриптов, и вы увидите, что функция была добавлена в ваш
скрипт. Однако если функция требует один или несколько параметров,
появится другой диалог, содержащий поле редактирования, и вам будет
предложено ввести параметры. Например, если вы выбираете функцию
SayString, вы будете помещены в поле редактирования, куда вы можете
ввести текст или сообщение, которое вы хотите озвучить. Это и есть
параметр, которого требует функция SayString. Если функция, которую
вы выбрали, требует, чтобы вы выбрали другую функцию в качестве
параметра, вы можете нажать комбинацию клавиш Alt+I, после чего
появится новый диалог, очень похожий на диалог Insert Function. Вы
услышите заголовок "Insert Function 2". Единственная разница состоит в
том, что в этом списке показаны только функции, которые диспетчер
скриптов считает подходящими параметрами для данного выбора.
Следовательно, в этом дополнительном списке будут показаны не все
функции главного списка. Вы должны либо выбрать функцию из этого
списка, либо непосредственно ввести имя функции в поле
редактирования Параметров, когда оно появится в первый раз. Затем
нажмите Enter. продолжайте этот процесс, пока не введете все нужные
параметры. Иногда вам придется выходить даже на третий уровень, или
даже выше, т.е. "Insert Function 3", "Insert Function 4", и т.д., снова
нажимая Alt+E. (Этот процесс использования функций в качестве
параметров для других функций, называется "Вложение", и он будет
описан более подробно ниже в разделе под названием "Использование
вложенных функций".)

Затем диспетчер скриптов вернет вас в главное окно редактирования, и
ваша функция, вместе со всеми параметрами, будет присутствовать в
скрипте. Находясь в диалоге Insert Function, вы также можете
переместиться клавишей Tab к полям Description и Returns чтобы
просмотреть информацию, описывающую функцию и ее возвраты, если
таковая информация существует, более подробно. Стоит также
заметить, что список функций в этом диалоге содержит и встроенные
в Jaws функции, и функции, определенные пользователем в текущем
файле скриптов., Таким образом, если вы задали для скрипта новую
функцию в файле скриптов, после компиляции вы увидите свою
функцию в списке.

Insert PerformScript (вставить выполнение скрипта) - при выборе этой
опции вы попадаете в список, содержащий все доступные скрипты,
которые вы можете вызвать из скрипта, который вы пишете. Вы
можете перемещаться по списку клавишами-стрелками, или начать
набирать имя скрипта, чтобы перескочить к нему. Нажатие Enter на
одном из имен, например, скрипта SayMyName" приведет к тому, что в
вашем скрипте появится следующая строка:

PerformScript SayMyName()

Эта строка приведет к тому, что будет выполнен скнипт "SayMyName",
как если бы вы сами нажали клавишу. Таким способом можно
повторно использовать скрипты, которые вы уже написали, не
переписывая код заново.

                  Создание простых скриптов

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

                    Документация скрипта

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

Script Name -  введите имя вашего скрипта.
Блок проверки Can be attached to Key - всегда включайте этот блок
проверки для скриптов, привязанных к клавишам.
Synopsis - представьте краткое описание назначения вашего скрипта.
Description - представьте дополнительную информацию о вашем скрипте.
Category - выберите категорию для вашего скрипта. Название категории
нужно либо набрать непосредственно, либо выбрать его из списка.
Постарайтесь выбирать такие категории, которые будут иметь смысл,
чтобы позже перечислить их в логическом порядке, в том случае, если
эта возможность будет добавлена в диспетчер скриптов.

                 Структура отдельного скрипта

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

Сначала идет начальное ключевое слово скрипта. Это просто слово
"Script", после которого идет пробел. На той же строке, после слова
"Script", записывается имя скрипта. Это обычно несколько слов,
объединенных вместе, и описывающих действие данного скрипта,
например CloseDocumentWindow. Обратите внимание, что каждое из
соединенных вместе слов начинается с заглавной буквы, чтобы Jaws
мог их корректно прочесть. Затем следует () которая и завершает
оператор начала скрипта. Все это автоматически вводится диспетчером
скриптов, когда вы создаете новый скрипт с помощью диалога New
Script. (если вы обнаружили, что ваша копия Jaws произносит такие
слова неправильно, проверьте опцию Mixed Case Processing (Обработка
смешанного регистра) раздела Text Processing (Обработка текста) меню
Set Options (Установка параметров) в диспетчере конфигурации. Этот
блок проверки должен быть включен).

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

Ключевое слово окончания скрипта EndScript всегда стоит в последней
строке скрипта. Она автоматически добавляется диспетчером скриптов,
когда вы создаете скрипт.

               Использование функций скриптов

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

                        Чтение текста

Ниже приведены некоторые функции, используемые для чтения текста:

SayCharacter() - читает символ в позиции активного курсора.
SayWord() - читает слово в позиции активного курсора.
SayToCursor - читает от начала строки до активного курсора.
SayFromCursor - читает от позиции активного курсора до конца строки.
SayColor - называет цвет шрифта в позиции активного курсора.
SayFont - называет шрифт и его размер в позиции активного курсора.
SayTextBetween - озвучивает весь текст между двумя координатами
столбцов на строке, где находится активный курсор.
SayWindow - озвучивает окно в позиции активного курсора.
SayToBottom - читает весь текст от позиции активного курсора до
нижнего края окна.
SayString() - читает текст, заключенный между скобками. Текст должен
быть помещен в двойные кавычки.
Say - озвучивает строку текста, используя некоторый набор речевых
характеристик, называемых средствами вывода. Возможно использовать
раздельные способы вывода для озвучивания строк заголовка, органов
управления в диалогах, пунктах меню, и т.д.
SayAll - читает всю читаемую информацию от позиции активного
курсора до нижнего края окна. Если активным является PC курсор,
Jaws прокручивает экран, перемещая PC курсор вниз. Если активным
является Jaws курсор, будет прочитана оставшаяся часть окна, путем
построчного перемещения Jaws курсора.
SayChunk - озвучивает цепочку информации, на которую указывает
активный курсор. Цепочка - это текстовая или графическая
информация, которая была написана на экране в течение одной
операции. SayChunk подобна функции SayField, однако функция
SayField использует логику, чтобы определить, какой текст озвучивать,
тогда как SayChunk просто читает текст, который был сохранен в
модели Off Screen в качестве одинарной единицы.
SayField - читает поле текста, на которое указывает активный курсор.
Полем называется раздел или блок текста, имеющий общий атрибут,
например жирный шрифт, курсив, подчеркивание и т.п. Использование
атрибута должно быть непрерывным. Функция SayField использует
логику для определения текста, который должен быть озвучен, тогда
как функция SayChunk просто читает текст, который был сохранен в
модели Jaws Off screen в качестве одинарной единицы.
SayFrame -  читает содержание указанного фрейма.
SayFrameAtCursor - озвучивается весь текст, находящийся в границах
фрейма, в котором находится активный курсор.
SayFrameAtCursor - озвучивает целочисленное значение данных, часто
содержание целочисленной переменной.
SayParagraph - читает текущий абзац от начала.
SaySentence - читается предложение, которое содержит символ, на
который указывает активный курсор.

                    Перемещение по экрану

Прежде чем вы попытаетесь прочитать что-нибудь на экране с
помощью скрипта, вам вероятно понадобится переместить один из
курсоров к тому месту, где находится объект, который вы хотите
прочитать. Следовательно, важно будет понять кое-что о курсорах. Для
тех, кто пользуется Jaws без брайлевского дисплея, есть три типа
курсора: PC курсор, Jaws курсор и invisible (невидимый) курсор. Те,
кто пользуется еще и брайлевским дисплеем, получают и четвертый
курсор, Braille курсор. (этот курсор предназначен для внутреннего
использования брайлевским дисплеем, и он никогда не должен
оставаться после выполнения скрипта). Если вы вводите или
редактируете текст, PC курсор будет находиться там, куда будут
помещаться символы при их вводе с клавиатуры. (Этот курсор
редактирования или вставки также называется курсором каретки).
Однако, если вы находитесь в меню или перемещаетесь клавишей Tab
по кнопкам в окне диалога, на экране нет курсора каретки. В этом
случае PC курсором становится фокус. Если вы хотите прочитать
другие области окна, или прочитать часть экрана, куда PC курсор
переместиться не может, вы можете переключиться на Jaws курсор.
Jaws курсор можно перемещать куда угодно в границах реального
окна, что делает возможным исследование областей экрана, куда не
может переместиться PC курсор. Кстати, реальным окном называется
окно, которое имеет заголовок. Это означает, что в норме ваш Jaws
курсор ограничен только перемещением в границах родительского окна наивысшего
уровня, с заголовком, начиная от окна, в котором вы в данный момент
находитесь. Именно это мы и имеем в виду, когда говорим, что Jaws
курсор ограничен границами реального окна (если вы хотите
ограничить Jaws курсор границами окна, в котором вы в данный
момент находитесь, даже если оно не является реальным окном, вы
можете сделать это, воспользовавшись комбинацией клавиш Insert+R).
Поскольку Jaws курсор всегда тащит за собой указатель мыши,
указатель мыши всегда помещается в позицию Jaws курсора, и его
всегда можно щелкнуть, если вы того пожелаете

Третий вид курсора называется Невидимый курсор (Invisible cursor). В
одном отношении.этот курсор подобен Jaws курсору, поскольку его
перемещение ограничивается только границами реального окна, но на
экране нет его видимого представления, поскольку он не тащит за
собой указатель мыши.

              Как пользоваться этими курсорами?

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

Для выполнения операций чтения можно использовать как Jaws, так и
невидимый курсор, поэтому до определенной степени выбор курсора
является вопросом личных предпочтений. Однако, бывают ситуации,
когда вам придется предпочесть один из этих курсоров другому. Если вы
намереваетесь щелкнуть кнопкой мыши или предпринять какое-либо другое
действие с мышью, необходимо будет использовать Jaws курсор. Поскольку
указатель мыши сопровождает Jaws курсор в его путешествиях, то щелкнуть
мышью становится очень простым делом, поскольку она уже находится в
нужной позиции. Если вы не хотите перемещать Jaws курсор с его текущей
позиции, или не будет никакой необходимости на чем-нибудь щелкать,
лучшим выбором будет невидимый (invisible) курсор. На ум приходит
конкретная ситуация, когда вам уж точно не захочется перемещать указатель
мыши/Jaws курсор. Иногда в Windows информационный текст появляется
где-то на экране, обычно в строке состояния, когда указатель мыши находится
в определенной позиции. Если вы переместите Jaws курсор чтобы прочитать
текст, указатель мыши переместится вместе с ним, и текст исчезнет. Чтобы
прочитать такой текст, вы должны будете пользоваться невидимым курсором.
Да и вообще, было бы неплохо пользоваться невидимым курсором для чтения
текста, когда не нужно делать никаких щелчков, если нет конкретной
причины использовать Jaws курсор. В некоторых случаях бывает необходимо
переместить один из курсоров, например, Jaws курсор, даже если вы хотите
вернуть его в первоначальную позицию, когда скрипт закончит работу. На
этот случай имеются функции SaveCursor и RestoreCursor, с помощью которых
все можно вернуть в то положение, каким оно было до начала выполнения
вашего скрипта. Ниже приводится список функций, которыми можно
пользоваться, чтобы выбирать курсоры и манипулировать ими.

PCCursor() - активизирует системный курсор.
JAWSCursor() - активизирует Jaws курсор.
InvisibleCursor() - активизирует невидимый курсор.
BrailleCursor () - активизирует брайлевский курсор.
RouteBrailleToPc () - перемещает брайлевский курсор к системному курсору.
RouteBrailleToJAWS () - перемещает брайлевский курсор к Jaws курсору.
RouteJAWSToBraille () - перемещает Jaws курсор к брайлевскому курсору.
RoutePCToBraille () - перемещает системный курсор к брайлевскому курсору,
если это возможно.
RouteJAWSToPC() - перемещает Jaws курсор к системному курсору, если это
возможно.
RouteJAWSToInvisible() - перемещает Jaws курсор к невидимому курсору.
RouteInvisibleToPC() - перемещает невидимый курсор к системному курсору.
RouteInvisibleToJAWS() - перемещает невидимый курсор к Jaws курсору.
SaveCursor() - сохраняет активный курсор и его позицию.
RestoreCursor() - вновь активизирует сохраненный курсор и восстанавливает
его в своей первоначальной позиции.

Следующая группа функций предназначена для перемещения курсора.

PriorCharacter() - перемещает активный курсор к предыдущему символу.
PriorWord() - перемещает активный курсор к предыдущему слову.
PriorLine() - перемещает активный курсор на предыдущую строку.
NextCharacter() - перемещает активный курсор к следующему символу.
NextWord() - перемещает активный курсор к следующему слову.
NextLine() - перемещает активный курсор к следующей строке.
NextParagraph - перемещает активный курсор к началу следующего абзаца.
Если активным является PC курсор, а начало следующего абзаца уже
невидимо, то текст в окне автоматически прокрутится, чтобы оно стало
видимым.
NextSentence - перемещает активный курсор к началу следующего
предложения. Если активным является PC курсор, а начала следующего
предложения еще не видно, текст в окне будет автоматически прокручиваться,
пока начало следующего предложения не станет видимым.
PriorParagraph - перемещает активный курсор к началу предыдущего абзаца.
Если активным является PC курсор, а начала предыдущего абзаца уже не
видно, текст в окне будет автоматически прокручен, чтобы оно стало видимым.
PriorSentence - перемещает активный курсор в начало предыдущего
предложения. Если активным является PC курсор, а начала предыдущего
предложения уже не видно, текст в окне будет автоматически прокручиваться,
пока начало предыдущего предложения не станет видимым.
JAWSHome() - перемещает активный курсор в начало строки.
JAWSEnd() - перемещает активный курсор в конец строки.
JAWSPageUp() - перемещает активный курсор к верхнему краю окна.
JAWSPageDown() - перемещает активный курсор к нижнему краю окна.
MoveTo - перемещает Jaws или невидимый курсор в координаты экрана,
указанные пользователем.
MoveToControl - перемещает активный курсор к конкретному органу
управления внутри окна.
MoveToFrame - перемещает активный курсор в левый верхний угол
указанного фрейма. Если активным является PC курсор, когда используется
эта функция, то активизируется JAWS курсор, и он перемещается в новую
позицию, в противном случае перемещается активный курсор.
MoveToGraphic - перемещает JAWS курсор, невидимый курсор или
брайлевский курсор в указанном направлении, чтобы найти графический
символ в активном окне.
MoveToWindow - перемещает активный курсор в указанное окно. Если окно
содержит текст, то курсор устанавливается на первый символ. В противном
случае, он устанавливается в центре окна. Если активным является PC курсор,
когда используется эта функция, то активизируется JAWS курсор, и он
перемещается в новую позицию.
PriorChunk - перемещает активный курсор к предыдущей порции текста.
Порция текста - это раздел, или блок текста, который записывается на экране
за один раз.
NextChunk - перемещает активный курсор к следующей порции текста.
Порцией текста называется раздел или блок текста, который записывается на
экране за один раз.

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

JAWSPageDown () ; перемещает активный курсор к нижнему краю окна.
SayLine () ; читается строка, на которую поместился курсор.

                      Создание скриптов чтения

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

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

Script ReadBottomLine() ; начинает скрипт и присваивает ему имя, ReadBottomLine
JAWSCursor(); активизируем JAWS курсор
RouteJAWSToPC() ; переместить JAWS курсор к PC курсору, чтобы быть
уверенными, что курсор находится в окне, в котором мы работаем, а не в
каком-то другом окне на экране.
JAWSPageDown() ; перемещаем JAWS курсор в нижнюю строку окна
JAWSHome() ; перемещаем JAWS курсор в начало нижней строки окна
SayLine() ; озвучиваем нижнюю строку окна
EndScript ; конец скрипта

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

Script ReadBottomLine() ; начинает скрипт и присваивает ему имя, ReadBottomLine
SaveCursor() ; сохраняет текущий курсор и его позицию
InvisibleCursor() ; активизируется невидимый курсор
RouteInvisibleToPC() ; перемещает невидимый курсор к PC курсору, чтобы он
был в нужном окне
JAWSPageDown() ; перемещает невидимый курсор в нижнюю строку окна
JAWSHome() ; перемещает невидимый курсор в начало нижней строки
SayLine() ; озвучиваем нижнюю строку окна
RestoreCursor() ; восстанавливаем курсор, который мы сохранили, и его позицию
EndScript ; конец скрипта

Посмотрите, как все это работает! Вы могли бы использовать этот скрипт,
чтобы читать строку состояния в Microsoft Word. В строке состояния
сообщаются номер страницы, номер строки, номер столбца и другая
подобная информация. Если вам нужен был только номер страницы, вы могли
бы подставить функцию SayWord(), после чего NextWord(), и еще одну
функцию SayWord(), вместо функции SayLine(). Тогда вы услышите только
слова: страница и номер.

Есть важная тонкость в функциях SaveCursor и RestoreCursor, и эту тонкость
необходимо понимать. Эти функции сохраняют, а затем восстанавливают тип
курсора, каким бы ни был активный курсор, когда используется функция
SaveCursor. Кроме того, если активными являются JAWS курсор или
невидимый курсор, когда используется функция SaveCursor, позиция курсора
также сохраняется, а затем восстанавливается функцией RestoreCursor.
Курсоры, которые активизируются и перемещаются после того, как была
использована функция SaveCursor, не будут восстанавливаться в своем
первоначальном типе или позициях. Таким образом, в вышеприведенном
примере, позиция невидимого курсора не будет восстановлена, если он не
оказался активным курсором при вызове функции SaveCursor. Однако, есть
возможность использовать несколько утверждений типа SaveCursor и
RestoreCursor в одном скрипте. Эти утверждения будут "вкладываться", во
многом походя на то, как вкладываются скрипты приложений и скрипты по
умолчанию. Это означает, что если вам пришлось воспользоваться вторым
утверждением SaveCursor, и вам нужно было иметь активным другой курсор,
а не тот, который у вас был, когда вы использовали первое утверждение
SaveCursor, то сохранена будет позиция второго курсора, когда SaveCursor
будет выполняться во второй раз. Более того, утверждения RestoreCursor будут
откатывать утверждения SaveCursor в обратном порядке. Таким образом, если
вы выполняете два утверждения SaveCursor, а затем выполняете RestoreCursor,
сначала будет восстановлен второй сохраненный курсор. Чтобы вернуть
первый SaveCursor, вы должны выполнить RestoreCursor во второй раз.
Следующий пример иллюстрирует вложение вызовов функции SaveCursor:

Script ReadBottomLine () ; начинает скрипт и присваивает ему имя
ReadBottomLine
SaveCursor () ; мы не знаем, какой курсор был активным, но мы сохраняем
его и его положение
InvisibleCursor () ; активизируется невидимый курсор
SaveCursor () ; сохраняет невидимый курсор и его положение
RouteInvisibleToPC () ; перемещает невидимый курсор к PC курсору, так чтобы
тот находился в нужном окне
JAWSPageDown () ; перемещает невидимый курсор в нижний край окна
JAWSHome () ; перемещаем невидимый курсор в начало нижней строки окна
SayLine () ; озвучивается нижняя строка окна
RestoreCursor () ; восстанавливается невидимый курсор и позиция, которую мы
сохранили
RestoreCursor () ; восстанавливается первоначальный курсор пользователя и
положение, которое мы сохранили
EndScript ; конец скрипта

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

                        Соединяем все вместе

Теперь давайте рассмотрим процесс создания скрипта, закрепления его за
определенной клавишей и компиляции файла скриптов, чтобы им можно было
пользоваться. Предлагается такой план. Мы создадим скрипт для диспетчера
скриптов, который будет читать номер текущей строки. Для этой задачи нам
понадобится диспетчер скриптов. Как вы помните, мы уже пользовались этим
редактором ранее, когда создавали наши первые скрипты. На этот раз мы
заставим диспетчер скриптов поработать на нас немного побольше. В точности
выполняйте все шаги:
Запустите диспетчер скриптов, выбрав его в меню Jaws Utilities.
Нажмите Insert+Q чтобы убедиться, что настройки диспетчера скриптов
загружены в стек поверх файла скрипта по умолчанию и что имя программы
для диспетчера скриптов - jscript.exe. Это, конечно, означает, что текущим
файлом, контролирующим Jaws, является jscript.jss.
Чтобы загрузить этот файл, чтобы вы могли его отредактировать, войдите в
меню "Файл", нажав ALT+F, нажимайте стрелку вниз, пока не дойдете до
пункта "open" и нажмите Enter. В поле редактирования, введите имя файла
jscript.jss и нажмите Enter.
Наконец, нажмите Ctrl+End чтобы поместить курсор в конец файла скриптов,
то есть, в самое лучшее место для добавления новых скриптов.

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

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

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

Сначала активизируйте Jaws курсор.
Затем нажмите Pgdn, чтобы встать на нижнюю строку, после чего нажмите
Home, чтобы встать в начало строки.
Теперь нажмите Insert+5 на цифровой клавиатуре, чтобы озвучить текущее
слово, и вы услышите слово "for". Воспользуйтесь командой "Следующее
слово" (Insert+^ на цифровой клавиатуре), чтобы прочесть строку слово за
словом. Теперь вы знаете, что пятое слово на этой строке является номером
текущей строки. Теперь мы знаем, что должен делать наш скрипт: он должен
активизировать курсор, поставить его в нужное место, а затем прочитать
слово. Ладно, активизируйте снова PC курсор, и мы начнем.

В меню Script (скрипт) выберите New script (Новый скрипт). Появится диалог
нового скрипта. Теперь мы должны назвать наш скрипт и написать его
документацию. Когда появляется диалог нового скрипта, курсор находится в
поле имени скрипта. Наберите SayLineNumber. Буквы S,L и N должны быть
заглавными, никаких пробелов быть не должно.

Нажмите Tab, чтобы переместиться к блоку проверки Can be attached to key
(может быть закреплен за клавишей) и нажмите пробел, чтобы включить его.
Позже мы закрепим наш скрипт за клавишей.

Нажмите Tab, чтобы переместиться к полю Synopsis и наберите "читает номер
текущей строки"

Нажмите Tab, чтобы переместиться к полю Description ?описание% и наберите
"строку, которая содержит PC курсор".

Нажмите Tab, чтобы переместиться в поле "Category" (категория) и наберите
"Say", потому что наш скрипт будет что-то говорить.

Нажмите Tab, чтобы переместиться в поле Assign To (закреплен за) и
нажмите Shift+Ctrl+L, чтобы закрепить эту комбинацию клавиш за скриптом
SayLineNumber.

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

Теперь у нас есть скрипт с утверждением begin с именем скрипта и
утверждение EndScript. Между ними имеется несколько пустых строк, куда
мы и должны вводить наши утверждения, и курсор находится на одной из
пустых строк. Нажимайте клавишу "Стрелка вверх", пока не окажетесь на
первой пустой строке скрипта.

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

Выберите Insert Function Call (вставить вызов функции) в меню Скрипт или
воспользуйтесь горячей клавишей Ctrl+I. Появляется диалог вставки функции
и курсор устанавливается в поле редактирования имени функции. Под полем
редактирования имени функции также выводится список всех функций. С
помощью клавиши Tab можно переместиться в этот список и с помощью
клавиш-стрелок найти ту, которая вам нужна, но это не очень-то эффективно,
поскольку их больше двух сотен. Jaws имеет способ получше, но он требует,
чтобы вы имели хоть какое-то представление об имени функции.

Как и в нашем предыдущем примере, мы должны начать с сохранения
курсора и его положения. Функция будет SaveCursor(), но нам нужно будет
нажать только букву S, после чего инструмент Insert Function начнет искать
сразу же, как только вы начнете набирать. SaveCursor() - это первая функция,
которая начинается с буквы S. Обратите внимание, что как только фокус
переместился к SaveCursor(), было прочитано сообщение-подсказка,
объясняющая, как используется эта функция. Нажмите Enter, и функция
поместится в наш скрипт. Просто, не правда ли?

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

На этот раз нам нужна функция InvisibleCursor(). На этот раз нам придется
набрать две буквы, поскольку InvisibleCursor() - это не первая функция,
которая начинается на букву I. Набирайте медленно, чтобы вы успевали
услышать, какая функция высвечивается. Как только вы услышите
InvisibleCursor(), нажимайте Enter, чтобы вставить ее в наш скрипт.

Воспользуйтесь аналогичной процедурой, чтобы добавить остальные наши
функции, в таком порядке:RouteInvisibleToPC (), JAWSPageDown(),
JAWSHome(), NextWord() 5 раз, SayWord() и RestoreCursor().
Нажмите CTRL+S, чтобы скомпилировать файл скриптов. Если вы не сделали
ни одной ошибки, вы услышите сообщение "compile complete" (компиляция
завершена). Если вы этого не услышали, повторите предыдущие процедуры,
пока не сможете скомпилировать без ошибок. Если вы получите ошибку,
диспетчер скриптов поместит курсор примерно в то место, где, по его мнению,
допущена ошибка, так что вы будете иметь лучший шанс ее найти.

Теперь проверьте свою работу, нажав Ctrl+Shift+L, чтобы услышать номер
текущей строки. Попробуйте некоторые вариации, как, например, озвучивание
целой строки, вместо отдельного слова. Затем добавьте сообщение "Строка
номер" перед тем, как будет фактически озвучен номер строки. Когда вы
освоитесь с этим процессом, либо переходите к следующему разделу,
"Создание сложных файлов скриптов", или перескакивайте и напишите
какие-нибудь скрипты, которые вам хотелось написать.

                       Домашнее задание № 2.

А вот вам второе домашнее задание. Как вы, вероятно, знаете, большинство
окон имеют три состояния: свернутое, распахнутое и восстановленное. В
правом верхнем углу большинства окон есть три кнопки. Первая - свернуть, а
последняя - закрыть. Средняя может быть либо "распахнуть", либо
"Восстановить", в зависимости от текущего состояния окна. Переместившись к
средней кнопке и прочитав ее, вы можете определить состояние окна. Если
произносится "Restore Symbol", (Символ восстановить), то окно распахнуто.
Если озвучивается "Maximize Symbol" (символ Распахнуть), то окно является
восстановленным. Ваше задание - написать скрипт для файла скриптов по
умолчанию default.jss, который будет читать эту кнопку. Конечно, чтобы
протестировать свой скрипт должным образом, убедитесь, что вы находитесь в
окне, в котором эти кнопки есть. Окно диспетчера скриптов послужит
прекрасным примером. После того, как вы напишете этот скрипт, вы сможете
определять текущее состояние окна с помощью одного нажатия клавиши. Мы
хотим, чтобы в этом задании вы использовали Jaws курсор, и вы должны
убедиться, что Jaws курсор возвращет на прежнюю позицию к тому времени,
когда скрипт закончит работу. Предположите, что PC курсор является
активным когда вы начинаете скрипт, и убедитесь, что он является активным,
когда скрипт выполнен.

Вы можете загрузить файл скриптов по умолчанию выбрав диспетчер
скриптов из меню утилит окна Jaws, а затем загрузить default.jss.
Альтернативным способом проделать это является нажатие CTRL+SHIFT+0 на
основной клавиатуре. Автоматически откроется диспетчер скриптов и
загрузится файл default.jss. Добавьте свой скрипт в конец этого файла.

Один возможный ответ можно посмотреть в главе ?, но не делайте этого,
пока не попытаетесь сами написаать этот скрипт.

Дополнительное задание - если вы чувствуете тягу к приключениям,
попробуйте модифицировать вышеприведенный скрипт, чтобы он был немного
более разумным. Вместо того, чтобы просто читать символы Maximize и
Restore, используйте If-Then, ElIf, Else, GetWord, и функции SayString чтобы
решить, каково состояние окна и какое сообщение нужно читать. Если окно
показывает символ "Восстановить", пусть скрипт говорит "распахнуто", а если
показан символ "Восстановить", пусть скрипт говорит "Восстановлено". Если ни
одного из этих двух символов найдено не будет, пусть он скажет "НЕ могу
найти символы". Намек - графика, имеющая ярлыки, такая, как символы
восстановления или распахивания, может интерпретироваться как текст, и ее
ярлык можно читать и им можно манипулировать с помощью тех же
функций, которые используются для чистого текста.

                       Домашнее задание №3

И просто для смеха, вот вам третье домашнее задание. Windows поставляется
с программой звукозаписи, которая называется Фонограф. Обычно эту
программу можно найти в папке Multimedia папки "дополнительные
возможности" в главном меню. Откройте ее, и поизучайте ее окно с помощью
Jaws курсора, если вы не знакомы с этой программой. Вы обнаружите
несколько кнопок для воспроизведения, записи, остановки и т.д. Вы также
обнаружите, что на четвертой строке сверху имеется счетчик, который
сообщает вам, сколько секунд проиграно и сколько секунд длится файл.
Загрузите какой-нибудь файл на вашем компьютере с расширением .wav,
воспользовавшись диалогом "Открыть" в меню "Файл". (вы найдете много .wav
файлов в папке C:\WINDOWS\MEDIA. Щелкните кнопку Play, чтобы начать
проигрывание, затем щелкните кнопку Stop до того, как файл будет проигран
до конца. (если вы предпочитаете пользоваться клавиатурой для этих
процедур, горячими клавишами для этих функций являются CTRL+P и
CTRL+S соответственно). Если вы теперь посмотрите на счетчик прошедшего
времени, то вы увидите, что там появились цифры, указывающие, сколько
времени прошло из суммарного количества времени. Мы хотим, чтобы вы
написаали скрипт для файла скриптов этого приложения (SNDREC32.JSS),
который будет читать вам этотсчетчик по одному нажатию клавиши.
Сообщение должно быть в форме "текущее время X секундс, из Y секунд".
Значения X и Y нужно бтать с дисплея счетчика фонографа, а остальная
часть сообщения должна быть создана с помощью утверждений SayString. Для
чтения воспользуйтесь невидимым курсором, и верните начальный курсор в
первоначальное положение, когда скрипт закончит работу.

Часть II

                  Создаем сложные файлы скриптов

                    Структура программ Windows

Вы, вероятно, слышали, как люди используют термины класс окна Window
class) и ручка окна (handle) в дискуссиях о том, как структурированы
программы Windows. Что же означают эти термины? В этом разделе мы
объясним иерархию окон, идентификацию и структуру, так что вы сможете
воспользоваться функциями скриптов, которые запрашивают и сравнивают эти
объекты.

Вопрос первый: что такое окно? Ну, это кажется простым. Программы
работают в окнах. Даже Jaws имеет свое окно. Это верно. Окно Jaws - это
окно, но вас, возможно, удивит, когда вы узнаете, что любое поле ввода,
кнопка или любой другой орган управления также является окном. По
крайней мере, он должен им быть. Как и все другие правила в компьютерных
программах, это правило не всегда соблюдается. Программист может создать
органы управления, такие, как поля ввода данных, не делая их фактическими
окнами. Доступ к таким программам осуществлять труднее всего, поскольку
нет простого способа определить и озвучить различные органы управления.
Для таких программ написаание скриптов является еще более необходимым,
поскольку скрипты в файлах по умолчанию не будут озвучивать такие окна
как положено. На некоторое время мы будем предполагать, что программист
присваивает каждому органу управления свое окно. Звучит, сложно, не
правда ли? Давайте посмотрим, сможем ли мы с этим разобраться.

                             Иерархия

Большинство людей, работающих в среде Windows, что же в действительности
означает слово "окно" в отношении этой среды. Они, конечно, понимают, что
большая прямоугольная штука, которая всплывает на экране, когда они
открывают новое приложение, является окном, и они, вероятно, считают также
окном текстовую область своего текстового редактора, но окно - это нечто
гораздо большее. В большинстве приложений каждое окно диалога, кнопка
меню, поле редактирования, окно списка и т.д., фактически является
отдельным окном с одним или несколькими идентификационными номерами,
которые можно использовать, чтобы ссылаться на них. Эти номера окон,
которые могут присутствовать на экране в любое время, не являются чем-то
случайным, с их помощью осуществляется взаимодействие со специальной
иерархией, которая позволяет операционной системе Windows и программисту,
который в ней работает, отслеживать все эти окна. Все это станет более
понятным, если мы рассмотрим иерархию окон в системе. Наиболее часто
используется метафора родителей и детей. Выглядит все это примерно так.
Рабочий стол вашего компьютера является родительским окном для всех окон
приложений. Это означает, что окно Jaws, окно вашего текстового редактора,
и окно вашего интернет браузера являются детьми рабочего стола. Эти окна
находятся уровнем ниже, чем рабочий стол, поэтому все они являются детьми
рабочего стола, на том же логическом уровне.В этом смысле все они равны
друг другу, и покда вы позже столкнетесь с терминами "Предыдущее окно"
или "Следующее окно", то речь будет идти о перемещении между равными
окнами на одном и том же уровне.

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

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

Просто на тот случай, если у вас остались некоторые проблемы, чтобы
визуально представить все это, давайте попробуем воспользоваться аналогией.
Большинство людей знакомо со структурой дерева каталогов, или из работы в
DOS, или в Проводнике Windows. На вашем диске, скажем, диске C, C:\
является родителем всех других директорий на диске. Все поддиректории,
находящиеся на один уровень ниже C:\, являются детьми этого родителя и
находятся на одинаковом логическом уровне. Таким образом, если у вас есть
поддиректории с именами Eudora, JFW33, Myljcuments, Recycled и Windows,
все они будут находиться на один уровень ниже от c:\. Все они являются
прямыми детьми C:\ и все они находятся на один логический уровень ниже.
Для целей структуры дерева каталогов и иерархии окон вы можете допустить,
что находиться на одном и том же логическом уровне означает, что все
члены были порождены или сгенерированы одним и тем же родителем.
Вспомните, мы сказали, что команды "Предыдущее окно" и "Следующее окно"
можно использовать для перехода к окнам на одном и том же логическом
уровне? Так вот, в отношении дерева каталогов, это может означать
перемещение к предыдущей директории или к следующей директории в дереве
каталогов. Если мы откроем поддиректорию JFW33, мы увидим 4 новые
поддиректории - Help, Cettings, Manuals и Tecnotes. Все эти 4 поддиректории
находятся уровнем ниже JFW33, являются детьми JFW33 и все они находятся
на одном логическом уровне, и находятся на два уровня ниже, чем c:\.
Конечно, это может продолжаться до тех пор, пока мы не достигнем самого
нижнего уровня конкретной ветви. Структура окон "родитель-дитя" работает во
многом аналогично структуре каталогов. Каждое приложение является веткой
дерева, и им порождаются дочерние окна. Все окна уровнем ниже
родительского приложения, являются детьми на одном и том же логическом
уровне, уровнем ниже относительно родителя. Каждое из этих окон-детей
может само порождать детей, и эти дети будут находиться на три уровня
ниже родительского приложения. Попробуйте поперемещаться вверх и вниз по
разным логическим уровням различных ветвей вашего дерева каталогов в
Проводнике Windowd, и вы лучше почувствуете эту иерархию родителей/детей.

                        Идентификация окон

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

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

                        Классы окон, типы,
                    коды типов и коды подтипов

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

Другие категории окон, перечисленные ниже, можно использовать для
получения этой информации. Кроме того, некоторые программисты
используют пользовательские классы окон (custom window classes), имеющие
странные и нераспознаваемые имена, которые Jaws не понимает. Нам
понадобится некоторый способ, чтобы сообщить Jaws, как обращаться с этими
пользовательскими классами окон, и это описывается ниже.
                                                            Класс окна можно получить с помощью функции GetWindowClass.

тип окна (Window type) - как и в случае с классом окна, тип окна
возвращает строку или имя, которое в отношении окна является
описательным. Иногда эта категория может дать более конкретную
информацию о некоторых окнах. Однако, запрос о типе окна возвратит ту же
самую информацию об окне, что и запрос класса окна, если никакой более
конкретной информации нет. Например, класс окна и тип окна Edit Field
(поле редактирования) будут в точности одним и тем же. Однако, если
доступна более конкретная информация, типом окна можно воспользоваться,
чтобы разобраться с этим. Так, если класс окна кнопки, радиокнопки или
блока проверки будет всегда "button", типы окна всех этих трех окон будут
сообщаться как "Button", "Radiobutton" и "Checkbox". Такая конкретная
информация позволит нам сообщить Jaws, как поступать с каждым из этих
типов. Если программист использовал пользовательские классы окон Custom
window classes), то запрос типа окна возвратит строку, которая говорит, что
тип окна неизвестен. Однако, когда пользовательский тип окна (custom
window type) переклассифицирован на известный класс окна (см. ниже), тип
окна вернет имя переклассифицированного окна и, таким образом, сообщит
нам, что делает окно. Единственная проблема с типом окон состоит в том, что
строка, возвращаемая этой функцией, всегда по-английски, и поэтому не
очень-то полезна для тех, кто использует Jaws на других языках. По этой
причине был разработан код типа окна. Тип окна можно получить с помощью
функции GetWindowType.

Код типа окна (Window type code) - запрос кода типа окна возвращает число,
а не строку. Это число переводится в понятную строку с помощью
определений констант, которые можно найти в файле HJCONST.JSH.
Например, в этом файле вы увидите такие, например, строки, как
WT_Button =1, WT_Edit = 3, WT_ListBox = 4, и WT_ScrollBar = 5. Префикс
константы WT сообщает вам, что эта константа относится к типу окна. Хотя
код типа окна не сообщает нам больше информации, чем тип окна, его
преимущество заключается в том, что он является независимым. Поскольку
для данных типов окон всегда возвращаются одни и те же номера, числа
можно приравнять к строкам на любом из возможных языков. Код типа окна
можно получить с помощью функции GetWindowTypeCode.

Код подтипа окна - как и в случае с типом окна, код подтипа окна также
возвращает целое число. Коды подтипа окна также переводятся в строки с
помощью тех же определений констант, что и для кода типа окна.
Единственное различие состоит в том, что код подтипа окна предоставляет
более подробную информацию, если она доступна. Если нет, обе функции
возвратят одну и ту же информацию. Например, радиокнопка возвратит код
типа окна 1, (WT_Button) но код подтипа 19 (WT_RadioButton). Кнопка
"Пуск", находящаяся на панели задач, также вернет код типа 1
(WT_Button), но вернет код подтипа 32 (WT_StartButton). Аналогичным
образом, GetWindowTypeCode вернет WT_TABCONTROL для панели задач,
тогда как GetWindowSubtypeCode вернет WT_TASKBAR. Вам захочется
использовать GetWindowTypeCode, когда вам не нужна более конкретная
информация, которую возвращает GetWindowSubtypeCode. Коды подтипов окон
также независимы с точки зрения языка. Их можно получить с помощью
функции GetWindowSubtypeCode.

Причина, по которой эти категории окон так важны для пользователей Jaws
состоит в том, что Jaws будет вести себя по-разному, в зависимости от того,
к какой категории принадлежит окно, содержащее фокус. Например, если
фокус находится в поле редактирования, Jaws отслеживает каретку, или
курсор вставки. Если вы нажимаете клавишу "Стрелка вниз", Jaws озвучит
строку текста, на которую переместилась ваша каретка. С другой стороны,
если вы находитесь в списке или в меню, Jaws отслеживает выделение или
курсорную рамку, когда используются клавиши-стрелки, чтобы перемещаться
вверх и вниз по списку. Jaws знает, что надо делать, благодаря скриптам,
ассоциированным с клавишами "Стрелка вверх" и "Стрелка вниз" в файле
скриптов default.jss. Эти скрипты содержат логику, которая определяет, что
делать, основываясь на категории окна, в котором находится фокус, когда вы
используете одну из этих клавиш. Если вы внимательно изучите скрипты
SayPriorLine и SayNextLine в файле default.jss, вы увидите, что решения, в
отношении того, что говорить, принимаются, основываясь на кодах типа и
подтипа окон, которые являются текущими, когда вызывается скрипт.

Как и в случае с типами окон, кодами типов, кодами подтипов окон,
существует стандартный набор классов окон, которым пользуется большинство
программистов, и Jaws скрипты по умолчанию содержат необходимую логику,
чтобы обеспечить нормальное озвучивание таких стандартных классов в
большинстве случаев. Однако, классы окон не всегда настолько стандартны,
как эти другие категории. Если вам когда-либо пришлось воспользоваться
диалогом классов окон в диспетчере конфигурации, чтобы переназначить
пользовательский или неизвестный класс окон, вы знаете, что иногда
программист создает пользовательские классы окон, о которых мы должны
информировать Jaws. Поскольку эти пользовательские классы по определению
являются нестандартными, Jaws не имеет никакого понятия, что с ними
делать. Поэтому мы должны воспользоваться диспетчером конфигурации,
чтобы приравнять неизвестный класс к одному из известных классов, чтобы
Jaws знал, как себя вести, когда оно ему встретится. Этот процесс называется
переклассификацией или переназначением класса окна. Если вы никогда не
пользовались этой процедурой, воспользуйтесь или комбинацией клавиш
Insert+7, или комбинацией клавиш Insert+F2, после чего нажмите W, а затем
Enter, чтобы вызвать диалог переназначения класса окон, и поизучайте
различные органы управления, чтобы познакомиться с ними.

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

          Контрольные идентификаторы и ручки (handles) окон

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

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

Конечно, нет никакой гарантии, что два окна в различных программах не
будут иметь один и тот же контрольный идентификатор. Поэтому, чтобы
предотвратить путаницу, система присваивает уникальный идентификатор,
который называется ручкой окна (a window handle), каждому окну, к
которому она осуществляет доступ во время данной конкретной сессии. Ручки
окон являются числами,но они не являются неизменными значениями, в
отличие от контрольных идентификаторов. Пока ручка активно присвоена
конкретному окну, ею можно пользоваться, чтобы ссылаться на это окно и
идентифицировать его. Когда ручка будет присвоена, она остается активной,
пока существует окно. Однако, когда окно уничтожается, оно освобождает и
свою ручку. Если окно повторно вызывается позже, оно, вероятнее всего,
будет иметь другую ручку. Поскольку система присваивает эти ручки, покуда
окна используются, ручка, присвоенная окну сегодня, может быть не той же
самой, какой она будет завтра. Хорошей аналогией для оконной ручки будет
пронумерованный распределитель билетов, используемый во многих булочных
и магазинах деликатесов. Когда вы входите, вы берете номерок у
распределителя, и этот номерок становится вашей ручкой на сей день. Сегодня
ваш номер может быть 31, и когда кассир скажет 31, вы будете знать, что
это ваша очередь. Если вы придете в другой день, у вас, вероятнее всего,
будет другой номер, но он по-прежнему бедет вашей ручкой, хотя он и не
тот, каким он был в предыдущий раз. Смысл заключается в том, что это
система идентификации, которая сообщает служащему, кто следующий в
очереди. Используйте ручку окна, чтобы идентифицировать его среди других
окон в системе в данное конкретное время. Ручку окна можно получить с
помощью встроенных функций GetCurrentWindow () и GetFocus (). Одним из
способов проделать это будет, например, воспользоваться функцией
GetCurrentWindow () в качестве параметра для функции SayInteger (). Таким
образом, SayInteger (GetCurrentWindow ()) сообщит ручку окна, содержащего
активный курсор. Кстати, это еще один пример использования вложенных
функций, которые упоминались ранее.

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

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

                 Строительные блоки языка скриптов

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

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

                              Скрипт

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

На этой же строке, после слова "Script", приводится его имя. Обычно это
несколько слов, объединенных вместе и описывающих действие скрипта, как,
например, CloseDocumentWindow (ЗакрытьОкноДокумента). Обратите
внимание, что каждое из объединенных слов начинается с заглавной буквы,
чтобы Jaws мог правильно прочитать название. После имени записывается (),
чтобы завершить начальное утверждение скрипта. Все это автоматически
добавляется диспетчером скриптов, когда вы создаете скрипт.

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

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

Оператор окончания скрипта, EndScript, всегда является последней строкой
скрипта. Она также автоматически добавляется диспетчером скриптов, когда
вы создаете скрипт.

Диспетчер скриптов корректно создаст базовую структуру скрипта, когда вы
выберете "New Script" в меню "Script", или воспользуетесь
клавишей-ускорителем CTRL+E. Вы всегда должны создавать скрипты таким
образом, поскольку диспетчер скриптов также запросит у вас
соответствующую документацию скрипта и позволит вам закрепить скрипт за
клавишей.

                             Функция

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

Мы близки к тому, чтобы поговорить о функциях, которые могут быть
созданы вами, и под этим мы будем подразумевать скрипт, который вы
напишете, и который не будет закреплен за клавишей. Это функция,
определяемая пользователем (User-defined aunction), имея в виду, что она
написана вами, пользователями. Также имеются функции, уже
присутствующие в файлах скриптов, и которые вы можете модифицировать, и
эти функции были написаны авторами скриптов из Henter-Joyce. Это тоже
функции, определяемые пользователем, но их определяли другие пользователи,
а не вы. И наконец, имеются встроенные функции, которые являются
строительными блоками языка Jaws. Вы, пользгватели, не можете
модифицировать встроенные функции, как вы можете модифицировать
свои собственные функции, или функции, написанные другими людьми. Вы
можете использовать любой из этих трех типов функций, как строительными
блоками, когда будете писать скрипты или новые функции, но встроенные
функции жестко закодированы в Jaws, и поэтому дальнейшая дискуссия к
ним не применяется. (Встроенные функции будут обсуждаться позже).

Не встроенная функция должна иметь следующие части, в точности соблюдая
следующий порядок: тип возврата: Handle (ручка), int (целое), Object (Объект),
String (строка) или Void (Пустая)
Начальное ключевое слово функции. Это просто слово "Function", после
которого следует пробел.
На той же строке, где написано слово "function", записывается имя функции.
Обычно это несколько слов, объединенных вместе, которые описывают
действие этой функции, например SayFocusedWindow (НазватьОкноСФокусом).
Обратите внимание, что каждое из объединенных слов начинается с большой
буквы. Таким способом Jaws может правильно прочитать название, как если
бы это были отдельные слова. После имени функции следуют (), чтобы
завершить начальный оператор функции. Обратите внимание, что все функции
должны иметь обозначения типа возврата, как те, которые были перечислены
в пункте 1, перед ключевым словом начала функции. Эти типы возврата
упоминались ранее и описывают, какой тип информации возвращается в
вызывающий скрипт, когда функция заканчивает работу. Конечно, функцию
можно придумать так, чтобы ее можно было вызвать и завершить ее задачу,
без необходимости возвращать какую-либо информацию обратно в
вызывающий скрипт или функцию. В этом случае возврат обозначается как
Void.

С другой стороны, кроме завершения любых других задач, функция также
может передать целое число, строку, объект или значение ручки (handle),
обратно в вызывающий скрипт. Если именно это она и делает, вы должны
увидеть слово String, Object, или Handle перед словом Function на первой
строке.

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

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

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

Оператор окончания функции, EndFunction, всегда является последней строкой
функции. Диспетчер скриптов автоматически создаст базовую структуру
функции, когда вы выберете New Script из меню Script. Вы всегда должны
создавать функции таким образом, поскольку диспетчер скриптов также
запросит соответствующую документацию функции и и позволит вам
присвоить параметры и возвраты.

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

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

                         Типы утверждений

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

                           Комментарии

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

                        Включения (Include)

Утверждения включения (Include) сообщают компилятору, что наряду с этим
файлом он должен включить содержание другого файла, так, как если бы эта
информация была набрана в главный файл на том месте, где находится
утверждение включения. Следовательно, вся информация во включенном файле
доступна для главного файла от точки включения и до конца главного файла.
Это означает, что все включенные файлы будут скомпилированы наряду с
главным файлом, в один большой .jsb файл. Файлы включения - это отдельные
файлы с общими пунктами, которые могут оказаться полезными для
нескольких файлов скриптов, или которые вы можете пожелать хранить по
отдельности из соображений ясности или удобства.

Есть два типа файлов включения: файлы заголовков (Header files) обозначены
с помощью расширения .JSH и содержат или объявления переменных, или
объявления констант.

Файлы сообщений обозначены с помощью расширения >JSM и содержат
утверждения сообщений с присвоенными номерами.

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

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

Include "HJGLOBAL.JSH"

Если вы забудете поставить кавычки, синтаксис будет неверным, и вы
получите сообщение об ошибке, когда попытаетесь скомпилировать файл.
Также предполагается, что файл, который нужно включить, содержится внутри
директории языка (Например, поддиректории ENU в поддиректории \SETTINGS
в директории, где находится Jaws).

Ниже приводится список стандартных include файлов, поставляемых с Jaws и
включенных в default.jss:

HJGLOBAL.JSH - содержит глобальные переменные JFW.
HJCONST.JSH - содержит глобальные константы JFW по умолчанию.
DEFAULT.JSM - содержит стандартные сообщения, на которые
ссылается default.jss.

Как мы уже говорили прежде, помните, что файл сообщений - это
специальный файл включений, который присваивает номера сообщений
обычным сообщениям. Таким образом автор скрипта может
использовать номер сообщения вместо самого сообщения, и Jaws
будет искать фактический текст сообщения в файле сообщений. На
самом деле, номер сообщения - это просто константа, которой
присвоена строка фактического сообщения. Все файлы скриптов,
поставляемые с JFW, имеют свои собственные файлы сообщений.
Используйте то же имя, что и файл скриптов, после чего поместите
расширение .JSM, когда будете воздавать свой файл сообщений.
Затем включите его в свой файл скриптов. Если файл default.jsm
содержит сообщения, полезные только для default.jss,
HJGLOBAL.JSH и HJCONST.JSH используются в любом файле скриптов,
который ссылается на глобальные переменные Jaws и его константы.

                       Домашнее задание 4

Представьте, что вы начинаете строить файл скриптов для
приложения, которое называется JAWSWINS.EXE. Вы хотите
использовать операторы включения (include) для файла заголовка
констант и переменных, файл сообщений для сообщений и два файла
Jaws, HJCONST.JSH и HJGLOBAL.JSH. Напишите операторы включения,
необходимые для этой цели.

                           Переменные

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

Ниже приводится описание типов переменных, допустимых в языке
скриптов Jaws:

Integer - переменная, предназначенная для хранения
целочисленного значения. (Integer - это целое число, не
содержащее десятичную точку). Переменная объявляется так:

Int MyIntegerVariable

Обратите внимание, что после типа (int) следует уникальное имя,
присвоенное этой переменной (MyIntegerVariable).

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

К использованию переменной integer применяются следующие правила:

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

String - хранит строку символов. String - это группа символов,
включая буквы, цифры, знаки препинания и пробелы. Эта переменная
объявляется так:

String MyStringVariable

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

К использованию переменной типа string применяются следующие
правила:

1. Переменная string должна быть объявлена прежде, чем ее можно
будет использовать.
2. Ее значение по умолчанию всегда "null" или никаких символов.

Когда вы присваиваете значение переменной String, вы должны
помещать строку в кавычки. Например, корректным будет следующий
синтаксис: Let StringVariable = "Hello". Обратите внимание, что
в версиях Jaws ранее 3 вы должны были помещать пробел между
кавычками, когда вы проверяете на нулевое значение. Теперь все
изменилось. Null показывается двумя кавычками, без пробела между
ними.

Handle - хранит ручку окна. Ручка окна (Window handle) - это
уникальный номер, который система присваивает каждому окну в
текущей работающей программе. Переменная объявляется так:

Handle MyHandleVariable

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

К использованию переменной handle применяются следующие правила:

1. Переменная типа Handle должна быть объявлена прежде, чем ее
можно будет использовать.
2. Ее значение по умолчанию равно нулю.

Object - это переменная, предназначенная для хранения объекта.
Объект, для целей языка скриптов Jaws, обращается к типам
объектов, представленных в некоторых приложениях Microsoft,
таких, как Office 97 suite. Переменная объявляется так:

Object MyObjectVariable

Переменная типа object используется для хранения объекта,
который был возвращен в Jaws скрипт или функцию. Ее роль
заключается в том, чтобы получать определенные виды информации
из некоторых приложений Microsoft, которую обычно очень трудно
или невозможно получить, просто озвучивая экран. К использованию
переменной object применяются следующие правила:

1. Переменная типа object должна быть объявлена прежде, чем ее
можно будет использовать.
2. Ее значение по умолчанию всегда Null или Empty (пусто).

Переменные могут быть локальными, что означает, что они могут
использоваться в скрипте, в котором они объявлены, и
глобальными, что означает, что они могут использоваться в любом
скриипте в файле скриптов, где они определены. Глобальные
переменные могут быть объявлены в начале файла скриптов, с
помощью заголовка globals. Поместите эту группу сразу же после
операторов включения. Глобальные переменные также могут быть
объявлены в include файле, как это сделано в случае с файлом
скриптов по умолчанию и его заголовочным файлом включения
HJGLOBAL.JSH. Если этот файл включен, глобальные переменные,
объявленные в этом файле, можно использовать в любом скрипте по
умолчанию. Вам следует создать заголовочный файл для переменных,
которые вы намерены использовать в нескольких файлах скриптов.
Если вы объявляете глобальную переменную, которую вы намерены
использовать только с одним приложением, то будет лучше объявить
эту переменную прямо в файле скриптов, а не в файле заголовков,
и включить имя приложения в в имя переменной. Это послужит тем,
что сообщит пользователю, что это глобальная переменная,
предназначенная для использования только в этом приложении.
Пользователь также должен понимать, что коль скоро переменная
создана и ей присвоено какое-то значение, это значение остается
в памяти, даже после того, как приложение, которое ее
использовало, было закрыто. Если приложение открыто снова во
время одной и той же компьютерной сессии, глобальные переменные
из файла скриптов для этого приложения будут иметь те же
значения, которые они имели перед тем, как программа была
закрыта. Единственный способ очистить глобальные переменные -
выгрузить, а потом снова загрузить Jaws.

Локальные переменные объявляются в скрипте в первом утверждении
после начального оператора скрипта. Они имеют заголовок Var.

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

Следующие операторы объявления взяты из WINWORD.JSS, файла
скриптов для Microsoft Word For Windows. Обратите внимание, что
большая часть имен глобальных переменных начинается со слова
Global, так чтобы их легко можно было отличить от локальной
переменной. Соглашения о присвоении имен будут подробно
обсуждаться позже, когда мы будем обсуждать технику написания
скриптов.

Globals
String GlobalWinwordVersion,
Int GlobalCurrentControl,
Handle GlobalRealWindow,
String GlobalRealWindowName,
Int WinWordFirstTime, ; to say auto start message only first time
Handle WinWordContextHandle, ; read word in context
Int WinwordFontCode ; when font buttons are pushed

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

Следующее утверждение объявления локальной переменной взято из функции
HotKeyHelp97 () в WINWORD.JSS, файла скриптов для Microsoft Word For
Wondows. Как показано ниже, объявления переменной появляютсясразу же,
после начального оператора функции.

Function HotKeyHelp97 ()
var
	handle WinHandle,
	Int verbosity

Здесь также, все строки, за исключением последней, заканчиваются запятой.

                            Константы

Как мы уже сказали прежде, константы - это способ использовать легко
запоминающиеся имена для сохранения труднозапоминающихся строк
символов или чисел. Константы можно представить в виде некоторого числа
или группы букв или слов, которым дали, или присвоили, новое имя. Это
делается по чисто мнемоническим соображениям, поскольку гораздо легче
запомнить имя, чем число или длинный ряд чимволов или слов. Нет никаких
ограничений на то, сколько имен констант вы присвоите числу. Например, в
стандартном файле констант Jaws, и константам TRUE, и ON, присваивается
значение 1. Это означает то, что вы можете написать утверждение скрипта,
чтобы проверить, соответствует ли условие TRUE, On или 1. Все они
рассматриваются как имеющие одно значение, коль скоро константы были
объявлены. Мы настоятельно рекомендуем вам пользоваться константами,
поскольку гораздо труднее запомнить, что когда что-либо истинно, его
состояние равно 1, но легко понять разницу между TRUE и FALSE (истиной
и ложью). Кроме того, когда кто-то другой читает ваш файл скриптов, ему
будет гораздо легче понять, что вы хотели сделать, если они увидят хорошо
поименованные константы, а не числа. И наконец, если вам нужно изменить
значение числа, которое используется в нескольких местах, вы можете
изменить их все сразу, если вы использовали константу для представления
этого числа, просто изменив значение объявления константы.

Константы объявляются в начале файла скриптов с помощью заголовка
группы Const, следующим образом:

Const
	True = 1,
	False = 0,
	On = 1,
	Off = 0

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

                  Встроенные функции и операторы

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

                        Встроенные функции

Язык Jaws предоставляет для использования в скриптах более 200
предзаданных функций. Каждая функция выполняет специфический вид
деятельности. Это строительные блоки, или инструкции, из которых мы
создаем наши скрипты. Например, RouteJAWSToPC проверяет положение Jaws
и PC курсоров, делает необходимые расчеты и перемещает Jaws курсор в ту
же точку, в которой находится PC курсор. Вся эта деятельность для вас
прозрачна, поскольку все, что вам надо знать, это то, что она перемещает
Jaws курсор к PC курсору.

Нет никакого практического смысла обсуждать здесь все предзаданные
функции, поэтому мы удовлетворимся обсуждением наиболее важных из них.
В приложении C перечислены многие из наиболее важных функций и даны
краткие описания каждой. Эти описания основаны на информации, которую
можно найти в файле BUILTIN.JSD, который можно найти в поддиректории
\settings\enu вашей главной JFW директории, предполагая, что вы используете
U. S. English версию Jaws. Эти описания в BUILTIN.JSD являются теми же
описаниями, которые вы слышите, когда просматриваете список функций
диспетчера скриптов. Хотя все Jaws функции являются важными, те, которые
приведены в приложении C показались нам самыми важными и достойными
того, чтобы быть включенными здесь. Хорошее понимание этого материала
сослужит вам хорошую службу на вашем пути к тому, чтобы стать мастером
по написанию скриптов. Эти описания и описания оставшихся функций
можно просмотреть в любое время, вызвав диалог Insert Function (вставка
функции) в диспетчере скриптов или просмотрев файл BUILTIN.JSD.

Мы также сгруппировали многие встроенные функции по типу задачи,
которую они выполняют. Эти группировки можно просмотреть в приложении
D. Если вы хотите выполнить конкретный тип задачи, но не знаете имя
функции, можете попытаться посмотреть в приложении D категориий, вместо
того, чтобы просматривать весь алфавитный список приложения C или
BUILTIN.JSD.

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

Синтаксис функции следующий:

ИмяФункции ([параметры])

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

Некоторые встроенные функции предоставляют "возвраты". Вспомним, что
возврат - это данные, которые функция возвращает обратно в скрипт для
дальнейшей обработки. Если функция предоставляет возврат, эта информация
предоставляется в файле BUILTIN.JSD и в документации списка функций
диспетчера скриптов.

                Функции GetCurrentWindow и GetFocus

Есть две встроенные функции, которые настолько важны для написания
скриптов, что они заслуживают отдельного внимания. Эти две функции
называются GetCurrentWindow и GetFocus. Какого же черта они делают? Мы
уже немного говорили о ручках окон, но мы никогда не говорили вам в
явном виде, как ее получить и что с ней делать, если даже вы ее получили.
Именно здесь вы должны начать изучение того, как делать две эти штуки.
Это позволит вам получить подробную информацию об окне (которое, как мы
уже сказали, также означает любой орган управления), которое присутствует
в вашем приложении.

Ниже приведены определения двух этих функций, взятые из
BUILTIN.JDF.

GetCurrentWindow - определяет ручку окна (Window Handle) для
окна, которое содержит активный курсор. В противоположность
этому, функция GetFocus использует аналитический процесс, чтобы
найти окно, которое в данный момент содержит фокус, независимо
от того, какой курсор является активным.

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

Так что же означают эти определения? Прежде всего, обе функции
сообщают ручки окон, поэтому их использование позволит нам
получить эту информацию об окне в нашем приложении. Например,
утверждения Let MyHandle = GetCurrentWindow () и Let MyHandle = GetFocus ()
установят Handle переменную равной значению ручки запрашиваемого
окна.Если вслед за этим вы использовали утверждение, такое как
SayInteger (MyHandle), Jaws озвучит число или ручку окна, о
котором идет речь. Разница между двумя этими функциями состоит в
том, что GetFocus будет сообщать ручку любого окна, в котором,
по мнению Jaws, находится фокус. Это может быть, например,
выделенная в данный момент кнопка или поле редактирования в окне
диалога. GetCurrentWindow будет проверять, какой курсор является
активным а затем сообщит ручку окна, содержащего этот курсор.
Таким образом, если вы активизируете Jaws курсор, например, и
удаляетесь от фокуса к другому органу управления,
GetCurrentWindow сообщит ручку окна этого нового органа
управления, тогда как GetFocus будет по-прежнему сообщать ручку
окна, содержащего фокус.

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

GetControlID (GetCurrentWindow ()) - сообщит идентификатор
органа управления окна, содержащего активный курсор.

GetFirstChild (GetFocus ()) - сообщает ручку первого дочернего
окна для окна, в котором находится фокус. Эту дочернюю ручку
можно затем использовать для получения информации о дочернем
окне.

GetParent (GetCurrentWindow ()) - сообщает ручку родительского
окна, которое породило текущее дочернее окно.

SayControl (GetFocus ()) - озвучит содержание и приглашение
органа управления, который в данный момент содержит фокус.

SayWindowTypeAndText (GetCurrentWindow ()) - сообщит
разнообразную информацию об окне, содержащем активный курсор,
такую, как заголовок окна, если он есть, содержание окна, тип
окна и другую информацию.

Итак, теперь у вас есть некоторое понимание того, как
использовать некоторые Jaws Функции, чтобы получить ручки,
которые могут использоваться другими Jaws функциями для
получения информации, которая будет необходима для ваших
скриптов, или для того, чтобы озвучивать какую-либо информацию,
или для того, чтобы принять решение относительно того, как
продолжать обработку скрипта. Повторим, что вы найдете список
наиболее важных встроенных функций в приложении C, а полный
список этих функций - в файле BUILTIN.JSD.

                     Функции Pause и Delay

Есть две функции, которые временно приостанавливают обработку
скрипта, Pause () и Delay (). Такая приостановка работы скрипта
часто бывает необходима, чтобы не дать скрипту уйти слишком
далеко вперед по сравнению с приложением, с которым он работает.
Например, если вы используете функцию, которая перемещает Jaws
курсор в другую часть экрана, или которая убирает меню, вам
может понадобиться приостановить работу скрипта, чтобы разрешить
завершение действий, прежде чем скрипт продолжит работу. Функция
Pause просто останавливает обработку скрипта, и дает другому
приложению возможность завершить свою обработку. Затем скрипт
продолжает работу. Функция Delay останавливает обработку скрипта
на указанный период времени, который указывается целым числом в
скобках. Чем больше целое число, тем дольше остановка. Однако,
если выбранного времени недостаточно, чтобы наше приложение
завершило свою работу, скрипт продолжит работу в любом случае.
Иногда необходим процесс проб и ошибок, чтобы определить
необходимое время задержки. В общем, функция Delay является
более полезной, когда вы хотите заставить скрипт остановиться,
независимо от того, закончило приложение свою работу, или нет.
Иногда функция Pause просто не останавливает скрипт на
достаточно долгий промежуток времени, и для того, чтобы достичь
желаемого эффекта, вызывается Delay. В общем, стоит сначала
попробовать Pause. Если требуется более длительная приостановка,
то можно использовать Delay.

                       Слово об SDM окнах

Как только вы узнали кое-что об окнах, вам придется кое-что
узнать об исключении. Раньше мы уже говорили о взаимодействии
родительских и дочерних окон, и описали, как каждый орган
управления (то есть, кнопка, поле редактирования, блок проверки
и т.д.) является окном со своими собственными правами и является
дочерним окном родительского окна, которое породило его, Обычно
окна диалога. В общем, как оказалось, есть такая ситуация, когда
это не так. В Windows есть тип окна, который он использует в
некоторых своих приложениях, который называется SDM окно, что
расшифровывается как standard dialog manager (стандартный
диспетчер диалога). В SDM окне органы управления не являются
дочерними окнами родительского диалога, и на самом деле, вообще
не являются отдельными окнами. Поэтому у них нет своих ручек.
Это делает невозможным написание скриптов, чтобы получать о них
информацию, используя стандартные методы, используемые для
других органов управления. Например, в общепринятом диалоге,
если вы хотите получить информацию об органе управления, на
котором в данный момент находится фокус, вы можете
воспользоваться вложенным оператором функции, как, например,
GetWindowSubtypeCode (GetFocus ()). GetFocus () передаст ручку
окна, в данный момент содержащего фокус функции GetWindowSubtypeCode ()
а эта функция затем возвратит код подтипа органа управления, в
настоящий момент содержащего фокус. Таким способом вы можете
узнать, является ли текущий орган управления кнопкой,
раюиокнопко, слайдером, блоком проверки или другим типом органа
управления. Но это просто не будет работать в SDM окнах,
поскольку его органы управления просто не имеют уникальных
ручек. Поэтому в Jaws входят некоторые специальные функции,
которые вы увидите в приложении C и которые используются для
получения информации об органах управления в SDM окне.

Ну а как мы узнаем, что имеем дело с SDM окном? Ну, по крайней
мере, это-то легко. Вы всегда можете воспользоваться горячей
клавишей Jaws Ctrl+Insert+F1, чтобы получить некоторую
информацию об окне, на котором вы в данный момент
сфокусировались, и один из пунктов, который вы получите, это
класс окна. SDM окна всегда имеют в своих именах буквы SDM.
Например, если вы вызовете диалог открытия файлв в Microsoft
Word и нажмете CTRL+Insert+F1 на органах управления в этом
диалоге, вы обнаружите, что большинство из них имеют имя класса
окна bosa_sdm_Microsoft Word 8.0. Вы также заметите, что все
органы управления с этим именем также имеют одну и ту же ручку
(window handle). Это ручка самого диалога открытия, и таким
образом, в самой по себе в ней нет никакой пользы, в
предоставлении информации о конкретных органах управления. Тогда
как же получать такую информацию? Специальные функции в Jaws,
которые предназначены для того, чтобы делать это, основываются
на том факте, что органы управления в SDM диалоге имеют
уникальный контрольный идентификатор, даже если у них нет
уникальной ручки окна. Используя этот уникальный контрольный
идентификатор в комбинации с ручкой окна диалога, можно получить
информацию об органах управления SDM диалога. Например, две из
специальных SDM функций, приведенных в приложении C, это
SDMGetCurrentControl и SDMGetNextControl. Первая из них
возвращает контрольный идентификатор органа управления, на
котором находится активный курсор, а вторая сообщит контрольный
идентификатор следующего органа управления в SDM диалоге. Таким
образом, если вы хотите получить более подробную информацию о
текущем или следующем органе управления в SDM диалоге, он может
воспользоваться информацией о контрольном идентификаторе или из
двух этих функций с одним из других специальных SDM утверждений,
чтобы сообщить дополнительную информацию об органе управления.
Например, такое утверждение показано ниже.

SDMSayControl (GetFocus (), SDMGetCurrentControl ())

Функция SDMSayControl озвучит орган управления в SDM диалоге, но
мы хотим, чтобы она сообщила, какой. Чтобы сделать это,
потребуются два параметра. Первый, GetFocus, заставляет функцию
получить ручку текущего активного SDM диалога. Второй параметр,
SDMGetCurrentControl, сообщает функции, что нам нужен
контрольный идентификатор органа управления SDM, на котором мы
сейчас находимся. Таким образом, эта функция озвучит имя и
другую информацию об органе управления SDM, на котором мы
находимся в данный момент в SDM диалоге. Другими словами, мы
можем вычислить уникальный орган управления, сообщив Jaws и
ручку SDM диалога, на который мы ссылаемся, и контрольный
идентификатор органа управления, который нас интересует. Две этих
частей информации, взятые вместе, оказывается достаточно, чтобы
сообщить Jaws, о каком органе управления в SDM диалоге мы хотим
узнать. Другие SDM функции, приведенные в приложении C,
предоставляют другие опции для идентификации органов управления
в SDM диалогах.

Арифметические операторы

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

        Let IntVar = IntVar + 1
(это увеличит целочисленную переменную, которая называется
IntVar на 1)
        Let IntVar = FirstVar * SecondVar
(это устанавливает, что IntVar равняется FirstVar, умноженная на
SecondVar)
        SayString (MyConstant + "YourConstant)
(это озвучит содержание двух констант, Myconstant и
YourConstant, как если бы это было одно сообщение).

                      Логические операторы

Логические операторы используются для сравнения переменных с
другими переменными или константами. Нам часто бывает необходимо
знать, имеет ли объект то же значение, меньшее значение или
большее значение, чем другой объект. Иногда необходимо сравнить
несколько объектов или группу объектов, с другими объектами.
Логические операторы обычно используются внутри циклов if-then и
While, чтобы решить, являются ли условия, необходимые для
логических решений, истинными или ложными. Ниже приводится
список логических операторов Jaws.

== - два знака равенства подряд спрашивают, является ли первое
условие равным второму условию. То есть, является ли выражение
слева от двух знаков равенства эквивалентным выражению справа.
Например, выражение (A == B) спрашивает, является ли A равным B.

!=- восклицательный знак и знак равенства - спрашивает, является
ли первое условие неравным второму условию. То есть, является ли
выражение слева от восклицательного знака и знака равенства
отличным от выражения справа. Например, выражение (A != B)
является истинным, если A не равно B.

< - знак "меньше" спрашивает, является ли первое условие меньше
второго условия. То есть, является ли выражение слева от знака <
меньше, чем выражение справа. Таким образом, выражение (A < B)
является истинным, если если A меньше B.
<= - знак "меньше", после которого следует знак равенства,
спрашивает, является ли первое условие меньшим или равным
второму условию. То есть, является ли выражение слева от <=
меньшим или равным выражению справа. Таким образом, выражение (A
<= B) будет истинным, если A меньше или равно B.

> - знак "Больше" - спрашивает, является ли первое условие
больше второго условия. То есть, является ли выражение слева от
знака > больше, чем выражение справа. Таким образом, выражение
(A > B_  является истинным, если A больше B.

>= - знак "Больше", после которого следует знак равенства,
спрашивает, является ли первое условие большим или равным, чем
второму условию. То есть, является ли выражение слева от >=
большим либо равным выражению справа. Таким образом, выражение
(A >= B) будет истинным, если A будет больше или равно B.

&& - этот оператор помещается между двумя логическими
сравнениями, которые производятся с использованием таких
логических операторов, как те, которые были описаны выше. Он
спрашивает, является ли первое условие верным "и кроме того"
является ли верным второе условие. Выражение в целом оценивается
как истинное только в том случае, если сравниваемые элементы по
обеим сторонам оператора && являются истинными. Таким образом,
в выражении (A == B) && (C != D), значение истины возвращается
только в том случае, если A равно B, а C не равно D.

|| - этот оператор помещается между двумя логическими
сравнениями, которые производятся с использованием логических
операторов, таких, как те, которые были перечислены выше. Он
спрашивает, является ли истинным либо первое, либо второе
условие. Выражение в целом оценивается как истинное, если любое
выражение на любой стороне от оператора || является истинным.
Таким образом, в примере (A == B) || (C == D), значение истины
возвращается, либо если A равно B, либо если C равно D. Конечно,
истина будет возвращена и в том случае, если верными будут оба
выражения.

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

!Выражение ==True

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

                       Поразрядные операторы

Поразрядные операторы - это инструмент, который позволяет нам сравнить
два фрагмента данных скорее необычным способом. Они позволяют нам
сравнить два фрагмента информации байт за байтом, а не значения в целом.
Все мы знаем, что компьютерная информация хранится в цифровой форме,
как ряд нулей и единиц. ЭтО, конечно, верно для констант и переменных.
Например, константа Jaws для выбранного или выделенного текста называется
Attrib_highlight. Если вы заглянете в файл HJCONST.JSH, то вы обнаружите,
что эта константа имеет значение 64. Что же значит это 64? Очевидно, что
64 - это десятичное число, а не бинарное число. Мы можем это утверждать,
потому что бинарные числа состоят только из нулей и единиц, поэтому 64 не
может быть двоичным числом. Когда мы переведем 64 в двоичную систему
счисления, мы получим число 01000000. (Обсуждение двоичной арифметики
не входит в компетенцию данного руководства, поэтому если вы не знаете,
как было проведено преобразование, просто примите это на веру).
HJCONST.JSH также сообщает нам, что атрибут жирного шрифта, Attrib_Bold,
имеет значение 2 или 00000010 в двоичном формате, атрибут курсива,
Attrib_Italic, имеет значение 4 или 00000100 в двоичном формате, а атрибут
подчеркивания, Attrib_Underline, имеет значение 8 или 00001000 в двоичном
формате. Помните, как раньше мы говорили в этом руководстве, что
константы используются потому, что их легче запомнить, чем числа? Ну вот
вам и превосходный пример такой ситуации. Имена типа
ATTRIB_HIGHLIGHT гораздо легче запомнить, чем длинные двоичные числа.

Так что же мы будем делать с этими числами, и что они будут делать с
поразрядными операторами? Допустим, мы хотим знать, является ли некоторая
часть текста выделенной. Мы будем пользоваться одним из поразрядных
операторов, который обозначается одиночным символом & чтобы узнать это.
Этот поразрядный оператор позволяет нам взять переменную и сравнить ее,
бит за битом, с другой переменной или константой, такой, например, как
ATTRIB_HIGHLIGHT. Есть существенная разница между стандартным
сравнением и поразрядным сравнением двух фрагментов информации с
использованием оператора &. В стандартном сравнении значение True или 1,
будет возвращена, только если оба фрагмента информации являются
идентичными во всех отношениях. В поразрядном сравнении, использующем
оператор &, значение True или 1 будет возвращено для каждой пары битовых
позиций в двух фрагментах информации, которые являются идентичными.
Допустим, нам нужно сравнить два двоичных числа, 0101 и 0001. В
стандартном сравнении два эти числа не одно и то же. В поразрядном
сравнении правая цифра одна и та же для обоих чисел, поэтому для
поразрядного сравнения будет возвращено значение 0001. Этот возврат
означает, что сравнение было истинным, но только в первой, или в самой
правой позиции. Если бы нам надо было сравнить числа 0111 и 010, то мы
бы увидели, что вторая и третья позиции справа - единицы в обеих числах.
Следовательно, поразрядное значение возвратит значение 0110. Аналогичным
образом, 0011 и 0110 возвратят значение 0010. Только вторая цифра в обоих
числах является единицей. Мы можем проводить аналогичные сравнения, когда
одно из чисел является переменной,как, например, переменная, которая
сообщает атрибуты, которые ассоциированы с атрибутами текста в функции
скрипта NewTextEvent. (Вспомните, что функция NewTextEvent начинает
работать автоматически всякий раз, когда на экране появляется новый текст.
Следующая строка взята из этой функции:

If (nAttributes & ATTRIB_HIGHLIGHT) Then 

На первый взгляд, это очень странное утверждение. Переменная nAttributes
является параметром, который вносит информацию об атрибуте в функцию
NewTextEvent, когда на экране появляется новый текст. Таким образом, если
этот текст выделен цветом, nAttributes будет иметь значение 01000000. Если
текст выделен жирным шрифтом, переменная будет иметь значение 00000010.
Если текст выделен курсивом и жирным шрифтом, nAttributes будет иметь
значение 00000110. Если он выделен цветом, курсивом и жирным шрифтом,
она будет иметь значение 01000110. Каждую позицию в nAttributes можно
представить в виде переключателя, который включает и выключает один из
возможных атрибутов. Ну, мы уже знаем, что ATTRIB_HIGHLIGHT имеет
значение 01000000, так что вышеприведенная строка кода говорит, что
возьмите nAttributes и сравните его, используя поразрядный оператор, с
константой Attrib_highlight. Если совпадение есть, верните назад сообщение 1
для каждого положения бита, которое совпадает. Если мы сравним, например,
текст, который является выделенным цветом, подчеркнутым и жирным
шрифтом (nAttributes = 01000110) поразрядным способом с ATTRIB_HIGHLIGHT
(01000000), то мы вернем значение 01000000. Это означает, что утверждение
If-Then возвращает значение True, или 1 для седьмой позиции справа, той,
которая указывает, является ли текст выделенным, и NewTextEvent узнала,
что текст, который появился на экране, действительно является выделенным.
Поэтому текст будет обрабатываться как выделенный текст. Тот факт, что
этот текст также выделен курсивом и жирным шрифтом также истинен, но
для данного теста это не имеет значения. Вышеприведенное утверждение
If-Then проверяет только то, является ли бит выделения истинным или 1, и
эта информация посылается в скрипт NewTextEvent.

Кроме того, есть еще один поразрядный оператор, который
выполняет операцию Или, вместо операции И. Этот оператор
обозначается единичным символом | чтобы отличить его оператора
Или, который обозначается двойным символом, ||. Когда вы
используете поразрядный оператор Или, значение True возвращается
в том случае, если любой из бит, или они оба, которые участвуют
в сравнении, равны единице. Таким образом, сравнение двух
бинарных чисел 0101 и 0010 вернет значение 0111. Аналогичным
образом, сравнение чисел 0100 и 0001 вернет значение 0101. Таким
образом, поразрядный оператор Или удовлетворяется, если любое из
чисел имеет 1 в конкретной позиции.

                          Hook функции

Иногда бывает необходимо перевести Jaws в измененное состояние,
когда некоторые, или все клавиши на клавиатуре выполняют
функции, которые отличаются от обычных. До некоторой степени мы
уже знакомы с этим понятием. Вы можете переключать такие
настройки, как Эхо экрана, эхо клавиатуры и состояние Home Row,
последний режим будет описан позже. Эти типы переключений
возможны потому, что Jaws имеет встроенные функции, которые
могут вызываться скриптами, чтобы переключать эти состояния
определенным образом. Однако, Jaws также содержит две функции,
которые позволяют вам изменять состояние системы сообразно вашим
нуждам. Это функции AddHook () и RemoveHook (). В общих чертах
происходит примерно следующее: если вы устанавливаете hook,
вызвав функцию AddHook () из скрипта, мы говорим, что hook
помещен. Когда вы используете функцию AddHook, вы даете ей имя
хука. Этот хук является специальной функцией, определяемой
пользователем, которую вы должны создать, и которая должна
выполняться вместо кода, обычно выполняемого скриптами Jaws.
Когда хук на месте, он вызывается прямо перед выполнением
каждого скрипта, и передает имя текущего скрипта и фрейма в
качестве двух своих параметров. Поскольку хук функция фактически
вызывается Jaws, когда он на месте, а не скриптом, эти параметры
предоставляются внутренним кодом Jaws, а не вызовом функции.
Если хук возвращает истину, скрипту разрешается выполняться.
Если хук возвращает ложь, скрипту не позволяется выполняться.
Таким образом, если хук на месте, и мы разработали хук таким
образом, что он будет возвращать ложь, пока он на месте, скрипт,
закрепленный за клавишей, которую мы нажали, работать не будет,
и мы можем заставить хук функцию сделать что-то другое. Вы
можете, если хотите, разработать хук, который будет заставлять
каждую клавишу, закрепленную за скриптом Jaws, воспроизводить "У
маленькой Мэри жила-была овечка" вместо того, чтобы выполнять
нормальные функции Jaws. Ну, сейчас в этом особой пользы нет, но
было бы здорово, если бы у вас был такой хук и вы бы его
включали всякий раз, когда вы позволяете своему другу
воспользоваться вашим компьютером! Но давайте рассмотрим более
полезную хук функцию, KeyboardHelpHook.

Как вы теперь, вероятно, знаете, вы можете включить помощь по
клавиатуре, нажав Insert+1. Когда вы это делаете, каждая клавиша
начинает воспроизводить свои функции, если она закреплена за
каким-либо скриптом Jaws, вместо того, чтобы реально выполнять
эти функции. Когда вы снова нажимаете Insert+1, клавиатура
возвращается к выполнению функций, вместо того, чтобы выдавать
описания. А вы когда-нибудь задумывались, как это сделано? А
сделано это с помощью хук функций. Давайте рассмотрим скрипт
KeyboardHelp и функцию KeyboardHelpHook чтобы посмотреть, как
выполняются эти задачи.

Script KeyboardHelp()
SayString (msg401) ; "Keyboard Help on". Сообщается, когда вы в
первый раз нажимаете Insert+1.
let nKeyboardHelpSavedTypingEcho =
GetJcfOption(OPT_TYPING_ECHO); сохраняет текущую настройку эха
клавиатуры.
SetJcfOption(OPT_TYPING_ECHO,1) ;Эхо клавиатуры символы. Помощи
по клавиатуре необходимо, чтобы эхо клавиатуры находилось в
режиме "символы".
AddHook (HK_SCRIPT, "KeyboardHelpHook") ;добавляет хук по имени KeyboardHelpHook.
TrapKeys(TRUE) ;юудучи истинной, эта функция заставляет Jaws
игнорировать любые клавиши, не закрепленные за скриптами
EndScript

Происходит следующее: озвучивается сообщение, оповещающее вас,
что помощь по клавиатуре включена, сохраняется текущее состояние
эха клавиатуры, эхо клавиатуры переводится в режим "Символы",
чтобы помощь по клавиатуре функционировала должным образом, и
устанавливается KeyboardHelpHook. Кроме того, TrapKeys
устанавливается в значении True, поэтому клавиши, не связанные
со скриптами Jaws, или фреймами, будут игнорироваться. (Вы не
можете назначить подсказку на клавишу, с которой не
ассоциировано скриптов Jaws или фреймов). Также, пожалуйста,
обратите внимание,что функция AddHook требует два параметра.
Первый, HK_SCRIPT, это константа, заданная в HJCONST.JSSH, вы
должны использовать для каждой AddHook. Второй - это имя хука,
который вы устанавливаете. Так что теперь любая клавиша,
связанная с функцией Jaws, не будет выполнять свою функцию, а
будет вызывать функцию KeyboardHelpHook, показанную ниже.

Void Function KeyboardHelpHook (string ScriptName, string FrameName)
if (ScriptName == "KeyboardHelp") then ;если мы нажимаем
Insert+1 когда хук установлен, это означает, что мы хотим
выключить помощь по клавиатуре.
	SayString(msg402) ; "Keyboard Help off"
                                               RemoveHook
(HK_SCRIPT, "KeyboardHelpHook") ;хук удаляется
TrapKeys(FALSE) ;теперь клавиши снова будут распознаваться.
SetJcfOption(OPT_TYPING_ECHO,nKeyboardHelpSavedTypingEcho) ;
восстанавливается первоначальное состояние эха клавиатуры.
return FALSE ;несмотря на то, что мы отключили хук, нам лучше
еще раз вернуть ложь, или скрипт Insert+1 запустится снова и
снова установит хук.
EndIf
Оставшаяся часть функции, как показано ниже, решает, что
говорить, в зависимости от того, привязана ли клавиша к клавише
или к скрипту, и нажата клавиша один раз или дважды. Внимательно
изучите этот код, пока не поймете его досконально. Если у вас
будут проблемы с пониманием if-then-else утверждений, прочитайте
следующий раздел о контроле переполнения, затем вернитесь назад
и изучите этот скрипт снова.

if IsSameScript () then
	if ((FrameName != "") && (GetFrameDescription (FrameName) != "")) then
		SayString (msg420) ; "This frame "
		SayString (GetFrameDescription (FrameName))
	EndIf
	if (FrameName == "") then
		SayString(GetScriptDescription(ScriptName))
	EndIf
else
	SayString (GetCurrentScriptKeyName ()) ; says key name, "INSERT+UP ARROW"
	if (FrameName != "") then
		SayString (msg421 + FrameName) ; "says the content of the frame " 
		SayString (GetFrameSynopsis (FrameName))
	else
		SayString (ScriptName) ; will say the name of the script, "SayLine"
		SayString(GetScriptSynopsis(ScriptName))
	EndIf
EndIf
return FALSE ;Prevent the script from running since we only want the help message.
EndFunction

                Знакомство с написанием скриптов
                     с объектами Microsoft

Если вам довелось прочитать какой-нибудь скрипт для Microsoft
Word или Excel, вы, вероятно, наталкивались на очень странный
код, который не похож ни на какие блоки построения скриптов, о
которых мы говорили до сих пор. Этот код содержит такие слова,
как Selection, Range, Text, Collapse, отделенные друг от друга
точками. Если вы не знакомы с объектно-ориентированным
программированием с использованием таких языков, как Visual
Basic и C++, этот тип кода будет совершенно непонятным. Так что
же это за штука и что она делает среди скриптов Jaws? Чтобы
пояснить, нам придется ввести три новых понятия - объекты,
методы и свойства.

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

Так почему же мы так заботимся об этих объектах? Есть некоторые
вещи, которые пользователи любят уметь делать, как, например,
читать и перемещаться по предложениям или абзацам, а не просто
по строкам. К сожалению, в большинстве текстовых процессоров
добиться этого довольно трудно, поскольку они не предусмотрены
для навигации в такой манере. Кроме того, мы должны помнить, что
программа доступа к экрану по определению читает то, что видимо
на экране, и если часть предложения или абзаца, который мы
пытаемся прочитать, находится за экраном, обычно он не сможет
получить доступ к этой части материала без прокрутки экрана. Но
пользователь может не захотеть этого делать, поскольку,
например, он находится в процессе редактирования, и ему не
хочется перемещать курсор. Объекты предоставляют нам средства,
чтобы выполнить эту задачу, поскольку объект,представляющий
данный документ, содержит все процедуры и свойства, необходимые
для того, чтобы сообщить информацию, необходимую Jaws. Microsoft
решил выставить эти "объекты автоматизации" на всеобщее
обозрение, в некоторых своих приложениях, таких, как Office 97
Suite, и Jaws, исследуя и манипулируя этими объектами, может
выполнить некоторый спектр желательных задач, описанных выше. По
сути дела, Jaws временно становится программой доступа к
объектам, а не только программой доступа к экрану. Термин
"Объект автоматизации" ("automation object") здесь используется,
чтобы показать объект, выставленный на всеобщее обозрение, так
что другие агенты, как например Jaws, могут иметь доступ к таким
объектам. Приложения, которые не используют некоторый вид модели
объекта, описанную здесь, для своего кодирования, или не
показывают эти объекты для внешнего мира, не могут быть
доступными с помощью этой технологии. Таким образом,
использование объектов для улучшения чтения экрана ограничено
некоторыми приложениями Microsoft, или любым приложением,
которое решает показать эти объекты автоматизации(или
автоматические объекты, не знаю, как лучше. Прим. пер.).

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

В этом пункте стоит прочитать раздел из помощи по Microsoft
Visual Basic, который поставляется с Microsoft Office. Читатель
должен обратить внимание, что синтаксис в примерах
программирования,
использованный в этих и других извлечениях, выглядит иначе, чем
кодирование, которое можно увидеть в скриптах Jaws. Так
происходит потому, что примеры полностью являются кодом на
Visual Basic, тогда как в скриптах Jaws, можно только вызвать
процедуры и получить значение свойств. Другие операции Visual
Basic, такие, как использование ключевых слов, не допускаются.

             Понимание объектов, свойств и процедур

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

                 Что такое объекты и коллекции?

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

                      Что такое свойство?

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

Documents("MyDoc.doc").TrackRevisions = True

В этом примере Documents ссылается на коллекцию открытых
документов, а имя "MyDoc.doc" идентифицирует один документ в
коллекции. Свойство TrackRevisions задается только для этого
документа.

Некоторые свойства задавать нельзя. Раздел помощи для свойства
(property) указывает, можно ли задавать это свойство
(read-write) или его можно только просматривать (read-only).

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

docName = ActiveDocument.Name

В этом примере ActiveDocument обращается к документу в активном
окне в Wordе. Имя этого документа присвоено переменной docName.

Обратите внимание, что раздел помощи для каждого свойства
указывает, можете ли вы задавать это свойство (read-write),
только просматривать свойство (read-only), или только задавать
(write-only). Браузер объектов в редакторе Visual Basic также
выводит статус чтения-записи в нижней строке окна браузера,
когда выбирается свойство.

                      Что такое процедура?

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

ActiveDocument.PrintOut From:=1, To:=3

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

                      Возвращение объекта

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

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

Следующий пример использует свойство Documents для получения
доступа к коллекции Document. Число индекса используется для
того, чтобы возвратить первый документ в коллекции Documents.
Затем к объекту Document применяется процедура Close, чтобы
закрыть первый документ в коллекции Documents.

Documents(1).Close

Следующий пример использует имя (указанное как строка (string))
чтобы идентифицировать объект Document внутри коллекции
Documents.

Documents("Sales.doc").Close

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

Documents.Save

Объекту Document также доступна процедура Save, для сохранения
только одного документа. Следующий пример сохраняет документ
под именем report.doc.

Documents.Save

Надеемся, что вам становится ясно, что манипулирование этими
типами объектов является фундаментальным в действиях, которые
происходят в приложениях Microsoft Office, и что манипулируя
этими объектами Jaws может получить желанную информацию из
модели объекта. На самом деле, если вы затратите время, чтобы
научиться писать макросы в Word (что делается просто в подменю
Макро в меню Сервис), вы увидите нечто крайне интересное. (вы
можете получить информацию о том, как писать макро из системы
помощи Windows, если нажмете F1 находясь в Word). Войдите в меню
Указатель и наберите слово Макро. Вам будет представлено
несколько тем, включая создание макросов). Попробуйте написать
макрос, когда будете делать какую-нибудь типичную операцию, как
открытие документа, сохранение документа, или выбор, а затем
удаление какого-либо текста. Затем, после того, как запись макро
будет выключена, вернитесь в подменю Макросы и нажмите Enter на
первой опции, Макросы, или Alt+F8. Вы откроете список
существующих макросов и вам будет предложено их отредактировать.
Выберите опцию "Правка", и вы окажетесь в редакторе Visual Basic
вам будет показана копия вашего макроса. Вы обратите внимание,
что код выглядит так, как объектно-ориентированное
программирование, которое мы только что обсуждали. Это означает,
что все, что вы делаете, работая в этом приложении, делается
посредством доступа к объектам и работы с их процедурами и
свойствами. Таким образом, изучение макросов, которые вы
записали, является одним из способов изучить, как манипулировать
объектами в приложениях Office. Есть еще один полезный способ,
который вы можете использовать, находясь в редакторе Visual
Basic. Если вы нажмете F1 когда курсор вставки будет находиться
на процедуре или свойстве программного кода, появится экран
помощи, который объясняет термин и как он используется. Если у
вас этой помощи нет, это может означать, что помощь по Visual
Basic на вашей системе не установлена. Вы можете установить ее с
установочного диска Microsoft Office, вставив диск в дисковод, а
затем вызвав диалог "Выполнить" главного меню и набрать X/setup,
где X - буква вашего дисковода для компакт-дисков. Когда
появится диалог установки, щелкните кнопку "Добавить/Удалить".
Затем, когда появится список вариантов, выберите одно из
приложений Office, например Word, и перейдите к кнопке "изменить
параметры". Щелкните ее. Вы окажетесь еще в одном списке
вариантов. Выберите пункт "Помощь" и перейдите к кнопке
"изменить настройки" снова. Щелкните ее. Вы попадете в третий
список: выберите опцию "Справка по Visual Basic", а затем
перейдите к кнопке OK и щелкните ее. Щелкайте кнопку OK, пока не
вернетесь на самый верхний уровень списка. Повторяйте процедуру,
пока не установите систему помощи для Visual Basic в каждом
приложении, которое вас интересует. Затем нажмите OK на верхнем
уровне, чтобы закончить установку. Вы можете в любое время
вернуться в редактор Visual Basic, выбрав его в подменю Макро в
меню Сервис, или нажав Alt+F11.

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

Script SayParagraph ()
SaveCursor ()
PCCursor ()
if (GetLine () == "") then
	SayString (msge18); "Blank"
else
	SayString (GetParagraphContent ())
EndIf
EndScript

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

String Function GetParagraphContent ()
var
	object o
let o = oWord.Selection.Paragraphs(1).Range;
return (o.Text);
EndFunction

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

let o = oWord.Selection.Paragraphs(1).Range;

Прежде чем мы проанализируем эту строку, мы хотели бы упомянуть о
точках с запятой, которые появляются на концах некоторых строк. Они означают то,
что означали всегда, что все, что написано после них, является комментарием.
Некоторые программисты добавляют эти точки с запятой, чтобы показать
окончание действительного кода в строке, даже если они не помещают после
точки с запятой никаких комментариев. Теперь давайте проанализируем эту
строку слева направо. Слева от знака равенства мы говорим, что собираемся
присвоить некоторое значение переменной o. Первое, что написано справа от
знака равенства, это нечто, называющее себя oWord. oWord - это глобальная
переменная, которая была объявлена в заголовочном файле WINWORD.JSH, и
это переменная типа Object, которая хранит объект application (приложение), а
приложением является Microsoft Word. oWord определена в функции
AutoStartEvent в начале файла скрипта. Вспомните, что эта функция события
отрабатывает автоматически всякий раз, когда загружается Word или когда он
получает фокус системы. Код в функции AutoStartEvent, написанный
программистами из Henter-Joyce, устанавливает указатель на Word, поэтому
Jaws будет знать, где искать объекты приложения. Если бы на этой строке не
было ничего, кроме Let o = oWord, мы бы задали переменную o равной
глобальной переменной типа Object oWord, объекту приложения в целом. Это
не дало бы нам ничего хорошего, если все, что мы хотели сделать, это
прочитать текущий абзац. Поэтому мы намерены найти какой-то способ
извлечь текстуальную информацию этого абзаца из объекта приложения в
целом.

Следующий пункт - это знак точки. Он используется, чтобы разделить
переменные, процедуры и свойства. Затем идет Selection. Это свойство
Selection, и, по сути дела, оно возвращает объект Selection, который содержит
информацию о том, что в данный момент выделено в документе. Если вы
выделили в документе какой-то текст, этот текст будет возвращаться в
объекте Selection. Если ничего не выделено, объект Selection сколлапсируется в
простую точку в курсоре вставки. Вот некоторая информация об объекте
Selection, которая выдается в справочной системе по Visual Basic.

                          Объект Selection

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

Обратите внимание, что в панели окна может быть только один объект
Selection, и только один объект Selection может быть активным.

                   Использование объекта Selection

Используйте свойство Selection, чтобы возвратить объект
Selection.

Все это имеет смысл, если мы подумаем о том, что мы знаем о
выделении текста. Мы знаем, что можно выделить только один блок
текста в данном документе. Таким образом понятно, что может быть
только один объект Selection. Если ничего не выделено, тогда
выделение и объект Selection должны будут сколлапсироваться в
одну точку, курсор вставки.

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

Итак, давайте еще раз рассмотрим все, что мы имеем. Мы имеем
объект Приложение Word в целом, представленный переменной oWord,
а свойство Selection возвратило объект Selection, который
содержит информацию о том, что в данный момент выделено в
текущем документе.

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

                        Объект Paragraph

Представляет один абзац в выделении, диапазоне или документе.
Объект Paragraph является членом коллекции Paragraphs. Коллекция
Paragraphs включает все абзацы в выделении (selection),
диапазоне (range) или документе.

                Использование объекта Paragraph

Используйте Paragraphs(index), где Index является индексным
номером, чтобы возвратить один объект Paragraph.

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

Далее следует свойство Range. Свойство Range возвращает объект
Range, который представляет часть документа, которая содержится
в указанном объекте. В этом случае указанным объектом является
объект Paragraph, который был возвращен свойством Paragraph
слева. Range подобен паре закладок. Первая представляет начало
диапазона, вторая - его конец. Объект Range, который
возвращается свойством Range, используя информацию из объекта
Paragraph, будет иметь начальную и конечную точки указанного
абзаца, установленные как диапазон (range). Этот окончательный
объект теперь установлен, чтобы позволить нам вытащить
информацию, которая нам нужна, чтобы озвучить текущий абзац. Вот
еще один отрывок из системы помощи по Visual Basic.

                          Объект Range

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

Обратите внимание, что объекты Range независимы от выделения. То
есть, вы можете определить диапазон и манипулировать им, не
изменяя выделения. Вы также можете задать в документе несколько
диапазонов (ranges), тогда как выделение в панели может быть
только одно.

                  Использование объекта Range

Используйте процедуру Range, чтобы возвратить объект Range,
заданный данными начальной и конечной позициями символов.
Следующий пример возвращает объект Range, который ссылается на
первые 10 символов в активном документе.

     Set myRange = ActiveDocument.Range(Start:=0, End:=10)

Используйте свойство Range чтобы возвратить объект Range,
заданный началом и концом другого объекта. Свойство Range
применяется ко многим объектам (например, Paaragraph (абзац),
Bookmark (закладка) и Wtll (ячейка). Следующий пример возвращает
объект Range, который ссылается на первый абзац в активном
документе.

Set aRange = ActiveDocument.Paragraphs(1).Range

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

return (o.Text);

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

Ключ ко всем этим сложным махинациям состоит в том, что каждый
объект может использовать только определенные свойства и
процедуры (как мы сказали примерно в начале этого раздела),и не
может использовать процедуры и свойства других объектов. Чтобы
получить информацию, которую мы хотим, мы должны использовать
корректную процедуру или свойство для нашего текущего объекта, и
мы должны использовать эту процедуру или свойство таким образом,
чтобы был возвращен новый объект, который установлен должным
образом, чтобы позволить нам получить доступ к информации,
которая нам нужна, на более низком уровне в иерархии. Если мы
все сделаем правильно, в конечном итоге мы доберемся до
информации, которая нам нужна. Очень скоро мы познакомим вас с
системой помощи Visual Basic, и покажем, как ей пользоваться,
чтобы найти допустимые процедуры и свойства для объекта, с
которого вы начинаете. Однако, прежде чем мы этим займемся,
давайте выполним эксперимент, чтобы показать, как свойства,
использованные в функции GetParagraphContent, извлекают
информацию, которая нам нужна, из объекта приложения и как
изменение способа, которым мы используем эти свойства, изменяет
информацию, которую мы слышим в конечном итоге. Прежде, чем мы
продолжим, необходимо сделать предупреждение. Эксперимент
включает модификацию файлов WINWORD.JSS и WINWORD.JSB.
Настоятельно рекомендуется сделать резервные копии этих файлов,
прежде чем вносить какие-либо изменения. Это позволит вам
вытащить неповрежденные копии файлов, если вы нечаянно
что-нибудь напартачите.

Чтобы выполнить этот эксперимент, откройте файл скриптов для
Word 8 и найдите функцию GetParagraphContent. Затем спуститесь к
первой строке после того, как объявлена переменная o. Очень
скоро мы внесем в эту строку некоторые изменения, но прежде, чем
мы это сделаем, давайте на некоторое время вернем фокус в Word и
посмотрим, что делает эта функция в своем немодифицированном
состоянии. Вы должны вернуться в Word и установить курсор на
первое слово в этом абзаце. Воспользуйтесь горячей клавишей
"Прочитать абзац" (CTRL+Плюс на цифровой клавиатуре) и вы должны
услышать, как будет озвучиваться весь этот параграф. Теперь
воспользуйтесь командой Shift+Стрелка вниз, чтобы выделить
первую строку этого абзаца. Подтвердите, что вы это сделали,
прочитав выделенный текст с помощью команды Shift+Insert+Стрелка
вниз, и вы должны услышать, как озвучивается первая строка
абзаца. Теперь снова воспользуйтесь горячей клавишей "Прочитать
абзац". Вы снова должны услышать, как озвучивается абзац.
Хорошо, мы убедились в том, что функция GetParagraphContent
достаточно сообразительна, чтобы прочитать нам весь абзац, даже
несмотря на то, что мы выделили часть его. Это хорошо, потому
что именно так и должна вести себя эта функция. Теперь вернитесь
в диспетчер скриптов и удалите свойство Paragraphs(1) из строки,
которая его содержит. После того, как вы это проделаете, строка
должна выглядеть следующим образом:

let o = oWord.Selection.Range;

Сохраните и перекомпилируйте файл с помощью команды Ctrl+S.
Вернитесь в Word и поставьте курсор вставки в начало того же
параграфа, который вы читали перед этим. Убедитесь, что не
выделено никакого текста, а затем воспользуйтесь командой
"Прочитать абзац" и посмотрите, что происходит. Как интересно!
Ничего не озвучивается. А почему? Ну, поскольку ничего не
выделено, свойство Selection возвращает объект Selection,
который эквивалентен курсору вставки. Поскольку мы убрали
свойство Paragraphs, свойство Range будет оперировать прямо с
этим объектом Selection, и возвращать объект Range, который
начальная и конечная точки которого находятся в одном и том же
месте, там, где находится курсор вставки. Очевидно, диапазон,
длина которого составляет 0 символов, не может содержать
никакого текста, поэтому свойство Text в следующей строке
скрипта возвращает Null или пустую строку, и мы вообще ничего не
слышим. А теперь выполните еще один эксперимент. Снова выделите
первую строку абзаца с помощью команды SHift+Стрелка вниз, а
потом снова воспользуйтесь командой "Прочитать абзац". На этот
раз вы услышите, как будет озвучен выделенный текст. Это
происходит потому, что объект Selection, который возвращается
свойством Selection, включает весь выделенный текст, а свойство
Range теперь установит диапазон в начале и конце выделенного
текста. Свойство Text в следующей строке вернет этот текст,
который, в свою очередь, будет возвращен в вызывающий скрипт для
озвучивания. Убедитесь, что вы не забыли возвратить свойство
Paragraphs обратно в функцию, точно так же, как оно и было, и
перекомпилировать файл скриптов, чтобы функция снова работала
как положено. Теперь свойство Paragraphs будет снова будет
возвращать объект Paragraph из объекта Selection и поставлять
эту информацию свойству Range. Вы снова будете слышать, как
озвучивается абзац целиком, независимо от того, выделен ли
какой-либо текст.

И наконец, как мы и обещали, вот некоторые советы относительно
использования справочной системы Visual Basic, чтобы узнать,
какие процедуры и свойства применяются к к каждому объекту.
Приведенные ниже инструкции относятся к Microsoft Word, но
аналогичные процедуры можно использовать и для других
приложений, таких как Excel. Предполагая, что справочная система
по Visual Basic установлена, нажмите F1, находясь в Wordе, а
затем нажимайте Ctrl+Tab, пока не попадете на страницу
оглавления. Спускайтесь вниз почти до самого последнего пункта,
которым является "Справочная система Visual Basic в Microsoft
Word". Откройте эту книгу и спускайтесь к единственной теме,
"Справка по Visual Basic". Нажмите Enter, чтобы открыть эту
тему. Теперь спускайтесь ко второй книге нового списка, которая
называется тоже "Справочная система по Visual Basic в Microsoft
Word". Открывайте эту книгу и спускайтесь к третьему пункту,
который называется "Объекты". Открывайте эту книгу, и вы увидите
алфавитный список книг. Каждая из книг содержит объекты
Microsoft Word, которые начинаются с указанной буквы. Вы можете
открывать каждую книгу и изучать доступные вам объекты.
Спускайтесь к букве "R" и открывайте эту книгу. Первый объект в
этой книге - объект Range. Если вы нажмете Enter на этой строке,
вы получите описание объекта Range, то же самое, которое было
процитировано выше. Вы также обратите внимание, что около
верхней части экрана есть строка, на которой написано "см. также
свойства, процедуры, события". Именно здесь вы можете найти,
какие свойства и процедуры доступны для этого объекта. Щелкните
Jaws курсором кнопку "Свойства" и вам будет представлен список
свойств Range. Спускайтесь к свойству Text, и нажимайте Enter.
Здесь вы можете прочитать о свойстве Text, которым мы
воспользовались., чтобы возвратить действительный текст из
функции GetParagraphContent. Таким же способом можно получить
доступ к процедурам Range.

Если вы вернетесь в алфавитный список книг с объектами и
откроете книгу "A", вы найдете объект, который называется
"Объект Application". Это объект самого верхнего уровня, к
которому вы можете получить доступ. Глобальная переменная,
которой мы пользовались прежде, oWord, является объектом
application. Именно здесь вы вообще начинаете, когда будете
писать скрипты с объектами. Нажмите Enter на этом пункте, и вы
получите информацию об объекте application.Если вы щелкнете на
кнопке "Свойства" в верхней части окна, вы получите список всех
свойств, доступных для объекта application. А знаете что? Этот
список содержит свойство Selection, свойство, которое мы впервые
использовали, чтобы начать операции над объектом application,
oWord. Все возвращается на круги своя.

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

                       Управление потоком

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

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

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

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

Скрипт может содержать любой из этих способов, или все их
вместе. Давайте рассмотрим каждый из этих видов действий.

                        Последовательный

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

Script SayTheAValue()
Var
	Int A
Let A = 1
SayInteger (A)
                           EndScript

                        Выбор (условный)

Структура утверждения if-then предоставляет средство выбора
одного пути или другого. Для структуры if нужны три утверждения:
if, then и endif. Давайте начнем с очень простого утверждения
if-then.

If (x == 1) 
Then 
	SayString ("You are right")
EndIf 

Если, и только если переменная A равняется 1, скрипт выполнит
утверждение SayString, и произнесет слова "You are right" (Вы
правы). А вот пример посложнее.

If GetWindowName (GetCurrentWindow ()) == "Main"
Then
SayString("In the main window.")
EndIf

Функция GetWindowName, и ее параметр, GetCurrentWindow,
использованные в утверждении if, возвращает заголовок текущего
окна. А происходит следующее. Если и только если имя текущего
окна является Main, (главное), тогда выполняется функция
SayString. В остальных случаях она игнорируется. Мы выбираем
путь "Then" только в том случае, если условие If является
истинным.

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

If GetWindowName (GetCurrentWindow ()) == "Main" Then
SayString("In the main window.")
EndIf

Отныне мы будем показывать наши утверждения If-Then именно в
такой форме.

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

If GetWindowName (GetCurrentWindow ()) == "Main" Then
SayString("In the main window.")
Else
SayString("Not in a known window.")
EndIf

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

If GetWindowName (GetCurrentWindow ()) == "Main" Then
SayString("In the main window.")
Else
If GetWindowName (GetCurrentWindow ()) == "Alternate" Then
SayString("In the alternate window.")
EndIf
Else
SayString("Not in a known window.")
EndIf

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

Утверждение Elif - это более простой способ сформулировать
ветвь, которая говорит: "делай что-то другое, если истинно
другое условие". Вышеприведенную последовательность скрипта
можно переформулировать, чтобы выполнялось в точности то же
самое, используя утверждение Elif. Это показано ниже:

If GetWindowName (GetCurrentWindow ()) == "Main" Then
SayString("In the main window.")
ElIf GetWindowName (GetCurrentWindow ()) == "Alternate" Then
SayString("In the alternate window.")
Else
SayString("Not in a known window.")
EndIf

Здесь мы снова можем отправиться по альтернативным путям. Если
окно называется Main, мы идем его путем. Если окно называется
Alternate, мы идем его путем. В противном случае мы идем по пути
Else. Утверждение Elif занимает место утверждения Else, за
которым следует утверждение If. Вы можете использовать столько
утверждений Elif, сколько захотите.

Утверждения If могут быть вложенными. Это означает, что
утверждение If может быть помещено внутри другого утверждения
If. Это позволяет вам проверять какое-то условие только в том
случае, если существует другое условие. Второе условие If будет
проверяться только в том случае, если истинно первое условие.
Последовательность утверждений внутри второго блока If-Then
будет,таким образом, выполнена, только если оба условия будут
сочтены истинными. Не забудьте для любого и каждого утверждения
If, которое вы используете, добавлять утверждение Endif. Вот
пример вложенных утверждений If-Then:

If GetWindowName (GetCurrentWindow ()) == "Main" Then
If GetWindowClass (GetCurrentWindow ()) == "Edit" Then
SayString("In the main edit window.")
Else
SayString ("In the main window")
EndIf ;Is this an edit window?
Else
SayString ("Not in a known window")
EndIf ;Is this the main window?

В этом примере сначала мы проверяем, находимся ли мы в главном
(Main) окне.Если да, то мы проверяем, находимся ли мы в окне
редактирования (Edit Window). Если да, то мы говорим, что
находимся в главном окне редактирования (Main Edit Window). Если
это не окно редактирования, то мы просто говорим, что мы в
главном окне. Условие Edit будет проверяться только в том
случае, если условие Main является истинным. Обратите внимание,
что мы использовали комментарии, чтобы показать, какую If
проверку завершает утверждение Endif. Это очень полезно, чтобы
избежать путаницы при использовании вложенных утверждений
If-Then.

                           Итеративы

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

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

Давайте возьмем довольно обычную проблему. Вы работаете в
программе редакторе, которая нумерует строки пятью цифрами.
Поэтому первая строка нумеруется как 00001. Jaws тратит массу
времени, читая нули. Было бы здорово начать чтение с первой
ненулевой позиции, не правда ли? Здесь самое место для цикла
While. Рассмотрим следующий скрипт:

Script SayEditLine()
SaveCursor ()
JAWSCursor()
RouteJAWSToPC()
JAWSHome()
While (GetCharacter () == "0")
NextCharacter ()
EndWhile
SayFromCursor()
RestoreCursor ()
EndScript

Использование такого скрипта для чтения номера строки устранит
для нас начальные нули. Вот как это делается. Первые четыре
строки сохраняют позицию курсора, активизируют Jaws курсор и
перемещают его к началу строки, на которой мы находимся. Затем
цикл While просматривает каждый символ в начале строки по
очереди и смотрит, не ноль ли это. Если ноль, то он просто
переходит к следующему символу и тоже его проверяет. когда он
находит символ, который не является нулем, условие для
продолжения цикла больше не является истинным, и цикл While
завершается. Затем JFW продолжает обрабатывать оставшуюся часть
скрипта после цикла Whilt. Сюда входит чтение оставшейся части
строки от курсора до конца строки. Это избавляет от всех нулей.

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

While FirstVariable < SecondVariable
Let BreakOutVariable = BreakOutVariable+1
	(Rest of loop would be here.)
If (BreakOutVariable > 100) Then
Return
EndIf
EndWhile

Этот цикл задуман таким образом, что он будет работать до тех
пор, пока первая переменная не станет больше второй переменной.
Давайте представим, что мы допустили логическую ошибку, и первая
переменная никогда не будет больше второй переменной. Без
дополнительных утверждений, призванных предотвратить такой
оборот событий,цикл будет работать вечно. Однако, вторая строка
добавляет 1 к переменной BreakOutVariable всякий раз, когда цикл
повторяется. Когда значение BreakOutVariable превышает 100,
утверждение If-Then в конце цикла выполнит возврат и завершит
цикл. Если вы уверены, что цикл While работает как положено, вы
можете удалить логику прерывания.

                      Домашнее задание # 5

Для этого домашнего задания давайте опять воспользуемся
программой Фонограф. В прошлый раз, когда  мы писали скрипт для этой
программы, мы обратили внимание, что счетчик над кнопками
показывает и время, которое прошло, и полное время звукового
файла. Напишите скрипт, используя утверждения If-Then и
утверждения Elif, который проверяет, что прошедшее время не
является нулем. Если это так, пусть выдается сообщение "В начале
записи". Если прошедшее время больше нуля, но меньше полного
времени, пусть выдается сообщение "Проигрывание завершено только
частично". Если прошедшее время равно полному времени, пусть он
говорит "Проигрывание завершено" и щелкает кнопку "Искать
начало" или обратную перемотку, чтобы вернуть счетчик к нулю.
Затем пусть скрипт сделает паузу, чтобы дать приложению время
перемотать обратно, а потом снова проверит счетчик, чтобы
посмотреть, находится ли он в нулевой позиции. Если да, пусть он
выдаст сообщение "ОБратная перемотка завершена". Если счетчик не
находится в нулевой позиции, пусть он выдаст сообщение "Обратная
перемотка невозможна. Проверьте ваши батарейки". Также
воспользуйтесь локальными переменными, чтобы хранить время в
целом и прошедшее время.

              Функции, определяемые пользователем

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

                        Простые функции

                                                         Опреде-
ляемые пользователем функции обычно создаются как
самостоятельные модули скриптового кода, который предназначен
для выполнения конкретной задачи. Это особенно полезно, когда
работа, которую должна выполнить функция, должна выполняться
большое количество раз и разными скриптами. Это позволяет
повторно использовать код функции, не переписывая его несколько
раз. Все, что должен сделать пользователь, это вызвать функцию
из другого скрипта или функции, и работа будет выполнена. Затем
вызванная функция возвращает управление обратно вызывающему
скрипту или функции, который, в свою очередь, продолжает свою
работу. Простейший тип функции не принимает никаких данных
(параметров) и не возвращает никаких данных (возвратов) в
вызывающий скрипт. Давайте рассмотрим пример определяемой
пользователем функции, который взят из файла скриптов для
Microsoft Excel, EXCEL.JSS. Этот скрипт называется NextSheet, и
в его задачу входит переместить фокус к следующей таблице. Вот
код из скрипта:

Script NextSheet()
;переходит в следующую таблицу и читает номер
{CONTROL+PPAGE DOWN}
Delay (1)
SayWindowPromptAndText()
EndScript

Обратите внимание, что скрипт вызывает функцию, которая называется
SayWindowPromptAndText. Вы не найдете этой функции среди встроенных
функций Jaws. Это определяемая пользователем функция, которая была
написана программистами из Henter-Joyce и включена в EXCEL.JSS. Ниже
приводится код для SayWindowPromptAndText.

Function SayWindowPromptAndText ()
SaveCursor ()
InvisibleCursor ()
RouteInvisibleToPC ()
If (FindLastAttribute (ATTRIB_BOLD)) Then
SayChunk ()
Else
SayString (msg121) ;"bolded sheet tab not found"
EndIf 
EndFunction

Давайте теперь пройдемся по процедуре создания простой определяемой
пользователем функции. В качестве цели мы будем иметь создание функции,
которая будет озвучивать наше имя, точно также, как мы это сделали в
нашем первом скрипте. Как и прежде, мы поместим эту функцию в файл
скриптов для редактора "Блокнот" (Notepad).

1. Откройте Блокнот через главное меню/Программы/Стандартные.
2. Откройте диспетчер скриптов, нажав Insert+0 или Insert+F2, после чего s и
Enter. Jaws сообщит вам, что вы находитесь в файле notepad.jss, исходном
файле скриптов для Блокнота.
3. В меню Скрипт выберите пункт Новый скрипт, или нажмите
клавишу-ускоритель, CTRL+E.
4. Появляется диалог нового скрипта, и теперь мы можем назвать нашу
функцию и написать ее документацию. Когда появляется диалог нового
скрипта, курсор находится в поле имени скрипта. Наберите SayName
(СказатьИмя). Убедитесь, что буквы S и N являются большими и не делайте
пробелов.
5. Дважды нажмите Tab, чтобы переместиться к полю Synopsis. Наберите
слова "Say our name". (пропустив блок проверки Can be attached to key
(может быть привязан к клавише) без его включения мы сказали диспетчеру
скриптов, что мы создаем функцию, а не скрипт).
6. Нажмите Tab, чтобы переместиться в поле Description (Описание) и
наберите слова "The name of the person who wrote this function." (Имя
человека, написавшего эту функцию).
7. Нажмите Tab, чтобы переместиться в поле Категория, и наберите Test. Поле
Категория - это комбобокс, в котором вы можете либо вписать название
категории, либо просто выбрать одно из имеющихся.
8. Нажмите Tab, чтобы переместиться в поле Function returns (Возвраты
функции) и спуститесь к значению Void. Мы выбираем Void, потому что
наша функция не возвращает никакой информации в вызывающий скрипт.
9. Больше нам никаких полей заполнять не нужно, поэтому клавишей Tab
перемещайтесь к кнопке OK, и нажимайте клавишу Enter, чтобы закрыть
диалог нового скрипта и вставить пустую функцию в область редактирования.
10. Теперь мы снова находимся в главной текстовой области диспетчера
скриптов и мы имеем пустую функцию, где в первой строке написано
"Void Function SayName ()", а в последней строке написано "EndFunction".
Мы помещены между двумя этими строками. Клавишей "Стрелка вверх"
поднимайтесь до первой пустой строки после первой строки, и вы готовы к
тому, чтобы написать тело функции.
11. Для этой функции вам понадобится только одна строка, и это будет та же
самая строка, которую мы использовали для нашего первого скрипта. Эта
строка будет SayString ("My name is XXX"), где XXX - ваше имя. Чтобы
вставить эту строку в вашу функцию, нажмите CTRL+I, чтобы открыть диалог
Insert function (вставить функцию). Затем наберите s,a и y. Вы должны
услышать, как Jaws скажет SayString, имя встроенной функции, которая была
выделена. Нажмите Enter, чтобы принять эту функцию.
12. Теперь вам будет предложено ввести строку, которая должна озвучиваться.
Наберите "My name is XXX", и не забудьте включить кавычки. После того,
как вы нажмете Enter, вы вернетесь в область редактирования, где ваша
функция теперь закончена.
13. Теперь на вашей странице должно быть три строки, в точности так, как
они выглядят ниже. Помните, что близко - значит недостаточно хорошо,
поскольку компьютеры ожидают, что мы будем точными и совершенными.
Кроме того, несколько пустых строк роли не играют. Jaws игнорирует пустые
строки в функциях.
Void Function SayName()
SayString ("My name is XXX")
EndFunction
14. Теперь мы должны сохранить и скомпилировать файл скриптов для
Блокнота. Нажмите CTRL+S, и вы должны услышать "Compile Complete"
(Компиляция завершена). Если что-то не так, вернитесь и вновь проследите все
шаги и попробуйте снова.

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

Script SpeakName ()
SayName ()
EndScript

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

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

                 Функции, которые требуют параметры

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

Function ScriptAndAppNames (string sFileName)
If (GetVerbosity() == beginner) Then
	SayString(sFileName + " settings are loaded")
else
	SayString (sFileName+" Settings")
EndIf
If(GetVerbosity() == beginner) Then
	SayString ("The application currently being used is the ")
EndIf
SayString (GetAppFileName ())
SpellString (GetAppFileName ())
EndFunction

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

ScriptAndAppNames ("ApplicationName")

где ApplicationName представляет имя приложения, которое вы
хотите передать в функцию. Этот вызов функции говорит, что
строка (string) "ApplicationName", должна быть передана в
функцию, ScriptAndAppNames, через параметр sFileName. Тогда
функция будет "знать" эту информацию. Следовательно, она может
быть использована в речевых сообщениях, которые содержатся в
утверждениях типа SayString. Здесь информация о параметре
соединяется с фиксированным текстом, чтобы завершить сообщения,
которые будут озвучены во время выполнения.

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

1. Откройте блокнот, через главное меню/программы/стандартные.
2. Откройте диспетчер скриптов, нажав Insert+0, или нажав
Insert+F2, а затем s, а затем Enter. Jaws сообщит вам, что вы
находитесь в NOTEPAD.JSS, исходном файле скриптов для Блокнота.
Выберите New Script из меню Script, или нажмите
клавишу-ускоритель, CTRL+E.
3. Появляется диалог нового скрипта, и теперь мы можем
назвать нашу функцию и написать ее документацию. Когда
появляется диалог нового скрипта, курсор находится в поле
ScriptName (Имя скрипта). Наберите SayName. Убедитесь, что буквы
S и N являются большими, и не вставляйте пробелы между словами.
4. Дважды нажмите клавишу Tab, чтобы переместиться к полю
Synopsis. Наберите слова "Say our Name". (Пропустив блок
проверки Can be Attached to key, и не включив его, мы сообщили
диспетчеру скриптов, что создаем функцию, а не скрипт).
5. Нажмите Tab, чтобы переместиться в поле Description и
наберите слова "The name of the person who wrote this function.".
6. Нажмите Tab, чтобы переместиться в поле Категория, и наберите
слово Test. Поле Категория - это комбобокс, и категорию можно
либо вписать, либо выбрать из уже имеющихся.
7. Нажмите Enter, чтобы переместиться в поле Function Returns
(Возвраты функции) и выберите Void. Мы выбираем Void, потому что
наша функция не возвращает никакой информации в вызывающий
скрипт.
8. Нажмите CTRL+Tab, чтобы переместиться в поле Parameters
(Параметры). Вы окажетесь в поле Existing Parameters
(существующие параметры). Это поле пусто, поскольку еще не
существует никаких параметров.
9. Клавишей Tab переместитесь в поле редактирования New
Parameter (Новый параметр) и наберите "UserName".
10. Нажмите клавишу Tab дважды, пока не попадете в поле
редактирования Description (описание) и наберите "The name of the user".
11. Клавишей Tab переместитесь в список допустимых типов и
выберите String.
12. Клавишей Tab переместитесь к кнопке Add (добавить) и нажмите
пробел, чтобы добавить параметр. Вы вернетесь в поле
редактирования нового параметра, но снова мы его использовать не
будем, поскольку мы добавляем только один параметр. Клавишей Tab
переместитесь к кнопке OK и нажмите Enter.
13. Теперь мы снова находимся в главной текстовой области
диспетчера скриптов, и у нас есть пустая функция, где в первой
строке написано "Void Function SayName (String UserName)", а в
последней строке написано "EndFunction". Мы находимся между
двумя этими строками. Клавишами-стрелками поднимитесь на первую
пустую строку после первой строки и вы готовы к тому, чтобы
написать тело функции.
14. Для этой функции вам понадобится только одна строка, но она
будет немного отличаться от строки, которую мы использовали для
нашего первого скрипта и функции SayName, которую мы писали
прежде. Эта строка будет SayString ("My name is " + UserName),
где UserName является параметром, который передает ваше имя в
функцию. Чтобы вставить эту строку в функцию, нажмите Ctrl+I,
чтобы открыть диалог "Вставить функцию". Затем наберите s, a и
y. Вы должны услышать, как Jaws скажет SayString, имя встроенной
функции, которая была выбрана. Нажмите Enter, чтобы принять эту
функцию.
15. Теперь вам будет предложено ввести строку, которую нужно
озвучивать, или переменную, которая представляет строку.
Наберите "My name +UserName", и не забудьте про кавычки. После
того, как вы нажмете Enter, вы вернетесь в область
редактирования, где ваша функция теперь готова.
16. Теперь у вас на экране должны присутствовать три строки, в
точности такие, как на этой странице. Помните, что близко - это
не очень-то хорошо, поскольку компьютеры ожидают от нас, что мы
будем точными и совершенными. Кроме того, несколько пустых строк
значения не имеют. Jaws игнорирует пустые строки в функциях.
Void Function SayName(String UserName)
SayString ("My name is " + UserName)
EndFunction
17. Теперь нам нужно сохранитть и скомпилировать файл скриптов
для NotePad. Нажмите Ctrl+S, и вы должны услышать "Compile
complete". Если это не так, вернитесь и вновь проделайте все
вышеописанные шаги и попытайтесь еще раз.

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

Script SpeakName ()
SayName ("XXX")
EndScript

Когда вызывается функция SayName, строка "XXX", которая представляет
наше имя, передается в функцию через параметр UserName. Теперь у функции
есть эти данные и она может озвучить его как часть сообщения SayString.

               Функции, которые предоставляют возвраты

Теперь давайте рассмотрим функцию, которая предоставляет возврат. Возврат -
это информация, которая посылается обратно из функции в вызывающий
скрипт или в функцию, когда она отрабатывает. Эта возвращенная
информация затем может быть использована вызывающим скриптом или
функцией. Обратите внимание, что тип возвращаемой информации (то есть,
string, Int, Object, handle, или Void) объявляется перед именем функции.
Следующая функция взята из EXCEL.JSS, файла скриптов для Microsoft Excel.

Int Function GetExcelVersion()
var
	handle WinHandle
let WinHandle = GetAppMainWindow (GetFocus())
let WinHandle = GetFirstChild (WinHandle)
if (GetWindowClass (WinHandle) == "Excel4") then
	return TRUE ;This is Excel 97
else
	return FALSE ; this is Excel95 or earlier
EndIf
EndFunction

Вы, вероятно, догадались, что задача этой функции состоит в том, чтобы
определить, находимся мы в Excel 97 или нет. А происходит следующее:
функция выполняет тест, чтобы узнать, находимся ли мы в Excel 97. Если да,
функция возвращает, или посылает обратно, значение True, Истина, обратно в
вызывающий скрипт. Если нет, возвращается значение False, или ложь. Под
возвратом этого значения мы просто имеем в виду, что мы информируем
вызывающий скрипт о результатах определения. Вызывающий скрипт может
потом продолжать и делать что-то другое, в зависимости от того, является
значение True или False, то есть, то есть, находимся ли мы в
действительности в Excel 97 или нет. Вот пример того, как можно вызвать
эту функцию таким образом, чтобы возвращенную информацию можно было
использовать для принятия решения.

If GetExcelVersion== true Then
(Block of statements we want to execute if we're in Excel 97)
Else
	(Block of statements we want to execute if we're not in Excel 97)
EndIf

Другими словами, если GetExcelVersion является истинной, то есть, возвращает
True после своего вызова, то мы выполним один набор утверждений. Если она
не является истинной, то есть возвращает после своего вызова False, то мы
выполним другой набор.

Кстати, вам пора выучить сокращение, которое авторы скриптов часто
используют в таких ситуациях, как эта. Следующее утверждение немного
короче, чем If GetExcelVersion== true Then, но оно означает абсолютно то же
самое.

If GetExcelVersion Then

Когда вы видите такие утверждения, понятно, что мы подразумеваем
"== true". Оно опускается для удобства, но каждый должен понимать, что
"== true" или "== 1" (которые, как мы теперь знаем, являются эквивалентными
утверждениями),всегда подразумевается в такого рода утверждениях.

                       Домашнее задание # 6

Jaws произносит большие буквы, озвучивая их с другой высотой тона.
Некоторые пользователи хотели бы слышать перед словами, целиком
написанными заглавными буквами, сообщение "Все большие" ("all caps"), когда
они произносятся по буквам. Напишите функцию под именем SayAllCaps,
которая будет выполнять следующее:
1. Она должна принимать в качестве параметра слово, на котором находится
курсор, и это слово и нужно будет проверять. Используйте CurrentWord в
качестве параметра типа String, который будет принимать данные из
вызывающего скрипта.
2. Она должна проверять слово, чтобы посмотреть, содержит ли слово буквы,
которые не являются заглавными. Как только она найдет такое слово, она
должна будет возвратить нулевую строку, то есть пару кавычек, и ничего
между ними. Если она найдет, что все буквы являются заглавными, она
должна будет возвратить строку "all caps".

Совет: это довольно сложная работа, поэтому мы собираемся дать вам
подсказку. Вы должны будете использовать встроенную функцию,
StringContains, чтобы определить, содержит ли слово какие-либо незаглавные
буквы. (это единственная встроенная функция Jaws, которая является
чувствительной к регистру). Как только тест определяет, что представленная
буква не является заглавной, должен осуществляться возврат пустой строки,
поскольку дальнейшего тестирования не требуется. Если букв в нижнем
регистре найдено не будет, она должна возвратить строку "all caps". Функция
также должна возвращать нулевую строку, если встретится какое-либо число,
чтобы предотвратить появление сообщения "all caps" на каждой встретившейся
цифре. И наконец, функция должна содержать код, который не давал бы ей
выдавать сообщение "All Caps", если курсор находится на пустой строке, или
на знаке препинания, или на любом другом неалфавитном символе. Чтобы
выполнить эту задачу, вы должны знать, что все такие неалфавитные символы
имеют значение меньшее, чем буква A или большее, чем буква Z. Вы должны
протестировать слово, чтобы посмотреть, удовлетворяет ли текущее слово
этому критерию и возвращать нулевую строку, если удовлетворяет.

Наконец, чтобы использовать эту функцию в народном хозяйстве, конечная
часть задачи состоит в том, чтобы модифицировать скрипт, который
называется SayWord, который можно найти в DEFAULT.JSS. Вы должны
модифицировать этот скрипт, чтобы он вызывал функцию SayAllCaps в
нужное время и выполнял тест. SayWord активизируется, когда вы нажимаете
комбинацию клавиш Insert+5 на цифровой клавиатуре. Скрипт SayWord имеет
начальный раздел, который использует встроенную функцию IsSameScript
чтобы проверить, не нажали ли вы Insert+5 на цифровой клавиатуре дважды
быстро. Если быстро нажать эту комбинацию клавиш дважды, Jaws получить
задание произнести слово по буквам, а не просто озвучить его. Поместите
свой вызов функции SayAllCaps в функцию в нужное место  и вызовите ее
с таким расчетом, чтобы она озвучивала строку, возвращенную функцией,
сразу же перед тем, как она произносит слово по буквам. Если функция
нашла, что не все слово написано в верхнем регистре, она вернет нулевую
строку, и таким образом, не скажет ничего. Если функция обнаружила, что
все слово написано в верхнем регистре, она возвратит строку "All Caps",
которую вы затем услышите непосредственно перед тем, как слово будет
произнесено по буквам.

Последний совет: вы должны будете вызывать функцию внутри утверждения
SayString, чтобы услышать, как будет озвучена  ваша возвращенная строка.

                         Функции событий

Существует также особая категория определяемых пользователем функций,
название которых оканчивается словом Event (Событие). Такие функции
называются функциями событий, и они отрабатывают автоматически, всякий
раз, когда происходит ассоциированное с ними событие. Например, функция,
которая называется MouseMovedEvent работает, всякий раз, когда указатель
мыши изменяет положение. Задача таких функций событий состоит в том,
чтобы позволить Jaws выполнять специфические задачи автоматически, не
ожидая, когда пользователь инициирует действие с помощью нажатия клавиш.
Здесь требуется некоторое прояснение. Мы называем эти функции событий
определяемыми пользователем функциями, потому что некоторые пользователи
пишут или модифицируют утверждения, которые в них содержатся. Однако,
они отличаются от других определяемых пользователем функций, потому что
пользователи не могут изобретать новые функции событий. Те, которые
суещствуют, являются таковыми, поскольку они были запрограммированы в
Jaws, чтобы там существовать. Пользователи могут изменять код, которым они
пользуются, но не могут изобретать новый. Существует несколько таких
конкретных системных событий, которые могут запустить функцию. Когда
происходят такие события, они часто передают параметры в функции, которые
используются кодом функций событий. Вот пример функции такого типа,
AutoStartEvent, которую вы найдете в большинстве файлов скриптов.

Function AutoStartEvent()
If (GetWindowName (GetFocus ())== wn292)
 && SDMGetFocus (GetFocus ())== 18 Then ; on check box
SDMSayControl (GetFocus (), 17) ; say the tip of the day
SDMSayControl (GetFocus (), 18) ; say check box
EndIf ; tip of the day
If (WinWordFirstTime == 0) Then
let WinWordFirstTime = 1
let GlobalWinwordVersion = FALSE
if GetVerbosity() == beginner Then
SayString(msg293) ;"Use Insert plus the letter H for help in various dialog boxes"
EndIf ; verbosity beginner
EndIf ; first time
EndFunction

AutoStartEvent происходит всякий раз, когда загружается файл скриптов. Эта
функция взята из файла скриптов для Microsoft Word. Она озвучивает совет
дня, если он является видимым, устанавливает несколько переменных, а затем
озвучивает подсказку Jaws. Она также проверяет, является ли это первый раз,
когда функция AutoStartEvent отрабатывает во время текущей сессии Jaws.
Если это так, она изменяет значение переменной WinWordFirstTime с 0 на 1.
Когда в следующий раз AutoStartEvent будет выполнять свою работу, она
пропустит сообщение-подсказку. Это полезный способ, который можно
симмитировать, когда вы хотите, чтобы скрипт делал что-нибудь, когда
приложение загружается в первый раз, но хотите избежать этого при
последующих загрузках. Если вы хотите, чтобы что-нибудь происходило при
каждой загрузке приложения, просто поместите код в функцию
AutoStartEvent, без всяких окружающих его условных утверждений. Эта
функция не принимает никаких параметров и не возвращает ничего. Теперь
давайте рассмотрим более сложную функцию, которая принимает
передаваемые ей параметры. Это функция NewTextEvent, которая обрабатывает
весь новый текст, появляющийся на экране.

Void Function NewTextEvent (handle hwnd, string buffer, Int nAttributes, 
Int nTextColor, Int nBackgroundColor, Int nEcho, string sFrameName)
; Обрабатывает весь новый текст. Если текст содержится во
; фрейме, то имя фрейма передается в качестве параметра
if (ProcessSelectText(nAttributes, buffer)) then
	return
EndIf
if (sFrameName == "") then
        ; Этот текст не ассоциирован с фреймом
	if (nAttributes & ATTRIB_HIGHLIGHT) then
		SayHighlightedText(hwnd, buffer)
	else
		SayNonHighlightedText(hwnd, buffer)
	EndIf
else
        ; Этот текст ассоциирован с фреймом
	if (nEcho == ECHO_NONE) then
		return; frame is being silenced
	EndIf
	if (nEcho == ECHO_ALL ||
	   (nAttributes & ATTRIB_HIGHLIGHT)) then
		; if Frame echo is set to all or the text being written is highlighted
		SayString(buffer)
	EndIf
EndIf
EndFunction

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

Handle hwnd - это оконная ручка того окна, которое получает текст.
String buffer - это действительный текст, который пишется в окне.
Int nAttributes - это атрибут текста, который пишется.
Int nTextColor - это цвет текста, который пишется.
Int nBackgroundColor - это цвет фона текста, который пишется7
Int nEcho - уровень озвучивания, установленный для фрейма,если таковой
есть, который получает текст.
String sFrameName - имя фрейма, если таковое есть, который получает текст.

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

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

Первая строка после начальных комментариев в этой функции является
следующей

if (ProcessSelectText(nAttributes, buffer)) then

Эта:строка является оператором If-Then, вызывающий функцию по имени
ProcessSelectText. Эта функция занимается озвучиванием текста, по мере его
выделения или снятия выделения. Синтаксис этого утверждения абсолютно
идентичен тому, как если бы было написано

if (ProcessSelectText(nAttributes, buffer) == True) then

Та часть, которая говорит "== true" всегда подразумевается, даже если она
опускается. Поэтому, если этот вызов функции возвращает значение True,
тогда следующая строка, Return, будет выполнена. А происходит то, что
функция NewTextEvent передает задачу определения,происходит ли выделение
текста, или происходит снятие выделения , в функцию ProcessSelectText.
Если эта функция решает, что происходит выделение текста или выделение
снимается, она производит необходимое
озвучивание и функции NewTextEvent больше делать нечего. Таким образом,
когда управление возвращается в функцию NewTextEvent возвращением
истины, то функция NewTextEvent завершает работу через свое собственное
утверждение Return, и работа окончена. Если функция ProcessSelectText
возвращает False, значит, текст не помечается для выделения или для снятия
выделения, утверждение If-Then является ложным и функция NewTextEvent
продолжит работу. Следующая строка в этой функции такая:

if (sFrameName == "") then

Поскольку параметр sFrameName передает имя любого фрейма, содержащего
новый текст, в функцию NewTextEvent, этот параметр будет иметь нулевое
или пустое значение, если текст не ассоциирован с каким-либо фреймом.
Нулевое значение для имени фрейма указывается двумя кавычками, между
которыми нет никакого текста. Таким образом, если с текстом не
ассоциировано никаких фреймов, никакого имени фрейма не будет, нулевое
значение, и утверждение If-Then будет истинным. Тогда будет выполняться
следующее утверждение в последовательности. Если утверждение If-Then
является ложным, имея в виду, что есть фрейм, тогда выполнение
перескакивает в другую точку скрипта, которая обрабатывает текст,
ассоциированный с фреймом. Предполагая, что фрейма нет, далее
обрабатываются следующие утверждения:

	if (nAttributes & ATTRIB_HIGHLIGHT) then
		SayHighlightedText(hwnd, buffer)

Первая из двух строк является знаменитым поразрядным If-Then
утверждением, о котором мы говорили в разделе о поразрядных операторах.
Если обнаружится, что это утверждение истинно, мы знаем, что текст
является выделенным и обработка передается в следующую строку, которая
является вызовом функции SayHighlightedText. Эта функция обрабатывает
озвучивание всего нового выделенного текста. Если поразрядное If-Then
утверждение является ложным, функция SayHighlightedText не вызывается а
вместо этого выполняются следующие строки. Там написано:

	else
		SayNonHighlightedText(hwnd, buffer)

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

Так что же происходит, если скрипт решил, что текст ассоциирован с
каким-либо фреймом? В этом случае обработка функций перескочит к
следующей строке:

	if (nEcho == ECHO_NONE) then

Эта строка сравнивает значение параметра nEcho с константой ECHO_NONE.
Если выяснится, что они равны, это означает, что эхо фрейма установлено в
значении"Нет", и ничего говорить не надо. В этом случае выполняется простой
возврат (Return), ничего не озвучивается и все дела. Если это утверждение
If-Then возвращает False, эхо не установлено в значение "Нет" и необходимо
проделать еще кое-какую работу. Тогда необходимо обработать следующую
строку:

	if (nEcho == ECHO_ALL ||
	   (nAttributes & ATTRIB_HIGHLIGHT)) then

Первая часть этого If-Then утверждения спрашивает, является ли nEcho
равным Echo_All. Другими словами, не установлено ли эхо фрейма в значение
"Озвучивать весь текст"? Вторая часть утверждения If-Then является нашей
старой доброй поразрядной операцией, которая определяет, является ли текст
выделенным цветом. Если оба эти утверждения оказываются верными
(вспомните, что оператор || является оператором Или), то выполняется
следующая строка функции. В этой строке написано:

		SayString(buffer)

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

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

                      Список функций событий

Далее приведен список специальных функций, запускаемых системными
событиями. Если вы хотите использовать эти функции для создания
собственных скриптов, вы должны использовать имя в точности так, как
написано здесь, и задавать все предписанные переменные в вызове функции в
предписанном порядке. Более подробную информацию об этих функциях
можно найти в файле BUKLTIN.JSD. Обратите внимание, что этот список был
обновлен, чтобы включить функции событий из версии 3.3. Если вы
пользуетесь более ранней версией, у вас не будет всех элементов, которые
перечислены ниже.

AutoStartEvent - запускается, когда файл секриптов, содержащий эту
функцию, загружается или получает фокус.
Параметры - нет.
AutoFinishEvent - запускается, когда файл скриптов, содержащий эту
функцию, закрывается или теряет фокус.
Параметры - никаких.
ItemNotFoundEvent - запускается, когда запрошенный элемент не был найден в
модели Off-Screen.
Параметры:
целое, содержащее оконную ручку текущего окна.
NewTextEvent - запускается, если где-то на экране появляется новый текст.
Параметры:
Handle, содержащий оконную ручку текущего окна;
String, в котором содержится появившийся текст.
Integer, содержащий атрибут текста.
Integer, содержащий цвет текста;
Integer, содержащий цвет фона;
Integer, содержащий установку эхо;
String, содержащий имя фрейма,  где появился текст.
TopEdgeEvent - запускается, когда активный курсор сталкивается с верхним
краем окна.
Параметры:
Handle, содержащий оконную ручку окна, край которого был достигнут.
BottomEdgeEvent - запускается, когда активный курсор сталкивается с
нижним краем окна.
Параметры:
Handle, содержащий оконную ручку окна, край которого был достигнут.
FocusChangedEvent - запускается, когда визуальный фокус изменяется.
Параметры:
Handle, содержащий оконную ручку текущего активного окна.
Handle, содержащий оконную ручку предыдущего окна.
MenuModeEvent -  запускается, когда фокус входит в меню.
Параметры:
Handle, содержащий оконную ручку текущего активного окна.
Integer, содержащий режим меню.
CursorChangedEvent - запускается, когда изменяется указатель мыши (Jaws
курсор).
Параметры:
Integer, содержащий новую форму указателя.
WindowCreatedEvent -  запускается, когда появляется новое окно.
Параметры:
Handle, содержащий оконную ручку нового окна.
Integer, содержащий координату левого края окна.
Integer, содержащий координату верхнего края окна.
Integer, содержащий координату правого края окна.
Integer, содержащий координату нижнего края окна.
WindowDestroyedEvent - запускается, когда окно исчезает.
Параметры:
Handle, содержащий оконную ручку исчезнувшего окна.
WindowMinMaxEvent - запускается, когда изменяется статус окна
свернуть/распахнуть.
Параметры:
Handle, содержащий оконную ручку окна
Integer, описывающий общее действие, происходящее в окне;
Integer, описывающий специфическое действие, имеющее место в окне.
WindowResizedEvent - запускается, когда окно близко к тому, чтобы изменить
свой размер.
Параметры:
Handle, содержащий оконную ручку окна, которое изменяет свой размер;
Integer, содержащий левый край окна, изменяющего свой размер;
Integer, содержащий верхний край окна, изменяющего свой размер;
Integer, содержащий правый край окна, изменяющего свой размер;
Integer, содержащий нижний край окна, изменяющего свой размер;
                        AppWillNotSpeakEvent - эта функция событий
используется только при инсталляции Jaws и не предназначена для общих
задач создания скриптов.
KeyPressedEvent - запускается любым нажатием клавиш, за которыми
закреплен скрипт, прежде чем отрабатывает этот скрипт.
Параметры:
целое, содержащее код клавиши.
String, содержащий имя клавиши, как оно выглядит в раскладке клавиш
Integer, определяющий, закреплена ли клавиша за брайлевским дисплеем;
Integer, определяющий, закреплена ли клавиша за скриптом;
MouseMovedEvent -  запускается при перемещении мыши.
Параметры:
Integer, задающее координату X
Integer, задающий координату Y
FocusPointMovedEvent - вызывается всякий раз, когда PC курсор перемещается
в другое место на экране.
Параметры:
Integer, задающий текущее горизонтальное положение PC курсора
Integer, задающий текущее вертикальное положение PC курсора
Integer, задающий предыдущее горизонтальное положение PC курсора
Integer, задающий предыдущее вертикальное положение PC курсора
Integer, содержащий единицу перемещения, как задано в HJConst.jsh
Integer, задающий направление перемещения, как указано в HJConst.jsh
Integer, указывающий количество времени6 которое прошло со времени
перемещения.
ActiveItemChangedEvent - запускается, когда изменяется активный элемент в
объекте
Параметры: нет
CursorShapeChangedEvent - это событие происходит, когда изменяется форма
указателя мыши.
параметры:
String, содержащий текущий тип курсора.
TooltipEvent - это событие вызывается если JCF опция
OPT_PROCESSTOOLTIPEVENT установлена в значении 1 или On. Она также
вызывается автоматическим маркировщиком графики. Это событие
отрабатывает всякий раз, когда появляется совет на панели инструментов. В
данный момент используется только для хранения текста последнего совета в
глобальной переменной типа String strLastTooltip.
Параметры:
Handle, содержащий ручку совета на панели инструментов.
String, содержащий текст совета.
ScreenMagnifiedEvent - функция события, которая запускается всякий раз,:
когда активизируется увеличение экрана, деативизируется или уровень
увеличения изменяется (используется Magic).
Параметры:
Integer, который указывает, включено ли увеличение.
Integer, который указывает уровень увеличения.
FocusChangedMagEvent - эта функция запускается, когда фокус перемещается
от одного органа управления к другому.
Параметры:
Handle окна, содержащего фокус.
Handle предыдущего окна, в котором был фокус.
ActiveItemChangedMagEvent - эта функция событий вызывается, когда
выбранный элемент в списке или в дереве меняется, чтобы обрабатывать все
специфические функции Magic, которые должны иметь место, когда
выбранный элемент изменяется (используется Magic)
FocusPointMovedMagEvent - эта функция вызывается FocusPointMovedEvent
чтобы обрабатывать специфические функции Magic, которые должны иметь
место, когда ууказатель фокуса изменяется.
Параметры:
Integer, содержащий X координату курсора после изменения фокуса.
Integer, содержащий Y координату курсора после изменения фокуса.
Integer, содержащий X координату курсора перед изменением фокуса.
Integer, содержащий Y координату курсора перед изменением. фокуса.
Integer, содержащий единицу перемещения, как задано в файле HJConst.JSH.
Integer, содержащий направление перемещения, как указано в файле HJConst.JSH.
Integer, содержащий количество времени, которое прошло со времени
перемещения.
NewTextMagEvent - функция, предназначенная для обработки, которая
специфична для отслеживания Magic, когда на экране появляется новый текст.
(используется Magic).
Параметры:
Handle, содержащий ручку окна текущего окна.
String, содержащий новый текст.
Integer, содержащий атрибут текста.
Integer, содержащий цвет текста.
Integer, содержащий цвет фона.
Integer, содержащий установку эхо.
String, содержащий имя фрейма, в котором появился текст.
MenuModeMagEvent - это событие срабатывает, когда статус меню изменяется
(используется Magic).
Параметры:
Handle, содержащий ручку меню.
Integer, содержащий состояние меню, которое изменилось.

                     Техника создания скриптов

            Изучаем приложение с помощью функций утилит

Прежде чем писать файл скриптов, мы должны иметь некоторое
представление о том, что мы хотим выполнить с его помощью. Нам также
часто необходимо познакомиться с окнами в нашем приложении, чтобы
посмотреть, что имеется на экране и как это можно озвучить. Нам также
может понадобиться подробная информация об окнах, такая, как класс,
контрольный идентификатор и ручка (Handle), а равно как и отношения
родители-дети. В файле скриптов по умолчанию есть набор скриптов, которые
называются скрипты утилит, которые могут сослужить здесь немалую
службу. Эти утилиты способствуют написанию скриптов тем, что позволяют
пользователю познакомиться с взаимоотношениями типа родители-дети для
различных окон в приложении и предоставляя подробную информацию о
каждом окне, такую, как класс, контрольный идентификатор и т.д. Каждая из
утилит описана ниже, вместе с закрепленной за ней комбинацией клавиш. Все
эти утилиты используются в режиме Home Row (Insert+Пробел). Режим Home
Row представляет собой смещенное состояние клавиатуры, несколько
напоминающее смещенное состояние, которое можно получить с помощью
клавиш CapsLock и NumLock. Это означает, что вы получаете доступ к
каждой функции с помощью указанной комбинации клавиш, после того, как
вы включили режим Home Row путем одновременного нажатия клавиш Insert
и Пробел. Чтобы выйти из режима, нажмите Insert+Пробел во второй раз.

INSERT + H - помощь по горячим клавишам, перечисляет все утилиты вместе
с закрепленными за ними горячими клавишами.
F1 - эта клавиша используется для озвучивания информации о текущем окне
или органе управления. Какая информация будет озвучиваться, зависит от
режима вывода, который вы выбрали. Этот режим вывода задается клавишей
F3 (см. ниже). Клавиша F3 похожа на селектор, который определяет, какие
данные вы будете получать, а клавиша F1 в действительности предоставляет
вам эти данные. Когда клавиша F1 быстро нажимается дважды подряд,
информация произносится по буквам. Режим посимвольного чтения не
применяется к целым числам.
F3 - эта клавиша задает режим вывода. Если повторно нажимать F3, режим
вывода будет циклически переключаться в следующем порядке:
SayTypeAndText, фокус или Handle окна, контрольный идентификатор, класс
окна, тип окна, и первое действительное имя окна. Это означает, что это
будут данные, которые вы услышите, если нажмете клавишу F1. Можно
прокручиваться и в обратном порядке, если нажимать Shift+F3.
Insert+Home на цифровой клавиатуре - эта клавиша устанавливает режим
вывода обратно в SayTypeAndText и ею можно пользоваться чтобы вернуться
к этой настройке, вместо того, чтобы прокручиваться через все режимы.
INSERT + F1 - эта клавиша посылает запрошенную информацию (режим
вывода) в окно сообщения. Это недоступно в тех режимах вывода, которые
возвращают целочисленные значения.
Tab - эта клавиша перемещает Jaws курсор к следующему окну того же
самого логического уровня, что и то, в котором вы в данный момент
находитесь, и озвучивает требуемую информацию соответственно режиму
вывода, который вы установили клавишей F3.
Shift+Tab - эта клавиша перемещает Jaws курсор к предыдущему окну того
же логического уровня, что и то, в котором вы находитесь, и озвучивает
требуемую информацию, соответственно режиму вывода, который вы
установили клавишей F3.
F2 - эта клавиша перемещает Jaws курсор к первому дочернему окну
текущего окна и озвучивает требуемую информацию, соответственно режиму
вывода, который вы установили клавишей F3.
SHIFT + F2 - перемещает Jaws курсор к родительскому окну текущего окна
и озвучивает требуемую информацию, соответственно режиму вывода, который
вы установили клавишей F3.
F4 - эта клавиша является селектором, которая задает режим поиска
атрибутов. Режим поиска атрибутов - это стиль атрибутов, который будет
разыскиваться, с помощью четырех горячих клавиш, описанных ниже. При
повторном нажатии F4 атрибуты будут прокручиваться в следующем порядке:
полужирный, курсив, подчеркнутый, выделенный цветом и зачеркнутый.
GRAVE ACCENT - эта клавиша перемещает Jaws курсор к следующему
запрошенному атрибуту. Режим поиска атрибутов задается клавишей F4, как
было описано выше.
SHIFT + GRAVE ACCENT - эта клавиша перемещает Jaws курсор к
предыдущему запрошенному атрибуту. Режим поиска атрибутов задается
клавишей F4, как было описано выше.
CONTROL + GRAVE ACCENT - эта клавиша перемещает Jaws курсор к
первому запрошенному атрибуту. Режим поиска атрибутов задается клавишей
F4, как было описано выше.
SHIFT + CONTROL + GRAVE ACCENT - эта клавиша перемещает Jaws
курсор к последнему запрошенному атрибуту. Режим поиска атрибутов
задается клавишей F4, как было описано выше.
p - эта клавиша читает предыдущее окно. Это полезно, если необходимо
определить, можно ли прочитать приглашение, прочитав предыдущее окно.
Например, приглашением для поля редактирования в базе данных может быть
предыдущее окно, и использование этой клавиши, когда вы находитесь в поле
редактирования, озвучит приглашение, и вам, возможно, удастся написать
скрипт, который с успехом будет читать приглашение, используя информацию
предыдущего окна.

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

                       Домашнее задание # 7

Откройте приложение WordPad. Затем включите режим Home Row. Используя
F1 и F3 получите всю необходимую информацию о параметрах главного окна
редактирования и поля редактирования имени файла в диалоге открытия файла.

                   Получение информации об окне
             с помощью скрипта ScreenSensitiveHelpTechnical

Если вам нужно быстро прочитать контрольный идентификатор окна, класс
или ручку, эту информацию можно легко получить с помощью скрипта под
названием ScreenSensitiveHelpTechnical в файле скриптов по умолчанию.
Доступ к этому скрипту можно получить с помощью комбинации клавиш
Ctrl+Insert|F1, и будет озвучен контрольный идентификатор, класс и ручка
окна, содержащего активный курсор. Это самый быстрый способ получить эту
информацию, если вам не нужны все другие данные, предоставляемые
скриптами утилит.

                       Типы файлов скриптов

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

JSS - исходные файлы скриптов
JSH - файлы заголовков (включены в .JSS файлы)
JSM - файлы сообщений (включены в .JSS файлы)
JSB - скомпилированные файлы скриптов
JKM - файлы раскладки клавиатуры, которые содержат комбинации клавиш,
закрепленные за различными скриптами.
JSD - файлы документации скриптов, которые содержат имена скриптов и
ассоциированные с ними синопсисы и описания.

                          Исходные файлы

исходный код для файлов скриптов имеет очень свободную форму. Вы можете
вставлять пробелы или пустые строки везде, где только захотите. Заглавные
буквы не требуются, и игнорируются компилятором, за исключением
определенных функций сравнения строк, таких как StringContains (). Надо
сказать, что имеются некоторые соображения по поводу форматирования. Хотя
ваш код может быть лично вам абсолютно понятен, другие могут вообще
ничего в нем не понять, поскольку они не зналиЯ, что вы имели в виду и их
работа, возможно, организована не так, как у вас. Поэтому мы хотели бы
порекомендовать несколько правил правой руки, которые облегчат другим
понимание вашего кода и помогут вам понять скрипты, написанные другими.

1. Отдельные скрипты всегда должны разделяться пустыми строками.
2. Набирайте с отступом любой раздел кода, который является
служебным по отношению к тому, который над ним и к тому, который
под ним. Это помогает пользователю разобраться в логике скрипта.
Рассмотрим следующий скрипт:

Script CheckVerbosity()
If GetVerbosity() == BEGINNER Then
SayString("Beginning verbosity is active.")
Else
SayString("Beginning verbosity is not active.")
EndIf
EndScript

Обратите внимание, что If, Else и Endif находятся на одном
уровне отступа, а утверждения внутри каждого раздела отодвинуты
дальше. Каков должен быть отступ, это дело ваше, но мы
рекомендуем примерно 5 символов. Использование табуляции для
создания отступа работает лучше, чем пробелы, поскольку отступ
будет постоянным, даже если вы работаете с пропорциональными
шрифтами.
3. Каждая функция должна быть на отдельной строке.
4. Вот несколько рекомендаций по поводу заглавных букв:
А. Начинайте каждое утверждение с большой буквы;
Б. Многие стандартные имена функций Jaws являются комбинациями
двух или более слов, которые описывают функцию. Первая буква в
каждом слове в имени функции начинается с заглавной буквы. В
предыдущем примере мы использовали функции GetVerbosity и
SayString. Это помогает правильно их озвучивать. Когда вы
создаете переменные и функции, вы должны использовать
аналогичное соглашение.
5. Структура файла скриптов также является важной. А. Начинайте
каждый файл с комментария, в котором описано, что содержит
данный файл и как им полагается пользоваться. Перечислите всю
конкретную информацию, которая может понадобиться тому, кто
будет читать этот файл. Вы также могли бы включить список всех
переменных и как они используются. Также важно включать дату и
природу любых изменений и улучшений, которые были внесены со
времени первого написания файла. Теперь любой может прочитать
первые несколько строк вашего файла и все о нем узнать
Б. Следующим разделом должны быть утверждения включения (Include
statements).
В. В следующем разделе поместите все объявления глобальных
переменных.
Г. В следующем разделе поместите объявления констант.
Д. Следующим элементом вашего файла скриптов должна быть функция
AutoStartEvent, если вы намерены ее использовать. Любой код,
ассоциированный с этой функцией, автоматически начинает
работать, когда загружается файл скриптов. Обычно эта функция
используется для озвучивания каких-либо ознакомительных
сообщений, или для инициализации каких-нибудь глобальных
переменных, если они имеют ненулевое значение. Например, в файле
скриптов по умолчанию стартовые сообщения Jaws о том, как
получить помощь, находятся в этой функции.
Е. Следующим скриптом должен быть скрипт, который называется
ScriptFileName, скрипт, прикрепленный к клавише Insert+Q. Этот
скрипт будет сообщать имя текущего активного файла скриптов и
приложения. Пример того, как нужно формулировать этот скрипт, вы
можете найти в файле default.jss. Вы должны заменить данные,
которые передаются в функцию ScriptAndAppNames именем вашего
приложения.
Ж. Далее следуют скрипты и определяемые пользователем функции.
Постарайтесь соблюдать логический порядок, так чтобы всякий,
читающий ваш файл скриптов смог его понять. Например, если у вас
есть скрипт, который выполняет какое-либо действие, и другой,
выполняющий противоположное действие, поместите их один за
другим. Помещайте каждую функцию над первым скриптом или
функцией, которая ее вызывает. Несоблюдение этого может привести
к ошибке.
1. Используйте комментарии, комментарии и еще раз комментарии!
Комментарии предоставляют план местности для всякого, кто будет
работать с вашим кодом. Помещайте строку с комментарием сразу же
после начальной строки каждого скрипта или функции, и в этом
комментарии описывайте назначение скрипта или функции. Помещайте
комментарии внутри кода, описывая любое сложное утверждение,
которое может оказаться непонятным интуитивно. Поставьте себя на
место того, кто будет просматривать ваш код и предоставьте ему
необходимую помощь. Вы даже можете помочь сами себе, поскольку
можете забыть назначение конкретного раздела.

                     Скомпилированные файлы

Когда вы закончите писать свой код, его нужно скомпилировать,
чтобы Jaws мог его использовать. Вашему файлу будет присвоено то
же имя, что и приложение, и расширение .JSB, когда вы его
скомпилируете, так что Jaws будет знать, когда его загружать.
Процесс компиляции автоматически выполняется диспетчером
скриптов, когда вы выбираете Save (Сохранить) из меню Файл.
Исходный файл с расширением .JSS сохраняется, и в это же время
создается и сохраняется файл с расширением .JSB. Эта компиляция
включает все файлы заголовков и сообщений, которые были включены
соответствующими утверждениями в начале .JSS файла.

                        Файлы включения

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

Файлы заголовков обозначаются расширением .JSH и содержат или
операторы переменных, или операторы констант.
Файлы сообщений обозначаются расширением .JSM и содержат
сообщения вместе с присвоенными им номерами.

Всегда группируйте свои утверждения включения где-нибудь поближе
к началу файла скриптов.

Помещение глобальных переменных и констант в отдельный файл
заголовков, а сообщений в отдельный файл сообщений помогает
лучше организовать работу. С Jaws поставляются два файла,
которые предоставляют все стандартные глобальные переменные и
константы. Они называются HJGLOBAL.JSH и HJCONST.JSH. Они
сделаны с таким расчетом, чтобы разработчики могли использовать
любую стандартную переменную или константу, просто включив их в
свои собственные файлы скриптов. Файлы сообщений также сделаны в
виде файлов включения. Стандартным файлом сообщений является
DEFAULT.JSM. Использовать файлы сообщений в ваших скриптах
необязательно. Henter-Joyce поместил сообщения в отдельном файле
для более простого перевода на другие языки. Если вы намерены
писать скрипты для общего пользования, было бы неплохо соблюдать
это соглашение. Если вы все же используете файл сообщений, он
должен быть назван также, как4 и файл скриптов, чтобы вы могли
легко его найти.

                    Использование переменных

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

                      Соглашения об именах

Это щекотливый вопрос. У каждого есть свое мнение, и эти мнения
часто конфликтуют. Независимо от того, какого соглашения об
именах вы придерживаетесь, использование такового соглашения
предотвратит напрасную трату времени и раздражающие ошибки.
Принимая стандарты и придерживаясь их вам гарантировано, что вы
сможете вернуться к этому коду позже и с легкостью
модифицировать или отладить его. Мы среди инвалидов проводим
много времени, обсуждая стандарты. У вас есть шанс внести свою
лепту. Давайте рассмотрим некоторые рекомендации о создании
вашего стандарта. Что должно быть в имени? Очень многое. Имеет
смысл выбирать описательное имя. Самое простое - назвать свою
переменную, сложив вместе описательные слова. Постарайтесь не
делать имя слишком длинным, поскольку вам придется набирать эти
имена, и иногда довольно много. Если вы называете глобальную
переменную,начните ее имя с G_ или Global. Вы также должны
начинать с заглавной буквы каждое слово, когда будете соединять
их вместе, чтобы Jaws смог правильно прочитать эти слова,
предполагая, что опция Mixed Case (Смешанный регистр) включена в
диспетчере конфигурации. Вы могли бы продолжить это и
использовать Int, Str, Obj, и HND в именах, чтобы пометить
переменные String, Object, Integer и Handle. Таким образом, G_Int_VariableName
будет глобальной переменной типа Integer, а Str_VariableName
будет локальной переменной типа String.

                    Где объявлять переменную

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

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

              Использование глобальных переменных

Помните, что переменные, которые вы намерены использовать в
нескольких скриптах, объявляются как глобальные. Кроме
глобальных переменных, которые вы определили для своего
собственного использования, существует набор стандартных
глобальных переменных Jaws, что очень полезно для создания
скриптов. Эти переменные содержатся в файле HJGLOBAL.JSH, и вы
можете ими пользоваться, поставив оператор включения для этого
файла в ваш собственный файл скриптов. Потратьте некоторое время
на просмотр глобальных переменных, определенных в HJGLOBAL.JSH,
поскольку они часто используются в скриптах по умолчанию. Там
есть описания того, как использовать каждую из них. Помните, что
значения, которые хранятся в этих переменных, часто
модифицируются скриптами по умолчанию. Поэтому, если вы включите
HJGLOBAL.JSH в свой файл скриптов, вы можете вызывать эти
переменные, чтобы получать необходимую информацию по мере
надобности. Например, проверка содержимого переменной
GlobalMenuMode сообщит вам, находитесь ли вы на линейке меню или
в меню. Здесь мы просто хотим сказать, что переменные,
объявленные в файле HJGLOBAL.JSH постоянно используются
скриптами по умолчанию в Jaws, и если вы их выучите и поймете,
как ими пользоваться и будете включать их в свои собственные
файлы скриптов для приложений, вы сможете вызывать значения,
которые они содержат, во время выполнения своих собственных
скриптов.

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

                     Использование констант

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

Коды типов окна и коды подтипов - эти коды закреплены за типами
окон. Помните, что даже орган самого нижнего уровня
квалифицируется как окно. Следовательно, каждое окно будет
возвращать код типа, если его запросить. Кнопка будет возвращать
код типа 1, или имя своей константы, WT_BUTTON. Существуют две
функции для получения такой информации, GetWindowTypeCode и
GetWindowSubtypeCode.

Рассмотрим следующее утверждение If-Then из скрипта
PriorCharacter в DEFAULT.JSS. Это скрипт, который отрабатывает,
когда нажимается стрелка влево. Нога Else этого оператора If
работает, когда нет видимого PC курсора. Эта ветка предназначена
для того, чтобы проверять, не находимся ли мы в меню. После
каждого раздела кода мы добавили комментарии, где описано его
назначение.

If CaretVisible() Then ; Если PC курсор виден e
        SayCharacter() ; Сказать символ, на котором он находится
Return ; Завершить работу скрипта
Else ; Если PC курсор не виден
	Let TheTypeCode = GetWindowSubtypeCode (GetCurrentWindow()) 
                ; установить переменную Integer для кода типа текущего окна
        If (TheTypeCode == WT_MENU) Then ; Если текущее окно меню     u
	SayString (msg3) ;"Menu" 
                SayWindow (GetCurrentWindow(), READ_HIGHLIGHTED) ; Озвучить текущий пункт
                Return ; Завершить работу скрипта
	EndIf
EndIf

А происходит следующее: скрипт решает, что озвучивать, в
зависимости от кода подтипа окна, в котором мы находимся. Из
этого с очевидностью следует, что этот набор констант и
ассоциированные с ними числовые коды является очень важным для
пользователей Jaws, поскольку именно отсюда мы узнаем, с каким
типом органа управления мы имеем дело. Вы можете пожелать
просмотреть эту группу констант в HJCONST.JSH, они все
начинаются с WT_ (Window Type).

Идентификаторы атрибутов текста - используются для сравнения
текстовых атрибутов. Все они начинаются с ATTRIB_ (Attribute).
Константы общего назначения - сюда входят типы поиска строк и
графики, которые начинаются с S_, True, False, On и Off.
Режимы вывода - они еще не реализованы.
Режимы брайля и типы маркировки - все они начинаются с BRL_.
Настройки подробности - сюда входят новичок, середнячок и
продвинутый.
Общие - сюда входят тесты на активность и успех, курсоры,
различные настройки чтения, и установки опций.
Типы курсоров - это для различных форм указателя мыши. Например,
если вы получаете код окна CT_Waitas, то видны песочные часы.
Это еще не реализовано для Windows 95.
Разное - и наконец, мы имеем константы, используемые для статуса
меню, операционной системы и текущего файла по умолчанию.

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

                      Домашнее задание # 8

Предположим, вы хотите написать скрипт для приложения, которое называется
SPAMKILLER.EXE. Вы будете использовать файл заголовков, файл сообщений,
и два файла с глобальными переменными и константами HJ. Также вам
понадобится определить три дополнительных глобальных переменных, которые
будут называться GlobalSpamInteger, GlobalSpamString и GlobalSpamHandle и
три дополнительных константы, заданных как SpammerOne =1, SpammerTwo =
2, и SpammerThree = 3 внутри файла скрипта. Покажите начало файла
скрипта со всеми утверждениями, которые все это  сделают.

                  Использование нескольких функций

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

                Последовательное применение функций

Достаточно редко удается решить задачу с помощью одной функции. Обычно
требуется несколько функций в соответствующем порядке. Следующий код
взят из файла скриптов для Visual Basic 4.0, и его задача состоит в том,
чтобы проверить, является ли панель инструментов окном с фокусом, и если
нет, сделать его таковым и поставить Jaws курсор на первый ярлык. Кстати,
мы использовали утилиту Home Row, чтобы узнать класс окна панели
инструментов, палитры инструментов, прежде чем написали этот скрипт.

Script GoToToolBox()
; Этот скрипт передает фокус на панель инструментов и помещает Jaws курсор
; на первый инструмент панели инструментов
SayString ("Tool Box") ; Пусть пользователь знает, что происходит
While GetScreenEcho() != 2 ; Прокручивает через эхо экрана, пока не будет установлено значение "Все"
ToggleScreenEcho ()          ; увеличивает эхо экрана
EndWhile
If GetWindowClass (GetFocus ()) != "ToolsPalette" Then ;Если мы уже не на панели инструментов
PCCursor();
{ALT+V} ; Меню View
Pause() ; Время, чтобы появилось меню
{x};      ; Выбрать панель инструментов
EndIf
Delay(10)             ; Время, чтобы появилась панель инструментов
RouteJAWSToPC()
JAWSCursor()
JAWSPageUp()
JAWSHome()
PerformScript ({DOWN ARROW}) ; Обычная стрелка вниз со специальным заданием для панели инструментов
EndScript

Сначала мы убеждаемся, что находимся в режиме экрана "Say all".
Затем мы проверяем, не находимся ли мы уже на панели инструментов,
получая класс окна, где находится фокус, и сравнивая его со строкой,
ToolsPalette, которая является известным классом окна для панели
инструментов. (Этот класс окна должен был быть определен в файле
включения для констант для данного файла скриптов). Если мы не находимся
в панели инструментов, мы должны передать фокус этому окну, выполнив
несколько функций, которые могут гарантировать конечный результат.
Мы используем функцию PCCursor, чтобы активизировать PC курсор.
Мы используем симуляцию клавиатуры, чтобы послать в приложение Alt+V.
Появляется меню View. Помните, что все, что находится в фигурных скобках,
передается приложению, как если бы вы набрали это с клавиатуры. Обратите
внимание, что там есть комментарий, чтобы каждый, кто будет читать, знал, в
чем назначение {Alt+V}.
Затем функция Pause дает системе время показать меню, прежде чем мы
продолжим.
Мы используем симуляцию клавиатуры, чтобы послать в приложение X,
которая является клавишей быстрого запуска для пункта меню "Панель
инструментов" (Toolbox). Это тоже прокомментировано.
Затем EndIf завершает нашу If-Then последовательность.
Теперь мы уверены, что панель инструментов открыта и этому окну передан
фокус.
Затем мы активизируем Jaws курсор и устанавливаем его на первую кнопку.

Чтобы решить нашу задачу, мы использовали последовательно несколько
функций.

                  Использование вложенных функций

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

Script IsJAWSWindow()
If (GetWindowClass (GetAppMainWindow (GetFocus())) == JFWUI2) Then
SayString (msg113) ;"This is the JAWS application window"
EndIf
EndScript

Мы можем узнать, что класс окна для окна Jaws JFWUI2 перейдя в окно
Jaws и включив функции Home Row. Использование Shift+F2 переведет нас в
родительское окно, а F3 будет прокручиваться через режимы вывода, пока мы
не найдем класс. Затем F1 озвучит класс, который будет JFWUI2. Мы хотим
сравнить наш класс окна с ним, но сначала мы должны убедиться в том, что
наш скрипт ищет в нужном месте. Мы используем функцию GetWindowClass
чтобы запросить класс окна. Ее параметром является ручка окна (Window
Handle), поэтому мы даем ей AppMainWindow, которое является родителем в
текущем приложении. Мы используем это, потому что Jaws является
приложением, и мы хотим проверить класс окна этого приложения.
AppMainWindow требует ручку окна в качестве параметра, поэтому функция
знает, какое приложение проверять. В нашем случае мы используем функцию
GetFocus, которая возвращает ручку окна для окна, которое имеет фокус.
Проще говоря, все обстоит примерно так: получаем класс окна для окна
приложения, которое имеет фокус.

                       Домашнее задание $ 9

Давайте еще раз вернемся к диалогу открытия файла в приложении WordPad.
Откройте этот диалог и осмотритесь,. чтобы освежить свою память. Напишите
скрипт, который будет определять, прежде всего, находитесь ли вы в этом
диалоге. Если да, пусть ваш скрипт скажет "В диалоге открытия". Затем
определите, находится ли фокус в окне редактирования имени файла. Если да,
пусть скрипт также скажет "и в поле имени файла". Однако, если фокус
находится на другом элементе управления, пусть скрипт вместо второго
сообщения скажет "но не в поле имени файла". И наконец, если фокус даже
не в окне открытия файла, пусть скрипт скажет "не в окне открытия файла".
Совет: диалог открытия файла - это действительное окно. Вспомните, что это
означает, что это окно, у которого есть заголовок. Используйте этот факт,
чтобы определить, находитесь ли вы в диалоге открытия файла. Используйте
класс окна вашего текущего элемента управления, чтобы определить,
находится ли фокус на поле имени файла. Второй совет: обратите внимание
на функцию GetRealWindow в приложении C.

                 Выбор курсора и манипуляции с ним

Прежде, чем вы попытаетесь прочитать что-нибудь на экране с
помощью скрипта, есть смысл просмотреть некоторую информацию о
курсорах, о чем мы уже говорили прежде. Существует три типа
курсора: PC курсор, Jaws курсор и невидимы й курсор. Если вы
редактируете или вводите текст, PC курсор будет находиться там,
где будут появляться символы, которые вы будете набирать. (Эта
форма курсора редактирования или вставки также называется курсор
каретки). Однако, когда вы работаете в меню или клавишей Tab
перемещаетесь по опциям,например по кнопкам в окне диалога, PC
курсор является фокусом. Если вы хотите прочитать другие области
окна или прочитать часть экрана, куда не может попасть PC
курсор, вы можете переключиться на Jaws курсор. Jaws курсор
можно двигать куда угодно в рамках текущего действительного
окна, что делает возможным исследование тех областей экрана,
куда PC курсор попасть не может. Поскольку Jaws курсор всегда
перемещает за собой указатель мыши, указатель мыши также
позиционируется, и им можно щелкнуть в том месте, где находится
Jaws курсор, если вы решили это проделать. Третий вид курсора
называется невидимый курсор, и в одном отношении он похож на
Jaws курсор, поскольку его перемещение ограничено только рамками
действительного окна, но он не имеет видимого воплощения на
экране и он не таскает за собой указатель мыши.

Как же нам пользоваться этими курсорами? Было бы непрактичным, а
зачастую и невозможным исследовать экран с помощью PC курсора.
Поэтому, прежде чем прочитать какой-нибудь текст в окне, мы
обычно сначала переключаемся на один из оставшихся курсоров.
Можно использовать как Jaws, так и невидимый курсор, чтобы
выполнять функции чтения, поэтому до некоторой степени это
просто вопрос предпочтения. Однако, если вы намерены щелкнуть
мышью или предпринять другие действия с применением мыши,
необходимо будет воспользоваться Jaws курсором. Поскольку  указатель
мыши сопровождает Jaws курсор в его путешествиях, щелкнуть мышью
оказывается очень просто, поскольку она будет уже в нужной
позиции. Если вы не хотите перемещать Jaws курсор с его текущей
позиции, или нигде щелкать не надо, лучшим выбором будет
невидимый курсор. На ум приходит одна конкретная ситуация, когда
вы уж точно не захотите перемещать "Jaws курсор/указатель мыши.
Иногда в приложении Windows информационный текст будет
появляться где-то на экране, обычно в строке состояния, когда
указатель мыши будет находиться в каком-нибудь конкретном месте.
Если вы переместите Jaws курсор чтобы прочитать текст, с ним
переместится и указатель мыши и текст исчезнет. В такой ситуации
чтобы прочитать текст, придется воспользоваться невидимым
курсором.

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

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

PCCursor() -  активизирует PC курсор.
JAWSCursor() -  активизирует Jaws курсор.
InvisibleCursor() -  активизирует невидимый курсор.
BrailleCursor () -  активизирует брайлевский курсор.
RouteBrailleToPc () - перемещает брайлевский курсор к PCC
курсору.
RouteBrailleToJAWS () - перемещает брайлевский курсор к Jaws
курсору.
RouteJAWSToBraille () - перемещает Jaws курсор к брайлевскому
курсору.
RoutePCToBraille () - перемещает PC курсор к брайлевскому
курсору.
RoutePCToJAWS() -  перемещает PC курсор к Jaws курсору.
RouteJAWSToPC() -  перемещает Jaws курсор к PC курсору.
RouteJAWSTo Invisible() - перемещает Jaws курсор к невидимому
курсору.
RouteInvisibleToPC() -  перемещает невидимый курсор к PC курсору.
RouteInvisibleToJAWS() - перемещает невидимый курсор к Jaws
курсору.
SaveCursor() -  сохраняет активный курсор и его позицию.
RestoreCursor() - снова активизирует сохраненный курсор и
восстанавливает его первоначальную позицию.

Следующая группа функций используется для перемещения курсора.

PriorCharacter() - перемещает активный курсор на предыдущий
символ.
PriorWord() -  перемещает активный курсор к предыдущему слову.
PriorLine() -  перемещает активный курсор на предыдущую строку.
NextCharacter() - перемещает активный курсор к следующему
символу.
NextWord() -  перемещает активный курсор к следующему слову.
NextLine() -  перемещает активный курсор на следующую строку.
JAWSHome() -  перемещает активный курсор в начало строки.
JAWSEnd() -  перемещает активный курсор в конец строки.
JAWSPageUp() -  перемещает активный курсор к верхнему краю  окна
JAWSPageDown() -  перемещает активный курсор к нижнему краю окна.
MoveTo - перемещает невидимый или Jaws курсор в координаты окна,
указанные пользователем.
MoveToControl - перемещает активный курсор к конкретному органу
управления в окне. Если при вызове этой функции активным
является PC курсор, автоматически включается Jaws курсор. В
противном случае используется активный курсор.
MoveToFrame - перемещает активный курсор в левый верхний угол
указанного фрейма. Если при вызове этой функции активным
является PC курсор, автоматически включается Jaws курсор,
который и перемещается в новую позицию. В противном случае
используется активный курсор.
MoveToGraphic - перемещает Jaws курсор, невидимый курсор или
брайлевский курсор в указанном направлении, чтобы найти
графический символ в активном окне.
MoveToWindow - перемещает активный курсор в указанное окно. Если
окно содержит текст, курсор позиционируется на первый символ, в
противном случае он позиционируется в центре окна. Если при
вызове этой функции активным является PC курсор, то
активизируется Jaws курсор, который и перемещается в новую
позицию.
PriorChunk - перемещает активный курсор к предыдущей цепочке
текста. Цепочка текста - это раздел или блок текста, который
пишется на экране за один раз.
NextChunk - перемещает активный курсор к следующей цепочке
текста. Цепочка - это раздел или блок текста, который пишется на
экране за один раз.

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

Script ReadBottomLine()
Var ;Объявляем наши локальные переменные
Int TheTypeCode ;У нас есть переменная типа Integer TheTypeCode
Let TheTypeCode = GetWindowSubtypeCode (GetCurrentWindow()) ;узнаем, в каком типе окна мы находимся и присваиваем его переменной TheTypeCode
SaveCursor() ; сохраняем текущий курсор и его позицию.
InvisibleCursor() ; Переключаемся на невидимый курсор.
RouteInvisibleToPC() ; Перемещаем невидимый курсор к PC курсору.or
If (TheTypeCode == WT_MENU) Then ; Если мы в меню
MoveToWindow (GetAppMainWindow (GetCurrentWindow())) ; Перефокусироваться на главное окно
JAWSPageDown () ; Перейти в нижний край
JAWSHome() ; перейти в самую левую позицию.
NextWord() ; Перейти на слово вправо.
SayChunk() ; Озвучивает цепочку текста, которая была написана на экране вместе с
Else
JAWSPageDown() ; Перейти в нижний край
SayLine() ; Прочитать строку
EndIf
RestoreCursor() ; Вернуться к первоначальному курсору и восстановить его позицию.
EndScript

Этот скрипт озвучивает нижнюю строку окна. Обычно там находится
строка состояния. PC курсор в это место попасть не может,
поэтому мы должны переключиться на невидимый курсор и прочитать
строку с его помощью. Обратите внимание, что перед тем, как
предпринять это действие, используется функция SaveCursor, а
после - функция RestoreCursor. Таким образом, после чтения
строки состояния все стало точно так же, как было перед этим.
Этот скрипт использует код подтипа окна, чтобы определить, в
каком типе окна мы находимся, и, какое утверждение скрипта надо
использовать чтобы прочитать то, что нам нужно.

                     Посылка нажатий клавиш

Если вам нужно послать нажатие клавиши или комбинации клавиш из
скрипта (то есть, если вы хотите, чтобы скрипт ввел эти клавиши,
точно также, как если бы вы сами ввели их с клавиатуры),
поместите название клавиши в фигурные скобки. Например,
{CONTROL+H} пошлет в систему Ctrl+H. Этот способ также можно
использовать, чтобы посылть буквенно-цифровые символы. Таким
образом, {h} пошлет в приложение, с которым вы работаете, букву
H. Каждая буква, которую вы намерены послать, должна иметь свой
собственный набор фигурных скобок. Если вам нужно послать
больше, чем пару символов, вы можете воспользоваться функцией
TypeString, которая сразу пошлет всю строку символов в
приложение.

                   Синхронизация документации

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

1. Диспетчер скриптов просматривает в файле >JSD строки для
каждого скрипта в >JSS файле и добавляет пустые строки для
каждого скрипта, у которого отсутствует документация. (вы должны
просмотреть все скрипты, которые, как вам кажется, имеют пустые
строки, и ввести соответствующий синопсис и описание после
процесса синхронизации). Вы заметите, когда появится диалог
документации, что если в файле скриптов вашего приложения есть
скрипт с тем же именем, что и в файле скриптов по умолчанию,
документация из скрипта по умолчанию была помещена в поля для
вашего скрипта. Вам может понадобиься модифицировать эту
документацию, чтобы привести в соответствие с тем, как ваш
скрипт или функция работают в данном приложении.
2. Диспетчер скриптов проверяет .JSD файл на наличие строк
документации, которым больше не соответствует никаких скриптов в
.JSSS файле и спрашивает, хотите ли вы удалить строки
документации.

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

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

                            Отладка

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

                    Компилятор скриптов Jaws

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

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

                     Ошибочная деятельность

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

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

Сообщения: в ключевых точках вашего кода можно вставлять
сообщения, чтобы Jaws сообщал, что он делает. ВЫ можете вставить
сообщения SayString в ключевых точках скрипта чтобы посмотреть,
действительно ли они выполняются, когда вы предполагаете это.
Ряд таких сообщений, которые выдают несколько различные
сообщения, могут быть весьма информативными в том, чтобы помочь
вам расшифровать, если код выполняется в том порядке, в каком вы
задумали, и ветвление происходит корректно. Например, сообщения
SayString в каждой ноге утверждения If-Then проинформируют вас,
какая нога выполняется. Вы также можете использовать функцию
SayInteger, чтобы она информировала вас о значениях
целочисленных переменных и о том, как эти значения изменяются в
ходе выполнения скрипта. Вы можете обнаружить, что эти
переменные имеют не те значения, которые вы ожидали, в некоторых
точках выполнения скрипта. Функция SayInteger также может
оказаться полезной в том, чтобы помочь вам отслеживать значения
целочисленных переменных во время выполнения цикла While.

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

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

Script SayVars
SayString( MyVariable) ; Наберите имя своей переменной   e
; Скопируйте предыдущую строку для каждой своей переменной
EndScript

Script WindowInfo
SayString( GetWindowClass (GetFocus ())) ; Класс окна с фокусом
SayString ( GetWindowClass (GetParent (GetFocus ()))) ; Класс окна для родительского окна
UtilitySayInfoAccess() ; Название элемента управления
EndScript

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

                     Домашнее задание # 10

Приведенный скрипт содержит ошибки на каждой строке. Найдите
ошибки и перепишите скрипт правильно.

Script SayDefaultButton (Int Button )
vars
	string DefaultButtonName,
if (DialogActive ()) 
	let DefaultButtonName == GetDefaultButtonName 
	if (DefaultButtonName != " ") then
		if (GetVerbosity () = 0) then
			SayString ("msg70") ;"default button is"
		EndIf ()
		SayString (DefaultButtonName))
	Else ()
		SayString (msg444) : "Can not determine default button in this dialog box "
	End If
Else ()
	SayString (msg71 ;"not in a dialog box"
EndIf ()
End Script
(cont)

              Стратегия атаки на новые приложения

Когда вы впервые открываете новое приложение, особенно то,
которое не является дружественным к речевому доступу, может
оказаться весьма затруднительным решить, как изучить
расположение приложения и как приспособить его для лучшего
доступа. Это руководство познакомило вас с инструментами
создания скриптов, которые помогут вам проделать это. Одна
стратегия подхода к таким приложениям показана в приложении E.
Там вы найдете некоторые идеи о том, как подходить к проблеме
анализа и создания скриптов для нового приложения, в комбинации
с использованием других возможностей Jaws, таких, например, как
использование фреймов.

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

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

Имена переменных: используйте осмысленные имена переменных,
после которых вставляйте комментарий, когда имя является
недостаточно описательным.
Комментарии: вставляйте комментарии сразу же после начала
каждого скрипта или функции, описывающие его назначение.
Комментарии также необходимо вставлять в сложные утверждения,
где задача не всегда очевидна, такие, как сложные утверждения
типа If-Then-Else.
Сообщения: все озвучиваемые или брайлевские сообщения должны
помещаться в файл сообщений для текущего приложения, где скрипт
может к ним обращаться. Эти сообщения никогда не должны
помещаться в кавычках после SayString в самом .JSS файле.
Соблюдение этого правила делает перевод сообщений на другие
языки куда проще.
Документация к скриптам: заполняйте поля Синопсис и Описание
(Description) в диалоге "Новый скрипт". Они должны заполняться
точно и полностью, поскольку они используются в помощи по
клавиатуре, вызываемой по Insert+F1. Например, в скрипте
SayTextAndAttributes, вы найдете следующий синопсис и описание.
Синопсис: озвучивает изменения в атрибутах, когда читает текст в
активном окне. Описание: читает видимый текст в активном окне не
перемещая курсор. Когда попадаются изменения атрибутов, ОНИ
СООБЩАЮТСЯ.
Убедитесь, что ваш файл скриптов включает настроенные версии
скриптов HotKeyHelp, ScriptFileName, и, если необходимо,
ScreenSensitiveHelp.

                 Преобразование файлов макросов

Диспетчер скриптов можно использовать, чтобы преобразовать файлы
макросов, которые вы создавали для версий Jaws старше 3.0. Далее
приводятся шаги, которые предпринимает диспетчер скриптов, чтобы
переконвертировать файлы макросов в файлы скриптов.
1. Сначала диспетчер скриптов потребует от вас некоторого ввода.
Когда в меню Файл вы выбираете пункт Импортировать макрофайл, вы
должны будете ввести имя файла макросов. Диспетчер скриптов
использует эту информацию для определения пути и имени файла,
который получится в результате. Вы также должны будете выбрать
среду, для которой создавался макрофайл: Desktop, Laptop или оба
сразу.
2. Диспетчер скриптов создаст пустой файл скриптов, основываясь
целевом пути и имени файла.
3. Файлы включения обрабатываются следующим образом: файл
сообщений копируется в целевую директорию, переименовывается,
получая расширение .JSM, и в .JSS файл добавляется оператор
Inckude.
Макросы в Inckude файлах перемещаются в .JSS файл и
конвертируются. Процедура конвертирования следующая: Если есть
раздел определения глобальных переменных или констант в Inckude
файле, создается .JSH файл и все это переносится туда. В .JSS
файл добавляется оператор Inckude для этого файла
Макросы конвертируются следующим образом: если соответствующая
клавиша обнаруживается в файле раскладки клавиатуры по
умолчанию, основываясь на выбранной среде, скрипту присваивается
соответствующее имя.
Если соответствующая клавиша будет найдена в разделе "Старые
клавиши" файла раскладки клавиатуры по умолчанию, макрос
конвертируется в функцию Jaws с соответствующим именем.
Если соответствия не найдено, скрипту присваивается имя имени
файла, после которого идет номер.
Создается файл раскладки клавиатуры, с присвоениями, основанными
на первоначальных нажатиях клавиш. Макросам, которые
конвертированы в определяемые пользователем функции, клавишных
команд не присваивается, но после имени функции помещается
комментарий, с первоначальным макронажатием клавиши.
Каждое PerformMacro конвертируется в PerformScript, если только
вызванный макрос не был переконвертирован в функцию Jaws. В этом
случае PerformMacro конвертируется в вызов функции
Файл скриптов, который получается в результате, открывается в
диспетчере скриптов.
Предыдущая версия Jaws требовала пробелов между кавычками для
обозначения нулевого значения. В текущей версии нулевые значения
обозначаются просто двумя кавычами без пробелов. Если ваш файл
макросов содержал такие тесты на нулевое значение, вам придется
убирать пробелы между кавычками вручную.
Последнее, что вы должны сделать, это просмотреть скрипты,
изменить имена, если это необходимо, и написать документацию для
каждого скрипта. Если у вас были макросы, служившие в качестве
функций, сконвертируйте их в определяемые пользователем функции.
Затем скомпилируйте новый файл скриптов. Примечание: если вы
вносите обширные изменения в скрипты и функции, вы можете
пожелать компилировать после каждого изменения.

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

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

                          Приложение A

                   Ответы на домашние задания

                 Ответ на домашнее задание # 1

Script LastFourFiles ()
SpeechOff ()
{Alt+F}
Pause ()
NextLine ()
NextLine ()
NextLine ()
NextLine ()
NextLine ()
NextLine ()
NextLine ()
SpeechOn ()
SayLine ()
NextLine ()
SayLine ()
NextLine ()
SayLine ()
NextLine ()
SayLine ()
SpeechOff ()
{escape}
{escape}
Pause ()
SpeechOn ()
EndScript

                 Ответ на домашнее задание # 2

Script SpeakWindowState ()
JAWSCursor ()
SaveCursor ()
RouteJAWSToPC ()
JAWSPageUp ()
JAWSEnd ()
PriorWord ()
SayWord ()
RestoreCursor ()
PCCursor ()
EndScript

Обратите внимание, что в этом примере мы активизировали Jaws
курсор, прежде чем использовать функцию SaveCursor. Поскольку
Jaws курсор является активным курсором, когда выполняется
функция SaveCursor, функция RestoreCursor вернет в
первоначальное положение именно Jaws курсор. Функция PCCursor ()
в конце снова включит PC курсор. Это необходимо, поскольку
скрипт, когда работал, включил Jaws курсор.

Ниже приводится ответ на "Отлично"5

Script SpeakWindowState ()
InvisibleCursor ()
SaveCursor ()
RouteInvisibleToPC ()
JAWSPageUp ()
JAWSEnd ()
PriorWord ()
If GetWord () == "Restore Symbol" Then
SayString ("Maximized")
ElIf GetWord () == "Maximize Symbol" Then
SayString ("Restored")
Else
SayString ("Couldn't find the symbol")
EndIf
RestoreCursor ()
PCCursor ()
EndScript

                 Ответ к домашнему заданию # 3

Script PlaybackPosition ()
SaveCursor ()
RouteInvisibleToPC ()
InvisibleCursor ()
JAWSPageUp ()
NextLine ()
NextLine ()
NextLine ()
JAWSHome ()
SayString ("Current time is")
SayWord ()
SayString ("seconds out of")
NextWord ()
NextWord ()
SayWord ()
SayString ("seconds")
RestoreCursor ()
EndScript

                 Ответ к домашнему заданию # 4

Include "JAWSWINS.JSH"
Include "JAWSWINS.JMH"
Include "HJCONST.JSH"
Include "HJGLOBAL.JSH"

                 Ответ к домашнему заданию # 5

Script CheckAndReset ()
Var
String TotalTime ;Хранит полное время звучания звукового файла
SaveCursor ()
RouteInvisibleToPC ()
InvisibleCursor ()
JAWSPageUp ()
NextLine ()
NextLine ()
NextLine ()
JAWSEnd ()
PriorWord ()
Let TotalTime = GetWord ()
JAWSHome ()
If GetWord () == "0.00" Then
SayString ("At the beginning of the recording")
ElIf GetWord () != "0.00" && GetWord () < TotalTime Then
SayString ("Playback only partially complete")
ElIf GetWord () == TotalTime Then
SayString ("Playback is complete.")
JAWSCursor ()
RouteJAWSToPC ()
JAWSHome ()
Pause ()
LeftMouseButton ()
Pause ()
InvisibleCursor ()
If GetWord () == "0.00" Then
SayString ("Rewind complete")
Else
SayString ("Rewind failed.  Please check your batteries.")
EndIf
EndIf
EndScript

Обратите внимание, что Jaws может произносить некоторые
дополнительные фразы, такие как "Seek to Start" или "Seek to
End" когда он выполняет перемотку. Все правильно.

                 Ответ к домашнему заданию # 6

String Function SayAllCaps (string CurrentWord)
If CurrentWord < "a" || CurrentWord > "zzzzz" Then
Return ""
EndIf
If (StringContains (CurrentWord, "a")) || (StringContains (CurrentWord, "b"))
 || (StringContains (CurrentWord, "c")) || (StringContains (CurrentWord, "d")) 
|| (StringContains (CurrentWord, "e")) || (StringContains (CurrentWord, "f"))
|| (StringContains (CurrentWord, "g")) || (StringContains (CurrentWord, "h")) 
|| (StringContains (CurrentWord, "i")) || (StringContains (CurrentWord, "j")) 
|| (StringContains (CurrentWord, "k")) || (StringContains (CurrentWord, "l"))
|| (StringContains (CurrentWord, "m")) || (StringContains (CurrentWord, "n")) 
|| (StringContains (CurrentWord, "o")) || (StringContains (CurrentWord, "p")) 
|| (StringContains (CurrentWord, "q")) || (StringContains (CurrentWord, "r"))
|| (StringContains (CurrentWord, "s")) || (StringContains (CurrentWord, "t")) 
|| (StringContains (CurrentWord, "u")) || (StringContains (CurrentWord, "v")) 
|| (StringContains (CurrentWord, "w")) || (StringContains (CurrentWord, "x"))
|| (StringContains (CurrentWord, "y")) || (StringContains (CurrentWord, "z")) 
|| (StringContains (CurrentWord, "1")) || (StringContains (CurrentWord, "2")) 
|| (StringContains (CurrentWord, "3")) || (StringContains (CurrentWord, "4")) 
|| (StringContains (CurrentWord, "5")) || (StringContains (CurrentWord, "6"))
|| (StringContains (CurrentWord, "7")) || (StringContains (CurrentWord, "8")) 
|| (StringContains (CurrentWord, "9")) || (StringContains (CurrentWord, "0")) Then
Return ""
EndIf
Return "All Caps"
EndFunction

Script SayWord()
If (IsSameScript ()) Then
SayString (SayAllCaps (GetWord ()))	
SpellWord()	
AddHook (HK_SCRIPT, "SpellWordHook")
Else
SayWord ()
EndIf
EndScript

                 Ответ к домашнему заданию # 7

Edit Window:

SayTypeAndText - Edit
Focus - Это ручка окна, поэтому она всегда изменяется
ControlID - 59648
Class - Edit
Type - RichEdit
SubTypeCode - 3
Real Name - Document WordPad (assuming you have not loaded a file)

Filename Window:

SayTypeAndText - Filename Edit
Focus - Это ручка окна, поэтому она всегда изменяется
ControlID - 1152
Class - Edit
Type - Edit
SubTypeCode - 3
Real Name Open

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

                 Ответ к домашнему заданию # 8

;This is the script file for SPAMKILLER.EXE, created by Michael Glen
;This file was last updated on July 4, 1776.

Include "SPAMKILLER.JSH" ;Header file
Include "SPAMKILLER.JSM" ;Message file
Include "HJCONST.JSH"
Include "HJGLOBAL.JSH"

Globals
Int GlobalSpamInteger,
String GlobalSpamString,
Handle GlobalSpamHandle

Const
SpammerOne = 1
SpammerTwo = 2
SpammerThree =3

                 Ответ к домашнему заданию # 9

Script IsThisOpenEdit ()
If GetWindowName (GetRealWindow (GetFocus ())) == "Open" Then
SayString ("In the Open dialog,")
If GetWindowClass (GetFocus ()) == "Edit" Then
SayString ("and in the filename field.")
Else 
SayString ("but not in the filename field.")
EndIf ;Are we in the edit field?
Else
SayString ("Not in the Open dialog")
EndIf ;Are we in the Open dialog?
EndScript

                 Ответ к домашнему заданию # 10

Каждая ошибка показана ниже строкой, начинающейся с *** после
строки, содержащей ошибку.

Script SayDefaultButton (Int Button )
***Скрипты не используют параметры, параметры используют только функции
vars
***Var, а не Varsa
	string DefaultButtonName,
***Последняя или единственная переменная не должна оканчиваться запятой
if (DialogActive ()) 
***В конце строки должно быть Then
	let DefaultButtonName == GetDefaultButtonName 
***в этом типе утверждения, где вы присваиваете значение, должен быть только один знак равенства
If (DefaultButtonName != " ") then
***Между кавычками пробелов быть не должно.
		if (GetVerbosity () = 0) then
***В этом утверждении должно быть два знака равенства.
			SayString ("msg70") ;"default button is"
***Внутри скобок кавычек быть не должно.
		EndIf ()
***После Endif скобок не требуется.
		SayString (DefaultButtonName))
***В конце строки лишняя закрывающая скобка.
	Else ()
***После утверждения Else скобок ставить не нужно.
		SayString (msg444) : "Can not determine default button in this dialog box "
***Комментарий должен начинаться с точки с запятой, а не с двоеточия.
	End If
***В операторе Endif пробелов быть не должно.
Else ()
***После оператора Else скобки не ставятся.
	SayString (msg71 ;"not in a dialog box"
***После MSG71 должна быть закрывающая скобка.
EndIf ()
***После EndIf скобки не ставятся.
End Script
***В EndScript пробелов быть не должно.

Скрипт, в таком виде, в каком он должен быть, и в каком виде он
присутствует в default.jss, приводится ниже.

Script SayDefaultButton () 
var
	string DefaultButtonName
if (DialogActive ()) then
	let DefaultButtonName = GetDefaultButtonName ()
	if (DefaultButtonName != "") then
		if (GetVerbosity () == 0) then
			SayString (msg70) ;"default button is"
		EndIf
		SayString (DefaultButtonName)
	else
		SayString (msg444) ; "Can not determine default button in this dialog box ")
	EndIf
else
	SayString (msg71) ;"not in a dialog box"
EndIf
EndScript

                 Описание меню диспетчера скриптов

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

                            Меню Файл

New: Стандартная функция.
Open: стандартная функция.
Open Default File: открывает файл скриптов Jaws по умолчанию DEFAULT.JSS.
Close: стандартная функция.
Save: сохраняет файл, а также компилирует и сохраняет бинарную JSB
версию, сохраняя .JSS файл.
Save As: стандартная функция.
Save Without Compile:  сохраняет любой файл, и не компилирует .JSS файл.
Import Macro File: используется для импорта файла макроса из ранних версий
JFW.
Synchronize Documentation: используется, чтобы убедиться в том, что файлы
скриптов и документация соответствуют друг другу. Также при вставке
скриптов из других .JSS файлов, он скопирует документацию в
соответствующий .JSD файл.
Print: стандартная функция.
Print Preview: стандартная функция.
Print Setup: стандартная функция.
Exit: стандартная функция.

                            Меню Edit

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

Select Script: выделяет скрипт целиком, в котором находится курсор.

                            Меню Script

New Script: открывается диалог New Script для создания нового скрипта.
Delete Script:  удаляет скрипт, на котором находится курсор.
Insert Function Call: выводит диалог Insert Function для добавления в скрипт
новой функции.
Insert Perform Script: выводит диалог Insert Perform Script для вызова другого
скрипта. Это аналогично вызову функции, но вызывается другой связанный с
клавишей скрипт, а не функция.
Next Script: перемещает курсор к началу следующего скрипта в файле.
Prior Script: перемещает курсор к началу предыдущего скрипта в файле.
Go To Line: перемещает курсор к указанной строке. Номера страницы
показаны на нижнем крае страницы.
Script List: выводит диалог Script List, в котором показаны скрипты в текущем
файле в алфавитном пррядке. Нажатие Enter на имени скрипта перемещает
вас к этому скрипту.

                            Меню View

Documentation: выводит диалог Script Information, который содержит всю
документацию для текущего скрипта.
Toolbar: стандартная функция.
Status Bar: стандартная функция.
Zoom: стандартная функция.

                           Меню Window

Все элементы в меню Window выполняют стандартные функции.

                            Меню Help

Help Topics: Стандартная функция.
keyword Help: выводит диалог KeyWord, который содержит помощь по
скрипту или функции, на которой находится курсор.
About Script Manager: стандартная функция.

                          Приложение C

                 Самые важные встроенные функции

Обратите внимание, что большинство элементов в этом списке расположены в
алфавитном порядке. Однако, некоторые были выведены из порядка, чтобы
расположить их рядом с функциями с аналогичной или соотносительной
функциональностью. Этот список был обновлен, чтобы отразить новые
функции, появившиеся в JFW 3.5. Те, кто пользуется более ранними версиями
Jaws, не будут иметь всех функций, перечисленных здесь.

ActivateMenuBar - активизирует/деактивизирует линейку меню для активной
программы. То же самое, что нажать и отпустить клавишу Alt.
? ActivateStartMenu - выводит меню "Пуск" в Windows 95, 98 и NT. То же
самое, что нажать Ctrl+Escape&
AddHook - устанавливает Hook функцию. Когда Hook на месте, он вызывается
перед тем, как отрабатывает скрипт и ему передается имя текущего скрипта и
фрейма в качестве параметров. Если Hook возвращает True, скрипту
разрешается выполняться. Если Hook возвращает False, скрипту не будет
позволено выполняться. Обратитесь к скрипту KeyboardHelp и функции
KeyboardHelpHook в DEFAULT.JSS для примера Hщщл функции в действии.
Более подробно этот инструмент обсуждается в разделе о Hook функциях.
AltLeftMouseClick - отменяет выбор ранее выбранных элементов. Посылает в
систему Alt+щелчок левой кнопкой мыши.
ControlLeftMouseClick - симулирует Ctrl+щелчок левой кнопкой мыши. Эта
функция предоставляет способ выбирать элементы, расположенные вразброс. В
качестве примера может служить выбор пунктов в списке вразбивку.
ShiftLeftMouseClick - симулирует Shift+щелчок левой кнопкой мыши. Эта
функция предоставляет способ выбора элементов, расположенных друг за
другом. Примером может служить выделение элементов в списке,
расположенных подряд.
BackspaceKey - если виртуальный курсор не является активным, эта функция
просто передает в приложение клавишу Enter. Если виртуальный курсор
активен, выполняется любая специальная обработка, требуемая виртуальным
режимом.
BrailleAddFocusItem - используется из функции BrailleBuildLine, чтобы
добавить содержание текущего органа управления к данным, которые должны
быть показаны на брайлевском дисплее.
BrailleAddFocusLine - используется из функции BrailleBuildLine, чтобы
добавить содержание текущей строки к данным, которые должны быть
показаны на брайлевском дисплее.
BrailleAddFrame - используется из функции BrailleBuildLine, чтобы добавить
содержание конкретного фрейма к данным, которые должны быть показаны
на брайлевском дисплее.
BrailleAddString - используется из функции BrailleBuildLine, чтобы добавить
текст к брайлевскому дисплею.
BrailleCursor - включает брайлевский курсор. Этот курсор используется только
внутренне брайлевскими скриптами и его никогда не следует оставлять
активизированным, после того как скрипт завершает свою работу.
BrailleG2StringLength - определяет длину перевода в брайль второй степени
данной строки.
BrailleG2StringLength - если структурированный режим является активным,
выводится следующая строка в брайлевской очереди. Если активным является
режим навигации, Jaws активизирует невидимый курсор и перемещает его к
следующей строке. В противном случае выполняется обычная функция
NextLine.
BraillePriorLine - если активным является структурированный режим,
выводится предыдущая строка в брайлевской очереди. Если активным является
режим навигации, Jaws активизирует невидимый курсор и и перемещает его к
предыдущей строке. в противном случае выполняется обычная функция
PriorLine.
BrailleRefresh - используется для обновления брайлевского дисплея и для
повторного вывода соответствующего текста.
BrailleSetStatusCells - выводит символы в клетках статуса на брайлевском
дисплее. Эту функцию следует вызывать только из функции BrailleBuildStatus.
BrailleString - посылает указанную строку на брайлевский дисплей,
независимо от того, видима эта строка или нет.
CaretVisible - показывает, является ли курсор вставки, или каретка, видимой в
активном окне. Функция возвращает значение константы "True", чтобы
показать, что курсор виден, и значение "False", чтобы показать, что он не
виден.
ColorToRGBString - преобразует значение цвета в строку вида "255255255",
где первые три цифры представляют долю красного цвета, вторые три - долю
зеленого, а последние три - долю синего цвета.
ControlCanBeChecked - определяет, можно ли включать и выключать текущий
орган управления.
ControlIsChecked - определяет, является ли включенным текущий орган
управления.
CopyToClipboard - помещает строку текста в буфер обмена Windows, удаляя
любое предшествовавшее содержание буфера обмена. Чтобы скопировать
несколько строк текста, они должны быть сначала объединены в одну строку,
прежде чем вызывать CopyToClipboard. В соединенной строке строки должны
быть разделены символами \r\n.
CreateObject - для некоторых приложений, например Internet Explorer и
Microsoft Office, Jaws может получать информацию прямо из этого
приложения, а не ссылаться на то, что показано на экране. Для того, чтобы
сделать это, Jaws нужно место, чтобы получать эту информацию, и что-то
вроде путеводителя, чтобы сообщать, где искать. Путеводитель называется
указатель объекта, а место, куда он отсылает Jaws, называется
автоматический объект для этого приложения. Есть несколько способов
получения такого указателя объекта для данной задачи, не все из которых
работают со всеми приложениями. Один из таких способов - CreateObject.
CreateObject запускает приложение под управлением Jaws, при чем это
приложение является автоматическим объектом. Затем Jaws может запросить
этот автоматический объект, чтобы тот предоставил информацию, нужную
Jaws. Функция CreateObject аналогична функции GetObject, за исключением
того, что GetObject создает указатель на автоматический объект, который уже
существует, тогда как CreateObject также создает автоматический объект для
приложения.
Delay - заставляет скрипт остановиться на указанный промежуток времени.
Она заставляет скрипт остановиться, подождать некоторый период времени, а
затем снова продолжить работу. Она отличается от функции Pause, которая
приспосабливается к нуждам обработки приложения. После Delay скрипт
продолжит работу, независимо от того, закончило приложение необходимую
обработку, или нет.
DialogActive - используется для определения того, является ли в настоящий
момент активным окно диалога. Функция возвращает значение константы,
чтобы показать статус: "ACTIVE" = окно диалога активно, и "INACTIVE" =
окно диалога неактивно. Эти константы могут использоваться в If-Then-Else
конструкциях.
DLGSelectItemInList - выводит диалог, содержащий набор элементов меню.
Содержание меню строится пользователем, который должен предоставить
строку, содержащую каждый из элементов меню, которые должны быть
отделены друг от друга вертикальной чертой (|). Эта функция обычно
используется внутри другого скрипта или функции, который указывает, какие
действия нужно предпринимать, когда когда выбирается пункт меню и диалог
закрывается кнопкой OK. Когда диалог закрывается кнопкой OK, эта функция
возвращает индекс, который позволяет вызывающему скрипту решить, какие
действия предпринимать дальше. См. функцию под названием ToolBar4 в
файле SHDOCVW.JSS, где вы найдете пример того, как используется эта
функция.
DLGSelectScriptToRun - выводит диалог, содержащий набор скриптов. Список
скриптов строится пользователем. См. скрипт, озаглавленный
AdjustJawsVerbosity для примера того, как это сделано. Скрипты могут
выполняться из этого диалога.
DLGSysTray - выводит список, содержащий ярлыки в системном поддоне.
DownCell - находясь внутри таблицы, перемещает активный курсор к ячейке в
той же колонке, но в следующем ряду.
UpCell - находясь в таблице, перемещает активный курсор к
ячейке,находящейся в той же колонке, но на предыдущем ряду.
PriorCell - находясь в таблице, перемещает активный курсор к ячейке,
находящейся в том же ряду, но в предыдущей колонке.
NextCell - находясь в таблице, перемещает активный курсор к ячейке в том
же ряду, но в следующей колонке.
SayCell -  находясь в таблице, озвучивает содержание текущей ячейки.
SayColumnHeader - находясь в таблице, озвучивает содержание заголовка
колонки.
SayRowHeader -  находясь в таблице, озвучивает содержание заголовка ряда.
DragItemWithMouse - функция DragAndDrop (перетащить и бросить)
используется для перетаскивания содержания одной области экрана в другую
область экрана.
ElIf - вместо использования оператора Else в конструкции типа If-Then-Else,
можно использовать оператор ElIf. Утверждение можно будет
реконструировать в утверждение If-Then-ElIf-Then-Else. Каждое утверждение
должно заканчиваться оператором "EndIf". Функции скрипта, которые
помещаются между ElIf и Then используются для того, чтобы оценить,
наличествуют ли определенные условия.
Else - оператор Else является опциональной частью утверждения If-Then-Else.
Утверждения If-Then-Else всегда задают вопрос, является ли что-либо
истинным или ложным, то есть, наличествует определенное условие или
отсутствует. Когда условие отсутствует (False), выполняются действия,
стоящие после "Else". Утверждения If-Then-Else всегда должны включать: If,
Then, EndIf. Else является опциональным.
EndIf - оператор EndIf отмечает конец утверждения If-Then-Else. Полностью
сформулированное If-Then-Else утверждение включает jgthfnjhs "If", "Then", "Else" и
"Endif". "EndIf' всегда требуется для завершения утверждения If-Then-Else.
EndWhile - оператор EndWhile отмечает конец цикла While. Функции
скриптов, которые должны повторяться, необходимо помещать между "While"
и "EndWhile". (См. ниже описание функции While).
EnterKey - если виртуальный курсор не является активным, эта функция
просто передает в приложение клавишу Enter. Если виртуальный курсор
активен, и он позиционирован на линке или кнопке, активизируется этот
элемент управления. Если виртуальный курсор находится на другом элементе
формы, активизируется режим форм.
FileExists - проверяет, существует ли указанный путь.
FindColors - ищет наличие указанной комбинации цвета символа и заднего
плана. Если поиск оказывается успешным, Jaws курсор устанавливается в
начало текста с указанной комбинацией цветов.
FindDescendentWindow - нисходящее окно )Descendent window) - любое
дочернее окно некоторого указанного родительского окна. Оно может быть
дочерним на любом уровне ниже родительского и в любой ветви. Эта функция
ищет по всем ветвям родительского окна, чтобы найти любое дочернее окно
(нисходящее окно) с указанным контрольным идентификатором.
FindFirstAttribute - ищет первое вхождение текста с определенными
атрибутами. Она начинает поиск в левом верхнем углу указанного окна и
перемещается вниз. Если поиск оказывается успешным, активный курсор
устанавливается на первый символ, имеющий запрашиваемые атрибуты.
Обычно PC курсор может быть успешно установлен на атрибуты внутри
текстового окна.
FindNextAttribute - ищет следующее вхождение текста с определенными
атрибутами. Поиск начинается там, где находится активный курсор и
продолжается вниз, по оставшейся части окна. Если поиск оказывается
успешным, активный курсор устанавливается на первый символ, имеющий
запрошенные атрибуты.
FindPriorAttribute - ищет предыдущее вхождение текста с указанными
атрибутами. Поиск начинается в точке, где находится активный курсор и
продолжается вверх по оставшейся части активного окна. Если поиск
оказывается успешным, активный курсор устанавливается на первый символ с
запрашиваемыми атрибутами.
FindLastAttribute - ищет последнее вхождение текста с определенными
атрибутами. Поиск начинается в правом нижнем углу окна и ведется вверх
по окну. Если поиск оказывается успешным, курсор помещается на первый
символ, имеющий запрошенные атрибуты.
FindGraphic - FindGraphic ищет графику в указанном кне. Если графика
найдена, на нее устанавливается Jaws курсор. Графика должна иметь
ассоциированный с ней текстовый ярлык, поскольку функция FindGraphic
ищет текстовый ярлык. Текстовые ярлыки присваивает маркировщик графики.
FindString - FindString ищет строку текста в указанном окне. Если текст
найден, JaWS курсор устанавливается в начало текста.
FindTopLevelWindow - ищет самый верхний уровень окна с указанным
классом окна и/или именем окна. Если вам не нужен поиск, основанный на
одном из аргументов, используйте "" для этого аргумента.
GetActiveCursor - определяет, какой курсор является активным.
GetAppFileName - определяет имя файла активного приложения, или активный
компонент этого приложения, который был последовательно выполнен. Эти
имена файлов являются действительными файлами программ, которые
выполняются Windows. Имя файла приложения используется при присвоении
имени файлу скриптов.
GetAppFilePath - используется для получения полного пути и имени файла
текущего активного приложения. При совместном использовании с GetFileDate,
результаты можно использовать для определения версии приложения.
GetAppMainWindow - определяет ручку окна для главного окна активного
приложения.
GetAppTitle - получает заголовок текущего активного приложения. Чтобы
озвучить заголовок приложения, вы должны использовать эту функцию в
качестве параметра для функции Say.
GetBrailleCellColumn - вытаскивает столбец экрана, на котором находится
указанная брайлевская клетка.
GetBrailleCellRow - вытаскивает строку экрана, на которой находится
указанная брайлевская клетка.
GetCell - находясь в таблице, получает содержание текущей ячейки.
GetColumnHeader - находясь в таблице, получает заголовок текущей колонки.
GetRowHeader - находясь в таблице, получает заголовок текущего ряда.
GetCharacter - копирует символ или графический ярлык, где находится
активный курсор. Скопированный текст затем может быть использован
другими функциями скрипта.
GetCharacterAttributes - вытаскивает текстовые атрибуты символа в точке, где
находится активный курсор. Возвращенное значение является комбинацией тех
же битовых полей, которые используются в FindFirstAttribute,
FindNextAttribute и т.д. Чтобы протестировать на наличие конкретного
атрибута, используйте код в следующей форме:
if (GetAttributes() & ATTRIB_UNDERLINE) then ... (более подробное описание
можно найти в разделе, посвященном поразрядным операторам).
GetCharacterFont - вытаскивает название шрифта, использованного для символа
в точке, где находится активный курсор.
GetCharacterPoints - вытаскивает кегль символа в точке, где находится
активный курсор.
GetCharacterWidth - вытаскивает ширину символа или графического элемента
в точке, где находится активный курсор.
GetChunk - получает цепочку информации, на которую указывает активный
курсор. "Chunk" - это текстовая или графическая информация,которая была
нарисована на экране за одну операцию.
GetField, однако функция GetField использует логику, чтобы определить текст,
который нужно получить, тогда как GetChunk просто получает текст, который
был сохранен в модели Off-Screen за одну единицу.
GetField - получает информацию в поле, куда указывает активный курсор.
Полем (field) называется раздел информации, обычно текстовой, который имеет
общие атрибуты, то есть, полужирный, подчеркнутый, Курсив или
Зачеркнутый. Использование атрибута должно быть непрерывным. GetField
подобна GetChunk, однако Getfield использует логику, чтобы определить текст,
который необходимо получить, тогда как GetChunk просто получает
информацию, которая была сохранена в модели Off-Screen в качестве единицы.
GetColorBackground - вытаскивает цвет фона символа в текущей позиции
курсора. Эти цвета обычно указываются в виде 9 цифр, где первые три цифры
указывают долю красного цвета, вторые три - долю зеленого, и три последних
- долю синего цвета.
GetColorText - вытаскивает текстовый цвет символа в текущей позиции
курсора.
GetColorField - получает поле цвета в текущей позиции курсора. Поле цвета
(colour field) это раздел информации, (обычно текст), который имеет общую
комбинацию цветов, то есть, белый символ на синем фоне. Использование
комбинации цветов должно быть непрерывным. Функция GetColorField
аналогична функции GetField, однако GetColorField основана на изменениях
цветов, а GetField основана на изменениях атрибутов.
GetColorName - цветовые числа приравнены к именам цветов в файле Jaws,
который называется Colors.ini. Эта функция вытаскивает текстовое имя для
данного номера цветов, найденного в COLORS.INI.
GetControlAttributes - возвращает целочисленное значение, указывающее
атрибуты текущего органа управления.
GetControlID - определяет контрольный идентификатор для указанного
дочернего окна в окне диалога. Интересующее окно указывается через
передачу в эту функцию ручки окна в качестве параметра. Каждое окно
списка, поле редактирования, радиокнопка и т.д. в диалоге имеют уникальный
контрольный идентификатор. Дочерние окна, содержащие статический текст,
имеют один и тот же контрольный идентификатор.
GetCurrentControlID - определяет контрольный идентификатор текущего
дочернего окна в окне диалога. Каждый список, поле редактирования,
радиокнопка в диалоге имеют уникальный контрольный идентификатор.
Дочерние окна, содержащие статический текст, имеют один и тот же
контрольный идентификатор. Эта функция выполняет ту же задачу6 что и
GetControlID, но она не требует ручки окна в качестве параметра, чтобы
сообщить ей, какое дочернее окно нас интересует.
GetControlName - сообщает имя текущего органа управления.
GetCurrentObject - использует MSAA чтобы получить текущий объект с
фокусом в позиции активного курсора.
GetFocusObject - использует MSAA чтобы получить объект с фокусом.
GetObjectAtPoint - использует MSAA чтобы определить объект в наборе
координат X/Y.
GetCurrentScriptKeyName - вытаскивает название клавиши, которая
используется для вызова текущего активного скрипта.
GetCurrentWindow - определяет ручку окна для окна, содержащего активный
курсор. В противоположность этому, функция GetFocus использует
аналитическую обработку, чтобы найти окно, в данный момент содержащее
фокус, вне зависимости от того, какой курсор является активным.
GetFocus - сообщает ручку окна для окна, содержащего фокус. Она всегда
ищет PC курсор или выделенный цветом объект, который имеет фокус. Какой
курсор является активным, в расчет не принимается. В противоположность
этому, функция GetCurrentWindow является менее сообразительной. Она
просто получает ручку для окна, в котором находится активный курсор.
GetCursorCol - определяет горизонтальную позицию, или столбец, в котором
находится активный курсор. Она возвращает целочисленное значение, которое
может быть озвучено с помощью скриптовой функции SayInteger.
GetCursorRow - определяет вертикальную позицию, или ряд, в котором
находится текущий активный курсор. Функция возвращает целочисленное
значение, которое может быть озвучено с помощью функции SayInteger.
GetCursorShape - возвращает текущую форму курсора мыши.
GetDefaultButtonName - определяет кнопку по умолчанию в окне диалога. Эта
кнопка будет выбрана при нажатии клавиши Enter.
GetDefaultJcfOption - определяет значение для указанной опции в файле
конфигурации Jaws по умолчанию. Это такие опции, как подробность
озвучивания, или эхо клавиатуры, установленные в диспетчере конфигурации.
GetJcfOption - определяет значение указанной опции диспетчера
конфигурации в файле конфигурации Jaws для активного приложения, если
таковой существует.
GetDialogPageName - если активный курсор находится внутри диалога с
несколькими вкладками, вытаскивает имя текущей вкладки.
GetDialogStaticText - сообщает статический текст в окне диалога.
GetFileDate - используется для получения даты последней модификации для
конкретного файла.
GetFirstChild - определяет первое дочернее окно, которое могло быть создано
указанным родительским окном. Эта функция бывает полезной, когда вы
хотите просмотреть набор ручек окна, чтобы найти детей вашего начального
окна.
GetParent - перемещается вверх по стеку окон, найти родителя для указанного
дочернего окна. Таким образом, функция может быть использована для того,
чтобы определить, какое окно создало указанное дочернее окно. Например,
когда появляется диалог, ею можно воспользоваться, чтобы получить ручку
окна для окна, создавшего этот диалог. Ее можно использовать для
перемещения вверх по списку ручек окна, чтобы добраться до конкретного
окна.
GetFirstWindow - предоставляет ручку для первого окна, которое находится на
том же логическом )дочернем) уровне, что и указанная ручка окна.
Используется для того, чтобы добраться до начальной точки того же
логического уровня.
GetNextWindow - аналогична GetFirstWindow, но предоставляет следующую
ручку окна в ряду ручек окна, которые все находятся на одном логическом
уровне. Используется для перемещения по списку ручек окна.
GetPriorWindow - аналогична GetFirstWindow, но сообщает предыдущую ручку
окна в ряду ручек окна на одном и том же логическом уровне. Используется
для перемещения по списку ручек окна.
GetPriorWindow - вытаскивает ручку для текущего окна переднего плана.
Обычно это главное окно текущего приложения, но иногда может быть
ручкой окна диалога. Эта функция гораздо быстрее, чем GetAppMainWindow.
GetFocusRect - сообщает все координаты прямоугольного фокуса.
GetFocusRectBottom - сообщает координаты нижнего края прямоугольного
фокуса.
GetFocusRectLeft -  сообщает координаты левого края прямоугольного фокуса.
GetFocusRectRight - сообщает координаты правого края прямоугольного фокуса.
GetFocusRectTop - сообщает координаты верхнего края прямоугольного фокуса.
GetFromStartOfLine - вытаскивает текст на текущей строке, который
находится слева от активного курсора.
GetToEndOfLine - вытаскивает текст на текущей строке, который находится
справа от текущего курсора.
GetGraphicID - сообщает идентификатор, ассоциированный с графическим
элементом в позиции активного курсора. Если функция не срабатывает,
значит указатель не позиционирован в допустимое место на графическом
элементе. Перемещение в центр графического элемента увеличивает успех
вызова.
GetGroupBoxName - сообщает имя текущей группы.
GetHTMLFrameCount - сообщает количество фреймов HTML, имеющихся на
текущей вебстранице.
GetHotKey - вытаскивает первый подчеркнутый символ в цепочке текста, на
которой позиционирован активный курсор. Это особенно полезно в меню и
окнах диалога, где клавиша-ускоритель для конкретного пункта меню была
определена и изображается на экране в виде подчеркнутой буквы в имени
органа управления.
GetItemRect - сообщает ограничительный прямоугольник, окружающий
указанный элемент или элементы. Элементы могут быть объединены при
помощи поразрядного (|) оператора. Когда объединены два или более элемента,
результирующий прямоугольник включает все элементы.
GetJAWSDirectory - вытаскивает полный путь к директории, в которой
работает Jaws.
GetJAWSHelpDirectory - вытаскивает полный путь к директории помощи Jaws,
которая используется в данный момент. Это зависит от используемого в
данный момент языка.
GetJAWSSettingsDirectory - вытаскивает полный путь к директории с файлами
конфигурации Jaws. Это зависит от используемого в данный момент языка.
GetLineTop - определяет вертикальное положение в пикселях вершины самого
высокого символа на строке, в которой находится активный курсор. Поскольку
позиция курсора, сообщаемая Jaws, основывается на базовой строке символов,
эта функция является единственным способом определить, насколько высоко
простирается строка текста.
GetLinkCount - сообщает количество линков, имеющихся на текущей
вебстранице.
GetJAWSUserName - вытаскивает имя пользователя, в данный момент
работающего в JFW. Если этот пример JFW не осознает сети, функция
возвращает нулевую строку, "".
GetJFWVersion - используется для получения версии работающего в данный
момент JFW. Можно использовать чтобы гарантировать, что функция будет
вызываться на версиях JFW, которые ее поддерживают.
GetLine - копирует текст строки, в которой позиционирован активный курсор.
Скопированный текст затем могут использовать другие скрипты и функции.
GetObject - для некоторых приложений (Internet Explorer и Microsoft Office)
Jaws может получать информацию прямо из этого приложения, а не
полагаться на то, что написано на экране. Чтобы выполнить это, Jaws нужно
место, куда пойти и взять эту информацию, и что-то вроде "дорожной карты",
чтобы сообщить еМУ, где искать. План дороги называется указателем объекта,
а то место, куда он отправляет Jaws, называется автоматический объект для
этого приложения. Есть несколько способов получить такой указатель объекта
для этой цели, но не все эти способы работают со всеми приложениями.
Одним таким способом и является GetObject. GetObject устанавливает
указатель на предсуществующий автоматический объект. Затем Jaws может
запросить этот автоматический объект, чтобы получить информацию, которая
ему нужна. Функция GetObject аналогична функции CreateObject, за
исключением того, что GetObject создает указатель на автоматический объект,
который уже существует, тогда как CreateObject также создает
автоматический объект для приложения.
GetObjectName - вытаскивает имя объекта в позиции активного курсора. Если
активным является PC курсор, возвращается имя объекта с фокусом. В
противном случае возвращается имя объекта в позиции курсора. Значение
возвращается как строка (String).
GetObjectRect - вытаскивает прямоугольный фокус, окружающий объект в
позиции текущего активного курсора. Возвратит True, если объект имеет
прямоугольный фокус, в противном случае - False. Эта функция берет 4
целочисленных параметра, левое, правое, верхнее и нижнее. Объявляйте, но не
инициализируйте целочисленные переменные для этих параметров, поскольку
они передаются при ссылке.
GetObjectState - получает и возвращает состояние данного объекта. Если
активен PC курсор, возвращается состояние объекта с фокусом. В противном
случае возвращается состояние объекта в позиции активного курсора.
GetObjectType - вытаскивает тип объекта, расположенного в позиции
активного курсора. Поскольку тип является строкой, которая различается в
разных языках, эту функцию следует использовать только тогда, когда целью
является озвучить тип объекта. Во всех условных утверждениях должна
использоваться функция GetObjectTypeCode, поскольку она предоставляет
решение, независимое от языка.
GetObjectTypeCode - вытаскивает числовой код типа объекта, находящегося в
текущей позиции курсора. Все константы для этих кодов типа начинаются с
WT_ и определены в HJCONST.JSH. Числовые значения одни и те же для всех
языков Jaws. Использование этой функции во всех условных утверждениях
гарантирует, что это утверждение будет функционировать без изменений во
многих языках.
GetObjectValue - возвращает значение объекта в позиции активного курсора.
Если активен PC курсор, возвращается значение объекта с фокусом. В
противном случае, возвращается значение объекта в позиции активного
курсора. Значение возвращается как строка (String).
GetProgramVersion - функция возвращает основную версию программы.
Например, если полная версия была 3.00.62, GetProgramVersion вернет 3.
GetRealWindow - просматривает список ручек окна в поисках "реального
окна" (Real Window). Реальным называется окно, у которого есть заголовок.
GetRestriction - получает значение ограничения для текущего курсора.
GetRestrictionName - может использоваться для озвучивания текущего уровня
ограничения для активного курсора. Эта функция должна обеспечиваться
параметром, каковым является текущий уровень ограничения. Это значение
можно получить с помощью функции GetRestriction.
GetScreenEcho - получает текущую настройку эха экрана. Настройка эха
экрана определяет количество информации, которое должно будет сообщаться,
по мере появления информации на рабочем столе. Функция NewTextEvent
часто проверяет настройку эха экрана прежде чем решить, сколько
информации озвучивать.
GetScriptDescription - вытаскивает описание указанного скрипта.
GetScriptSynopsis - вытаскивает синопсис указанного скрипта.
GetScriptFileName - вытаскивает имя активного файла скриптов, по умолчанию
или для приложения. Имя файла скриптов для приложения будет тем же, что
и имя исполняемого файла приложения, за исключением тех случаев, где
первоначально загруженный файл скриптов приложения заменяет себя другим
файлом при помощи SwitchToScriptFile. Аналогично, для активного файла
скриптов по умолчанию это будет имя, указанное в JFW.INI, за исключением
тех случаев, когда первоначальный файл заменяет себя при помощи
SwitchToScriptFile.
GetScriptKeyName - вытаскивает имя горячей клавиши, закрепленной за
указанным скриптом. Эта функция главным образом используется для
создания файлов помощи Jaws по горячим клавишам, поскольку они потом
будут сообщать корректную клавишу, даже если горячая клавиша была
изменена.
GetSelectedText - вытаскивает текущий выделенный текст как строку (String).
GetTextBetween - получает текст между двумя горизонтальными точками на
экране в той же строке, где находится активный курсор. Эту функцию можно
использовать для озвучивания или перехвата части строки.
GetTextInFocusRects - вытаскивает содержание всех прямоугольных фокусов в
единый буфер.
GetTextInFrame - вытаскивает текст внутри указанного фрейма.
GetTextInRect - сообщает текст, находящийся внутри указанного
прямоугольника.
GetTopLevelWindow - окном первого уровня является родительское окно
первого, или наивысшего уровня, которое породило дочернее окно, из которого
и был начат поиск. Эта функция находит окно верхнего уровня с указанным
классом окна и/или именем окна. Если вы не хотите осуществлять поиск,
основанный на одном из аргументов, используйте "" для этого аргумента.
GetTreeViewLevel - получает уровень вхождения элемента в дерево, которое
имеет фокус. Корень дерева имеет значение 0.
GetVerbosity - используется для получения текущей настройки подробности.
Она возвращает значение константы, указывающей настройку: Beginner
означает озвучивать максимум информации, "Intermediate" означает озвучивать
умеренное количество информации, и "Advanced" означает озвучивать
минимальное количество информации. Эти значения могут использоваться в
утверждениях If-Then-Else.
GetWindowAtPoint - получает ручку окна в указанной точке. Может
использоваться, например, вместе с MouseMovedEvent чтобы получить ручку
окна, содержащего указатель мыши.
GetWindowClass - получает имя класса окна для окна. Большинство
стандартных окон (но не окна SDM) имеют имя класса окна и название типа
окна. Имена классов окон обычно уникальны для конкретных окон в
конкретных приложениях.
GetWindowBottom - получает координаты экрана для нижней границы
интересующего нас окна.
GetWindowLeft - получает координату экрана для левого края интересующего
нас окна.
GetWindowRight - получает координату экрана для правого края
интересующего нас окна.
GetWindowTop - получает координату экрана для верхней границы
интересующего нас окна.
GetWindowName - получает заголовок указанного окна, например главного
окна приложения, окна диалога или окна документа. Не все окна имеют
заголовки.
GetWindowsOS - предоставляет информацию о том, какая операционная
система используется в настоящий момент.
GetWindowRect - получает ограничивающий прямоугольник окна, ручка
которого указана.
GetWindowsSystemDirectory - возвращает путь к системной директории
Windows как строку (String).
GetWindowText - вытаскивает либо весь текст в указанном окне, либо только
выделенный текст.
GetWindowTextEx - как и в случае с GetWindowText, вытаскивает либо весь
текст в указанном окне, либо только выделенный текст. Однако, она также
может вытаскивать или игнорировать текст в дочерних окнах.
GetWindowType - получает имя типа окна. Большинство стандартных окон (не
окон SDM) имеют имя типа окна и имя класса окна. Примерами типов окна
могут быть: статический текст, поле редактирования, блок проверки,
радиокнопка, и т.д. Одни и те же имена типов обычно используются во
многих различных приложениях Windows.
GetWindowTypeCode - получает номер кода окна для указанного окна. Эти
номера являются одинаковыми для английской и неанглийской версий Jaws.
Многие номера типов окна имеют значения констант, которые назначены им в
файле HJCONST.JSH. Функция GetWindowType возвращает эти константы, а
не номера типов окна.
GetWindowSubtypeCode - получает номер подтипа окна для указанного окна.
Эта функция очень похожа на GetWindowTypeCode, но пытается быть еще
более конкретной. Если более конкретная информация недоступна, то
возвращается то же значение, что и GetWindowTypeCode. Например, вызов
GetWindowTypeCode, используя ручку для панели задач, вернет
WT_TABCONTROL, а вызов GetWindowSubtypeCode вернет WT_TASKBAR
(более конкретный тип элемента управления). (Более подробно см.
документацию к функции GetWindowTypeCode).
GetWord - получает слово, на котором позиционирован активный курсор.
Полученный таким образом текст затем может использоваться другими
функциями.
GraphicsEnumerate - вызывает указанную пользователем функцию для каждого
графического элемента, содержащегося внутри указанного окна, а затем
передает этой функции координаты каждого графического элемента. Функция
вызывается для каждого графического элемента, пока все не будут
пронумерованы, или пока определяемая пользователем функция не сообщит,
что нумерацию продолжать нельзя.
GraphicsListHelper - помогает функции GraphicsList создать разделенный на
строки список маркеров для графических элементов.
HasFocusRect - определяет, имеет ли указанное окно прямоугольный фокус.
Чтобы эта функция работала как положено, к файлу конфигуркци для
конкретного приложения необходимо добавить строку TrackFocusRect=1 в
разделе [OSM].
HasTitleBar - определяет, имеет ли окно панель заголовка. Если окно имеет
панель заголовка, то функция возвращает значение константы True. Если у
окна нет панели заголовка, то возвращается значение константы False. Панели
заголовка обычно имеют окна диалогов и главные окна приложений.
IE4GetCurrentDocument - возвращает объект, который представляет HTML
документ в данном окне браузера. Объект Document может использоваться,
чтобы вытащить информацию о документе, чтобы исследовать и
модифицировать HTML элементы и текст внутри документа, и чтобы
обрабатывать события. Эта функция получает объект Document для документа
в текущем окне.
If - оператор If отмечает начало выражения If-Then-Else. Полностью
сформулированное выражение включает: "If", "Then", "Else" и "EndIf". Функции
скриптов, которые оказываются между операторами If и Then предназначены
для того, чтобы оценить, наличествует ли определенное условие. Например,
можно ли найти в активном окне определенный графический символ? Каждое
выражение должно включать "If", "Then" и "EndIf'. "Else" является опциональным.
InHJDialog - проверяет, является ли активным один из диалогов, генерируемых
JFW. Сюда относятся JAWSFind, GraphicsLabeler, DLGSelectItemInList и
DLGSysTray.
InTable - используется для определения того, находится ли активный курсор в
таблице.
IntToString - преобразует целочисленное значение в строку, и возвращает
значение строки. Это может оказаться полезным, например, если вы хотите
использовать Integer как часть строки Say. Преобразования целого числа в
строку позволяет озвучивать значение как часть выражения Say и избежать
необходимости отдельного выражения SayInteger.
InvisibleCursor - активизирует невидимый курсор и деактивизирует другие
курсоры. Невидимый курсор не перемещает вместе с собой указатель мыши, и
его можно использовать в тех ситуациях, когда перемещения Jaws курсора и
указателя мыши могут привести к тому, что информация в окне изменится.
IsBrailleCursor - проверяет, является ли активным брайлевский курсор. Можно
использовать в выражениях If-Then-Else чтобы проверить активный статус
курсора.
IsInvisibleCursor - используется для проверки того, является ли активным
невидимый курсор. Можно использовать в выражениях If-Then-Else для
проверки статуса невидимого курсора.
IsJawsCursor - используется для проверки того, является ли активным
Jaws курсор. Можно использовать в выражениях If-Then-Else для
проверки статуса Jaws курсора.
IsPcCursor - используется для проверки того, является ли активным
PC курсор. Можно использовать в выражениях If-Then-Else для
проверки статуса PC курсора.
IsVirtualPCCursor - проверяет, является ли активизированным виртуальный PC
курсор и используется ли он для навигации в окне, имеющем фокус. Может
использоваться в выражениях If-Then-Else для проверки статуса виртуального
курсора.
IsJFWInstall - проверяет на тот предмет, работает ли Jaws в режиме
инсталляции (то есть с флагом /Install).
IsKeyWaiting - указывает, имеются ли в буфере другие клавиши, которые надо
обработать.
IsLeftButtonDown - проверяет, не заблокирована ли левая кнопка мыши.
IsRightButtonDown - проверяет, не заблокирована ли правая кнопка мыши.
IsMultiPageDialog - проверяет, не находится ли активный курсор внутри
многостраничного диалога.
IsPointInWindow - сравнивает указанные координаты пикселя с границами
окна, ручка которого указана в hwnd чтобы определить, находится ли он в
границах этого окна.
IsSameScript - определяет, не был ли вызван текущий скрипт два или три раза
подряд без каких-либо вмешивающихся скриптов, которые вызыались, и не
более чем с интервалом в 500 милисекунд между каждым вызовом.
Использование этой функции позволяет сделать так, что скрипт будет
работать по-другому, в зависимости от того, сколько раз он вызывался.
(скрипт вызывается всякий раз, когда нажимается закрепленная за ним
клавиша).
IsSpeechOff - проверяет, не заткнут ли синтезатор.

IsWindowDisabled - проверяет статус текущего окна или органа управления.
Возвращает False, если окно является активным, True если окно отключено.

IsWindowObscured - проверяет, не перекрыто ли окно каким-то другим окном,
и поэтому оно не может быть видимо целиком.

IsWindowVisible - проверяет визуальный статус окна. Эта функция возвращает
True, даже если окно полностью закрыто другими окнами. См. функцию
IsWindowObscured чтобы найти способ узнать, перекрыто ли какое-либо окно.
Возвращает True, если окно является видимым на экране,False если окна на
экране не видно.

JAWSCursor - активизирует Jaws курсор и деактивизирует все другие курсоры.

JAWSEnd - перемещает Jaws курсор, или невидимый курсор, если он активен,
к концу строки. Если активен PC курсор, Jaws посылает END в систему.
Результат контролируется активным приложением.

JAWSHome - перемещает Jaws курсор, если он активен, в начало строки. Если
активен PC курсор, Jaws посылает HOME в систему. Результат
контролируется активным приложением.

JAWSPageDown - перемещает Jaws курсор, если он активен, к нижнему краю
окна, не перемещая влево или вправо. Если активным является PC курсор,
Jaws посылает PGDN в систему. Результат контролируется активным
приложением.

JAWSPageUp - перемещает Jaws курсор, если он активен, к dth[ytve краю
окна, не перемещая влево или вправо. Если активным является PC курсор,
Jaws посылает PGUP в систему. Результат контролируется активным
приложением.

JAWSFind - вызывает диалог Jaws Find а затем ищет на видимом экране
текст или графический элемент, который вы вводите. Для поиска графических
элементов используется их текстовый маркер.

JAWSFindNext - ищет на видимом экране следующее вхождение текста или
графического элемента, последним введенного в диалоге Jaws Find.

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

LeftMouseButton - эта функция выполняет то же действие, что и щелчок
левой кнопки физической мыши. Двойное нажатие генерирует двойной
щелчок. Позиция Jaws курсора соответствует позиции указателя мыши.

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

MenusActive - определяет, является ли в данный момент активным меню.
Возвращает значение константы "Active", чтобы показать, что меню является
активным, и значение "Inactive", чтобы показать, что меню не является
активным. Эти константы можно использовать в выражениях If-Then-Else.

MessageBox - используется для вывода на рабочий стол окна сообщений.
Функцию можно включить в выражения If-Then-Else, так что при наличии
определенных условий появится нужное сообщение.

MinimizeAllApps - сворачивает все окна приложений, так что фокус получает
рабочий стол и визуально он чист. Для восстановления нужного приложения
пользуйтесь панелью задач.

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

MouseLeft - перемещает мышь влево на количество пикселей, стоящих в
скобках после имени функции.

MouseRight - перемещает мышь вправо на количество пикселей, стоящих в
скобках после имени функции.

MouseUp - перемещает мышь вверх на количество пикселей, стоящих в
скобках после имени функции.

MoveTo - перемещает активный курсор в указанные координаты X и Y.

MoveToControl - перемещает активный курсор к конкретному органу
управления в окне. Хотя по преимуществу функция полезна в окнах диалога,
ее можно использовать в любом окне, где дочерние элементы управления
имеют уникальные идентификаторы, которые можно получить с помощью
функции GetControlID. Также может использоваться в SDM окнах, где
идентификаторы получаются при помощи функций SDMGetFirstControl, SDMGetLastControl,
SDMGetFocus и т.д. Если при вызове этой функции включен PC курсор,
автоматически включается Jaws курсор. В противном случае используется
активный курсор.

MoveToFrame - перемещает активный курсор в левый верхний угол
указанного фрейма. Если при вызове этой функции активным является PC
курсор, автоматически активизируется Jaws курсор и он перемещается в
новую позицию, в противном случае активизируется активный курсор.

MoveToGraphic - перемещает Jaws курсор, невидимый курсор или брайлевский
курсор в указанном направлении, чтобы найти графический символ в
активном окне. Графический символ ищется по его текстовому маркеру.

MoveToWindow - перемещает активный курсор в указанное окно. Если окно
содержит текст, курсор позиционируется на первом символе, в противном
случае он позиционируется в центре окна. Если при вызове этой функции
активным является PC курсор, активизируется Jaws курсор и перемещается в
новую позицию.

MSOGetMenuBarObject - Получает объект Menu Bar в приложениях MS Office
97.

NextCharacter - выполняет специальную версию клавишной команды {RIGHT
ARROW} или Следующий символ. Если активен PC курсор, Jaws разрешает
приложению перемещать курсор. Если активны другие курсоры, Jaws пытается
переместить курсоры к следующему символу или графическому символу,
который он находит справа от текущей позиции курсора. Чтобы озвучить
символ в новой позиции, поставьте после функции NextCharacter функцию
SayCharacter.

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

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

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

NextParagraph - перемещает активный курсор в начало следующего абзаца.
Если активен PC курсор, а следующий абзац еще не виден, текст в окне
автоматически прокрутится, чтобы новый абзац попал в поле зрения.

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

NextWord -  Выполняет специальную версию клавишной команды {CONTROL+RIGHT
ARROW} или Следующее слово. Если активен PC курсор, Jaws разрешает
приложению перемещать курсор. Если активны другие курсоры, Jaws пытается
переместить курсоры к следующему слову или графическому элементу,
который он находит справа от текущей позиции курсора. Чтобы озвучить
слово в новой позиции курсора, поместите после функции NextWord ()
функцию SayWord ().

Not - оператор Not придает противоположное значение вопросу, задаваемому
выражением If-Then-Else. В выражении типа If-Then-Else Not ставится сразу
же после If. Он говорит: если какие-либо условия не имеют место, то нужно
выполнить следующее действие7

PassKeyThrough - если вызывается эта функция, Jaws не будет использовать
или обрабатывать следующую клавишу. Она будет непосредственно передана в
приложение, как будто Jaws вообще не загружен. Это очень полезно, если
ваши клавиши конфликтуют.

Pause - Останавливает обработку скрипта, так чтобы другое приложение могло
завершить задачи. Если функция Pause помещается в скрипт, Jaws
приспосабливается к времени, необходимому другим приложениям. После того,
как другому приложению будет дана возможность использовать время
обработки, Jaws продолжит скрипт. Функция Pause выполняется иначе, чем
функция Delay, которая приостанавливает обработку скрипта на указанный
промежуток времени, независимо от того, выполнило приложение обработку,
или нет.

PCCursor - активизирует PC курсор и деактивизирует все другие курсоры.

PlaySound - проигрывает звуковой файл через звуковую систему компьютера.
Требует один параметр, который указывает имя звукового файла. Если полный
путь к файлу не указан, Jaws будет искать путь к файлу.

PriorCharacter - выполняет специальную версию клавишной команды
Предыдущий символ или {LEFT ARROW}. Если активен PC курсор, Jaws
позволяет приложению перемещать курсор. Когда активны другие курсоры,
Jaws пытается переместить курсор к предыдущему символу или графическому
элементу, который он находит слева от текущей позиции курсора. Чтобы
озвучить информацию в новой позиции курсора, поместите после функции
PriorCharacter функцию SayCharacter.

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

PriorLine - выполняет специальную версию клавишной команды Предыдущая
строка или {UP ARROW}. Когда активен PC курсор, Jaws позволяет
приложению перемещать курсор. Если активны другие курсоры, Jaws пытается
переместить курсор на одну строку вверх относительно текущей позиции
курсора. Чтобы озвучить информацию в новой позиции курсора, поместите
после функции PriorLine функцию SayLine.

PriorParagraph - перемещает активный курсор в начало предыдущего абзаца.
Если активен PC курсор, а предыдущий абзац уже не виден, текст в окне
будет автоматически прокручен, чтобы начало предыдущего абзаца попало в
поле зрения.

PriorSentence - перемещает активный курсор в начало предыдущего
предложения. Если активен PC курсор, а начало предыдущего предложения на
экране не видно, текст в окне будет автоматически прокручен, чтобы начало
предыдущего предложения попало в поле зрения.

PriorWord - выполняет специальную версию клавишной команды
{CONTROL+LEFT ARROW} или Предыдущее слово. Если активен PC курсор,
Jaws разрешает приложению перемещать курсор. Если активны другие
курсоры, Jaws пытается переместить курсор к предыдущему слову или
графическому элементу, который он находит слева от курсора. Чтобы
озвучить слово в новой позиции, поставьте после функции PriorWord ()
функцию SayWord ().

ProcessNewText - эта функция используется для принудительного вызова
NewTextEvent. Обычно функция NewTextEvent вызывается только в том
случае, когда на экране пишется новый текст. ProcessNewText может
оказаться полезной, если вам нужно вызвать NewTextEvent перед
FocusChangedEvent.

Refresh - обновляет экран. Информация пишется в Jaws Off screen model и
может использоваться для очистки избыточных данных с экрана.

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

RemoveHook - убирает Hook функцию, поставленную функцией AddHook.
Более подробно см. в разделе, посвященном Hook функциям.

ResetSynth - реинициализирует синтезатор с нужной громкостью, скоростью и высотой тона. Используется, чтобы привести синтезатор в норму, если он рассогласовался с Jaws.

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

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

RGBStringToColor - преобразует строку из 9 цифр, в формате 255255255 в в
значение цвета. Строка из 9 цифр должна быть заключена в кавычки. (В этом
случае, цвет будет белым). Цветовые эквиваленты находятся в файле colors.ini.

RightMouseButton - эта функция выполняет действие, аналогичное щелчку
правой кнопки мыши на физической мыши. Двухкратное нажатие производит
двойной щелчок. Позиция Jaws курсора соответствует позиции указателя
мыши.

RightMouseButtonLock - функция блокирует правую кнопку мыши и позволяет
пользователю выполнять любые функции, которые требует приложение.

RouteBrailleToJAWS - позиционирует брайлевский курсор в позицию Jaws
курсора.

RouteBrailleToPC - позиционирует брайлевский курсор в позицию PC курсора.

RouteInvisibleToJAWS - позиционирует невидимый курсор в позицию Jaws
курсора и активизирует невидимый курсор.

RouteInvisibleToPC - перемещает невидимый курсор в позицию PC курсора и
активизирует невидимый курсор.

RouteJAWSToBraille - перемещает Jaws курсор в ту же позицию, где
находится брайлевский курсор.

RouteJAWSToInvisible - перемещает Jaws курсор в позицию невидимого
курсора и активизирует Jaws курсор.

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

RoutePCToBraille - перемещает PC курсор таким образом, что он находится в
той же позиции, что и брайлевский курсор.

RoutePcToInvisible - перемещает PC курсор таким образом, что он находится в
той же позиции, что и невидимый курсор.

RoutePCToJAWS - пытается переместить PC курсор в позицию Jaws курсора.
Эта функция аналогична одиночному щелчку левой кнопкой мыши, который
сообщает Windows, что нужно переместить курсор вставки в позицию
указателя мыши. Успешное использование этой функции зависит от
операционной системы Windows: часто бывают ситуации, когда Windows не
может переместить PC курсор к указателю мыши.

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

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

SayActiveCursor - называет имя активного курсора и его положение в
пикселях.

SayAll - озвучивает всю читаемую информацию от позиции активного
курсора до нижнего края окна. Если активен PC курсор, Jaws прокручивает
экран, перемещая PC курсор вниз. Если активен Jaws курсор, читается
оставшаяся часть окна, путем перемещения Jaws курсора вниз по строке за
один прием.

SayCharacter - озвучивает символ или графический элемент в позиции
активного курсора. Если активен PC курсор, Jaws ищет видимую каретку или
курсорную рамку. Если активен Jaws курсор, озвучивается символ или
графический элемент в позиции указателя мыши.

SayCharacterPhonetic - использует специальные правила произношения
символов, находящихся в позиции активного курсора. Таким образом, A
произносится как Alpha, B Bravo и т.д. Ассоциации между символами и их
фонетическими эквивалентами задаются в разделе [PhoneticSpell] .JCF файлов.
Пользователь, если это ему необходимо, может заменить слова, которые
используются.

SayChunk - озвучивает цепочку информации, на которую указывает активный
курсор. Цепочкой называется текстовая или графическая информация, которая
была написана на экране за одну операцию. SayChunk аналогична SayField,
однако SayField использует логику, чтобы определить текст, который нужно
озвучить, тогда как SayChunk просто читает текст, который был сохранен в
модели Off Screen как одна единица.

SayColor - сообщает цвет в позиции активного курсора. Использует файл
colors.ini для определения цветов из значений RGB состоящих из 9 цифр. Если
вместо названий цветов вы слышите числа, добавьте эту строку в файл
colors.ini и определите его цвет.

SayControl - используется в окнах диалога для озвучивания содержания
дочернего окна вместе с его приглашением. Читает поля редактирования,
списки, блоки проверки, радиокнопки и т.д.

SayCurrentScriptKeyLabel - озвучивает название клавиши, закрепленной за
текущим скриптом, благодаря и настройке эха клавиатуры и ярлыку, как это
определено в файле default.jcf.

SayCursorPos - озвучивает строку и позицию курсора.

SayField - читает поле текста, на которое указывает активный курсор.
"Текстовым полем" называется раздел или блок текста, имеющий общий
атрибут, то есть полужирный, курсив, подчеркивание или зачеркивание.
Использование атрибута должно быть непрерывным. Функция SayField
использует логику, чтобы определить текст, который надо озвучить, тогда как
функция SayChunk просто читает текст, сохраненный в Jaws модели Off
Screen как одна единица.

SayFocusRect - озвучивает содержание прямоугольника фокуса. Возвращает
True, если был озвучен какой-либо текст, в противном случае False.
Выражение A TrackFocusRect=1 необходимо добавить в раздел [OSM] файла
.JCF для приложения, чтобы эта функция работала как положено.

SayFocusRects - озвучивает содержимое прямоугольных фокусов. Если имеется
только один такой прямоугольник, это будет в точности как SayFocusRect.
Если прямоугольник не один, функция озвучит содержание всех, тогда как
SayFocusRect озвучит только первый. В раздел [OSM] файла конфигурации
.JCF для приложения необходимо добавить выражение TrackFocusRect=1, чтобы
эта функция работала как положено.

SayFont - озвучивает название и размер шрифта в позиции активного курсора.

SayFrame - озвучивает содержание указанного фрейма.

SayFrameAtCursor - будет озвучен весь текст в границах фрейма, который
содержит активный курсор.

SayFromCursor - читает текст от курсора до конца строки, включая текущий
символ.

SayToCursor - читает текст от начала строки до курсора, не включая текущий
символ.

SayInteger - озвучивает числовые, целочисленные данные, часто содержание
целочисленной переменной.

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

SayLine - озвучивает текущую строку. Если активен PC курсор, чтение будет
ограничено текущим объектом или окном. В противном случае чтение будет
включать весь текст приблизительно на той же строке, даже если он выходит
за пределы текущего объекта или окна, если только не включено
ограничение Jaws курсора.

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

SayObjectTypeAndText - озвучивает имя и тип объекта, находящегося в
позиции текущего курсора. Эта функция аналогична функции
SayWindowTypeAndText за исключением того, что она более специфична. Если
конкретное окно содержит несколько объектов, функция озвучит информацию
о том, который находится под курсором, тогда как SayWindowTypeAndText -
о включенном окне. Если окно не содержит нескольких объектов, функции
действуют идентично. Когда используется эта функция, она помечает текст,
который читает, поэтому функции SayNonHighlightedText и SayHighlightedText
не повторяют одну и ту же информацию, когда отрабатывают.

SayParagraph - читает текущий абзац от начала.

SaySentence - читает предложение, в котором содержится символ, на котором
находится активный курсор.

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

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

SayUsingVoice - озвучивает строку текста, используя специфический набор
речевых характеристик, которые называются голосовой контекст.

SayWindow - читает указанное окно. Функция или читает выделенный цветом
текст, или весь текст в окне, в зависимости от параметров, введенных
пользователем.

SayWindowTypeAndText - читает указанный ряд информации из окна. Читает
заголовок окна (если таковой имеется), тип окна, содержимое в окне и
предоставляет соответствующую информацию о текущей опции диалога. Когда
используется эта функция, она помечает текст, который читает, так что
функции SayNonHighlightedText и SayHighlightedText не повторяют одну и ту
же информацию, когда запускаются.

SayWord - читает слово или графический символ в позиции активного
курсора. Если активен PC курсор, Jaws ищет видимую каретку или
курсорную рамку. Если активен Jaws курсор, озвучивается слово или
графический символ в позиции указателя мыши.

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

UnscheduleFunction - используется для отмены вызова функции
ScheduleFunction.

ScreenEcho - переключает эхо экрана между тремя возможными состояниями.
По умолчанию устанавливается значение Highlighted, которое озвучивает
только выделенный текст, когда он появляется на экране. All озвучивает весь
текст, который пишется на экране, а None никакого текста не озвучивает.

ScreenGetHeight - получает высоту экрана в пикселях.

ScreenGetWidth - получает ширину экрана в пикселях.

SDMGetCurrentControl - вытаскивает идентификатор органа управления, на
котором позиционирован активный курсор внутри SDM диалога.

SDMGetFirstControl - получает контрольный идентификатор первой опции
диалога в SDM диалоге. Может предоставить контрольный идентификатор,
который необходим при помощи функции SDMSayControl.

SDMGetLastControl - предоставляет контрольный идентификатор последней
опции в SDM диалоге. Может предоставить контрольный идентификатор,
который необходим, при помощи функции SDMSayControl.

SDMGetFocus - используется для получения контрольного идентификатора
активной опции диалога или органа управления в SDM диалоге. Эта функция
чаще всего используется как параметр для функции
SDMSayWindowTypeAndText чтобы предоставить ей контрольный
идентификатор.

SDMGetNextControl - получает контрольный идентификатор следующей опции
в SDM диалоге. Может предоставить нужный контрольный идентификатор при
помощи функции SDMSayControl.

SDMGetPrevControl - получает контрольный идентификатор предыдущей опции
в SDM диалоге. Может предоставить нужный контрольный идентификатор при
помощи функции SDMSayControl.

SDMSayControl - озвучивает содержание дочернего окна, вместе с его
приглашением в SDM диалоге. Озвучивает поля редактирования, списки, блоки
проверки (checkboxes), радиокнопки и т.д. Эта функция эквивалентна
SayControk, но предназначена исключительно для SDM диалогов. Все дочерние
окна в SDM диалоге имеют одну и ту же ручку, и контрольный
идентификатор используется для разграничения опций в окне диалога.

SDMSayStaticText - читает текст, который называется статическим текстом,
который может быть выведен в SDM диалоге. Не читает текст в полях
редактирования, блоках проверки, или заголовки или приглашения, которые
часто ассоциированы с опциями диалога.

SDMSayWindowTypeAndText - используется с окнами SDM чтобы прочитать
заголовок окна (когда он есть), тип окна, содержимое в окне, и
соответствующая информация относительно текущей опции диалога. Когда
используется эта функция, она помечает текст, который читает, с тем чтобы
функции SayNonHighlightedText и SayHighlightedText не повторяли одну и ту
же информацию, когда запускаются. Эта функция используется только с SDM
окнами, а не со стандартными диалоговыми окнами.

SelectFromStartOfLine - посылает в систему Shift+Home. Результат
контролируется приложением. В WordPad выделяется весь текст от начала
строки до PC курсора (используется по преимуществу Magic).

SelectToEndOfLine - посылает в систему Shift+End. Результат контролируется
приложением. В WordPad выделяется весь текст от PC курсора до конца
строки. (используется по преимуществу Magic).

SelectFromTop - gjcskftn d cbcntve CONTROL+SHIFT+HOME. Результат
контролируется приложением. В WordPad выделяется весь текст от начала
документа до PC курсора. (Используется по преимуществу Magic).

SelectToBottom - посылает в систему CONTROL+SHIFT+END. Результат
контролируется приложением. В WordPad выделяется весь текст от PC
курсора до конца документа. (используется по преимуществу Magic).

SelectNextCharacter - посылает в систему Shift+Стрелка вправо. Результат
контролируется приложением. В WordPad выделяется символ справа от PC
курсора. (Используется по преимуществу Magic).

SelectPriorCharacter - посылает в систему Shift+Стрелка влево. Результат
контролируется приложением. В WordPad выделяется символ слева от PC
курсора. (Используется по преимуществу Magic).

SelectNextLine - посылает в систему Shift+стрелка вниз. Результат
контролируется приложением. В WordPad выделяется строка ниже PC курсора.
(Используется по преимуществу Magic).

SelectPriorLine - посылает в систему Shift+Стрелка вверх. Результат
контролируется приложением. В WordPad выделяется строка над PC курсором.
(используется по преимуществу Magic).

SelectNextScreen - посылает в систему SHIFT+PAGE DOWN. Результат
контролируется приложением. В WordPad выделяется следующий экран текста
(используется по преимуществу Magic).

SelectPriorScreen - посылает в систему SHIFT+PAGE UP. Результат
контролируется приложением. В WordPad выделяется предыдущий экран
текста. (используется по преимуществу Magic).

SelectNextWord - посылает в систему Shift+Control+стрелка вправо. Результат
контролируется приложением. В WordPad выделяется слово справа от PC
курсора (используется по преимуществу Magic).

SelectPriorWord - посылает в систему Shift+Control+стрелка влево. Результат
контролируется приложением. В WordPad выделяется слово слева от PC
курсора (используется по преимуществу Magic).

SetDefaultJcfOption - изменяет значение опции по умолчанию в файле
конфигурации Jaws по умолчанию. Настройки в default.jcf используются до
тех пор, пока не будет загружен .jcf файл для приложения. Если .jcf файл для
приложения недоступен, продолжают использоваться настройки из defaolt.jcf.
Функция SetJcfOption используется для установки значения в .jcf файле для
активного приложения.

SetJcfOption - изменяет значения в файле конфигурации Jaws для активного
приложения. Новый .jcf файл загружается всякий раз, когда используется
другое приложение. Если .jcf файл для приложения недоступен, тогда
используются значения из файла default.jcf. SetDefaultJcfOption используется
для изменения опций в default.jcf.

SetJAWSLanguage - в международных версиях Jaws, изменяет операционную
среду Jaws на указанный язык.

SetFocus - перемещает фокус в указанное окно.

SetGraphicLabel - добавляет графический маркер в указанный графический
файл (.jgf).

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

SetRestrictionToFrame - для любого активного курсора, за исключением PC
курсора, эта функция ограничивает перемещение этого курсора границами
указанного фрейма.

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

SetSynth - переключает JFW на указанный синтезатор.

SetSynthLanguage - для синтезаторов, которые поддерживают несколько
языков, переключает синтезатор на указанный язык.

ShiftTabKey - если виртуальный курсор неактивен, эта функция просто
передает в приложение команду Shift+Tab. Если виртуальный курсор активен,
он перемещается к предыдущей ссылке или органу управления в порядке
табуляции.

TabKey - если виртуальный курсор неактивен, эта функция просто
передает в приложение команду Tab. Если виртуальный курсор активен,
он перемещается к следующей ссылке или органу управления в порядке
табуляции.

ShowHelpByID - открывает WinHelp, используя указанный файл и
идентификатор раздела.

ShowHelpByName - открывает WinHelp, используя указанный файл и
указатель раздела.

ShutDownJAWS - завершает работу приложения Jaws.

SpeechInUse - проверяет, используется ли в данный момент речевой вывод.

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

SpeechOn - восстанавливает работу синтезатора. Действие функции
противоположно функции SpeechOff.

SpellString - произносит строку символов посимвольно. Функция аналогична
функции SayString, однако она озвучивает строку буква за буквой, а не
произносит слова целиком.

SpellWord - посимвольно произносит слово в позиции активного курсора.

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

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

StringLength - используется для определения длины строки.

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

StringUpper - преобразует строку символов со смешанным регистром в
символы верхнего регистра.

StringLeft - извлекает указанное количество самых левых символов из строки.

StringRight - извлекает из строки указанное количество самых правых
символов.

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

StringToInt - преобразует строковые значения в целочисленные и возвращает
целочисленные значения. Это используется на строковых именах, которые
состоят из чисел.

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

StopSpeech - затыкает синтезатор. Аналогично нажатию клавиши Control.

SwitchToScriptFile - убирает текущий активный скрипт и вместо него
загружает новый.

SysGetDate - получает текущую системную дату.

SysGetTime - получает текущее системное время.

SysTrayGetItemCount - получает количество объектов в системном поддоне.

SysTrayGetItemToolTip - используется в ListTaskTrayIcons для получения
подсказки, которая соответствует соответствующему ярлыку в списке ярлыков
в системном поддоне. Эта функция принимает единственный параметр, индекс
ярлыка в поддоне задач, для которого требуется подсказка. Возвращает
строковое значение, которое является текстом запрашиваемой подсказки.

SysTrayMoveToItem - перемещает Jaws курсор к месту, где находится пункт в
системном поддоне.

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

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

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

ToggleRestriction - переключает Jaws между ограниченным и неограниченным
режимами. Эти режимы не влияют на перемещение PC курсора. Когда
используется неограниченный режим, другие курсоры могут свободно
перемещаться в рамках окна активного приложения. Когда используется
ограниченный режим, движение курсоров ограничивается рамками дочернего
окна. Когда функция используется, она возвращает имя константы,
представляющей новую настройку. On = ограниченный режим, Off =
неограниченный режим.

TypeCurrentScriptKey - передает клавишу, закрепленную за текущим скриптом,
прямо в приложение.

TypeString - используется для симуляции набора строки символов. Например,
чтобы послать строку символов в приложение, симулируя строку "test",вы
можете либо ввести строку {t}{e}{s}{t}, или использовать
TypeString ("test").

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

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

                          Приложение D

      Важные встроенные функции, сгруппированные по назначению

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

                              Курсор

Используйте следующие функции для активизации и позиционирования
четырех курсоров, доступных в Jaws: PC, Jaws, невидимый и виртуальный.

GetActiveCursor
SayActiveCursor
GetCursorCol
GetCursorRow
SayCursorPos
CaretVisible
SaveCursor
RestoreCursor
InvisibleCursor
RouteInvisibleToJAWS	
RouteInvisibleToPC
IsInvisibleCursor
JAWSCursor
RouteJAWSToPC
RouteJAWSToInvisible
IsJAWSCursor
ToggleRestriction
SetRestriction
SetRestrictionToFrame
SetRestrictionToRect
GetRestriction
GetRestrictionName
PCCursor
RoutePCToJAWS
IsPCCursor
RouteBrailleToJAWS
RouteBrailleToPC
RouteJAWSToBraille
RoutePCToBraille
IsVirtualPCCursor
TurnOffFormsMode

                         Позиционирование

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

MoveTo
MoveToControl
MoveToGraphic
MoveToWindow
MoveToFrame
JAWSEnd
JAWSHome
JAWSPageDown
JAWSPageUp
PriorCharacter
GetCharacter
GetCharacterPoints
GetCharacterFont
NextCharacter
PriorChunk
GetChunk
NextChunk
PriorLine
GetLine
GetLineTop
NextLine
PriorWord
GetWord
NextWord
GetField
GetCharacterAttributes
GetCharacterWidth
NextParagraph
PriorParagraph
NextSentence
PriorSentence
NextNonLink
GetSelectedText
SelectNextCharacter (Used primarily by MAGic)
SelectPriorCharacter (Used primarily by MAGic)
SelectNextWord (Used primarily by MAGic)
SelectPriorWord (Used primarily by MAGic)
SelectNextLine (Used primarily by MAGic)
SelectPriorLine (Used primarily by MAGic)
SelectToEndOfLine (Used primarily by MAGic)
SelectFromStartOfLine (Used primarily by MAGic)
SelectNextScreen (Used primarily by MAGic)
SelectPriorScreen (Used primarily by MAGic)
SelectToBottom (Used primarily by MAGic)
SelectFromTop (Used primarily by MAGic)
TabKey
ShiftTabKey
BackspaceKey
EnterKey
NextCell
PriorCell
UpCell
DownCell
GetCell
GetColumnHeader
GetRowHeader
InTable

                     Условная обработка и циклы

Используйте следующие функции для условной обработки и циклических
операций.

If-Then
EndIf
Else
ElIf
Not
While
EndWhile

                               Say

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

Say
SayAll
SayInteger
SayCharacter
SayCharacterPhonetic
SayWord
SpellWord
SayChunk
SayControl
SayField
SayLine
SayToCursor
SayFromCursor
SayTextBetween
SayToBottom
SayFont
SayString
SpellString
SayParagraph
SaySentence
SayUsingVoice
SayCell
SayColumnHeader
SayRowHeader

                       Манипуляция строками

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

StringContains
SubString
StringToInt
IntToString
StringLength
StringLower
StringUpper
StringSegment
StringLeft
StringRight
ProcessNewText

                           Приложение

Используйте следующие функции для получения информации о приложении.

GetAppFileName
GetAppTitle
GetAppFilePath
GetTreeViewLevel
GetProgramVersion
GetWindowAtPoint
IsPointInWindow

                              Брайль

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

BrailleInUse
PriorBrailleString
BrailleString
NextBrailleString
BraillePanLeft
BraillePanRight
BrailleLine
SixDotBraille
EightDotBraille
GetBrailleCellColumn
GetBrailleCellRow
GetBrailleMode
SetBrailleMode
GetLastBrailleRoutingKey
BraillePriorLine
BrailleNextLine
BrailleG2StringLength
BrailleRefresh
BrailleString
IsBrailleCursor
BrailleAddFocusItem
BrailleAddFocusLine
BrailleAddFrame
BrailleAddString

                              Мышь

Используйте следующие функции, чтобы перемещать, щелкать и получать
информацию об указателе мыши.

MouseUp
MouseDown
MouseLeft
MouseRight
LeftMouseButton
LeftMouseButtonLock
ShiftLeftMouseClick
AltLeftMouseClick
ControlLeftMouseClick
IsLeftButtonDown
RightMouseButton
IsRightButtonDown
GetCursorShape
DragItemWithMouse

                              Поиск

Используйте следующие функции для поиска специфической информации на
экране.

FindFirstAttribute
FindPriorAttribute
FindNextAttribute
FindLastAttribute
FindGraphic
FindString
JAWSFind
JAWSFindNext
FindColors
FindDescendentWindow
FindTopLevelWindow

                          Окна и объекты

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

GetForegroundWindow
GetCurrentWindow
HasTitleBar
GetRealWindow
GetAppMainWindow
GetFirstWindow
GetPriorWindow
GetNextWindow
GetWindowLeft
GetWindowRight
GetParent
IsWindowDisabled
IsWindowObscured
IsWindowVisible
GetFirstChild
GetWindowClass
GetWindowName
GetWindowsOS
GetWindowSubtypeCode
GetWindowType
GetWindowTypeCode
GetWindowText
GetWindowTextEx
JAWSWindow
MinimizeAllApps
SayWindow
SayWindowTypeAndText
GetFocus
SetFocus
HasFocusRect
SayFocusRect
SayFocusRects
GetFocusRect
GetFocusRectBottom
GetFocusRectLeft
GetFocusRectRight
GetFocusRectTop
GetTextInFocusRects
ActivateMenuBar
DialogActive
GetDialogPageName
GetDialogStaticText
IsMultiPageDialog
GetControlID
GetCurrentControlID
GetDefaultButtonName
MenusActive
GetObject
GetObjectAtPoint
GetObjectType
GetObjectTypeCode
SayObjectTypeAndText
GetCurrentObject
GetFocusObject
GetObjectName
GetObjectValue
GetObjectRect
GetObjectState
GetLineTop
GetWindowBottom
GetWindowTop 
RefreshWindow
ToggleHomeRow
ControlCanBeChecked
ControlIsChecked
GetGroupBoxName
GetControlAttributes
SayObjectActiveItem
IE4GetCurrentDocument
GetHTMLFrameCount
GetLinkCount
MSOGetMenuBarObject
GetItemRect
GetWindowRect

                             Фреймы

Используйте следующие функции для чтения фреймов и манипуляции ими.

GetFrameDescription
GetFrameNameAtCursor
GetFrameSynopsis
SayFrame
SayFrameAtCursor
GetTextInFrame

                             Скрипты

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

GetCurrentScriptKeyName
GetScriptDescription
GetScriptKeyName
GetScriptSynopsis
IsSameScript 
PerformScript
AddHook
RemoveHook
TrapKeys
SwitchToScriptFile
GetScriptFileName

                               SDM

Следующие функции используются для получения только о диалогах SDM.

SDMGetFocus
SDMGetFirstControl
SDMGetPrevControl
SDMGetNextControl
SDMGetLastControl
SDMSayControl
SDMSayWindowTypeAndText
SDMGetCurrentControl

                        Уровень озвучивания

Следующие функции запрашивают настройки подробности и переставляют их.

GetScreenEcho
ScreenEcho
GetVerbosity
VerbosityLevel

                            Параметры

Используйте следующие функции для получения информации о настройках
Jaws и для их изменения.

SetJAWSLanguage
GetJcfOption
SetJcfOption
GetDefaultJcfOption
SetDefaultJcfOption
GetHotKey
GetJAWSDirectory
GetJAWSSettingsDirectory
GetJAWSHelpDirectory
GetJFWVersion
InHJDialog

                          Работа системы

Используйте следующие функции для взаимодействия с системой.

MessageBox
PassKeyThrough
PlaySound
Pause
Delay
Refresh
Run
FileExists
GetFileDate
DLGSelectItemInList
DLGSelectScriptToRun
ScheduleFunction
UnscheduleFunction
ActivateStartMenu
Beep
CopyToClipboard
GraphicsLabeler
SetGraphicLabel
GetGraphicID
GraphicsEnumerate
GraphicsListHelper
ShutDownJAWS
IsJFWInstall
IsKeyWaiting
ScreenGetWidth
ScreenGetHeight
SysTrayGetItemCount
SysTrayGetItemToolTip
SysTrayMoveToItem
DLGSysTray
SysGetDate
SysGetTime
StartJawsTaskList
GetWindowsSystemDirectory
GetJAWSDirectory
GetJAWSHelpDirectory
GetJAWSSettingsDirectory
GetJAWSUserName
GetJFWVersion
ShowHelpByName
ShowHelpByID

                              Цвета

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

GetColorBackground
GetColorText
GetColorName
ColorToRGBString
RGBStringToColor
GetColorField

                      Управление синтезатором

Следующие функции используются для управления работой синтезатора.

ResetSynth
SpeechOn
SpeechOff
IsSpeechOff
StopSpeech
SpeechInUse
SetSynth
SetSynthLanguage

                           Приложение E

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

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

II. Изучение диалогов
A. Скрипты утилит в режиме Home Row и скрипт ScreenSensitiveHelpTechnical
(Ctrl+Insert+F1) могут помочь следующим образом:
1. Определить, является ли каждый элемент управления самостоятельным
окном.
2. Если окна имеют нестандартные классы окон, постараться их
переназначить. Приводит ли это к озвучиванию правильных типов окон, когда
вы переходите к ним? (неизвестные классы окон можно переназначить на
известные, используя диалог Window Class (классы окон), доступ к которому
осуществляется через команду Insert+7 на цифровой клавиатуре или через
команду Insert+F2, после чего нужно нажать букву W и Enter.)
Рекласификация полей редактирования в Internet Explorer таким образом имеет
в результате то, что такие окна читаются как положено.

B. Если приглашения не озвучиваются, попробуйте изменить значение
EditPromptSearch. Это можно изменить в диспетчере конфигурации, доступ к
которому осуществляется через Insert+6 или по команде Insert+F2, после чего
нажимается Enter. Настройка EditPromptSearch находится в разделе Advanced
Options (Продвинутые опции) в пункте меню Set Options (установить
параметры). Более высокий номер означает более агрессивный поиск с
большей вероятностью того, что приглашения будут озвучиваться, но
возможность ошибок также увеличивается. Эта техника использовалась в
просмотре таблиц в MS Access.

C. Если PC курсор не отслеживает нужный объект в нестандартном элементе
управления,
1. Попробуйте установить TrackFocusRect=1 в файле конфигурации .jcf для
конкретного приложения. Это делается путем добавления этой строки к
разделу [OSM] соответствующего .jcf файла. Это должно позволить PC
курсору отслеживать фокус, если фокус является прямоугольником.
(некоторые электронные таблицы, такие как Microsoft Excel, используют
вариант прямоугольного фокуса, который может отслеживаться только
включением блока проверки "Include lines" (Включать строки), который
находится в разделе Advanced Options (Продвинутые настройки) в пункте
меню Set Options (Установить параметры). Если любая из этих настроек
приводит к отслеживанию фокуса, автоматическое озвучивание можно
заскриптировать, добавив вызовы функции SayFocusRect к скриптам,
связанным с клавишами курсора и табуляции.
2. Модифицируйте функцию FocusChangedEvent или SayFocusedWindow чтобы
настроить обработку диалогов, создающих проблемы. В качестве примера
посмотрите функцию FocusChangedEvent в файле EUDORA.JSS.
3. Напишите пользовательскую функцию для каждого диалога, и пусть
FocusChangedEvent вызывает эту функцию, когда будет активным этот диалог.
Для примера посмотрите функцию FocusChangedEvent в файде WINWORD.JSS,
которая была модифицирована для обработки SDM окон и двух версий
Microsoft Word.
4. Когда вы клавишей Tab перемещаетесь между органами управления,
вызывается ли FocusChangedEvent? Если нет, добавьте строку
ForceFocusChange=1 в раздел [OSM] файла конфигурации .JCF для
приложения, и попробуйте еще раз. Функция FocusChangedEvent обычно
вызывается только в том случае, если новый фокус имеет ручку окна,
отличную от той, которая была у предыдущего окна. В некоторых
приложениях, например в некоторых частях MS Access, поле редактирования
может иметь ту же самую ручку, что и предыдущее поле. Активизировав
опцию ForceFocusChange, вы заставляете функцию FocusChangedEvent
запускаться всякий раз, когда новое окно имеет другие координаты пикселей,
нежели старое.
5. Имеют ли органы управления уникальные контрольные идентификаторы?
Если да, пользуйтесь ими, чтобы определить, какой орган управления является
активным. Таким образом, можно использовать выражение If-Then чтобы
проверить значение контрольного идентификатора окна, а затем выполнить
какие-то операции или озвучивать какие-либо сообщения для каждого
уникального контрольного идентификатора.

6. Используйте координаты пикселей, чтобы определить, какой орган
управления является активным. (координаты должны быть относительно окна,
а не относительно экрана). Таким образом, можно использовать выражение
If-Then, чтобы проверить координаты текущей локализации, а затем выполнить
определенные операции или озвучить определенные сообщения для каждого
уникального набора координат.

7. Пишите пользовательский код для каждого проблематичного органа
управления.
A. Если диалог представляет собой одно большое окно, то есть, органы
управления не имеют уникальных контрольных идентификаторов, установив
TrackFocusRect=1, PC курсор может перемещаться, когда вы нажимаете
клавишу Tab, среди органов управления.
B. Напишите скрипт для озвучивания соответствующей информации,
основываясь на локализации пикселей, и закрепите этот скрипт за клавишами
Tab и Shift+Tab.

III. Обнаружение важной информации на экране

A. Создайте фреймы вокруг областей, представляющих интерес. Закрепите их
за горячими клавишами или сделайте так, чтобы они озвучивались
автоматически. (пример того, где это можно сделать, это номера страниц на
строке состояния в Microsoft Word. Можно читать номер текущей страницы
по горячей клавише, задав ей читать фрейм, или создать фрейм так, чтобы он
озвучивал все изменения в номерах страниц автоматически.
B. Проследите иерархию окон, чтобы найти интересующую информацию. То
есть, перемещайтесь вверх и вниз по родительским и дочерним окнам, или по
окнам на одном и том же логическом уровне, чтобы найти орган управления
или текстовое поле, которое вас интересует.
C. Поищите текст или графические элементы на экране. Примером этого
может служить поиск кнопок на панели инструментов в Microsoft Office
чтобы проверить их состояние нажатости или ненажатости. Это не так
надежно, как отслеживание иерархии окон.

     IV. Предоставление расширенного доступа при помощи клавиатуры

A. Напишите скрипт для перемещения в определенные места и пусть там
щелкает мышь. Закрепите эти скрипты за клавишами. Это симулирует доступ
через клавиатуру и увеличивает эффективность.
1. Воспользуйтесь функцией MoveToFrame для позиционирования в важные
точки внутри определяемых пользователем фреймов.
2. Воспользуйтесь функцией MoveTo для позиционирования в важных точках
на экране.
3. Используйте функцию FindGraphic для позиционирования в важных точках,
ассоциированных с элементами графики.
4. Используйте функцию FindString для позиционирования в важных точках,
которые содержат конкретный текст.

                  V. Настройка брайлевского вывода

A. Модифицируйте BrailleBuildLine чтобы объединить необходимую
информацию в разных обстоятельствах, такую как braille build диалог, меню и
другое в скриптах по умолчанию.
B. Модифицируйте BrailleBuildStatus чтобы использовать BrailleSetStatusCells
чтобы предоставлять контекстно зависимую информацию, такую как
информацию об атрибутах.
C. Добавьте информационные сообщения.
1. Сделайте пользовательские версии помощи по горячим клавишам (Insert+H0.
2. Сделайте пользовательскую версию контекстно зависимой подсказки
(Insert+F1).

VI. Наименование скриптов и функций для конкретных приложений

A. Если он имеет аналогичное назначение, что и скрипт или функция в файле
по умолчанию, присвойте ему то же имя и не присваивайте клавишу,
специфичную для конкретного приложения. Закрепление в раскладке
клавиатуры по умолчанию будет его запускать.
B. Используйте раскладку клавиатуры, специфичную для приложения, чтобы
закреплять клавиши за скриптами, которые являются уникальными (и имеют
уникальные имена) для данного приложения. Например, посмотрите
использование F7 для проверки орфографии в Microsoft Word.

C. Если скрипт обрабатывает и обычную, и специфичную ситуации, пусть
вызывается версия по умолчанию из default.jss для всех нормальных ситуаций,
чем дублировать код по умолчанию в файле скриптов по умолчанию. Скрипт
для приложения должен содержать специальный код, необходимый для
специальных ситуаций.
1. Используйте скрипты для создания действий, которые можно закрепить за
клавишами.
2. Используйте функции для создания шаблонных действий, которые нет
необходимости закреплять за клавишами.
C. Используйте поля Synopsis и Description, когда будете создавать скрипты и
функции. Эти поля предоставляют информацию для режима помощи по клавиатуре.