Главная База знаний "Allbest" Программирование, компьютеры и кибернетика Разработка клавиатурного тренажёра

Разработка клавиатурного тренажёра

Разработка учебного приложения, играющего роль клавиатурного тренажёра. Установка различных опций. Использование средств Borland C++Builder 6.0. Объектно-ориентированное проектирование и программирование системы. Тестирование и отладка программы.

Рубрика Программирование, компьютеры и кибернетика
Вид курсовая работа
Язык русский
Дата добавления 23.07.2013
Размер файла 730,4 K

Отправить свою хорошую работу в базу знаний просто. Используйте форму, расположенную ниже

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

Страница:

1

Размещено на http://www.allbest.ru/

Курсовой проект

по дисциплине "Системное программное обеспечение"

"Разработка клавиатурного тренажёра”

Реферат

Пояснительная записка: ____ листа, ___ рисунков, ___ источника, ___ приложения.

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

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

Программа написана с использованием инструментальных средств Borland C++Builder 6.0.

Содержание

  • Введение
  • 1. Объектно-ориентированный анализ
  • 2. Объектно-ориентированное проектирование системы
  • 3. Объектно-ориентированное программирование
  • 4. Тестирование и отладка программы
  • Заключение
  • Список использованных источников
  • Текст программы

Введение

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

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

Разработанное на языке Borland С++ Builder 6.0 по принципам объектно-ориентированного программирования приложение позволяет пользователю освоить клавиатуру персонального компьютера.

клавиатурный тренажер программа тестирование

1. Объектно-ориентированный анализ

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

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

Для ее построения необходимо:

выбрать актера, который будет являться инициатором какого-либо действия;

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

Вариант использования состоит из последовательностей действий актера и системы.

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

Язык UML был разработан в 1997 году Д. Рамбо и Г. Бучем.

Приложение предназначено для широкого использования. Оно разрабатывается на основании задания на курсовое проектирование по дисциплине "Системное программное обеспечение".

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

Основные функции приложения:

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

Установка необходимых опций: режим тренажера, сложность и время выполнения.

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

Приложение должно работать в среде Windоws XP.

Программу требуется разработать на языке Borland C++Builder 6.0.

Приложение должно осуществлять следующие функции:

открытие приложения;

установка необходимых опций

выполнение упражнения

вывод результата в графическом режиме

вывод справочных данных о программе

Программная документация должна включать разделы: объектно-ориентированный анализ объектно-ориентированное проектирование системы, объектно-ориентированное программирование системы, порядок контроля и приемки системы. Кроме того, документация должна включать в себя текст программы, список используемых источников, диаграммы.
На рисунке 1 представлена диаграмма вариантов использования (use case diagram) для разрабатываемого приложения.
Рисунок 1 - Диаграмма вариантов использования
Вариант использования "Просмотр справки":
Пользователь выбирает пункт меню "Справка".
Система выдаёт окно с информацией о программе.
Пользователь закрывает справку.
Вариант использования "Тренинг":
Если пользователь желает задать новые настройки, то выполнить "Задание настроек".
Если пользователя устраивают настройки по умолчанию (Время тренинга - 1 минута, Уровень сложности - Начинающий, Режим букв - Русский), пользователь выбирает пункт меню "Начать тренинг".
До тех пор, пока не истекло время тренинга, система отображает на экране падающий символ, определённый системой случайным образом.
Если выбран уровень сложности "Начинающий", то символ падает с низкой скоростью. Если выбран уровень сложности "Средний", то символ падает со скоростью, в 2 раза большей, чем на уровне сложности "Начинающий". Если выбран уровень сложности "Профессионал", то символ падает со скоростью, в 3 раза большей, чем на уровне сложности "Начинающий".
Система отображает подсказку в виде подсвечивания красным цветом нужной клавиши на клавиатуре внизу экрана.
Пользователь нажимает клавишу на клавиатуре, которая, как он считает, соответствует отображённому системой на экране символу.
Если пользователь нажал верную клавишу, то система отображает на экране следующий символ, определённый системой случайным образом.
Если пользователь нажал неверную клавишу или время для набора символа истекло, то счётчик ошибок по ошибочно набранному символу увеличивает своё значение на единицу.
Пользователь нажимает кнопку "Гистограмма ошибок". Система выдаёт гистограмму распределения частоты ошибок набираемых символов, построенную на основе значений счётчиков ошибок по каждому символу, отображённому на экране системой.
Вариант использования "Задание настроек":
Пользователь вводит время тренинга в окно ввода.
Пользователь выбирает уровень сложности в выпадающем списке (Начинающий, Средний, Профессионал).
Пользователь выбирает переключатель режима букв русского, латинского алфавитов или специальных символов.
Пользователь нажимает кнопку "Сохранить".
Система сохраняет настройки.

2. Объектно-ориентированное проектирование системы

Учитывая функции, которые должна обеспечить система, а также ее специфику, построим диаграммы классов - Class Diagram (см. рисунок 2, 3,4), которые показывают взаимодействие классов в системе "Клавиатурный тренажёр" для каждого из вариантов использования. Все классы, которые должны быть использованы в данной программе, являются стандартными, за исключением класса Letter.

При объектно-ориентированном подходе к проектированию разрабатываемое приложение представляет собой совокупность объектов и способов их взаимодействия. В данной системе должны быть использованы следующие классы:

Класс TForm:

Всего имеется 4 объекта данного класса:

Объект Main - предназначен для выполнения действий выбранных пользователем (установка опций, выполнение приложения, просмотр справки).

На форме Main расположен один объект класса TMainMenu, предназначенный выполнения действий выбранных пользователем.

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

На форме Options расположены следующие объекты: один объект класса TComboBox, один объект класса TEdit, один объект класса TUpDown, один объект класса TRadioGroup, один объект класса TLabel, один объект класса TButton, которые используются пользователем для установок необходимых опций.

Объект Training - предназначен для выполнения упражнения

На форме Training расположены следующие объекты: один объект класса TPanel, один объект класса TButton, 2 объекта класса TTimer, 104 объекта класса TSpeedButton, которые предназначены для обеспечения выполнения приложением определенных действий.

Объект Diagram - предназначен для вывода информации о выполненном упражнении в графическом режиме.

На форме Diagram расположены следующие объекты: один объект класса TChart. Класс Letter:

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

Рисунок 2 - Диаграмма классов для варианта использования "Тренинг"

