План
Роль интерфейса пользователя при построении прикладного ПО.
Краткая характеристика программы.
Результаты и их анализ.
Структура системы меню.
Текст программы
Список литературы
Роль интерфейса пользователя при построении прикладного ПО.
Сегодня трудно не заметить, какими темпами компьютерная техника входит в нашу жизнь. Входит она и в лице персональных компьютеров, которых с каждым днем становится все больше и больше, и в лице бытовой техники, которая уже сплошь «набита» электроникой, взять хотя бы микроволновые печи, мобильные телефоны, электронные записные книжки и т.д. Обычному человеку очень трудно приспособиться к массе новой техники, и очень часто ему приходится выбирать между соблазном использовать достижения научно-технического прогресса и необходимостью «перелопачивать» тонны сопроводительной литературы и руководств пользователя. Фирмы, занимающиеся производством бытовой компьютерной техники, должны показать пользователю, что ему стоит покупать данный продукт, и немаловажную роль играет в этом построение удобного и интуитивно-понятного интерфейса. Естественно, пользователю не нужна микроволновая печь с цифровой клавиатурой, на которой необходимо набрать массу команд, прежде чем печь начнет работать. Но его вполне устроит дисплей с таймером и кнопкой пуска. Трудно не догадаться, что нужно установить время и нажать на кнопку. Опять же, еще одна крайность – что если бы перед ним была бы панелька и ему пришлось бы отсоединить проводок от одного места и присоединить к другому… Какой выбор сделал бы пользователь? (Кстати, почему многие предпочитают импортную технику? В том числе и потому, что она удобна и проста).
Проводя аналогии, несложно понять, что программное обеспечение, которое управляет компьютеризированной техникой и, по сути, общается с пользователем, должно быть таким же простым, удобным и интуитивно понятным пользователю. И программное обеспечение персональных ЭВМ эволюционировало в том числе и таким образом. Начиная с режима командной строки, через псевдографику – к графическому и звуковому интерфейсу. И именно такой интерфейс позволяет максимально упростить общение с пользователем. Можно, например, нарисовать кнопку с подписью – понятно, что ее нужно нажать для произведения желаемого эффекта. Можно вывести подсказку, проинформировать пользователя иконкой и т.д. А если у вас что-то не получится, компьютер подскажет вам решение голосом. Уже на подходе и внедряются средства для управления техникой голосом.
Но мы остановимся пока на чисто-графическом интерфейсе. Для сложного программного обеспечения часто оказывается невозможным представить все ее возможности на экране с помощью кнопок, списков, флажков и т.д. Тут на помощь приходит меню – структура, использующая пространство экрана динамически. Основной идеей меню является последовательная конкретизация желания пользователя. Пусть, например, пользователь хочет вставить в свой документ иллюстрацию и не знает, как это сделать. Однако он знает, что меню предоставит ему доступ к любой функции программы. Если он начнет проглядывать все опции подряд (а их может оказаться несколько сотен), он может потратить довольно много времени. Но он пойдет по другому пути. Строчка меню довольно небольшая, всего 6-10 пунктов. Просматривая их названия по очереди, он вряд ли остановится на пункте «Вид» или «Файл», зато его точно заинтересует меню «Вставка». Открыв его, он аналогичным образом проглядывает новый список. И так же не обратит внимания на «Примечание» или, например, «Закладка», но выберет «Рисунок». Нетрудно видеть, что, в конце концов, он своей цели добьется довольно быстро.
Задача проектировщика ПО состоит в том, чтобы создать это меню наиболее очевидным образом, удачно построить иерархию в соответствии с принципом пошаговой конкретизации. Задача дизайнера – оформить меню так, чтобы нужный пункт сразу бросался в глаза (например, иконками, выделением и т.д.). Задача программиста – запрограммировать все это так, чтобы можно было бы создавать меню любой сложности (дальновидный программист знает, что ему вряд ли придется писать меню один раз и только простенькое), чтобы меню работало корректно (вряд ли кому понравятся постоянные «глюки»), чтобы пользователь мог достичь одной и той же цели разными путями (например, введение «горячих клавиш»), чтобы управление было интуитивно-понятным (курсор, Enter, с учетом, что до Enter’а пользователю лишний раз тянуться лень и что пользователь может захотеть изменить свой выбор), и чтобы программа была как можно менее требовательна к аппаратуре («Ну, на Pentium III может еще и пойдет…»).
Таким образом, мы сформулировали проблему и поставили задачу. Поскольку в данной работе в основном мы представляем программистское «сословие» (с небольшими добавками дизайнеров и проектировщиков), в дальнейшем будем смотреть на задачу именно под этим углом.
Краткая характеристика программы.
Прежде всего, следует сказать, что программа построена по принципам объектной ориентации. Программа легко допускает расширение (например, добавление реакций на мышь), позволяет создавать меню практически неограниченной вложенности и сложности, любой конфигурации. Интерфейс интуитивно понятен и знаком каждому, кто хотя бы раз общался с системой меню Windows.
В программе реализованы два класса: MainMenu и Menu. Класс Menu фактически может быть использован только классом MainMenu, с которым мы и ведем работу. Как программисту, владеющему таким классом, нам необходимо лишь создать экземпляр этого класса, сформировать систему меню с помощью нескольких методов класса и запустить метод Run. Дальше вся работа лежит на нашем классе. Не правда ли, просто? Это определяет доступность нашего класса широкой аудитории программистов.
Внутренняя реализация такова: компьютер переводится в графический режим и запускается так называемый «ждущий цикл», который ждет нажатия клавиши и, дождавшись, передает значение нажатой клавиши специальному обработчику класса, который уже решает, что с ним делать. Конечно, в сложных системах лучше было бы организовать принцип событий. «Ждущий цикл» ждет событие (нажатие клавиши, движение мышки, сигнал системы – что угодно), формирует объект типа Event, а затем рассылает его всем имеющимся в его распоряжении объектам, а их обработчики уже сами решают, нужно реагировать на это событие, или не нужно. Кроме того, полезно было бы определить классы Application, метод которого инициировал бы граф-режим, определял бы «ждущий цикл», класс Window, DialogWindow, добавить свойства, которые однозначно определяли бы каждый экземпляр каждого объекта, добавить канцепцию событий и т.д. Но это сильно усложнило бы программу и увело бы от цели работы. Поэтому здесь и наблюдается некоторое несоответствие принципам ООП.
Реакции класса на нажатия клавиш следующие:
♦ ВЛЕВО – находимся в подменю – выходим из него, если же выходить можно только в главное меню, то смещаем выделение в главном меню влево (если мы находимся в начале, то переходим в конец), при этом пункт остается открытым.
♦ ВВЕРХ – находимся в главном меню – открываем подменю выделенного пункта. Если же мы находимся в подменю – перемещаем курсор вверх (или переходим в конец списка, если была достигнута вершина).
♦ ВПРАВО – в главном меню просто двигаем выделение вправо. Если мы находимся в подменю и выделенный пункт еще может раскрыться, то раскрываем его. Если же пункт не раскрываем, переходим к следующему пункту главного меню, сохраняя отрытое подменю.
♦ ВНИЗ – работает аналогично ВВЕРХ.
♦ ENTER – если мы стоим на пункте с подменю – открываем пункт. Если пункт не содержит подменю, выдаем диалоговое окно с названием пункта, при этом закрывая все меню до главного.
♦ ESC – выход из программы.
Фактически, структура меню реализована двунаправленным динамическим списком, это обеспечивает экономный расход памяти.
Результаты и их анализ.
Программа работает корректно и в соответствии с характеристикой.
Структура системы меню.
Просмотр
Настройка
Печать
Открыть
Закрыть
Сохранить
Печать
Выход В задании к работе для каждого варианта указана своя собственная система меню. Обрисуем общие принципы. Уровень вложенности для каждого варианта – двукратный. В принципе, для проверки понимания способов графического построения меню этого достаточно. Да и реальные меню редко превосходят двойной уровень вложенности (хотя теоретически, он может быть неограниченным). Это иллюстрируется на рисунке. Верхний уровень представлен главным меню (и это всегда только полоска, не превышающая по длине экран). Второй уровень – меню, выпадающее «вниз» от главного. Тут уже приходится следить за попаданием в экран не только по ширине, но и по высоте. Третий (и последующие) уровни выпадают «вбок», и для них тоже необходимо проверять попадание в экран и сдвигать их при необходимости.
В задании приводится таблица, которая указывает, сколько пунктов должно содержать главное меню, сколько пунктов должно содержать каждое его подменю, какие из них, в свою очередь содержат подменю и сколько в них пунктов. Для удобства и наглядности я принял решение сформировать на основе этой таблицы меню, максимально приближенное к реальности, т.е. реализующее принцип пошагового уточнения. За основу была взята усовершенствованная среда разработки приложений. Иерархия меню приведена ниже.
Файл
Новый
Открыть
Программу
Проект
Печать
Программы
Проекта
Параметры страницы
Предварительный просмотр
Установки принтера
Правка
Поиск
Поиск вперед
Поиск назад
Поиск и замена
Переход
Стили
Основной текст
Комментарий
Заголовок
Ссылка
Очистить
Вставить объект
Из файла
Таблица
Диаграмма
Со сканнера
Сноска
Выделить все
Вид
Документ
Обычный
Разметка
Синтаксическая подсветка
Показывать ссылки
Среда
Панели инструментов
Окно отладчика
Окно процессора
Сервис
Совместная работа
Сверить версии
Сформировать апдейт
Сопроводительная информация
Подключить модуль
Список сотрудников
Авто-подсказки
Макросы
Список
Записать
Отредактировать
Язык
Изменить основной язык
Добавить язык к проекту
Отладка
Компилировать
Точки останова
Установить/сбросить
Перейти к следующей
Сбросить все
Отследить значение переменной
Пошаговое выполнение
Через
Внутрь
Выполнить
До курсора
Итерацию
До конца блока
До конца модуля
Справка
О программе
Помощь по среде
Содержание
Интерфейс
Меню
Горячие клавиши
Помощь по языку
Содержание
Поиск
Помощь по контексту
Он-лайн
Официальный сервер
Неофициальные страницы
Эта иерархия удовлетворяет следующей таблице:
3
6
2
4
5
4
2,2
3,5
1,3
3,4
5,5
1,4
2,3
1,5
3,3
4,2
2,3
4,2
5,4
2,4
3,3
4,2
Это означает, что главное меню должно содержать 6 пунктов. Первый пункт содержит, в свою очередь, 3 пункта. Второй пункт раскрывается в 2, третий в 5 пунктов. И т.д.
Текст программы
#include
#include
#include
void fillscreen()
{
int i;
setcolor(CYAN); // Заполняем экран цветом
for (i=0;i line(0,i,639,i);
setcolor(6); // Выводим информацию о программе
outtextxy(20,453,”Курсовая работа студента группы ПМ-92 Мульцына Константина”);
outtextxy(20,465,”программа написана на языке Си++ с использованием принципов ООП”);
}
void draw_window(int x1, int y1, int x2, int y2)
{ // Функция рисует окошко с тенью
int i; // фиксированного набора цветов
setcolor(LIGHTGRAY);
for (i=0; i line(x1,y1+i,x2,y1+i);
setcolor(BLACK);
line(x1+2,y1+2,x2-2,y1+2); // вывод рамки
line(x1+2,y2-2,x2-2,y2-2);
line(x1+2,y1+2,x1+2,y2-2);
line(x2-2,y1+2,x2-2,y2-2);
setcolor(DARKGRAY);
line(x1+2,y2+1,x2+2,y2+1); // вывод тени
line(x1+2,y2+2,x2+2,y2+2);
line(x2+1,y1+2,x2+1,y2+2);
line(x2+2,y1+2,x2+2,y2+2);
}
void ShowDialog(char* text) // демонстрирует небольшое диалоговое окно
{
int w,ch;
draw_window(130,130,510,240); // выводим окно
w=textwidth(“Радостная информация”)+10;
setcolor(LIGHTGRAY);
line(320-w/2,132,320+w/2,132); // стираем кусочек верхней линии
setcolor(BLACK);
line(132,135,319-w/2,135); // подрисовываем еще парочку линий
line(321+w/2,135,508,135);
outtextxy(320-w/2+5,131,”Радостная информация”);
outtextxy(250,165,”Выбран пункт меню”); // выводим заголовок и станд. текст
setcolor(RED);
outtextxy(320-textwidth(text)/2,180,text); // выводим переменную text
setcolor(BLACK);
outtextxy(225,195,”Нажмите любую клавишу .”);
ch=getch(); // Ждем нажатия клавиши
if (ch==0) ch=getch();
fillscreen(); // Перерисовываем экран
}
class Menu // класс меню представляет собой
{ // пункты меню и подменю
private:
char* name; // Имя пункта меню
Menu* next; // Указатель на следующий пункт
Menu* parent; // Указатель на родителя
Menu* sub; // Указатель на первый пункт подменю
unsigned int opened; // Пункт меню раскрыт
unsigned int selected; // Пункт меню выделен
public:
Menu(char* n) // Конструктор: создает пункт без подменю
{
name=n;
next=0;
sub=0;
parent=0;
opened=0;
selected=0;
}
Menu* AddItem(char* n) // Добавляет элемент следующим к текущему
{
next = new Menu(n);
next->SetParent(parent); // Родитель тот же
return next;
}
Menu* AddSubmenu(char* n) // Добавляет подменю к текущему
{
sub = new Menu(n);
sub->SetParent(this); // Родитель – текущий
return sub;
}
Menu* LevelUp() // Возвращает родителя текущего
{
if (parent!=0) return parent;
else return this;
}
void SetParent(Menu* m) // Устанавливает родителя
{
parent=m;
}
Menu* GetParent() // Возвращает родителя
{
return parent;
}
Menu* GetNext() // Возвращает указатель на седующий
{
return next;
}
Menu* GetSub() // Возвращает указатель на первый пункт
{ // подменю
return sub;
}
char* GetName() // Возвращает имя пункта
{
return name;
}
void PrintInfo() // Выводит информацию о пункте меню
{
cout }
void Select() // Выделяет данный пункт
{
selected=1;
}
void UnSelect() // Сбрасывает выделение
{
selected=0;
}
void OpenSubmenu() // Открывает подменю, если есть
{ // и выделяет там первый пункт
if (sub!=0)
{
opened=1;
sub->Select();
}
}
void CloseSubmenu() // Закрывает подменю, сбрасывая выделения
{ // и закрывая более “глубокие” открытые
opened=0; // подменю
Menu* tmp;
if (sub!=0)
{
tmp=sub;
while (tmp)
{
tmp->UnSelect();
tmp->CloseSubmenu();
tmp=tmp->GetNext();
}
}
}
int IsOpened() // Открыто ли здесь подменю?
{
return opened;
}
int IsSelected() // Выбран ли этот пункт?
{
return selected;
}
void paint(int x, int y) // Отрисовка системы подменю Главного Меню
{
Menu* tmp;
Menu* open=0; // Пункт с открытым подменю
int max_width=0, height, tw, num=0, i, xo,yo;
// max_width – максимальная длина названия пункта меню в пикселах
// height – суммарная высота пунктов в пикселах
// tw – рабочая переменная, смысловой нагрузки не несет
// num – количество пунктов
// i – рабочая переменная, смысловой нагрузки не несет
// xo, yo – координаты для отрисовки вложенного открытого подменю
tmp=this;
while (tmp) // Подсчитываем максимальную длину названий,
{ // кол-во пунктов
tw=textwidth(tmp->GetName());
if (tw > max_width) max_width=tw;
tmp=tmp->GetNext();
num++;
}
height = (textheight(“A”) + 4) * num + 6;
if (x+max_width+30 > 633) x=633 – max_width – 30;
if (y+height > 470) y=470 – height; // выполняем сдвиг,
// если меню выходит за границы
// экрана
draw_window(x,y,x+max_width+30,y+height);
// рисуем окошко, куда будем
// помещать пункты
tmp=this;
setcolor(BLACK);
x+=10;
y+=5;
while (tmp) // пока все не нарисуем
{
if (tmp->IsSelected()) // Пункт меню выделен – его надо инвертировать
{
setcolor(GREEN);
for (i=1;i line(x-5,i+y-2,x+max_width+15,i+y-2);
setcolor(BLACK);
outtextxy(x,y,tmp->GetName());
// Если пункт открыт, это тоже надо нарисовать
if (tmp->IsOpened()) // но мы это сделаем позже
{
open=tmp->GetSub(); // сохраняем координаты и указатель
xo=x+max_width+23;
yo=y;
}
}
else outtextxy(x,y,tmp->GetName()); // рисуем обычный пункт
if (tmp->GetSub()) // рисуем “треугольничек”, если у пункта
{ // есть подменю (в т.ч. и неоткрытое)
line(x+max_width+12,y+4,x+max_width+13,y+4);
line(x+max_width+12,y+3,x+max_width+12,y+5);
}
y+=textheight(“A”)+4;
tmp=tmp->GetNext();
// Нарисовав все текущее подменю, можем приступать
// к рисованию следующего вложенного. Если бы мы
// это сделали сразу, то потом дорисовывали бы
// текущее меню поверх уже нарисованного подменю
if (open) open->paint(xo,yo);
}
};
class MainMenu // Класс главное меню.
{
private:
Menu* list; // Список подменю
Menu* current; // Текущий пункт
Menu* selected; // Выделенный пункт
public:
MainMenu() // Конструктор
{
list=0;
current=0;
}
void AddItem(char* n) // Добавляет элемент следующим к текущему
{ // и делает новый элемент текущим
if (list==0)
{
selected = current = list = new Menu(n);
selected->Select();
}
else current = current->AddItem(n);
}
void AddSubmenu(char* n) // Добавляет подменю текущему и
{ // его первый элемент текущим
if (current!=0) current = current->AddSubmenu(n);
}
void LevelUp() // Делает текущим родителя текущего элемента
{
if (current!=0) current = current->LevelUp();
}
void paint() // Вывод системы меню на экран
{
Menu* tmp=list; // Рабочая переменная
int i, cur_x=18; // счетчик и координата вывода текста
setcolor(LIGHTGRAY); // Выводим полоску главного меню
for (i=0; i line(3,i+3,636,i+3);
setcolor(DARKGRAY); // Выводим тень полоски
line(5,i+3,638,i+3);
line(5,i+4,638,i+4);
line(637,4,637,i+4);
line(638,4,638,i+4);
setcolor(0); // Выводим пункты меню
while (tmp!=0 && cur_x {
if ( cur_x+textwidth (tmp->GetName()+18) {
if (tmp==selected) // Пункт меню выделен – его надо инвертировать
{
setcolor(GREEN);
for (i=0;i line(cur_x-3,i+5,cur_x+textwidth(tmp->GetName())+3,i+5);
setcolor(BLACK);
outtextxy(cur_x,6,tmp->GetName());
// Если пункт открыт, это тоже надо нарисовать
if (tmp->IsOpened()) tmp->GetSub()->paint(cur_x,12+textheight(“A”));
}
else outtextxy(cur_x,6,tmp->GetName()); // Выводим обычный пункт
cur_x+=textwidth(tmp->GetName())+18; // Увеличиваем позицию курсора
tmp=tmp->GetNext(); // Берем следующий пункт
}
}
}
Menu* FindSelection() // Поиск “активного” выделения
{ // по всей иерархии меню
Menu* tmp;
int found=0;
tmp=selected;
while (!found)
{
if (tmp->IsOpened()) tmp=tmp->GetSub(); // открыто – заходим
else if (tmp->IsSelected()) found=1; // выделено – нашли!
else tmp=tmp->GetNext(); // не выделено – дальше
}
return tmp;
}
int keypress(int ch) // Обработчик нажатий клавиш
{
Menu* tmp;
Menu* sel;
switch (ch)
{
case 0: // Спецклавиша, за ней идет другой код
{
ch=getch();
return keypress(ch);
}
case 75: // Нажата клавиша “Влево”
{ // реакция – если находимся в подменю
int open=0; // выходим из него, иначе – перемещаем
sel=FindSelection(); // выделение Главного меню
tmp=sel->GetParent();
if ((tmp->GetParent() != 0) && tmp)
{
tmp->CloseSubmenu();
fillscreen();
}
else
{
if (selected->IsOpened()) // Если мы не в главном меню
{ // то надо заново открыть подменю
selected->CloseSubmenu();
fillscreen();
open=1;
}
selected->UnSelect();
tmp=list;
while (tmp->GetNext() != selected && tmp->GetNext()!=0) tmp=tmp->GetNext();
selected=tmp;
selected->Select();
if (open) selected->OpenSubmenu();
}
paint(); // Перерисовываем меню
return 0;
}
case 72: // Нажата клавиша “Вверх”
{ // реакция – перемещение курсора вверх,
if (selected->IsOpened()) // если в Главном меню – открываем
{ // подменю
sel=FindSelection();
tmp = sel->GetParent();
tmp = tmp->GetSub();
if (tmp==sel)
while (tmp->GetNext()!=0) tmp=tmp->GetNext();
else
while (tmp->GetNext()!=sel) tmp=tmp->GetNext();
sel->UnSelect();
tmp->Select();
}
else keypress(13);
paint();
return 0;
}
case 77: // Нажата клавиша “Вправо”
{ // Реакция – если у данного пункта есть
int open=0; // подменю – открываем, если нет – переходим
sel=FindSelection(); // к след. пункту Главного меню.
// В Главном меню – просто переход.
if (sel->GetSub() && (sel != selected)) sel->OpenSubmenu();
else
{
if (selected->IsOpened())
{
selected->CloseSubmenu();
fillscreen();
open=1;
}
selected->UnSelect();
selected=selected->GetNext();
if (selected==0) selected=list;
selected->Select();
if (open) selected->OpenSubmenu();
}
paint(); // Перерисовываем меню
return 0;
}
case 80: // Нажата клавиша “Вниз”
{ // Просто перемещение, в Главном меню
if (selected->IsOpened()) // окрывает подменю
{
sel=selected->GetSub();
tmp=selected->GetSub();
while (tmp)
{
while (tmp && !tmp->IsOpened())
tmp=tmp->GetNext();
if (tmp) tmp=sel=tmp->GetSub();
}
tmp = sel;
while (!tmp->IsSelected())
tmp=tmp->GetNext();
tmp->UnSelect();
tmp=tmp->GetNext();
if (!tmp) tmp = sel;
tmp->Select();
}
else keypress(13);
paint();
return 0;
}
case 27: // Нажата клавиша “Escape”
{ // Реакция – выход и программы
return 1;
}
case 13: // Нажата клавиша “Enter”
{ // Реакция – открытие подменю, если есть,
Menu* tmp; // если нет – диалоговое окно с названием,
tmp=FindSelection(); // и закрываем все вплоть до Главного
if (tmp->GetSub())
{
tmp->OpenSubmenu();
paint();
}
else
{
selected->CloseSubmenu();
fillscreen();
paint();
ShowDialog(tmp->GetName());
paint();
}
return 0;
}
}
return 0;
}
void Run() // Основной цикл программы
{
int ch,rez=0;
fillscreen();
paint(); // Рисуем меню
while (rez!=1) // Пока не ключ выхода
{
ch=getch(); // Ждем нажатия кнопки
rez=keypress(ch); // Обрабатываем нажатие кнопки
}
}
};
void main()
{
MainMenu MyMenu; // Создание Главного Меню
MyMenu.AddItem(“Файл”); // Формирование структуры меню
MyMenu.AddSubmenu(“Новый”);
MyMenu.AddItem(“Открыть”);
MyMenu.AddSubmenu(“Программу”);
MyMenu.AddItem(“Проект”);
MyMenu.LevelUp();
MyMenu.AddItem(“Печать”);
MyMenu.AddSubmenu(“Программы”);
MyMenu.AddItem(“Проекта”);
MyMenu.AddItem(“Параметры страницы”);
MyMenu.AddItem(“Предварительный просмотр”);
MyMenu.AddItem(“Установки принтера”);
MyMenu.LevelUp();
MyMenu.LevelUp();
MyMenu.AddItem(“Правка”);
MyMenu.AddSubmenu(“Поиск”);
MyMenu.AddSubmenu(“Поиск вперед”);
MyMenu.AddItem(“Поиск назад”);
MyMenu.AddItem(“Поиск и замена”);
MyMenu.LevelUp();
MyMenu.AddItem(“Переход”);
MyMenu.AddItem(“Стили”);
MyMenu.AddSubmenu(“Основной текст”);
MyMenu.AddItem(“Комментарий”);
MyMenu.AddItem(“Заголовок”);
MyMenu.AddItem(“Ссылка”);
MyMenu.LevelUp();
MyMenu.AddItem(“Очистить”);
MyMenu.AddItem(“Вставить объект”);
MyMenu.AddSubmenu(“Из файла”);
MyMenu.AddItem(“Таблица”);
MyMenu.AddItem(“Диаграмма”);
MyMenu.AddItem(“Со сканнера”);
MyMenu.AddItem(“Сноска”);
MyMenu.LevelUp();
MyMenu.AddItem(“Выделить все”);
MyMenu.LevelUp();
MyMenu.AddItem(“Вид”);
MyMenu.AddSubmenu(“Документ”);
MyMenu.AddSubmenu(“Обычный”);
MyMenu.AddItem(“Разметка”);
MyMenu.AddItem(“Синтаксическая подсветка”);
MyMenu.AddItem(“Показывать ссылки”);
MyMenu.LevelUp();
MyMenu.AddItem(“Среда”);
MyMenu.AddSubmenu(“Панели инструментов”);
MyMenu.AddItem(“Окно отладчика”);
MyMenu.AddItem(“Окно процессора”);
MyMenu.LevelUp();
MyMenu.LevelUp();
MyMenu.AddItem(“Сервис”);
MyMenu.AddSubmenu(“Совместная работа”);
MyMenu.AddSubmenu(“Сверить версии”);
MyMenu.AddItem(“Сформировать апдейт”);
MyMenu.AddItem(“Сопроводительная информация”);
MyMenu.AddItem(“Подключить модуль”);
MyMenu.AddItem(“Список сотрудников”);
MyMenu.LevelUp();
MyMenu.AddItem(“Авто-подсказки”);
MyMenu.AddItem(“Макросы”);
MyMenu.AddSubmenu(“Список”);
MyMenu.AddItem(“Записать”);
MyMenu.AddItem(“Отредактировать”);
MyMenu.LevelUp();
MyMenu.AddItem(“Язык”);
MyMenu.AddSubmenu(“Изменить основной язык”);
MyMenu.AddItem(“Добавить язык к проекту”);
MyMenu.LevelUp();
MyMenu.LevelUp();
MyMenu.AddItem(“Отладка”);
MyMenu.AddSubmenu(“Компилировать”);
MyMenu.AddItem(“Точки останова”);
MyMenu.AddSubmenu(“Установить/сбросить”);
MyMenu.AddItem(“Перейти к следующей”);
MyMenu.AddItem(“Сбросить все”);
MyMenu.LevelUp();
MyMenu.AddItem(“Отследить значение переменной”);
MyMenu.AddItem(“Пошаговое выполнение”);
MyMenu.AddSubmenu(“Через”);
MyMenu.AddItem(“Внутрь”);
MyMenu.LevelUp();
MyMenu.AddItem(“Выполнить”);
MyMenu.AddSubmenu(“До курсора”);
MyMenu.AddItem(“Итерацию”);
MyMenu.AddItem(“До конца блока”);
MyMenu.AddItem(“До конца модуля”);
MyMenu.LevelUp();
MyMenu.LevelUp();
MyMenu.AddItem(“Справка”);
MyMenu.AddSubmenu(“О программе”);
MyMenu.AddItem(“Помощь по среде”);
MyMenu.AddSubmenu(“Содержание”);
MyMenu.AddItem(“Интерфейс”);
MyMenu.AddItem(“Меню”);
MyMenu.AddItem(“Горячие клавиши”);
MyMenu.LevelUp();
MyMenu.AddItem(“Помощь по языку”);
MyMenu.AddSubmenu(“Содержание”);
MyMenu.AddItem(“Поиск”);
MyMenu.AddItem(“Помощь по контексту”);
MyMenu.LevelUp();
MyMenu.AddItem(“Он-лайн”);
MyMenu.AddSubmenu(“Официальный сервер”);
MyMenu.AddItem(“Неофициальные страницы”);
int driver=DETECT,mode=VGAHI; // Переводим комп в граф-режим
initgraph(&driver,&mode,””);
MyMenu.Run(); // Запускаем систему
closegraph(); // Переводим назад в текст. режим
}
Список литературы
Айра Пол. Объектно-ориентированное программирование на C++. Второе издание. Пер. с англ. Д. Ковальчука – СПб.; М.: «Невский Диалект» – «Издательство БИНОМ», 1999 г. – 462 с., ил. Дональд Эрвин Кнут. Искусство программирования. Основные алгоритмы. Третье издание. Уч. пос. Пер. с англ. – М.: Издательский дом «Вильямс», 2000 – 720 с., ил. Алан И. Голуб. С и С++. Правила программирования. – М.: БИНОМ, 1996 – 272 с.