GCC. Си. Таблица с обработкой.

// О С Н О В Н А Я Ч А С Т Ь П Р О Г Р А М М Ы
// Файл lab9.cpp
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
// Включение модуля определений
#include "define.c"
// Включение модуля типов
#include "types.c"
// Включение модуля обработки ошибок
#include "error.c"
// Включение модуля инициализации таблицы
#include "init.c"
// Включение модуля работы с таблицей
#include "work.c"
// Включение модуля завершения работы с таблицей
#include "done.c"
TTable T [Nr+1]; // Таблица содержит Nr строк (+1 кнопка)
// Кнопка располагается в нижней части таблицы – «Всего по счету»
17
// Для нажатия на кнопку выберите ее и нажмите «Enter».
// Кнопка служит для вычисления сумм и общего количества
TField Field [Nf]; // Массив координат полей таблицы
void main ()
{
Init ( TabForm, Table, T, Field ); // Инициализация таблицы
Work ( T, Field ); // Работа с таблицей
Done ( TabForm, Table, T, Field ); // Завершение работы с таблицей
}
По мере того, как модули будут объявляться по тексту программы, мы
будем приводить их и в тексте методических указаний. Если модуль достаточно
прост, то дополнительных комментариев не будет, а только те, что есть по тек-
сту программы.
// МОДУЛЬ ОПРЕДЕЛЕНИЙ (Файл define.c)
// Количество строк в таблице
#define Nr 8
// Количество полей в таблице
#define Nf 7
// Ширина таблицы
#define TabWidth 79
// Номер строки на экране для вывода сообщения об ошибке
#define ErrLine 23
// Номер строки на экране для ввода данных
#define EnterLine 17
// Имя файла (форма таблицы)
#define TabForm "Tab_Form.txt"
// Имя файла (таблица)
#define Table "Table.txt"
// Первый символ рамки таблицы для определения ее границ
#define FirstChar '├'
// Последний символ рамки таблицы для определения ее границ
#define LastChar '┤'
// Средний символ рамки таблицы для определения ее границ
#define MiddleChar '┼'
// Цвет фона выбранного поля
#define SelCol GREEN
// Цвет фона других полей
#define Col BLACK
// Номер поля перечисления (фирма изготовитель)
#define enumfield 2
// Номер поля дополнительной информации
#define NoteField 4
18
// МОДУЛЬ ИСПОЛЬЗУЕМЫХ ТИПОВ ДАННЫХ (Файл types.c)
// Перечисление фирм – производителей процессоров
typedef enum { Empty, Intel, Cyrix, AMD, Unknown } TProc;
// Тип таблица
typedef struct {
int Num; // Номер по порядку
TProc Proc; // Тип процессора
long Frec; // Частота процессора
char Note[20]; // Доп. сведения
unsigned int Cost; // Цена за штуку
unsigned int Cnt; // Количество
long Sum; // Сумма в строке
int y; // Номер строки на экране
} TTable;
// Перечисление типов ошибок
typedef enum { erNotFound, erOpen, erLength, erConvert } TErrKind;
// Перечисление веса ошибки
typedef enum { erNo, erFatal, erWarning } TErrWeight;
// Тип для описания ошибки
typedef struct { TErrKind K; TErrWeight W; } TError;
// Тип описания параметров поля таблицы
typedef struct { int Pos; int Size; } TField;
// Перечисление видов целых чисел
typedef enum { Integer, Unsigned, LongInt} TNum;
// Перечисление видов команд
typedef enum { cmEmpty, // Пустая (не делает ничего)
cmLt, cmRt, cmUp, cmDn, // Перемещения курсора
cmQuit, // Команда "покинуть"
cmExit, // Команда выхода
cmEnter, // Команда ввода
cmPrepare, // Команда подготовки ввода
cmCalc // Команда вычисления
} TCommand;
// Перечисление активных элементов
typedef enum { ATab, // Вся таблица
AEnum, // Поле перечисления
AFields // Другие поля
} TActive;
// Пункт назначения при выводе поля (экран, файл)
typedef enum { Scr, File } TDest;
19
// МОДУЛЬ ОБРАБОТКИ ОШИБОК (Файл error.c)
// Включение модуля работы со строками
#include "strings.c"
// Функция обработки ошибки
void Processing (TError Err)
{ switch (Err.K)
{
case erOpen:
ErrorMsg ("Ошибка открытия файла или файл не найден."); break;
case erLength:
ErrorMsg ("Вводимые данные не входят в размер поля."); break;
case erConvert:
ErrorMsg ("Вводимые данные не соответствуют типу поля."); break;
}
switch (Err.W)
{
case erFatal:
ErrorMsg ("Фатальная ошибка. Программа завершается.");
exit (1); break;
}
}
// МОДУЛЬ ДЛЯ РАБОТЫ СО СТРОКАМИ (Файл strings.c)
#include <string.h>
// Функция вывода текста по центру экрана
void Center(int Line, char *Str)
{ int n;
n = (80-strlen(Str))/2;
gotoxy (n,Line); puts (Str);
}
// Функция печати по левому краю
void Left(int Line, char *Str)
{
gotoxy (1,Line);
clreol (); puts (Str);
}
// Функция стирания сообщения
void ClearMsg (int y)
{
textbackground (Col);
gotoxy(1,y); clreol();
}
20
// Функция выделения подстроки из строки
// по позиции в строке и размеру
void SelectSubStr (char *src, char *dest, int n, int size)
{ char *p; // Указатель на символ
strncpy (dest, (src + n), size); // Сначала копируем часть строки
*(dest + size)=0; // Ставим признак конца строки
// Удаляем пробелы в начале строки
while (dest[0] == ' ')
{
p = dest;
p++;
strcpy (dest, p);
}
// Удаляем пробелы в конце строки
n = strlen (dest); p = dest + n; p--;
while ((*p)==' ') { *p='\0'; p--; }
}
// Функция ввода строки с клавиатуры в строке ввода
void EnterString (char *s)
{
textbackground (SelCol);
gotoxy(1,EnterLine);
clreol();
gets(s);
ClearMsg (EnterLine);
}
// Функция вывода строки в строке ввода
void PrintToEnterLine (char *s)
{
textbackground (SelCol);
gotoxy(1,EnterLine);
clreol();
puts(s);
}
// Вывод сообщения об ошибке в строке вывода об ошибках
void ErrorMsg (char *Msg)
{
textbackground (SelCol);
Left (ErrLine, Msg);
getch();
ClearMsg (ErrLine);
}
21
Пришла пора представления модуля инициализации, то есть подготовки
всех исходных данных. Это модуль записан единым файлом. Модуль содержит
несколько основных функций, некоторые из которых также используют другие
функции. Поэтому перед описанием функции может идти предварительное
объявление других функций, более подробное описание, которых представлено
ниже по тексту. Такой стиль изложения позволяет выделить основные части.
// МОДУЛЬ ИНИЦИАЛИЗАЦИИ ТАБЛИЦЫ ( Файл init.c )
// Включение модуля обработки поля таблицы
#include "fields.c"
// Функция инициализации таблицы
void Init ( char *fTabForm, char *fTableName, TTable *T, TField *Field );
// Функции, используемые функцией инициализации
// 1. Печать заголовка программы
void PrintTitle ();
// 2. Печать формы таблицы
void PrintForm (char *fName);
// 3. Загрузка таблицы
void LoadTable (char *fTableName, TTable *T, TField *Field );
// 4. Печать таблицы на экране
void PrintTable (TTable *T, TField *Field);
// Описание функции инициализации
void Init ( char *fTabForm, char *fTableName, TTable *T, TField *F )
{ FILE *f;
PrintTitle (); // Вывод на экран заголовка
PrintForm ( fTabForm ); // Вывод на экран формы
LoadTable ( fTableName, T, F ); // Загрузка таблицы из файла
PrintTable ( T, F ); // Вывод таблицы на экран
}
// 1. Печать заголовка программы
void PrintTitle()
{
textbackground(BLACK); textcolor (WHITE);
highvideo (); clrscr ();
Center (5, "Лабораторная работа N 9");
Center (6, "Выполнил студент гр. ИСТл-12");
Center (7,"Пирогов Владимир");
getch (); clrscr ();
}
// Включение модуля работы с файлами
#include "file.c"
22
// 2. Печать формы таблицы
void PrintForm(char *fTabForm)
{
FILE *f; char s[100];
OpenFile (&f, fTabForm, "rt");
while ( !feof(f))
{
fgets (s,100,f);
printf ("%s", s);
}
fclose (f);
}
// Функции, используемые функцией загрузки таблицы
// Пропустить заголовок таблицы
void SkipTableTitle (FILE *f, char *s, int *Y);
// Вычислить местоположение полей
void CalcFieldPos ( char *s, TField *Field );
// 3. Загрузка таблицы
void LoadTable ( char *fTableName, TTable *T, TField *Field )
{
FILE *f;
char s[100];
char SubStr[20];
int R, F, Y;
OpenFile (&f, fTableName, "rt"); // Открыть файл для чтения
SkipTableTitle (f, s, &Y); // Пропустить заголовок
CalcFieldPos (s, Field); // Вычислить позиции полей
// Заполнение в цикле всех строк таблицы
for (R=0; R<Nr; R++)
{
Y++; // Определим позицию строки на экране монитора
// Определим начальные значения каждого поля
T[R]. Num = 0;
T[R]. Proc = Unknown;
T[R]. Frec = 0;
T[R]. Note[0] = '\0';
T[R]. Cnt = 0;
T[R]. Cost = 0;
T[R]. Sum = 0;
T[R]. y = Y;
23
// Введем очередную строку из файла
fgets (s,100,f);
// Заполним все поля
for (F=0; F<Nf; F++)
{
// Для этого выделим подстроку поля из строки…
SelectSubStr (s, SubStr, Field[F].Pos-1, Field[F].Size);
// и заполним поле значением из подстроки.
// При этом производится преобразование текстового
// значения к типу поля
EnterField (SubStr, T[R], Field[F], F);
}
}
fclose (f);
// Последние действие – это задание параметров поля,
// отведенного под клавишу
Y+=2;
T[Nr].Num = 0;
T[Nr].Proc = Unknown;
T[Nr].Frec = 0;
strcpy(T[Nr].Note," Всего по счету ");
T[Nr].Cnt = 0;
T[Nr].Cost = 0;
T[Nr].Sum = 0;
T[Nr].y = Y;
// Загрузка таблицы из файла завершена
}
// 4. Печать таблицы на экране
void PrintTable (TTable *T, TField *Field)
{ int R, F;
// Печать всех строк таблицы
for (R=0; R<Nr; R++)
// Печать всех полей строки таблицы
for (F=0; F<Nf; F++)
PrintField (T[R], Field[F], F); // Печать поля
// Печать выделенного поля на другом фоне
textbackground (SelCol);
PrintField (T[0], Field[0], 0);
}
// Пропустить заголовок таблицы
void SkipTableTitle(FILE *f, char *s, int *Y)
{
(*Y) = 0; // Отсчет строк на экране с 0
24
do
{
fgets (s,100,f); // Считать строку из файла
(*Y)++; // Увеличить счетчик строк
}
while ( s[0] != FirstChar ); // До достижения признака конца заголовка
}
// Вычислить местоположение полей таблицы
void CalcFieldPos ( char *s, TField *Field )
{
int i=0,n=0;
// Определить начало первого поля
while ( s[i] != FirstChar) i++;
do
{
i++; // Номер позиции в строке
Field[n].Pos = i+1; // Запомнить позицию поля
n++; // Номер поля
// Определить координаты промежуточного разделителя
while ( (s[i]!=MiddleChar) && (i<strlen(s)) ) i++;
} while (i<strlen(s));
// Вычисление размеров полей по координатам начал полей
for ( n=1; n<Nf; n++)
Field[n-1].Size = Field[n].Pos - Field[n-1].Pos - 1;
// Вычисление размера последнего поля в строке
Field[n-1].Size = TabWidth - Field[n-1].Pos;
}
// МОДУЛЬ РАБОТЫ С ФАЙЛАМИ (файл file.c)
// Функция открытия файла с проверкой открытия
void OpenFile(FILE** f, char *fName, char *Mode)
{ TError Err;
(*f) = fopen (fName, Mode);
Err.K = erNotFound; Err.W = erNo;
if ((*f)==NULL)
{ Err.K = erOpen; Err.W = erFatal; }
Processing(Err);
}
// МОДЛЬ РАБОТЫ С ПОЛЯМИ ТАБЛИЦЫ
// Файл Fields.c
// Предварительное объявление функций модуля
25
// 1. Функция ввода данных в поле
void EnterField (char *s, TTable &Ti, TField Field, int F);
// 2. Функция вывода содержимого поля на экран
void PrintField(TTable Ti, TField Field, int F);
// 3. Функция вывода содержимого поля в файл
void OutField (TTable Ti, TField Field, int F, FILE *f);
// Включения модуля преобразований данных в строку и обратно
// Имена функций показывают направление преобразования
#include "convert.c"
// 1. Функция ввода данных в поле из строки s, F – номер поля
void EnterField (char *s, TTable &Ti, TField Field, int F)
{
// Ввод возможен при соответствии размеров поля и строки
if (CheckSize (s, Field.Size))
// Преобразование в зависимости от номера поля
switch (F)
{
case 0: StrToNum ( &(Ti.Num), s, Integer ); break;
case 1: StrToEnum ( &(Ti.Proc), s ); break;
case 2: StrToNum ( &(Ti.Frec), s, LongInt ); break;
case 3: strcpy ( Ti.Note, s ); break;
case 4: StrToNum ( &(Ti.Cost), s, Unsigned ); break;
case 5: StrToNum ( &(Ti.Cnt), s, Unsigned ); break;
case 6: StrToNum ( &(Ti.Sum), s, LongInt ); break;
}
}
// Предварительное объявление функции преобразования
// содержимого поля в строку, которая используется
// функциями вывода на экран и в файл
void ConvertField (TTable Ti, int F, char *s);
// 2. Функция вывода содержимого поля на экран
void PrintField(TTable Ti, TField Field, int F)
{ char s[100];
char i;
// Преобразование содержимого поля в строку
ConvertField ( Ti, F, s);
// Вывод возможен при соответствии размеров
if (CheckSize (s, Field.Size))
{
// Задание цвета фона поля
gotoxy (Field.Pos, Ti.y);
26
for (i=0; i<Field.Size; i++)
putch(' ');
// Добавление строки пробелами до размеров поля
for ( i = strlen(s); i<Field.Size; i++)
strcat (s," ");
// Вывод строки
gotoxy (Field.Pos, Ti.y);
puts (s);
gotoxy (Field.Pos, Ti.y);
}
}
// Функция вывода содержимого поля в файл
void OutField(TTable Ti, TField Field, int F, FILE *f)
{ char s[100];
char i;
// Преобразование содержимого поля в строку
ConvertField( Ti, F, s);
// Добавление строки пробелами до размеров поля
for ( i = strlen(s); i<Field.Size; i++)
strcat(s," ");
fprintf (f,"%s",s);
}
// Функция преобразования содержимого поля в строку
void ConvertField(TTable Ti, int F, char *s)
{
switch (F) // Преобразование в зависимости от номера поля к строке
{
case 0: NumToStr (&(Ti.Num), s, Integer); break;
case 1: EnumToStr (Ti.Proc, s); break;
case 2: LongToStr (Ti.Frec, s); break;
case 3: strcpy (s, Ti.Note); break;
case 4: NumToStr (&(Ti.Cost), s, Unsigned); break;
case 5: NumToStr (&(Ti.Cnt), s, Unsigned); break;
case 6: LongToStr (Ti.Sum, s ); break;
}
}
// МОДУЛЬ ПРЕОБРАЗОВАНИЯ ДАННЫХ (файл Convert.c)
// Функции преобразования модуля
// Проверка размера строки на соответствие размеру поля
int CheckSize (char *s, int Size);
// Преобразование строки в число
void StrToNum (void *Num, char *s, TNum NumType);
27
// Преобразование строки в перечисление
void StrToEnum (TProc *Pr, char *s);
// Преобразование числа в строку
void NumToStr (void *Num, char *s, TNum NumType);
// Преобразование длинного числа в строку
void LongToStr (long L, char *s);
// Преобразование перечисления в строку
void EnumToStr(TProc P, char *s);
// Проверка размера строки на соответствие размеру поля
int CheckSize (char *s, int Size)
{ TError Err;
// Сначала считаем, что ошибки нет
Err.K = erNotFound; Err.W = erNo;
// Сравниваем размеры поля и строки
if ( (strlen(s)) > Size )
{
Err.K = erLength; // Ошибка размера
Err.W = erWarning; // Достаточно предупредить
Processing (Err); // Обработка ошибки
return 0; // если есть ошибка
}
return 1; // если ошибки нет
}
// Преобразование строки в число
void StrToNum (void *Num, char *s, TNum NumType)
{ TError Err; int n;
if (s[0]) // Преобразование не пустой строки
{ // Сначала считаем, что ошибки нет
Err.K = erNotFound; Err.W = erNo;
// Преобразование в зависимости от типа числа
switch (NumType)
{ case Integer : n = sscanf (s, "%d", Num); break;
case Unsigned : n = sscanf (s, "%u", Num); break;
case LongInt : n = sscanf (s, "%I", Num); break;
}
if (n==0)
{ // Преобразование с ошибкой
Err.K = erConvert; // Ошибка преобразования
Err.W = erWarning; // Достаточно предупредить
Processing(Err); // Обработка ошибки
}
}
}
28
// Преобразование строки в перечисление
void StrToEnum(TProc *Pr, char *s)
{
char Firm[][20] = { "", "Intel", "Cyrix", "AMD", "Unknown" };
TProc P;
// Перебор вариантов до совпадения со строкой
for ( P = Empty; P<=Unknown; ((int)P)++ )
if ( strcmp (s, Firm[P])==0)
(*Pr) = P;
}
// Преобразование числа в строку
void NumToStr (void *Num, char *s, TNum NumType)
{ Terror Err;
int n, *N;
unsigned int *U;
// Сначала считаем, что ошибки нет
Err.K = erNotFound; Err.W = erNo;
// Переход от нетипированного указателя к типированному
N = (int*) Num;
U = (unsigned int *) Num;
// Преобразование в зависимости от типа числа
switch (NumType)
{
case Integer : n = sprintf (s, “%d”, (*N)); break;
case Unsigned : n = sprintf (s, “%u”, (*U)); break;
}
if (n==0)
{ // Преобразование с ошибкой
Err.K = erConvert; // Ошибка преобразования
Err.W = erWarning; // Достаточно предупредить
Processing (Err); // Обработка ошибки
}
}
#include <math.h>
// Преобразование длинного числа в строку
void LongToStr (long L, char *s)
{ Terror Err; char n; long L1; char *p;
// Формирование строки будем вести с младших
// цифр к старшим. Поэтому сначала определим
// конец строки, например на позиции 80
s[80] = 0;
p = s+80; // Указатель определим на конец строки
29
// Далее преобразование по одной цифре
do
{
n = L % 10; // Выделим младшую цифру и поместим в n
p--; // Подготовим указатель на пред. символ
*p = '0'+ n; // Добавим выделенную цифру как символ
L = L/10; // Уберем из числа младшую цифру
}
while ( L>0 ); // будем повторять, пока есть цифры
// Перепишем результат в начало строки s
strcpy (s, p);
}
// Преобразование перечисления в строку
void EnumToStr(Tproc P, char *s)
{
char Firm[][20] = { “”, “Intel”, “Cyrix”, “AMD”, “Unknown” };
if (P == Empty) s[0] = 0;
else strcpy (s, Firm[(int)P] );
}
Теперь можно перейти к самому большому и самому интересному моду-
лю – работе с таблицей. Управление всей работой осуществляется по командам.
Перечень команд объявлен в типах данных. Команды формируются как после
нажатия на клавиши клавиатуры (функция GetKbCom), так и при выполнении
определенных условий в функциях обработки команд. Такой подход дает воз-
можность организовать более гибкое управление программой.
Для обработки команд предусмотрены три обработчика: обработчик ко-
манд в таблице (TabProcessing), обработчик команд в поле перечисляемого типа
(то есть в поле выбора фирмы изготовителя EnumProcessing) и обработчик ко-
манд в полях таблицы других типов (FieldsProcessing). Для разных элементов
может быть предусмотрен свой набор команд. В этом случае обработчик друго-
го элемента просто не будет реагировать на специфическую команду.
Но одна и та же команда, например, команда ввода «cmEnter» может пре-
дусмотрена для обработки и разных элементах программы и обрабатываться
по-разному таблицей, полем перечисления и другими полями. Чтобы узнать,
для кого предназначена команда, предусмотрена переменная для обозначения
активности элемента.
Другие особенности будут понятны из комментариев к программе.
// МОДУЛЬ ОПИСАНИЯ РАБОТЫ С ТАБЛИЦЕЙ (файл Work.c)
// Основной в данном модуле является функция работы с таблицей,
void Work (TTable *T, TField *F);
30
// которая получает команду с помощью функции получения команды.
TCommand GetKbCom ( TCommand Com );
// Обработкой команд занимаются:
// 1) функция обработки команд в таблице ( параметры функции)
void TabProcessing( TCommand &Com, // команда для обработки
int &Cx, // координата поля
int &Cy, // координата поля
TTable *T, // таблица
TField *F, // координаты полей
TActive &A); // активный элемент
// 2) функция обработки команд в поле перечисления,
void EnumProcessing ( TCommand &Com, int Cx, int Cy,
TTable *T, TField *F, TActive &A);
// 3) функция обработки команд в других полях таблицы
void FieldsProcessing ( TCommand &Com, int &Cx, int &Cy,
TTable *T, TField *F, TActive &A);
// ======================================================
// Функция работы с таблицей получает команду и выполняет ее
void Work (TTable *T, TField *F)
{ TCommand Com; // Команда
int Cx = 1, Cy = 1; // Номера выбранного столбца и строки таблицы
// Вначале активна сама таблица, а команда пустая
TActive Active = ATab; Com = cmEmpty;
// Цикл получения и обработки команд
do
{ // Получать новую команду надо, если она была пустая
if ( Com == cmEmpty ) Com = GetKbCom(Com);
// Теперь пытаемся обработать команду во всех элементах:
TabProcessing( Com, Cx, Cy, T, F, Active); // в таблице
EnumProcessing( Com, Cx, Cy, T, F, Active); // поле перечисления
FieldsProcessing( Com, Cx, Cy, T, F, Active); // других полях таблицы
}
while ( Com != cmExit ); // Повторение до получения команды выхода
}
// Функция обработки команд в таблице использует в своей работе:
// а) функцию движения по полям таблицы,
void Movement ( TCommand &C, int &Cx, int &Cy, TTable *T, TField *F);
// б) функцию ввода данных в поле таблицы с клавиатуры и
void EnterFromKb ( TCommand &C, int &Cx, int &Cy, TTable *T, TField *F);
// в) функцию вычисления значений полей сумм и итога.
void Calculation ( TCommand &C, int &Cx, int &Cy, TTable *T, TField *F);
31
// Сама функция обработки команд в таблице имеет вид:
void TabProcessing( TCommand &Com, int &Cx, int &Cy,
TTable *T, TField *F, TActive &A)
{ char *s = "Выберите вариант клавишами стрелок <- ->"; // сообщение
if (A == ATab) // действия выполняются, если активна таблица
{ // Действия по порядку (пронумерованы):
// 1. Обработка команд перемещения функцией Movement
if (( Com >= cmLt )&&( Com <= cmDn )) Movement (Com, Cx, Cy, T, F);
switch (Com) // Обработка других команд
{
// 2. Обработка команды ввода
case cmEnter :
{ // Команда ввода может выполняться
// на трех видах полей таблицы (варианты а) б) в) ):
// а) в поле подведения итога, т.е. вычисления
// путем формирования новой команды без
// передачи активности
if (Cy == (Nr+1)) Com = cmCalc;
else
{
// б) в поле поля перечисления, с передачей
// этому полю активности
if (Cx == EnumField)
{
PrintToEnterLine (s); // печать сообщения
Com = cmEmpty; // очистить команду
A = AEnum; // сделать активным поле перечисления
}
else
// в) ввод в поле значения с клавиатуры
// с передачей этому полю активности
{ Com = cmPrepare; // сформировать команду «подготовка»
A = AFields; // передать активность другим полям
}
} break;
} // конец обработки команды ввода «cmEnter».
// 3. Обработка команды вычисления суммы и количества
case cmCalc : Calculation (Com, Cx, Cy, T, F); break;
// 4. Обработка команды "покинуть"
case cmQuit : Com = cmExit; // трансформировать в выход
}
}
}
32
// =========================================================
// Функция обработки команд в поле перечисления
void EnumProcessing( TCommand &Com, int Cx, int Cy,
TTable *T, TField *F, TActive &A)
{
// Действия выполняются, если активно поле перечисления
// и команда не пустая
if ((A == AEnum)&&(Com != cmEmpty))
{
switch (Com)
{
// Обработка команд перемещения (выбора значения поля)
case cmLt :
if (T[Cy-1].Proc != Empty) (T[Cy-1].Proc)--;
else T[Cy-1].Proc = Unknown; break;
case cmRt :
if (T[Cy-1].Proc != Unknown) (T[Cy-1].Proc)++;
else T[Cy-1].Proc = Empty; break;
// Обработка команды ввода сделаем такое же, как «покинуть»
case cmEnter : ;
// Обработка команды «покинуть»
case cmQuit : ClearMsg (EnterLine); // очистить строку ввода
A = ATab; // сделать активной таблицу
}
textbackground (SelCol); // Фон выделенного поля
PrintField (T[Cy-1],F[Cx-1],Cx-1); // Вывод поля на экран
Com = cmEmpty; // После обработки команда очищается
}
}
// =========================================================
// функция обработки команд в другими полях таблицы
void FieldsProcessing( TCommand &Com, int &Cx, int &Cy,
TTable *T, TField *F, TActive &A)
{ char *s="Для начала ввода - <Enter>. Отказ - <Escape>";
if (A ==AFields) // действия выполняются, если активна таблица
{ switch (Com)
{ // Подготовка ввода данных
case cmPrepare : PrintToEnterLine(s); break;
// Обработка команды ввода значения поля
case cmEnter : EnterFromKb (Com, Cx, Cy, T, F); A = ATab; break;
// Обработка команды покинуть
case cmQuit : ClearMsg(EnterLine); A = ATab; break;
}
33
Com = cmEmpty;
}
}
// =========================================================
// Функция движения по полям таблицы использует функцию управления
// положением курсора, которая будет описана позднее
void Cursor ( TCommand C, int &Cx, int &Cy);
// Функция движения по полям таблицы
void Movement ( TCommand &Com, int &Cx, int &Cy, TTable *T, TField *F)
{ int Cxo = 1, Cyo = 1; // Номера предыдущего столбца и строки
Cxo = Cx; Cyo = Cy; // Запомнить старое местоположение
Cursor(Com, Cx, Cy); // Переместить курсор на место Cx, Cy
// Снять выделение с прежнего местоположения курсора
textbackground (Col); // Фон не выделенного поля
PrintField (T[Cyo-1],F[Cxo-1],Cxo-1); // Вывести поле на экран
// Выделить текущее местоположения курсора
textbackground (SelCol); // Фон выделенного поля
PrintField (T[Cy-1],F[Cx-1],Cx-1); // Вывести поле на экран
// Установить фон не выделенного поля
textbackground (Col); // Фон не выделенного поля
Com = cmEmpty; // Очистка команды
}
// Функция ввода данных в поле таблицы с клавиатуры
void EnterFromKb ( TCommand &Com, int &Cx, int &Cy,
TTable *T, TField *F)
{ char s[100]; // строка для данных
EnterString (s); // Вызов функции ввода данных в строку
EnterField (s, T[Cy-1], F[Cx-1], Cx-1); // Заполнение поля таблицы
// Вывести поле и выделить текущее местоположение курсора
textbackground (SelCol);
PrintField (T[Cy-1],F[Cx-1],Cx-1); // Вывод поля на экран
Com = cmEmpty; // Очистка команды
}
// Функция вычисления значений полей сумм и итога
void Calculation ( TCommand &Com, int &Cx, int &Cy, TTable *T, TField *F)
{ int R;
long S = 0; // Общая сумма
unsigned int Kol = 0; // Общее количество процессоров
textbackground(Col); // Установить фон не выделенного поля
34
// Подсчет по всем строкам
for ( R=0; R<Nr; R++)
{ T[R].Sum = (long)T[R].Cost * T[R].Cnt; // Сумма в каждой строке
S += T[R].Sum; // Сумма по всем строкам
Kol += T[R].Cnt; // Общее количество
PrintField (T[R],F[Nf-1],Nf-1); // Вывод суммы в строке
}
// Переписать вычисленные значения в соответствующие поля
T[Nr].Sum = S;
T[Nr].Cnt = Kol;
// Вывод на экран
PrintField (T[Nr],F[Nf-1],Nf-1); // Вывод общей суммы
PrintField (T[Nr],F[Nf-2],Nf-2); // Вывод общего количества
// Выделить текущее местоположение курсора
textbackground (SelCol); // Фон выделенного поля
PrintField (T[Cy-1],F[Cx-1],Cx-1); // Вывод поля на экран
Com = cmEmpty;
}
// Формирование команды по коду нажатой клавиши
TCommand GetKbCom ( TCommand Com )
{ char c;
if (kbhit()) // Действия выполнять, если была нажата клавиша
{ c = getch(); // Считать код нажатой клавиши
switch (c)
{ case 27 : return cmQuit; // покинуть
case 13 : return cmEnter; // ввод
// Обработка клавиш с двойным кодом (клавиши стрелок)
case 0: // первый код у этих клавиш равен 0
{
c = getch();
switch (c)
{ case 75 : return cmLt; // Влево
case 72 : return cmUp; // Вверх
case 77 : return cmRt; // Вправо
case 80 : return cmDn; // Вниз
}
}
}
}
return Com; // Возвратить значение команды
// Если значение команды не было изменено, то возвратится
// значение, переданное в функцию в качестве параметра
}
35
// Функция перемещения курсора
void Cursor ( TCommand C, int &Cx, int &Cy)
{ int x,y;
// Изменение координат курсора по командам
// В строке (Nr+1) (клавиша) перемещение по горизонтали нет
switch (C)
{ case cmLt : if ((Cx>1)&&(Cy!=Nr+1)) Cx- -; break;
case cmRt : if ((Cx<Nf-1)&&(Cy!=Nr+1)) Cx++; break;
case cmUp : if (Cy>1) Cy- -; break;
case cmDn :
if (Cy<Nr+1) Cy++;
// В строке Nr+1 надо перейти на поле доп. информации,
// так как клавиша расположена по этим координатам
if (Cy==Nr+1) Cx = NoteField;
}
}
// МОДУЛЬ ЗАВЕРШЕНИЯ РАБОТЫ С ТАБЛИЦЕЙ (файл Done.c)
// Завершение работы с таблицей
void Done ( char *fTabForm, char *fTableName, TTable *T, TField *F )
{ FILE *Fin; // Файл формы
FILE *Fout; // Файл таблицы
int i, j;
char s[100];
OpenFile (&Fin, fTabForm, "rt");
OpenFile (&Fout, fTableName, "wt");
// Вывод заголовка
for (i=1; i<T[0].y; i++)
{ fgets (s,90,Fin); fprintf (Fout,"%s",s); }
// Вывод содержимого таблицы
for (i=1; i<=Nr; i++)
{ fgets (s,90,Fin);
fprintf (Fout, "¦");
for (j=1; j<=Nf; j++)
{ OutField (T[i-1], F[j-1], j-1, Fout); fprintf (Fout,"¦"); }
fprintf (Fout, "\n");
}
// Вывод нижней части таблицы
for (i=1; i<4; i++)
{ fgets(s,90,Fin); fprintf (Fout,"%s",s); }
fclose (Fin); fclose (Fout);
}