Рисунок 3 - Диаграмма классов для варианта использования "Просмотр справки"

Рисунок 4 - Диаграмма классов для варианта использования "Задание настроек"

Построим диаграммы последовательности (Interaction Diagram), которые показывают последовательность действий, выполняемых пользователем и системой, в системе "Клавиатурный тренажёр" для каждого из вариантов использования. Ось времени направлена сверху вниз. На диаграмме располагаются объекты классов, созданных в диаграмме классов. Каждый объект имеет линию жизни.

На рисунке 5 изображена диаграмма последовательности для варианта использования "Тренинг".

Рисунок 5 - Диаграмма последовательности для варианта использования "Тренинг"

Сначала передаётся сообщение от объекта Пользователь класса Пользователь к объекту N2 класса TMenuItem - OnClick (). Затем от объекта N2 класса TMenuItem к объекту Training класса TTraining передаётся сообщение Show (). Далее объект Training класса TTraining передаёт сообщение сам себе - FormActivate (). Затем объект Training класса TTraining передаёт сообщение OnTimer () объекту Timer2 класса TTimer. Пока не истекло время тренинга, от объекта Training класса TTraining объекту Timer1 класса TTimer передаётся сообщение OnTimer (), от объекта Timer1 класса TTimer - сообщения AddYLet (), AddEY1EY2 (), DrawLetter (), SetXLet (), SetYLet (), SetEX1EX2 (), SetEY1EY2 (), newbukva (). После этого объект bukva класса Letter завершает свою линию жизни. Далее начинается линия жизни объекта Button1 класса TButton. Затем от объекта Пользователь класса Пользователь к объекту Button1 класса TButton передаётся сообщение Button1Click (). Затем начинается линия жизни объекта Diagram класса TDiagram. Далее объект Button1 класса TButton передаёт сообщение объекту Diagram класса TDiagram - FormActivate (). После этого объект Пользователь класса Пользователь передаёт сообщение FormClose () объекту Diagram класса TDiagram. После этого объект Diagram класса TDiagram завершает свою линию жизни. Затем объект Пользователь класса Пользователь передаёт сообщение FormClose () объекту Training класса TTraining. После этого объект Timer2 класса TTimer, Timer1 класса TTimer, Button1 класса TButton и Training класса TTraining завершают свою линию жизни.

На рисунке 6 изображена диаграмма последовательности для варианта использования "Просмотр справки".

Рисунок 6 - Диаграмма последовательности для варианта использования "Просмотр справки"

Сначала передаётся сообщение от объекта Пользователь класса Пользователь к объекту N3 класса TMenuItem - OnClick (). Далее объект N3 класса TMenuItem передаёт сообщение сам себе - ShowMessage ().

На рисунке 7 изображена диаграмма последовательности для варианта использования "Задание настроек".

Рисунок 7 - Диаграмма последовательности для варианта использования "Задание настроек"

Сначала передаётся сообщение от объекта Пользователь класса Пользователь к объекту N1 класса TMenuItem - OnClick (). Затем от объекта N1 класса TMenuItem к объекту Options класса TOptions передаётся сообщение Show (). Далее объект Options класса TOptions передаёт сообщение сам себе - FormActivate (). Затем объект Options класса TOptions передаёт сообщение Click () объекту RadioGroup1 класса TRadioGroup. После этого объект Options класса TOptions передаёт сообщение OnCloseUp () объекту ComboBox1 класса TComboBox. Далее объект Options класса TOptions передаёт сообщение OnChange () объекту Edit1 класса TEdit. Затем объект Options класса TOptions передаёт сообщение BitBtn1Click () объекту BitBtn1 класса TBitBtn.

Для объекта RadioGroup1 была составлена диаграмма состояний (Statechart Diagram), которая показывает состояние объекта во время работы системы. Она представлена на рисунке 8.

Рисунок 8 - Диаграмма состояний объекта RadioGroup1 системы "Клавиатурный тренажёр"

Объект RadioGroup1 может находиться в трёх состояниях:

1) выбран первый переключатель;

2) выбран второй переключатель;

3) выбран третий переключатель.

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

3. Объектно-ориентированное программирование

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

Модуль UnMain. Текст данного модуля должен содержаться в файле UnMain. cpp, а объявления (переменных, констант, типов, классов, функций) в файле UnMain. h. Модуль должен содержать 3 функции:

__fastcall TMain:: TMain (TComponent* Owner: TForm (Owner) - конструктор формы Main.

void __fastcall TMain:: N3Click (TObject *Sender), void __fastcall TMain:: N1Click (TObject *Sender), void __fastcall TMain:: N2Click (TObject *Sender) - предназначены для передачи управления в соответствующие окна.

Модуль UnOptions. Текст модуля содержится в файле UnOptions. cpp.

Он включает в себя следующие основные функции (события):

TOptions:: TOptions (TComponent* Owner): TForm (Owner) - конструктор формы Options.

__fastcall TOptions:: FormActivate (TObject *Sender) - установка начального значения в текстовое поле

__fastcall TOptions:: BitBtn1Click (TObject *Sender) - установка опций

Модуль unTraining. Текст модуля содержится в файле unTraining. cpp.

Модуль содержит следующие функции:

__fastcall TTraining:: TTraining (TComponent* Owner): TForm (Owner) - конструктор формы Training.

_SetFont () - возврат шрифтов кнопок в изначальное значение

KeyInput (int TType, char InKey) - анализ правильности нажатой пользователем клавиши

ConType (int TType) - прорисовка клавиатуры путем отображения на определенных кнопках определенных символов

KeyLetter (int TType) - выделение на клавиатуре текущей буквы другим цветом

__fastcall TTraining:: Timer1Timer (TObject *Sender) - движение буквы вниз

__fastcall TTraining:: FormActivate (TObject *Sender) - установка начальных значений переменным и объектам

__fastcall TTraining:: FormKeyPress (TObject *Sender, char &Key) - анализ нажатой пользователем клавиши

__fastcall TTraining:: Timer2Timer (TObject *Sender) - отсчет времени выполнения приложения

__fastcall TTraining:: Button1Click (TObject *Sender) - отображение диаграммы ошибок

Модуль unDiagram. Текст модуля содержится в файле unDiagram. cpp.

Модуль содержит следующие функции:

__fastcall TDiagram:: TDiagram (TComponent* Owner): TForm (Owner) - конструктор формы Diagram.

__fastcall TDiagram:: FormActivate (TObject *Sender) - построение диаграммы ошибок.

Текст программы и использующихся в ней классов приведены в приложении А.

4. Тестирование и отладка программы

Объектом испытания является программа Train, находящаяся в папке Клавиатурный тренажёр (листинг программы находится в приложении А).

Испытания проводятся с целью проверки правильности функционирования программы и выявления имеющихся недостатков.

Приложение работает в среде Windоws XP.

Программу разработана на языке Borland C++Builder 6.0.

Для проведения испытания программы Train необходимо войти в Borland C++Builder 6.0 (или более новой версии) и из папки Клавиатурный тренажёр загрузить файл проекта Train. bpr или исполняемый файл Train. ехе и проверить работу всех вариантов использования системы. Разработанное приложение может использоваться на персональном компьютере с операционной системой Windows.

Испытания проводятся по следующему алгоритму:

а) запустить на выполнение файл Train. bpr, находящийся в папке Train и среде программирования Borland C++ Builder 6.0 (см. рисунок Б.1);

