Если у вас возникли сложности с курсовой, контрольной, дипломной, рефератом, отчетом по практике, научно-исследовательской и любой другой работой - мы готовы помочь.
Предоплата всего
Подписываем
КАФЕДРА
Реєстраційний №________
Дата ___________________
Тема:
Скріпт мова управління віконним інтерфейсом на С++
Рекомендована до захисту
“____” __________ 2008р.
Робота захищена
“____” __________ 2008р.
з оцінкою
_____________________
Підписи членів комісії
Зміст
Вступ
Поставимо перед собою задачу створення програми скріпт мови управління віконним інтерфейсом. Для створення програми необхідно ознайомитися з основними можливостями середовища програмування С++ BILDER фірми Borland.
Замість окремого інструментарію, що оперує візуальними елементами керування, в C++ Builder інтегрована так називана Палітра компонентів, розділена картотечними вкладками на кілька функціональних груп. Функціональні можливості компонентів, що поставляють, можна досить просто модифікувати, а також розробляти компоненти, що володіють зовсім новим оригінальним поводженням.
ТЕОРІЯ
Бібліотека Візуальних Компонентів дозволяє програмістам візуально створювати програмні додатки, не прибігаючи більше до кодування класів "вручну", або кодуванню в рамках стандартних бібліотек MFC (Microsoft Foundation Class), або OWL (Object Windows Library).
C++ програмістам тепер не треба створювати або маніпулювати об'єктами інтерфейсу з користувачем шляхом написання відповідного коду. Переважна більшість додатків ви будете розробляти візуально за допомогою Редактора форм C++Builder, додаючи лише кілька рядків к.оброблювачам ключових події компонент. Використайте об'єкти завжди, коли це можливо; твердо пручайтеся позиву написати новий код те тих пор, поки всі інші можливості не будуть вичерпані.
Вам буде потрібно оперативне володіння пристроєм Бібліотеки Візуальних Компонентів. Глибина необхідних програмістам знань про склад і функціональні характеристики Бібліотеки визначається тим, як ви збираєтеся неї використати. За допомогою команди головного меню Help | VCL Reference ви можете одержувати відомості з довідкової служби в процесі роботи з Бібліотекою.
VCL для прикладних програмістів
Програміст створює закінчений додаток за допомогою інтерактивної взаємодії з інтегрованим візуальним середовищем C++Builder, використовуючи компоненти VCL для створення інтерфейсу програми з користувачем і з іншими керуючими елементами: обслуговування баз даних, контрольованого уведення параметрів і т.д. Характерна для C++Builder методика візуального стилю розробки програмного забезпечення не застосовується множиною інших систем програмування.
Програмісти повинні знати властивості, методи й події, властивим використовуваним компонентам. Більше того, розуміння архітектури VCL дозволяє вдосконалювати вашу програму в тих місцях, де відчувається необхідність розвитку існуючих або створення нових компонентів. Перш, ніж винаходити новий елемент, упевніться, як прийнято, чи не створив уже хтось компоненту з потрібними вам характеристиками.
VCL для системних програмістів
Системні програмісти розвивають існуючу Бібліотеку - або додаючи в неї нові елементи, або розширюючи функціональність уже наявних компонентів. Розроблювачі компонентів повинні мати більше глибокі знання про внутрішній пристрій VCL, ніж прикладні програмісти. Потрібно чітко уявляти собі, який прийом швидше приведе до поставленої мети: розвиток наявної або написання нового компонента. Написання компонентів являє собою більше традиційну задачу програмування й сполучено з більшими умовностями, ніж візуальне створення додатків.
Варіанти C++Builder Professional й C++Builder Client/Server Suite поставляються разом з вихідними текстами VCL. Наявність вихідних текстів полегшує завдання програмістів, які займаються розробкою нових компонентів і розширенням функціональних можливостей уже наявних компонентів Бібліотеки.
Для створення нових компонентів можна з однаковим успіхом користуватися засобами C++Builder або Delphi, однак якщо розроблені компоненти пропонуються для зовнішнього застосування, автор зобов'язаний упевнитися, що вони працюють у рамках обох систем.
Компоненти VCL
Компоненти - це будівельні цегли, з яких конструюється інтерфейс програми з користувачем, за допомогою яких "будинок" програми здобуває новий зовнішній вигляд і сховані особливості. Для прикладного програміста будь-який компонент VCL являє собою об'єкт, якому можна "перетягнути" із вкладок Палітри компонент (Рис. 6.1) на форму створюваного додатка. Помістивши компоненту на форму, можна маніпулювати її властивостями (за допомогою Редактора форм) і кодом (за допомогою Редактора коду), надаючи компоненті специфічне поводження.
Палітра компонентів з обраною піктограмою TLahel
Для розроблювача компонента являють собою об'єкти на C++ або на Об'єктному Паскале. Деякі компоненти инкапсулируют поводження типових елементів керування, надаваних операційними системами Windows. Інші компоненти вводять зовсім нові видимі й невидимі елементи, програмний код яких повністю визначає їхнє поводження.
Складність компонентів різна. Так TLabel із вкладки Standard Палітри компонентів здатна лише відображати статистичний текст. Можна сконструювати значно більше складний компонент, що, наприклад, инкапсулирует закінчене обслуговування бухгалтерських документів спеціалізованої бази даних.
Типи компонентів
З погляду прикладного програміста компонентний об'єкт являє собою закінчену конструкцію, що містить властивості, методи й події. На відміну від розроблювача компонентів, користувачеві компонентів байдуже, від якого класу зроблений даний компонент.
Прикладные програмісти приймають як факт, що кожен компонент має властивості Тор й Left, які визначають положення компонента на формі-власнику; для них не істотно, що ці властивості успадковані від загального попередника TComponent. Навпроти, коли ви створюєте компонент, ви зобов'язані знати, від якого батька можна запозичити потрібні вам властивості, а також всі інші його характеристики, так, щоб їх можна було успадковувати, а не створювати знову.
З визначення об'єктних класів ви знаєте, що при визначенні деякого класу (спадкоємця) ви робите його від існуючого об'єктного типу (безпосереднього попередника). Стандартний абстрактний тип TObject є, за замовчуванням, першим попередником (прабатьком) всіх об'єктів Бібліотеки Візуальних Компонентів.
Компоненти по суті являють собою об'єкти спеціальних типів. Лише трохи виключенні виділяють структуру компонентів із загальних правил структурування об'єктів мовою C++:
• Більшість компонентів являють собою елементи керування інтерфейсом з користувачем, причому деякі мають досить складне поводження.
• Усі компоненти є прямими або непрямими нащадками одного загального класу-прабатьків (TComponent).
• Компоненти звичайно використаються безпосередньо, шляхом маніпуляцій з їхніми властивостями; вони самі не можуть служити базовими класами для побудови нових підкласів.
• Компоненти розміщаються тільки в динамічній пам'яті за допомогою оператора new.
Розуміння VCL засноване на трьох фундаментальних принципах. По-перше, вам доведеться ознайомитися зі спеціальними характеристиками чотирьох базисних типів компонент: стандартного керування, оригінального керування (custom control), графічного керування й невидимих компонентів. По-друге, ви повинні розуміти структуру Бібліотеки, у яку убудовані описи й реалізації кодів компонент. У третіх, ви повинні знати положення згаданих чотирьох типів компонент в ієрархії VCL.
Стандартні компоненти
Деякі компоненти VCL инкапсулируют поводження таких типових елементів керування операційної системи Windows, як TButton, TListbox й TEdit. Ви знайдете стандартні компоненти на вкладках Standard й Win95 Палітри компонентів.
Будь-який стандартний компонент виглядає й поводити точно так само, як й инкапсулированный нею елемент керування Windows. VCL додає обрамлення, що ніяк не міняє властивостей вихідного елемента керування, а лише робить доступної модифікацію виду й поводження компоненти за допомогою властивостей і методів.
Якщо ви збираєтеся використати стандартні компоненти без змін, вам не потрібно вникати в правила побудови обрамлень VCL. Розроблювач компонентів може відкрити файл вихідних текстів стандартних компонентів, що входить у поставку версій C++Builder Professional або Client/Server Suite, щоб зрозуміти, яким образом відомі елементи керування Windows обрамляються при включенні в Бібліотеку.
Наприклад, компонента TListBox відображає елементи списку в один стовпець, хоча инкапсулирует клас простого списку LISTBOX з Windows, що може відображати список у кілька стовпців. Щоб змінити поводження компонента, вам доведеться реалізувати перевантаження методу створення даного компонента, прийнятого за замовчуванням.
Оригінальні компоненти
На відміну від стандартних компонентів, оригінальні компоненти являють собою елементи керування, у яких немає ні методу для власного відображення, ні заздалегідь певного поводження. Розроблювач компонентів повинен передбачити код, що реалізує малювання самого компонента й код, що визначає поводження компонента, коли користувач взаємодіє з нею. Прикладами оригінальних компонентів є TPanel й TStringGrid.
Слід зазначити, що як стандартні, так й оригінальні компоненти завжди асоціюються з деяким вікном керування, тому іноді називаються віконними (windowed components). Даний аспект докладно обговорюється в параграфі, що описує клас TWinControl. Віконні компоненти мають наступні властивості: вони можуть бути активізовані (прийняти фокус уведення), використають системні ресурси й можуть служити контейнерами, тобто бути родителями інших елементів керування. Прикладом контейнерного компонента є TPanel.
Графічні компоненти
Графічні компоненти являють собою видимі елементи керування, які не можуть прийняти фокус уведення, тому що не є віконними. Графічні компоненти забезпечують відображення об'єктів без використання системних ресурсів, вони вимагають менших "накладних витрат", ніж стандартні або оригінальні компоненти. Прикладами графічних компонентів є TImage й TShape.
Графічні компоненти не можуть служити контейнерами для інших елементів керувань, тобто не можуть володіти іншими компонентами.
Невидимі компоненти
Під час виконання програми невидимі компоненти не з'являються на формі у вигляді яких-небудь елементів керування. Поводження невидимих компонентів визначається на етапі проектування, шляхом інкапсуляції потрібних властивостей об'єкта.
За допомогою Інспектора об'єктів ви можете модифікувати властивості невидимих компонентів і передбачати код оброблювачів подій для них. Прикладами таких компонентів є TOpenDialog, TTable або TTimer.
Контейнерні компоненти
Деякі компоненти в VCL можуть володіти іншими компонентами або бути родителями інших компонентів. Зазначені аспекти мають різне значеннєве значення, що й проясняється в наступних параграфах.
Право володіння
Будь-який компонент може перебувати у володінні (ownership) інших компонентів, але не все компоненти можуть бути власниками. Властивість компонента
Owner (Власник) містить посилання на компонент, що нею володіє. Рис. 6.2 показує ієрархію володіння деякої форми.
Приклад ієрархії володіння
Власник відповідає за звільнення тих компонентів, якими володіє, коли сам руйнується. Так у процесі конструювання форми, вона автоматично стає власником всіх компонентів, розміщених на ній, навіть якщо частина їх розміщена на іншому компоненті, такий як TPanel. Володіння застосовне не тільки до видимих, але й до невидимого (Ttimer, DataSource) компонентам.
Коли компонента створюється динамічно в процесі виконання програми, конструкторам компонента передається її власник як параметр. У наступному прикладі неявний власник форми (this) передається конструкторові компонента TButton як параметр. TButton виконає присвоювання значення переданого параметра властивості Owner кнопки MyButton:
MyButton = new TButton(this);
Коли форма, що володіє компонентом TButton звільняється, автоматично знищується й кнопка MyButton.
Ви можете створити компоненту, у якої немає власника, передаючи значення параметра 0 конструкторові компоненти. Однак, коли цей компонент перестає бути потрібної, її знищення виконується примусово (за допомогою оператора delete). Наступний приклад ілюструє обіг з компонентом TTable, що не має власника:
TTable* MyTable = new TTable(0)
// Код, що реалізує роботу з MyTable
delete MyTable;
Властивість Components типу масив містить перелік компонентів, якими володіє даний компонент. Листинг 6.1 містить фрагмент коду оброблювача події OnClick із циклом відображення імен класів всіх компонентів, якими володіє деяка форма.
void _fastcall TForm::ButtonlClick(TObject *Sender) {
for (int i=0; i<ComponentCount; i++)
ShowMessage(Components[i]->ClassName()) ;
}
Батьківське право
Поняття батьківського права (parentship) істотно відрізняється від права володіння й застосовно тільки до видимого (віконним) компонентам.Батько компонента не може бути її власником.
Батьківські компоненти звертаються до відповідних внутрішніх функцій, щоб викликати відображення компонентів-нащадків. Батько також ответствен за звільнення своїх нащадків, коли сам батько знищується. Властивість компонента Parent (Батько) містить посилання на компонент, що є її батьком. показує батьківську ієрархію деякої форми.
Приклад батьківської ієрархії
Багато властивостей видимих компонентів (наприклад. Left, Width, Top, Height) ставляться до батьківських елементів керування. Інші властивості (наприклад, ParentColor й ParentFont) дозволяють нащадкам використати властивості батьків.
До віконних компонентів ставляться такі видимі елементи, як TEdit, TListBox й TMemo. Щоб відобразити віконний компонент, їй треба привласнити батька, відповідального за відображення. Це присвоювання виконується автоматично на стадії проектування, коли ви перетаскуєте потрібний компонент із Палітри компонентів на форму. Навпроти, при створенні компонента під час виконання програми ви повинні явно записати це присвоювання, інакше компонента не буде відображена (Листинг 6.2).
void _fastcall TForm::FormCreate(TObject *Sender)
{
MyEdit = new TEdit(this); // Передати this як власника MyEdit->Parent = this; // Передати this як батька
}
Потоковість
Потоковість (streaniabilily) компоненти виражається в способі зберігання самого компонента й інформації, що ставиться до значень її властивостей, у файлі або у відведеній області пам'яті. Наприклад, створюваний C++Builder ресурсний файл із расширением.dfm містить інформацію про форму й компоненти, розміщених на ній. Ця інформація автоматично скидається в потік ресурсного файлу.
Розроблювачі компонентів VCL повинні розбиратися в механізмі потокового уведення/висновку, оскільки їм доведеться вручну скидати в потік спеціальні дані про нові компоненти. VCL не автоматизує цей процес.
Властивості компонентів
Визначення класу в мові C++ містить інкапсуляцію членів даних і методів, що оперують із даними й визначають поводженням об'єкта. Ця концепція всіх систем ООП прийнята в VCL.
VCL дозволяє маніпулювати видом і функціональним поводженням компонент не тільки за допомогою методів (як це робиться зі звичайними класами), але й за допомогою властивостей і подій, властивим тільки класам компонент.
Властивості являють собою розширення поняття членів даних. Дозволено будь-які типи властивостей, за винятком файлового типу. На відміну від члена даних, властивість не зберігає дані, однак його методи читання й запису дозволяють одержати доступ до захищеного члена даних об'єкта.
Таким чином, присвоювання значення члену даних за допомогою присвоювання властивості викликає "побічний ефект", за яким можуть ховатися складні операції над компонентом. Наприклад, побічний ефект при зміні властивості Caption (Назва) деякої форми проявляється в негайній зміні назви заголовка вікна цієї форми, при відсутності явного звертання до методу, що реалізує операцію зміни заголовка.
Практична частина
Програма –скрипкова оболонка графічного інтерфейсу (програма управління інтерфейсом користувача)
#include <STDIO.H>
#include <STDLIB.H>
int dotX=230,dot=1;
/************************************************************************/
/**************************** MenuGenerator *****************************/
/************************************************************************/
void buildMenu(char *ScrF,char *OutF)
{
char F_Ch,tmpint[3];
int EOS=0,WriMode,tmpcnt=-1;
char DUMP[80];
FILE *EngF,*TarF;
if((EngF=fopen(ScrF,"r"))!=NULL)
{
TarF=fopen(OutF,"w");
while(!EOS)
{
fflush(stdin);
F_Ch=fgetc(EngF);
if(F_Ch!='\2')fputc(F_Ch,TarF);
else
{
WriMode=2;
F_Ch=fgetc(EngF);
switch(F_Ch)
{
case '*': fgets(DUMP,sizeof(DUMP),EngF);break;
case '#': EOS=1;break;
case '1': itoa(ScrItem.MenuBKColor,tmpint,10);
fputs(tmpint,TarF);break;
case '2': itoa(ScrItem.BorderColor,tmpint,10);
fputs(tmpint,TarF);break;
case '3': itoa(ScrItem.MenuColor,tmpint,10);
fputs(tmpint,TarF);break;
case '4': itoa(ScrItem.BorderTxtColor,tmpint,10);
fputs(tmpint,TarF);break;
case '5': fputs(ScrItem.TitleTxt,TarF);break;
case '6': fputs(ScrItem.AuthorTxt,TarF);break;
case '7': itoa(ScrItem.TxtColor,tmpint,10);
fputs(tmpint,TarF);break;
case '8': fputs(ScrItem.MenuAskTxt,TarF);break;
}
if(dot==1)
{
Shadow(".",dotX,230,15);dotX+=8;
dot=0;
}else dot=1;
/* Found Wanted Menu */
if(WriMode==1)
{
tmpcnt=-1;
while(WriMode!=2)
{
F_Ch=fgetc(EngF);
if(F_Ch!='\2')fputc(F_Ch,TarF);
else
{
F_Ch=fgetc(EngF);
switch(F_Ch)
{
case '*': fgets(DUMP,sizeof(DUMP),EngF);break;
case '/': WriMode=2;break;
}
}
}
}
/* Found Unwanted Menu, Dump whole part */
else if(WriMode==0)
{
while(WriMode!=2)
{
F_Ch=fgetc(EngF);
if(F_Ch!='\2')fgets(DUMP,sizeof(DUMP),EngF);
else
{
F_Ch=fgetc(EngF);
if(F_Ch=='/')WriMode=2;
}
}
}
}
}
fclose(EngF);
fclose(TarF);
}
}
void MenuGenerator()
{
Win3D(170,195,285,80,8);
Box3D(170,195,285,80,1);
Box3D(172,197,281,76,0);
Shadow("Generating Menu Soure code ",200,210,15);
buildMenu("cMenu.scr","Menu.c");
buildMenu("pasMenu.scr","Menu.pas");
/*== Produce Menu File ==*/
Shadow(" [ Done ]",dotX,230,15);
Shadow("Menu.C & Menu.PAS generated !",200,250,15);
getch();
ClrbyLine();
/*End of Production*/
}
/***************************************************************************
** Author : Ong Hui Lam <huilam@pl.jaring.my> **
** Library Name : GUI12h - Graphics User Interface for 12h mode **
** Desciption : A 12h mode (640x480 16 colors) GUI rountine **
***************************************************************************/
#include <GRAPHICS.H>
#include <ALLOC.H>
#include <STDIO.H>
#include <CONIO.H>
#include <STDLIB.H>
#include <STRING.H>
#include <DOS.H>
void GDrv();
void ClrbyLine();
void Button(char Btxt[],int Bx,int By,int BFloat);
void CheckBox(int IcoX,int IcoY,int Checked);
void OptBox(int IcoX,int IcoY,int Checked);
void Win3D(int Winx,int Winy,int Winw,int Winh,int WinCol);
void Win(int Winx,int Winy,int Winw,int Winh,int WinCol);
void Box3D(int BoxX,int BoxY,int BoxW,int BoxH,int BoxFloat);
void Box(int BoxX,int BoxY,int BoxW,int BoxH,int BoxCol);
void Shadow(char Txt[],int TxtX,int TxtY,int TxtCol);
void TextBox(int Tx,int Ty,int Tw,int Th,char Txt[]);
const char *ComboBox(int Tx,int Ty,int Tw,const char *Opt[],int OptCnt);
/***************************************************************************
** Module Name : GDrv **
** **
** Description : Initialize to 12h graphics mode, 640x480 16 colors. **
***************************************************************************/
void GDrv()
{
int gdriver = DETECT, gmode, errorcode;
initgraph(&gdriver, &gmode,"");
errorcode = graphresult();
if(errorcode != grOk)
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
getch();exit(1);
}
return;
}
/***************************************************************************
** Module Name : Shadow **
** **
** Desciption : Output the text on screen with shadow effect **
** **
** Parameters : Txt => Output String **
** TxtX => Coordinate-X of the output string **
** TxtY => Coordinate-X of the output string **
** TxtCol => Color of the output string **
***************************************************************************/
void Shadow(char Txt[],int TxtX,int TxtY,int TxtCol)
{
setcolor(0);outtextxy(TxtX+1,TxtY+1,Txt);
setcolor(TxtCol);outtextxy(TxtX,TxtY,Txt);
return;
}
/***************************************************************************
** Module Name : Box **
** **
** Desciption : Draw a Square Frame with desired color **
** **
** Parameters : BoxX => Coordinate-X of the Box **
** BoxY => Coordinate-Y of the Box **
** BoxW => Width of the Box **
** BoxH => Height of the Box **
** BoxCol => Color of the Box Line **
***************************************************************************/
void Box(int BoxX,int BoxY,int BoxW,int BoxH,int BoxCol)
{
setcolor(BoxCol); /*== Set Line Color ==*/
line(BoxX,BoxY,BoxX,BoxY+BoxH); /*== Left Line ==*/
line(BoxX+BoxW,BoxY,BoxX+BoxW,BoxY+BoxH); /*== Right Line ==*/
line(BoxX,BoxY,BoxX+BoxW,BoxY); /*== Top Line ==*/
line(BoxX,BoxY+BoxH,BoxX+BoxW,BoxY+BoxH); /*== Bottom Line ==*/
return;
}
/***************************************************************************
** Module Name : Box3D **
** **
** Desciption : Draw a Square Frame with 3D effect **
** **
** Parameters : BoxX => Coordinate-X of the Box **
** BoxY => Coordinate-Y of the Box **
** BoxW => Width of the Box **
** BoxH => Height of the Box **
** BoxFloat => "1" indicate float effect **
** "0" indicate sink effect **
***************************************************************************/
void Box3D(int BoxX,int BoxY,int BoxW,int BoxH,int BoxFloat)
{
if(BoxFloat==1)setcolor(15);else setcolor(0);
line(BoxX,BoxY,BoxX,BoxY+BoxH); /*== Left Line ==*/
line(BoxX,BoxY,BoxX+BoxW,BoxY); /*== Top Line ==*/
if(BoxFloat==1)setcolor(0);else setcolor(15);
line(BoxX,BoxY+BoxH,BoxX+BoxW,BoxY+BoxH); /*== Bottom Line ==*/
line(BoxX+BoxW,BoxY,BoxX+BoxW,BoxY+BoxH); /*== Right Line ==*/
return;
}
/***************************************************************************
** Module Name : Win **
** **
** Desciption : Draw a color filled Windows **
** **
** Parameters : Winx => Coordinate-X of Win **
** Winy => Coordinate-Y of Win **
** Winw => Width of Win **
** Winh => Height of Win **
** WinCol => Win filled color **
** LineCol => Win frame line color **
***************************************************************************/
void Win(int Winx,int Winy,int Winw,int Winh,int WinCol)
{
setfillstyle(1,WinCol);
bar(Winx,Winy,Winx+Winw,Winy+Winh);
return;
}
/***************************************************************************
** Module Name : Win3D **
** **
** Desciption : Draw a color filled Windows with 3D effect **
** **
** Parameters : Winx => Coordinate-X of Win **
** Winy => Coordinate-Y of Win **
** Winw => Width of Win **
** Winh => Height of Win **
** WinCol => Win filled color **
** LineCol => Win frame line color **
***************************************************************************/
void Win3D(int Winx,int Winy,int Winw,int Winh,int WinCol)
{
Win(Winx,Winy,Winw-1,Winh-1,WinCol); /*== Draw the Windows ==*/
setfillstyle(1,0); /*== set fill color to Black ==*/
bar(Winx+10,Winy+Winh,Winx+Winw+10,Winy+Winh+10); /*== Bottom Shadow ==*/
bar(Winx+Winw,Winy+10,Winx+Winw+10,Winy+Winh+10); /*== Right Shadow ==*/
return;
}
/***************************************************************************
** Module Name : OptBox **
** **
** Desciption : Allow selection made from a group of option. **
** Suitable for option where allow one selection **
** among the choice available. **
** **
** Parameters : IcoX => Coordinate-X of OptBox **
** IcoY => Coordinate-Y of OptBox **
** Checked => Value of OptBox **
** "0" indicate Unchecked **
** "1" indicate Checked **
***************************************************************************/
void OptBox(int IcoX,int IcoY,int Checked)
{
/*= 8x8 pixels 3D Round Button bitmap ==*/
int ICOMAP[8][8]=
{
-1,0,0,0,0,0,15,-1,0,0,7,7,7,7,7,15,
0,7,7,7,7,7,7,15,0,7,7,7,7,7,7,15,
0,7,7,7,7,7,7,15,0,7,7,7,7,7,7,15,
15,7,7,7,7,7,15,15,-1,15,15,15,15,15,15,-1
};
int IcoCnt,IcoCnt2;
/*== Plot the 8x8 pixel 3D round button on screen ==*/
for(IcoCnt=0;IcoCnt<=7;IcoCnt++)
{
for(IcoCnt2=0;IcoCnt2<=7;IcoCnt2++)
{
if(ICOMAP[IcoCnt2][IcoCnt]!=-1)
putpixel(IcoX+IcoCnt2,IcoY+IcoCnt,ICOMAP[IcoCnt2][IcoCnt]);
}
}
/*== if checked then plot the black dot on the round button ==*/
if(Checked==1)
{
setcolor(0);
line(IcoX+2,IcoY+3,IcoX+5,IcoY+3);
line(IcoX+2,IcoY+4,IcoX+5,IcoY+4);
line(IcoX+3,IcoY+2,IcoX+4,IcoY+2);
line(IcoX+3,IcoY+5,IcoX+4,IcoY+5);
}
return;
}
/***************************************************************************
** Module Name : CheckBox **
** **
** Desciption : As a check list for options. **
** **
** Parameters : IcoX => Coordinate-X of CheckBox **
** IcoY => Coordinate-Y of CheckBox **
** Checked => Value of CheckBox **
** "0" indicate Unchecked **
** "1" indicate Checked **
***************************************************************************/
void CheckBox(int IcoX,int IcoY,int Checked)
{
int IcoCnt,IcoCnt2;
Win(IcoX,IcoY,9,9,7);
Box3D(IcoX,IcoY,9,9,0);
if(Checked==1)
{
setcolor(0);
line(IcoX+7,IcoY+2,IcoX+2,IcoY+7); //RTop - LBottom
line(IcoX+2,IcoY+2,IcoX+7,IcoY+7);//LTop - RBottom
}
return;
}
/***************************************************************************
** Module Name : Button **
** **
** Desciption : Trigeable button with caption. **
** **
** Parameters : Btxt[] => Caption of the button **
** Bx => Coordinate-X **
** By => Coordinate-Y **
** BFloat => Button Effect **
** 1 = Float, Unpressed **
** 0 = Sink, Pressed **
***************************************************************************/
void Button(char Btxt[],int Bx,int By,int BFloat)
{
int Bw=strlen(Btxt)*8+16;
setfillstyle(1,7);
bar(Bx,By,Bx+Bw,By+15);
setcolor(0);
outtextxy(Bx+8,By+4,Btxt);
Box3D(Bx,By,Bw,15,BFloat);
return;
}
/***************************************************************************
** Module Name : ClrbyLine **
** **
** Desciption : Clearing Effect that clear line by line **
** **
***************************************************************************/
void ClrbyLine()
{
int ly;
setcolor(0);
for(ly=45;ly<390+45;ly+=2){line(29,ly,29+572,ly);delay(2);}
for(ly=390+44;ly>45;ly-=2){line(29,ly,29+572,ly);delay(1);}
return;
}
/***************************************************************************
** Module Name : TextBox **
** **
** Desciption : As a Input area to accept string **
** **
** Parameters : Tx => Coordinate-X of the textbox **
** Ty => Coordinate-Y of the textbox **
** Tw => Width of the textbox **
** Th => Height of the textbox **
** Txt => textbox's string to be output **
***************************************************************************/
void TextBox(int Tx,int Ty,int Tw,int Th,char Txt[])
{
Win(Tx,Ty,Tw,Th,7);
Box3D(Tx-1,Ty-1,Tw+2,Th+2,0);
setcolor(0);
outtextxy(Tx+5,Ty+3,Txt);
return;
}
/***************************************************************************
** Function Name : ComboBox **
** **
** Desciption : Allow user choice to be made through list combo **
** style by triggle <UP>, <DOWN> and <ENTER>. **
** **
** Parameters : Tx => Coordinate-X for the ComboBox. **
** Ty => Coordinate-Y for the ComboBox. **
** Tw => Width of the ComboBox. **
** Opt => The List of selection string. **
** Allowed Maximum of 50 array of string. **
** OptCnt => Total Number of choice. **
***************************************************************************/
const char *ComboBox(int Tx,int Ty,int Tw,const char *Opt[],int OptCnt)
{
int ComboCnt=0,Th=12;
char ComboK=1,FKey=0;
char Fstr[80];
/*== Draw ComboBox==*/
Win(Tx,Ty,Tw,Th,7);
Box3D(Tx-1,Ty-1,Tw+2,Th+2,0);
Box3D(Tx+Tw-31,Ty,15,Th,1); /*== Draw Up Arrow Button ==*/
Box3D(Tx+Tw-15,Ty,15,Th,1); /*== Draw Down Arrow Button ==*/
settextstyle(0,0,0);
setcolor(8);
outtextxy(Tx+Tw-27,Ty+3,"\36");/*== Write Up Arrow ==*/
/*== If list not empty paint Down Arrow with BLACK ==*/
if(OptCnt!=0)setcolor(0);
outtextxy(Tx+Tw-11,Ty+3,"\37");/*== Write Down Arrow ==*/
strcpy(Fstr,"");
while(ComboK!=13&&OptCnt!=0)
{
Win(Tx+5,Ty+2,Tw-40,Th-4,7);
setcolor(0);
outtextxy(Tx+5,Ty+3,Opt[ComboCnt]);
ComboK=getch();
switch(ComboK)
{
case 0:FKey=getch();
switch(FKey)
{
case 72: /*== If not first item ==*/
if(ComboCnt>0)
{
/*== Show Up Button Pressed Effect ==*/
Box3D(Tx+Tw-31,Ty,15,Th,0);
delay(100);
Box3D(Tx+Tw-31,Ty,15,Th,1);
/*== Decrease ComboCnt, point to previous item ==*/
ComboCnt--;
}
break;
case 80: /*== If not last item ==*/
if(ComboCnt<OptCnt-1)
{
/*== Show Down Button Pressed Effect ==*/
Box3D(Tx+Tw-15,Ty,15,Th,0);
delay(100);
Box3D(Tx+Tw-15,Ty,15,Th,1);
/*== Increase ComboCnt, point to next item ==*/
ComboCnt++;
}
break;
}
/*== GREY if not avaible, BLACK if available ==*/
/*== If current item is first item, show <UP> not avaible==*/
if(ComboCnt==0)setcolor(8);else setcolor(0);
outtextxy(Tx+Tw-27,Ty+3,"\36");//up
/*== If current item is last item, show <DOWN> not avaible==*/
if(ComboCnt==OptCnt-1)setcolor(8);else setcolor(0);
outtextxy(Tx+Tw-11,Ty+3,"\37");//down
break;
case 13: /*== <ENTER> Pressed, copy current item to Fstr for return ==*/
strcpy(Fstr,Opt[ComboCnt]);break;
}
}
return Fstr;
}
/***********************************************************************/
/************************** End of GUI12h ******************************/
/***********************************************************************/
/* Standard Library */
#include <GRAPHICS.H>
#include <STRING.H>
#include <CONIO.H>
/* User Defined Library Routines */
#include "GUI12H.C"
#include "COMCTRL.C"
#include "SCR_MOD.C"
#include "SCR_CODE.C"
void WebICO(int IcoX,int IcoY)
{
int IcoCnt,IcoCnt2;
const int ICOMAP[15][18]=
{
-1,-1,15,-1,-1,-1,-1,15,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,-1,15,15,-1,15,15,15,0,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,-1,-1,15,15,-1,0,15,15,15,-1,-1,-1,-1,-1,-1,15,-1,
-1,-1,15,-1,15,15,-1,15,0,0,15,15,-1,15,15,15,-1,0,
-1,-1,15,0,-1,15,15,15,15,15,-1,15,15,15,0,0,0,-1,
15,15,15,15,-1,15,15,0,15,0,15,-1,0,15,0,-1,-1,-1,
-1,0,15,15,15,15,0,15,-1,15,15,15,15,15,0,-1,-1,-1,
-1,-1,15,0,0,15,15,-1,15,-1,15,0,0,15,15,15,15,-1,
-1,-1,15,15,15,15,15,15,15,15,15,0,-1,-1,15,0,0,0,
-1,-1,15,15,0,0,0,15,0,0,15,15,-1,15,-1,0,-1,-1,
15,15,15,0,15,15,15,15,15,-1,-1,15,0,15,0,-1,-1,-1,
-1,0,0,0,-1,0,15,0,0,15,15,15,15,-1,0,-1,-1,-1,
-1,-1,-1,-1,-1,-1,15,0,-1,-1,0,0,15,0,-1,-1,-1,-1,
-1,-1,-1,-1,-1,-1,15,0,-1,-1,-1,-1,-1,15,-1,-1,-1,-1,
-1,-1,-1,-1,-1,-1,-1,0,-1,-1,-1,-1,-1,-1,0,-1,-1,-1
};
for(IcoCnt=0;IcoCnt<=17;IcoCnt++)
{
for(IcoCnt2=0;IcoCnt2<=14;IcoCnt2++)
{
if(ICOMAP[IcoCnt2][IcoCnt]!=-1)
putpixel(IcoX+IcoCnt,IcoY+IcoCnt2,ICOMAP[IcoCnt2][IcoCnt]);
}
}
return;
}
void MailICO(int IcoX,int IcoY)
{
int IcoCnt,IcoCnt2;
const int ICOMAP[10][16]=
{
15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,-1,
15,9,9,12,12,9,9,12,12,9,9,12,12,9,7,0,
15,12,15,15,15,15,15,15,15,15,15,15,15,9,7,0,
15,12,15,15,15,15,15,15,15,15,15,15,15,12,7,0,
15,9,15,15,15,15,15,15,15,15,15,15,15,12,7,0,
15,9,15,15,15,15,15,15,15,15,15,15,15,9,7,0,
15,12,15,15,15,15,15,15,15,15,15,15,15,9,7,0,
15,12,9,9,12,12,9,9,12,12,9,9,12,12,7,0,
7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,0,
-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
};
for(IcoCnt=0;IcoCnt<=15;IcoCnt++)
{
for(IcoCnt2=0;IcoCnt2<=9;IcoCnt2++)
{
if(ICOMAP[IcoCnt2][IcoCnt]!=-1)
putpixel(IcoX+IcoCnt,IcoY+IcoCnt2,ICOMAP[IcoCnt2][IcoCnt]);
}
}
return;
}
int main()
{
registerbgifont(gothic_font);
registerbgifont(small_font);
registerbgidriver(EGAVGA_driver);
GDrv();
settextstyle(2,0,0);
WebICO(100,450);Shadow("http://members.xoom.com/_XOOM/huilam/",130,450,10);
MailICO(400,452);Shadow("huilam@pl.jaring.my",430,450,10);
settextstyle(0,0,0);
Shadow("Menu Builder v1.0 for Pascal & C",20,20,10);
if(ScrDesign()==1)MenuGenerator();
closegraph();
return 0;
}
ПРИКЛАД РОБОТИ ПРОГРАМИ
Головне вікно програми побудови інтерфейсу користувача та введення системних команд
Висновки
Операційна система Windows надає розроблювачам додатку потужні засоби Інтерфейсу Графічних Пристроїв GDI (Graphics Device Interface) для побудови графічних зображень незалежно від типу використовуваного пристрою висновку. На жаль, GDI обтяжує програмістів множиною додаткових дій (зокрема, по керуванню системними ресурсами), які відволікають розроблювача від його основної задачі - створення графіки. C++Builder бере на себе всю допоміжну роботу GDI, звільняючи розроблювачів від непродуктивного програмування з пошуком загублених дескрипторів зображень і не звільнених ресурсів пам'яті. Це зовсім не означає, що прямий обіг додатків до окремих функцій Windows GDI забороняється - ви завжди зможете при необхідності викликати їх. Однак, інкапсуляція графічних функцій Windows візуальними компонентами являє собою більше перспективну методику створення графіки у вашому додатку.
Література
1. Нейбауэр А. Моя первая программа на С/С++. П., 1995. 368 С.
2. Бруно Бабэ. Просто и ясно о Borland C++. М., 1996. 400 С.
3. ObjectWindows для C++. К., 1993., 208 С.
4. Н. Барканати. Программирование игр для Windows на Borland C++. М., 1994.