б) в появившейся на экран форме необходимо выбрать интересующий пункт, например "Задание настроек" (см. рисунок Б.2);

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

г) при запуске на выполнение файла Train. bpr в появившейся на экран форме необходимо выбрать интересующий пункт, например "Справка" (см. рисунок Б.3) и прочитать её;

д) при запуске на выполнение файла Train. bpr в появившейся на экран форме необходимо выбрать интересующий пункт, например "Начать тренинг" (см. рисунок Б.4);

е) в появившейся на экран форме необходимо нажимать на клавиатуре клавиши с теми же символами, что отображены на падающей букве (см. рисунок Б.4);

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

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

Заключение

В результате проделанной работы было выполнено:

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

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

Реализация программы в среде Borland C++Builder 6.0 под Windows XP.

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

Список использованных источников

1. 1 Архангельский А. Я Программирование в C++Builder 6.0. - М.: ЗАО "Издательство БИНОМ", 2003. - 1152 с.

2. Якобсон А., Буч Г., Рамбо Дж. Унифицированный процесс разработки программного обеспечения. - СПб.: Питер, 2002. - 496 с.

Текст программы

Приложение А

// ---------------------------------------------------------------------------

#include <vcl. h>

#pragma hdrstop

// ---------------------------------------------------------------------------

USEFORM ("UnMain. cpp", Main);

USEFORM ("UnOptions. cpp", Options);

USEFORM ("UnTraining. cpp", Training);

USEFORM ("UnDiagram. cpp", Diagram);

// ---------------------------------------------------------------------------

WINAPI WinMain (HINSTANCE, HINSTANCE, LPSTR, int)

{

try

{

Application->Initialize ();

Application->Title="Клавиатурный тренажёр";

Application->CreateForm (__classid (TMain), &Main);

Application->CreateForm (__classid (TOptions), &Options);

Application->CreateForm (__classid (TTraining), &Training);

Application->CreateForm (__classid (TDiagram), &Diagram);

Application->Run ();

}

catch (Exception &exception)

{

Application->ShowException (&exception);

}

catch (.)

{

try

{

throw Exception ("");

}

catch (Exception &exception)

{

Application->ShowException (&exception);

}

}

return 0;

}

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

#include <vcl. h>

#pragma hdrstop

#include "UnMain. h"

#include "UnOptions. h"

#include "UnTraining. h"

// ---------------------------------------------------------------------------

#pragma package (smart_init)

#pragma resource "*. dfm"

TMain *Main;

int Time = 1, Lang = 0, Lev = 0;

// ---------------------------------------------------------------------------

__fastcall TMain:: TMain (TComponent* Owner)

: TForm (Owner)

{

}

// ---------------------------------------------------------------------------

void __fastcall TMain:: N3Click (TObject *Sender)

{

ShowMessage (" В программе заданы настройки по умолчанию (Время тренинга - 1 минута, Уровень сложности - Начинающий, Режим букв - Русский). Если Вы желаете задать новые настройки, то выберите пункт меню Задание настроек. В открывшемся окне выберите уровень сложности в выпадающем списке (Начинающий, Средний, Профессионал), переключатель режима букв русского, латинского алфавитов или специальных символов, введите время тренинга в окно ввода и нажмите кнопку Сохранить. Выберите пункт меню Начать тренинг. Нажимайте клавишу на клавиатуре, которая, как вы считаете, соответствует отображённому системой на экране символу. Внизу экрана отображается подсказка в виде клавиатуры с подсвеченной нужной клавишей. По истечении времени тренинга Вы можете нажать кнопку Гистограмма ошибок и увидеть гистограмму распределения частоты ошибок набираемых символов. ");

}

// ---------------------------------------------------------------------------

void __fastcall TMain:: N1Click (TObject *Sender)

{

Options->Show ();

}

// ---------------------------------------------------------------------------

void __fastcall TMain:: N2Click (TObject *Sender)

{

Training->Show ();

}

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

#include <vcl. h>

#pragma hdrstop

#include "unOptions. h"

#include "unTraining. h"

// ---------------------------------------------------------------------------

#pragma package (smart_init)

#pragma resource "*. dfm"

TOptions *Options;

// ---------------------------------------------------------------------------

__fastcall TOptions:: TOptions (TComponent* Owner)

: TForm (Owner)

{

}

// ---------------------------------------------------------------------------

void __fastcall TOptions:: RadioGroup1Click (TObject *Sender)

{

BitBtn1->Enabled = true;

}

// ---------------------------------------------------------------------------

void __fastcall TOptions:: FormActivate (TObject *Sender)

{

extern Time;

Edit1->Text = Time;

}

// ---------------------------------------------------------------------------

void __fastcall TOptions:: BitBtn1Click (TObject *Sender)

{

extern int Time,Lang,Lev;

Time = StrToInt (Edit1->Text);

Lang = RadioGroup1->ItemIndex;

Lev = ComboBox1->ItemIndex;

BitBtn1->Enabled = false;

switch (Lev)

{case 0: Training->Timer1->Interval = 100;

break;

case 1: Training->Timer1->Interval = 50;

break;

case 2: Training->Timer1->Interval = 25;

break;

}

Close ();

}

// ---------------------------------------------------------------------------

void __fastcall TOptions:: ComboBox1CloseUp (TObject *Sender)

{

BitBtn1->Enabled = true;

}

// ---------------------------------------------------------------------------

void __fastcall TOptions:: Edit1Change (TObject *Sender)

{

BitBtn1->Enabled = true;

}

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

#include <vcl. h>

#pragma hdrstop

#include "UnTraining. h"

#include "UnDiagram. h"

// ---------------------------------------------------------------------------

#pragma package (smart_init)

#pragma resource "*. dfm"

class Letter

{private:

int XLet;

int YLet;

int EY1;

int EX1;

int EX2;

public:

int EY2;

char letter;

int count;

int alfa;

void setXLet (int X)

{XLet = X;

};

void setYLet (int Y)

{YLet = Y;

};

void AddYLet (int Y)

{YLet += Y;

};

void setEX1EX2 (int X1, int X2)

{EX1 = X1;

EX2 = X2;

};

void setEY1EY2 (int Y1, int Y2)

{EY1 = Y1;

EY2 = Y2;

};

void AddEY1EY2 (int Y1, int Y2)

{EY1 += Y1;

EY2 += Y2;

};

void newbukva (int TType)

{

if (TType == 0)

{

alfa = random (32) +1;

switch (alfa)

{case 1: letter = 'а'; break;

case 2: letter = 'б'; break;

case 3: letter = 'в'; break;

case 4: letter = 'г'; break;

case 5: letter = 'д'; break;

case 6: letter = 'е'; break;

case 7: letter = 'ё'; break;

case 8: letter = 'ж'; break;

case 9: letter = 'з'; break;

case 10: letter = 'и'; break;

case 11: letter = 'й'; break;

case 12: letter = 'к'; break;

case 13: letter = 'л'; break;

case 14: letter = 'м'; break;

case 15: letter = 'н'; break;

case 16: letter = 'о'; break;

case 17: letter = 'п'; break;

case 18: letter = 'р'; break;

case 19: letter = 'с'; break;

case 20: letter = 'т'; break;

case 21: letter = 'у'; break;

case 22: letter = 'ф'; break;

case 23: letter = 'х'; break;

case 24: letter = 'ц'; break;

case 25: letter = 'ч'; break;

case 26: letter = 'ш'; break;

case 27: letter = 'щ'; break;

case 28: letter = 'ъ'; break;

case 29: letter = 'ы'; break;

case 30: letter = 'ь'; break;

case 31: letter = 'э'; break;

case 32: letter = 'ю'; break;

case 33: letter = 'я'; break;

}

}

if (TType == 1)

{

alfa = random (26) +1;

switch (alfa)

{case 1: letter = 'a'; break;

case 2: letter = 'b'; break;

case 3: letter = 'c'; break;

case 4: letter = 'd'; break;

case 5: letter = 'e'; break;

case 6: letter = 'f'; break;

case 7: letter = 'g'; break;

case 8: letter = 'h'; break;

case 9: letter = 'i'; break;

case 10: letter = 'j'; break;

case 11: letter = 'k'; break;

case 12: letter = 'l'; break;

case 13: letter = 'm'; break;

case 14: letter = 'n'; break;

case 15: letter = 'o'; break;

case 16: letter = 'p'; break;

case 17: letter = 'q'; break;

case 18: letter = 'r'; break;

case 19: letter = 's'; break;

case 20: letter = 't'; break;

case 21: letter = 'u'; break;

case 22: letter = 'v'; break;

case 23: letter = 'w'; break;

case 24: letter = 'x'; break;

case 25: letter = 'y'; break;

case 26: letter = 'z'; break;

}

}

if (TType == 2)

{

alfa = random (23) +1;

switch (alfa)

{case 1: letter = '1'; break;

case 2: letter = '2'; break;

case 3: letter = '3'; break;

case 4: letter = '4'; break;

case 5: letter = '5'; break;

case 6: letter = '6'; break;

case 7: letter = '7'; break;

case 8: letter = '8'; break;

case 9: letter = '9'; break;

case 10: letter = '0'; break;

case 11: letter = '-'; break;

case 12: letter = '='; break;

case 13: letter = '\\'; break;

case 14: letter = '`'; break;

case 15: letter = ' ['; break;

case 16: letter = '] '; break;

case 17: letter = '; '; break;

case 18: letter = '"'; break;

case 19: letter = ','; break;

case 20: letter = '. '; break;

case 21: letter = '/'; break;

case 22: letter = '*'; break;

case 23: letter = '+'; break;

}

}

count += 1;

};

void DrawLetter ()

{Training->Canvas->Brush->Color = clRed;

Training->Canvas->Ellipse (EX1,EY1,EX2,EY2);

Training->Canvas->TextOutA (XLet,YLet,letter);

};

};

Letter bukva; // Объект - экземпляр класса Letter

TTraining *Training;

// ---------------------------------------------------------------------------

__fastcall TTraining:: TTraining (TComponent* Owner)

: TForm (Owner)

{

}

// ---------------------------------------------------------------------------

TTime present;

char input;

int i,count;

int QMistakes [33] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};

char Mistakes [33] = {'а','б','в','г','д','е','ё','ж','з','и','й','к','л','м','н','о','п','р','с','т','у','ф','х','ц','ч','ш','щ','ь','ы','ъ','э','ю','я'};

void _SetFont ()

{ Training->SpeedButton2->Font->Color = clBlack;

Training->SpeedButton13->Font->Color = clBlack;

Training->SpeedButton14->Font->Color = clBlack;

Training->SpeedButton15->Font->Color = clBlack;

Training->SpeedButton16->Font->Color = clBlack;

Training->SpeedButton17->Font->Color = clBlack;

Training->SpeedButton18->Font->Color = clBlack;

Training->SpeedButton19->Font->Color = clBlack;

Training->SpeedButton20->Font->Color = clBlack;

Training->SpeedButton21->Font->Color = clBlack;

Training->SpeedButton22->Font->Color = clBlack;

Training->SpeedButton23->Font->Color = clBlack;

Training->SpeedButton24->Font->Color = clBlack;

Training->SpeedButton25->Font->Color = clBlack;

Training->SpeedButton26->Font->Color = clBlack;

Training->SpeedButton27->Font->Color = clBlack;

Training->SpeedButton28->Font->Color = clBlack;

Training->SpeedButton29->Font->Color = clBlack;

Training->SpeedButton30->Font->Color = clBlack;

Training->SpeedButton31->Font->Color = clBlack;

Training->SpeedButton32->Font->Color = clBlack;

Training->SpeedButton33->Font->Color = clBlack;

Training->SpeedButton34->Font->Color = clBlack;

Training->SpeedButton35->Font->Color = clBlack;

Training->SpeedButton36->Font->Color = clBlack;

Training->SpeedButton37->Font->Color = clBlack;

Training->SpeedButton38->Font->Color = clBlack;

Training->SpeedButton39->Font->Color = clBlack;

Training->SpeedButton40->Font->Color = clBlack;

Training->SpeedButton41->Font->Color = clBlack;

Training->SpeedButton42->Font->Color = clBlack;

Training->SpeedButton43->Font->Color = clBlack;

Training->SpeedButton44->Font->Color = clBlack;

Training->SpeedButton45->Font->Color = clBlack;

Training->SpeedButton46->Font->Color = clBlack;

Training->SpeedButton47->Font->Color = clBlack;

Training->SpeedButton48->Font->Color = clBlack;

Training->SpeedButton49->Font->Color = clBlack;

Training->SpeedButton50->Font->Color = clBlack;

Training->SpeedButton51->Font->Color = clBlack;

Training->SpeedButton52->Font->Color = clBlack;

Training->SpeedButton53->Font->Color = clBlack;

Training->SpeedButton54->Font->Color = clBlack;

Training->SpeedButton55->Font->Color = clBlack;

Training->SpeedButton56->Font->Color = clBlack;

Training->SpeedButton57->Font->Color = clBlack;

Training->SpeedButton58->Font->Color = clBlack;

Training->SpeedButton59->Font->Color = clBlack;

Training->SpeedButton60->Font->Color = clBlack;

Training->SpeedButton98->Font->Color = clBlack;

Training->SpeedButton93->Font->Color = clBlack;

Training->SpeedButton22->Font->Color = clBlack;

Training->SpeedButton21->Font->Color = clBlack;

Training->SpeedButton20->Font->Color = clBlack;

Training->SpeedButton34->Font->Color = clBlack;

Training->SpeedButton33->Font->Color = clBlack;

Training->SpeedButton2->Font->Size = 12;

Training->SpeedButton13->Font->Size = 12;

Training->SpeedButton14->Font->Size = 12;

Training->SpeedButton15->Font->Size = 12;

Training->SpeedButton16->Font->Size = 12;

Training->SpeedButton17->Font->Size = 12;

Training->SpeedButton18->Font->Size = 12;

Training->SpeedButton19->Font->Size = 12;

Training->SpeedButton20->Font->Size = 12;

Training->SpeedButton21->Font->Size = 12;

Training->SpeedButton22->Font->Size = 12;

Training->SpeedButton23->Font->Size = 12;

Training->SpeedButton24->Font->Size = 12;

Training->SpeedButton25->Font->Size = 12;

Training->SpeedButton26->Font->Size = 12;

Training->SpeedButton27->Font->Size = 12;

Training->SpeedButton28->Font->Size = 12;

Training->SpeedButton29->Font->Size = 12;

Training->SpeedButton30->Font->Size = 12;

Training->SpeedButton31->Font->Size = 12;

Training->SpeedButton32->Font->Size = 12;

Training->SpeedButton33->Font->Size = 12;

Training->SpeedButton34->Font->Size = 12;

Training->SpeedButton35->Font->Size = 12;

Training->SpeedButton36->Font->Size = 12;

Training->SpeedButton37->Font->Size = 12;

Training->SpeedButton38->Font->Size = 12;

Training->SpeedButton39->Font->Size = 12;

Training->SpeedButton40->Font->Size = 12;

Training->SpeedButton41->Font->Size = 12;

Training->SpeedButton42->Font->Size = 12;

Training->SpeedButton43->Font->Size = 12;

Training->SpeedButton44->Font->Size = 12;

Training->SpeedButton45->Font->Size = 12;

Training->SpeedButton46->Font->Size = 12;

Training->SpeedButton47->Font->Size = 12;

Training->SpeedButton48->Font->Size = 12;

Training->SpeedButton49->Font->Size = 12;

Training->SpeedButton50->Font->Size = 12;

Training->SpeedButton51->Font->Size = 12;

Training->SpeedButton52->Font->Size = 12;

Training->SpeedButton53->Font->Size = 12;

Training->SpeedButton54->Font->Size = 12;

Training->SpeedButton55->Font->Size = 12;

Training->SpeedButton56->Font->Size = 12;

Training->SpeedButton57->Font->Size = 12;

Training->SpeedButton58->Font->Size = 12;

Training->SpeedButton59->Font->Size = 12;

Training->SpeedButton60->Font->Size = 12;

Training->SpeedButton33->Font->Size = 12;

Training->SpeedButton34->Font->Size = 12;

Training->SpeedButton20->Font->Size = 12;

Training->SpeedButton21->Font->Size = 12;

Training->SpeedButton22->Font->Size = 12;

Training->SpeedButton98->Font->Size = 12;

Training->SpeedButton92->Font->Size = 12;

Training->SpeedButton93->Font->Size = 12;

Training->SpeedButton94->Font->Size = 12;

Training->SpeedButton98->Font->Size = 12;

Training->SpeedButton104->Font->Size = 12;

}

bool KeyInput (int TType, char InKey)

{

if (TType == 0)

switch (InKey)

{case - 23: input = 'й'; break;

case - 10: input = 'ц'; break;

case - 13: input = 'у'; break;

case - 22: input = 'к'; break;

case - 27: input = 'е'; break;

case - 19: input = 'н'; break;

case - 29: input = 'г'; break;

case - 8: input = 'ш'; break;

case - 7: input = 'щ'; break;

case - 25: input = 'з'; break;

case - 11: input = 'х'; break;

case - 6: input = 'ъ'; break;

case - 12: input = 'ф'; break;

case - 5: input = 'ы'; break;

case - 30: input = 'в'; break;

case - 32: input = 'а'; break;

case - 17: input = 'п'; break;

case - 16: input = 'р'; break;

case - 18: input = 'о'; break;

case - 21: input = 'л'; break;

case - 28: input = 'д'; break;

case - 26: input = 'ж'; break;

case - 3: input = 'э'; break;

case - 1: input = 'я'; break;

case - 9: input = 'ч'; break;

case - 15: input = 'с'; break;

case - 20: input = 'м'; break;

case - 24: input = 'и'; break;

case - 14: input = 'т'; break;

case - 4: input = 'ь'; break;

case - 31: input = 'б'; break;

case - 2: input = 'ю'; break;

case - 72: input = 'ё'; break;

}

if (TType == 2)

switch (InKey)

{case 44: input = ','; break;

case 46: input = '. '; break;

case 47: input = '/'; break;

case 42: input = '*'; break;

case 43: input = '+'; break;

case 59: input = '; '; break;

case 39: input = '"'; break;

case 96: input = '`'; break;

case 49: input = '1'; break;

case 50: input = '2'; break;

case 51: input = '3'; break;

case 52: input = '4'; break;

case 53: input = '5'; break;

case 54: input = '6'; break;

case 55: input = '7'; break;

case 56: input = '8'; break;

case 57: input = '9'; break;

case 48: input = '0'; break;

case 91: input = ' ['; break;

case 93: input = '] '; break;

case 45: input = '-'; break;

case 61: input = '='; break;

case 92: input = '\\'; break;

}

if (TType == 1)

switch (InKey)

{case 97: input = 'a'; break;

case 98: input = 'b'; break;

case 99: input = 'c'; break;

case 100: input = 'd'; break;

case 101: input = 'e'; break;

case 102: input = 'f'; break;

case 103: input = 'g'; break;

case 104: input = 'h'; break;

case 105: input = 'i'; break;

case 106: input = 'j'; break;

case 107: input = 'k'; break;

case 108: input = 'l'; break;

case 109: input = 'm'; break;

case 110: input = 'n'; break;

case 111: input = 'o'; break;

case 112: input = 'p'; break;

case 113: input = 'q'; break;

case 114: input = 'r'; break;

case 115: input = 's'; break;

case 116: input = 't'; break;

case 117: input = 'u'; break;

case 118: input = 'v'; break;

case 119: input = 'w'; break;

case 120: input = 'x'; break;

case 121: input = 'y'; break;

case 122: input = 'z'; break;

}

if (bukva. letter! = input)

{for (i=0; i<33; i++)

if (bukva. letter == Mistakes [i])

{QMistakes [i] =QMistakes [i] +1;

break;

}

return false;

}

if (bukva. letter == input)

{bukva. setXLet (313);

bukva. setYLet (5);

bukva. setEX1EX2 (305,330);

bukva. setEY1EY2 (0,25);

_SetFont ();

return true;

}

};

void ConType (int TType)

{

extern int Lang;

if (TType == 0)

{ Training->SpeedButton2->Caption ="ё";

Training->SpeedButton13->Caption ="я";

Training->SpeedButton14->Caption ="ч";

Training->SpeedButton15->Caption ="с";

Training->SpeedButton16->Caption ="м";

Training->SpeedButton17->Caption ="и";

Training->SpeedButton18->Caption ="т";

Training->SpeedButton19->Caption ="ь";

Training->SpeedButton20->Caption ="б";

Training->SpeedButton21->Caption ="ю";

Training->SpeedButton22->Caption =". ";

Training->SpeedButton24->Caption ="ф";

Training->SpeedButton25->Caption ="ы";

Training->SpeedButton26->Caption ="в";

Training->SpeedButton27->Caption ="а";

Training->SpeedButton28->Caption ="п";

Training->SpeedButton29->Caption ="р";

Training->SpeedButton30->Caption ="о";

Training->SpeedButton31->Caption ="л";

Training->SpeedButton32->Caption ="д";

Training->SpeedButton33->Caption ="ж";

Training->SpeedButton34->Caption ="э";

Training->SpeedButton36->Caption ="й";

Training->SpeedButton37->Caption ="ц";

Training->SpeedButton38->Caption ="у";

Training->SpeedButton39->Caption ="к";

Training->SpeedButton40->Caption ="е";

Training->SpeedButton41->Caption ="н";

Training->SpeedButton42->Caption ="г";

Training->SpeedButton43->Caption ="ш";

Training->SpeedButton44->Caption ="щ";

Training->SpeedButton45->Caption ="з";

Training->SpeedButton46->Caption ="х";

Training->SpeedButton47->Caption ="ъ";

};

if (TType == 1)

{ Training->SpeedButton13->Caption ="z";

Training->SpeedButton14->Caption ="x";

Training->SpeedButton15->Caption ="c";

Training->SpeedButton16->Caption ="v";

Training->SpeedButton17->Caption ="b";

Training->SpeedButton18->Caption ="n";

Training->SpeedButton19->Caption ="m";

Training->SpeedButton20->Caption =",";

Training->SpeedButton21->Caption =". ";

Training->SpeedButton22->Caption ="/";

Training->SpeedButton24->Caption ="a";

Training->SpeedButton25->Caption ="s";

Training->SpeedButton26->Caption ="d";

Training->SpeedButton27->Caption ="f";

Training->SpeedButton28->Caption ="g";

Training->SpeedButton29->Caption ="h";

Training->SpeedButton30->Caption ="j";

Training->SpeedButton31->Caption ="k";

Training->SpeedButton32->Caption ="l";

Training->SpeedButton33->Caption ="; ";

Training->SpeedButton34->Caption ="'";

Training->SpeedButton36->Caption ="q";

Training->SpeedButton37->Caption ="w";

Training->SpeedButton38->Caption ="e";

Training->SpeedButton39->Caption ="r";

Training->SpeedButton40->Caption ="t";

Training->SpeedButton41->Caption ="y";

Training->SpeedButton42->Caption ="u";

Training->SpeedButton43->Caption ="i";

Training->SpeedButton44->Caption ="o";

Training->SpeedButton45->Caption ="p";

Training->SpeedButton46->Caption =" [";

Training->SpeedButton47->Caption ="] ";

Mistakes [0] = 'a'; Mistakes [1] = 'b'; Mistakes [2] = 'c'; Mistakes [3] = 'd'; Mistakes [4] = 'e'; Mistakes [5] = 'f';

Mistakes [6] = 'g'; Mistakes [7] = 'h'; Mistakes [8] = 'i'; Mistakes [9] = 'j'; Mistakes [10] = 'k';

Mistakes [11] = 'l'; Mistakes [12] = 'm'; Mistakes [13] = 'n'; Mistakes [14] = 'o'; Mistakes [15] = 'p';

Mistakes [16] = 'q'; Mistakes [17] = 'r'; Mistakes [18] = 's'; Mistakes [19] = 't'; Mistakes [20] = 'u';

Mistakes [21] = 'v'; Mistakes [22] = 'w'; Mistakes [23] = 'x'; Mistakes [24] = 'y'; Mistakes [25] = 'z';

}

if (TType == 2)

{ Training->SpeedButton2->Caption ="`";

Training->SpeedButton20->Caption =",";

Training->SpeedButton21->Caption =". ";

Training->SpeedButton22->Caption ="/";

Training->SpeedButton58->Caption ="-";

Training->SpeedButton59->Caption ="=";

Training->SpeedButton60->Caption ="\\";

Training->SpeedButton93->Caption ="*";

Training->SpeedButton98->Caption ="+";

Training->SpeedButton104->Caption =". ";

Training->SpeedButton46->Caption =" [";

Training->SpeedButton47->Caption ="] ";

Training->SpeedButton33->Caption ="; ";

Training->SpeedButton34->Caption ="\"";

Mistakes [0] = '`'; Mistakes [1] = '1'; Mistakes [2] = '2'; Mistakes [3] = '3'; Mistakes [4] = '4'; Mistakes [5] = '5';

Mistakes [6] = '6'; Mistakes [7] = '7'; Mistakes [8] = '8'; Mistakes [9] = '9'; Mistakes [10] = '0';

Mistakes [11] = '-'; Mistakes [12] = '='; Mistakes [13] = '\\'; Mistakes [14] = ' ['; Mistakes [15] = '] ';

Mistakes [16] = '; '; Mistakes [17] = '"'; Mistakes [18] = ','; Mistakes [19] = '. '; Mistakes [20] = '/';

Mistakes [21] = '*'; Mistakes [22] = '*'; Mistakes [23] = '+';

}

};

void KeyLetter (int TType)

{

if (TType == 0)

{

switch (bukva. alfa)

{ case 1: // а

Training->SpeedButton27->Font->Color = clRed;

Training->SpeedButton27->Font->Size = 14;

Training->SpeedButton27->Font->Style << fsBold;

break;

case 2: // б

Training->SpeedButton20->Font->Color = clRed;

Training->SpeedButton20->Font->Size = 14;

Training->SpeedButton20->Font->Style << fsBold;

break;

case 3: // в

Training->SpeedButton26->Font->Color = clRed;

Training->SpeedButton26->Font->Size = 14;

Training->SpeedButton26->Font->Style << fsBold;

break;

case 4: // г

Training->SpeedButton42->Font->Color = clRed;

Training->SpeedButton42->Font->Size = 14;

Training->SpeedButton42->Font->Style << fsBold;

break;

case 5: // д

Training->SpeedButton32->Font->Color = clRed;

Training->SpeedButton32->Font->Size = 14;

Training->SpeedButton32->Font->Style << fsBold;

break;

case 6: // е

Training->SpeedButton40->Font->Color = clRed;

Training->SpeedButton40->Font->Size = 14;

Training->SpeedButton40->Font->Style << fsBold;

break;

case 7: // ё

Training->SpeedButton2->Font->Color = clRed;

Training->SpeedButton2->Font->Size = 14;

Training->SpeedButton2->Font->Style << fsBold;

break;

case 8: // ж

Training->SpeedButton33->Font->Color = clRed;

Training->SpeedButton33->Font->Size = 14;

Training->SpeedButton33->Font->Style << fsBold;

break;

case 9: // з

Training->SpeedButton45->Font->Color = clRed;

Training->SpeedButton45->Font->Size = 14;

Training->SpeedButton45->Font->Style << fsBold;

break;

case 10: // и

Training->SpeedButton17->Font->Color = clRed;

Training->SpeedButton17->Font->Size = 14;

Training->SpeedButton17->Font->Style << fsBold;

break;

case 11: // й

Training->SpeedButton36->Font->Color = clRed;

Training->SpeedButton36->Font->Size = 14;

Training->SpeedButton36->Font->Style << fsBold;

break;

case 12: // к

Training->SpeedButton39->Font->Color = clRed;

Training->SpeedButton39->Font->Size = 14;

Training->SpeedButton39->Font->Style << fsBold;

break;

case 13: // л

Training->SpeedButton31->Font->Color = clRed;

Training->SpeedButton31->Font->Size = 14;

Training->SpeedButton31->Font->Style << fsBold;

break;

case 14: // м

Training->SpeedButton16->Font->Color = clRed;

Training->SpeedButton16->Font->Size = 14;

Training->SpeedButton16->Font->Style << fsBold;

break;

case 15: // н

Training->SpeedButton41->Font->Color = clRed;

Training->SpeedButton41->Font->Size = 14;

Training->SpeedButton41->Font->Style << fsBold;

break;

case 16: // о

Training->SpeedButton30->Font->Color = clRed;

Training->SpeedButton30->Font->Size = 14;

Training->SpeedButton30->Font->Style << fsBold;

break;

case 17: // п

Training->SpeedButton28->Font->Color = clRed;

Training->SpeedButton28->Font->Size = 14;

Training->SpeedButton28->Font->Style << fsBold;

break;

case 18: // р

Training->SpeedButton29->Font->Color = clRed;

Training->SpeedButton29->Font->Size = 14;

Training->SpeedButton29->Font->Style << fsBold;

break;

case 19: // с

Training->SpeedButton15->Font->Color = clRed;

Training->SpeedButton15->Font->Size = 14;

Training->SpeedButton15->Font->Style << fsBold;

break;

case 20: // т

Training->SpeedButton18->Font->Color = clRed;

Training->SpeedButton18->Font->Size = 14;

Training->SpeedButton18->Font->Style << fsBold;

break;

case 21: // у

Training->SpeedButton38->Font->Color = clRed;

Training->SpeedButton38->Font->Size = 14;

Training->SpeedButton38->Font->Style << fsBold;

break;

case 22: // ф

Training->SpeedButton24->Font->Color = clRed;

Training->SpeedButton24->Font->Size = 14;

Training->SpeedButton24->Font->Style << fsBold;

break;

case 23: // х

Training->SpeedButton46->Font->Color = clRed;

Training->SpeedButton46->Font->Size = 14;

Training->SpeedButton46->Font->Style << fsBold;

break;

case 24: // ц

Training->SpeedButton37->Font->Color = clRed;

Training->SpeedButton37->Font->Size = 14;

Training->SpeedButton37->Font->Style << fsBold;

break;

case 25: // ч

Training->SpeedButton14->Font->Color = clRed;

Training->SpeedButton14->Font->Size = 14;

Training->SpeedButton14->Font->Style << fsBold;

break;

case 26: // ш

Training->SpeedButton43->Font->Color = clRed;

Training->SpeedButton43->Font->Size = 14;

Training->SpeedButton43->Font->Style << fsBold;

break;

case 27: // щ

Training->SpeedButton44->Font->Color = clRed;

Training->SpeedButton44->Font->Size = 14;

Training->SpeedButton44->Font->Style << fsBold;

break;

case 28: // ъ

Training->SpeedButton47->Font->Color = clRed;

Training->SpeedButton47->Font->Size = 14;

Training->SpeedButton47->Font->Style << fsBold;

break;

case 29: // ы

Training->SpeedButton25->Font->Color = clRed;

Training->SpeedButton25->Font->Size = 14;

Training->SpeedButton25->Font->Style << fsBold;

break;

case 30: // ь

Training->SpeedButton19->Font->Color = clRed;

Training->SpeedButton19->Font->Size = 14;

Training->SpeedButton19->Font->Style << fsBold;

break;

case 31: // э

Training->SpeedButton34->Font->Color = clRed;

Training->SpeedButton34->Font->Size = 14;

Training->SpeedButton34->Font->Style << fsBold;

break;

case 32: // ю

Training->SpeedButton21->Font->Color = clRed;

Training->SpeedButton21->Font->Size = 14;

Training->SpeedButton21->Font->Style << fsBold;

break;

case 33: // я

Training->SpeedButton13->Font->Color = clRed;

Training->SpeedButton13->Font->Size = 14;

Training->SpeedButton13->Font->Style << fsBold;

break;

}

}

if (TType == 1)

{

switch (bukva. alfa)

{ case 1: // a

Training->SpeedButton24->Font->Color = clRed;

Training->SpeedButton24->Font->Size = 14;

Training->SpeedButton24->Font->Style << fsBold;

break;

case 2: // b

Training->SpeedButton17->Font->Color = clRed;

Training->SpeedButton17->Font->Size = 14;

Training->SpeedButton17->Font->Style << fsBold;

break;

case 3: // c

Training->SpeedButton15->Font->Color = clRed;

Training->SpeedButton15->Font->Size = 14;

Training->SpeedButton15->Font->Style << fsBold;

break;

case 4: // d

Training->SpeedButton26->Font->Color = clRed;

Training->SpeedButton26->Font->Size = 14;

Training->SpeedButton26->Font->Style << fsBold;

break;

case 5: // e

Training->SpeedButton38->Font->Color = clRed;

Training->SpeedButton38->Font->Size = 14;

Training->SpeedButton38->Font->Style << fsBold;

break;

case 6: // f

Training->SpeedButton27->Font->Color = clRed;

Training->SpeedButton27->Font->Size = 14;

Training->SpeedButton27->Font->Style << fsBold;

break;

case 7: // g

Training->SpeedButton28->Font->Color = clRed;

Training->SpeedButton28->Font->Size = 14;

Training->SpeedButton28->Font->Style << fsBold;

break;

case 8: // h

Training->SpeedButton29->Font->Color = clRed;

Training->SpeedButton29->Font->Size = 14;

Training->SpeedButton29->Font->Style << fsBold;

break;

case 9: // i

Training->SpeedButton43->Font->Color = clRed;

Страница:


Подобные документы

  • Разработка приложения, представляющего собой компьютерную игру "Змейка"

    Введение в объектно-ориентированное программирование. Постановка задачи. Описание алгоритма решения в псевдокоде (команды в виде текста на русском языке). Исходный текст программы на С. Тестирование программы. Модификация программы. Полиморфизм.

    курсовая работа [294,0 K], добавлен 08.09.2008

  • Объектно-ориентированное программирование

    Разработка программы с использованием принципов объектно-ориентированного программирования на языке высокого уровня С средствами Microsoft Visual Studio 2010. Построение алгоритма реализации. Класс программы, инструкция по использованию программы.

    курсовая работа [1,0 M], добавлен 26.12.2013

  • Объектно-ориентированное программирование на языке С++

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

    курсовая работа [494,5 K], добавлен 20.06.2012

  • Разработка программы рисования замкнутых многоугольников на языке С++, с использованием библиотеки VCL

    Разработка программы для рисования различных правильных многоугольников с помощью объектно-ориентированного языка программирования. Использование для разработки среды C++ Builder 6 и библиотеки VCL. Разработка интерфейса приложения и алгоритма его работы.

    курсовая работа [616,4 K], добавлен 18.10.2010

  • Разработка клиент серверного приложения

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

    курсовая работа [191,5 K], добавлен 07.01.2015

  • Объектно-ориентированное программирование

    Описание разрабатываемой программы с точки зрения пользователя. Диаграмма вариантов использования приложения. Объектное представление программы. Разработка класса корабля, прикладного окна и события but. Окно приложения с перемещающимися кораблями.

    курсовая работа [207,0 K], добавлен 05.04.2014

  • Разработка игрового мобильного приложения на Android

    Структура Android-приложений. Особенности игрового движка. Алгоритмизация и программирование. Список игровых состояний. Настройка, отладка и тестирование программы. Разработка руководства пользователя. Тестирование инсталляции и отображения элементов.

    дипломная работа [4,5 M], добавлен 19.01.2017

  • Объектно-ориентированное программирование

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

    дипломная работа [1,7 M], добавлен 16.02.2016

  • Приложение "Сотовый телефон"

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

    курсовая работа [1,1 M], добавлен 24.01.2012

  • Разработка консольного приложения в интегрированной среде C++ Builder 6

    Визуальное проектирование и событийное программирование. Повышение производительности программиста при использовании RAD-систем. Составление алгоритмов, разработка приложения для решения прикладных задач на примере консольных приложений C++ Builder 6.

    курсовая работа [258,7 K], добавлен 30.10.2013

Работы в архивах красиво оформлены согласно требованиям ВУЗов и содержат рисунки, диаграммы, формулы и т.д.
PPT, PPTX и PDF-файлы представлены только в архивах.
Рекомендуем скачать работу.

© 2000 — 2023, ООО «Олбест» Все права защищены