main.cpp - master - fluffymax2005/course_work

Репозиторий помещен в архив 08 июня 2026. Вся функциональность доступна только для чтения.
main.cpp
1 716 строк78 KB
Максим Ледовский
Сделана рамка ячейки + масштабирование
29 янв 2025, 13:03
29 янв 2025, 13:03999038a
//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "main.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TformMain* formMain;

using namespace std;
//---------------------------------------------------------------------------
__fastcall TformMain::TformMain(TComponent* Owner)
    : TForm(Owner)
{
}
//---------------------------------------------------------------------------

void TformMain::initDataTabClear()
{
    for (size_t i = 1; i < tabIn->RowCount; i++) {
        tabIn->Rows[i]->Clear();
    }
    tabIn->RowCount = 2;
    tabIn->RowHeights[1] = -1;
    tabInSortNum = 0; // сброс номера для сортировки

    tabIn->Cells[0][0] = L"№";
    tabIn->Cells[1][0] = L"μ1";
    tabIn->Cells[2][0] = L"μ2";
}

void TformMain::chanceDataTabClear()
{
    // Очищение основной части со значениями
    for (size_t i = 2; i < tabQ->RowCount; i++) {
        tabQ->Rows[i]->Clear();
    }
    tabQ->RowCount = 3;

    // Очищение нефиксированных столбцов с t
    for (size_t j = 4; j < tabQ->ColCount; j++) {
        tabQ->Cols[j]->Clear();
    }
    tabQ->ColCount = 4;
    tabQ->FixedRows = 2;
    tabQ->RowHeights[2] = -1; // скрываем строку с №1
    tabQSortNum = 0; // сброс номера для сортировки

    tabQ->Cells[0][0] = L"";
    tabQ->Cells[0][1] = L"№";
    tabQ->Cells[0][2] = L"1";
    tabQ->Cells[1][0] = L"";
    tabQ->Cells[1][1] = L"μ1";
    tabQ->Cells[2][0] = L"";
    tabQ->Cells[2][1] = L"μ2";
    tabQ->Cells[3][0] = L"";
    tabQ->Cells[3][1] = L"λ";
}

TStringList* makeTabCopy(TStringGrid* tab, const uint32_t rowStart, const uint32_t colStart)
{
    TStringList* copy = nullptr;
    try {
        copy = new TStringList();
        for (uint32_t i = rowStart; i < tab->RowCount; i++) {
            for (uint32_t j = colStart; j < tab->ColCount; j++) {
                copy->Add(tab->Cells[j][i]);
            }
        }
    } __finally {
        return copy;
    }
}

void restoreTab(TStringGrid* tab, TStringList* copy, const uint32_t rows, const uint32_t cols,
    const uint32_t rowStart, const uint32_t colStart)
{
    if (!tab || !copy || !rows || !cols || rowStart >= rows || colStart >= cols) {
        return;
    }
    tab->RowCount = rows;
    tab->ColCount = cols;
    // Восстановление содержмого
    for (uint32_t i = rowStart; i < rows; i++) {
        for (uint32_t j = colStart; j < cols; j++) {
			tab->Cells[j][i] = copy->Strings[(cols - colStart) * (i - rowStart) + (j - colStart)];
        }
    }
}

void makeTabNumeration(TStringGrid* tab, const uint32_t rowStart, const uint32_t numColIndex) {
	if (rowStart >= tab->RowCount || numColIndex >= tab->ColCount) {
		return;
	}
	__int64 pos = 1;
	for (uint32_t i = rowStart; i < tab->RowCount; i++) {
		tab->Cells[numColIndex][i] = IntToStr(reinterpret_cast<__int64>(pos++));
	}
}

int32_t CalcGridColWidth(TStringGrid* tab, int colIndex)
{
    if (tab == nullptr || colIndex < 0 || colIndex >= tab->ColCount) {
        return 0;
    }
    tab->Canvas->Font->Assign(tab->Font);
    int32_t maxWidth = -1; // фиктивное значение
    for (int i = 0; i < tab->RowCount; i++) {
        int textWidth = tab->Canvas->TextWidth(tab->Cells[colIndex][i]);
        maxWidth = max(maxWidth, textWidth);
    }
    return maxWidth + MIN_COLUMN_WIDTH;
}

void sortTabByCol(TStringGrid* tab, uint32_t index, bool ascending)
{
    if (tab == nullptr) {
		return;
    }

    TStrings* col = tab->Cols[index];
    TStrings* tmpRow;
    try {
        tmpRow = new TStringList();
        for (uint64_t i = tab->FixedRows; i < tab->RowCount - 1; i++) {
            for (uint64_t j = i + 1; j < tab->RowCount; j++) {
				if (col->Strings[i] > col->Strings[j] && ascending /*по возрастанию*/ ||
					col->Strings[i] < col->Strings[j] && !ascending /*по убыванию*/) {
                    tmpRow->Assign(tab->Rows[i]);
                    tab->Rows[i]->Assign(tab->Rows[j]);
					tab->Rows[j]->Assign(tmpRow);
                }
            }
        }
    } __finally {
        delete tmpRow;
    }
}

fileSaveResult TformMain::TrySaveDataToFile()
{
    // Реализация сохранения с возвратом кода
	ofstream fs;
    fs.open(saveFile->FileName.c_str(), ios::binary);
    if (!fs.is_open()) {
        return Opening;
    }

    try {
        fs.write((char*)&SIGN, sizeof(TSign)); // запись сигнатуры
		if (fs.fail()) {
			_wremove(saveFile->FileName.c_str()); // Удаление файла
			return Sign;
		}

		fs.write(reinterpret_cast<char*>(&tabInSortNum), sizeof(int8_t)); // запись значения состояния сортировки таблицы 1
        if (fs.fail()) {
			_wremove(saveFile->FileName.c_str()); // Удаление файла
			return Sort;
		}

        // Запись t
		String time = timeEdit->Text;
		while (time != L"") {
            int blankIndex = PosEx(L" ", time);
            // Если не дошли до последнего элемента строки, то выделяем подстроки
            String subStr = blankIndex > 0 ? time.SubString(1, blankIndex - 1)
                                           : time; // Подстрока сравнения
            time = time.SubString(blankIndex + 1, time.Length() - subStr.Length()); // исключение проверяемое строки из time
            if (subStr == L"") {
                continue;
            }

            float tmp; // временная переменная для проверки конвертации в число
            // Проверка значения подстроки
            if (!TryStrToFloat(subStr, tmp) || tmp <= 0) {
                TFileVal type = timeStr; // данное значение является некорректным или недопустимым
                TTimeWordLen strLen = subStr.Length(); // длина некорректного или недопустимого значения

                fs.write((char*)&type, sizeof(TFileVal)); // тип - строка
                fs.write((char*)&strLen, sizeof(TTimeWordLen)); // длина строки
                fs.write((char*)AnsiString(subStr).c_str(), strLen * sizeof(TChar)); // сама строка
            } else {
                TFileVal type = timeNum; // данное значение является корректным

                fs.write((char*)&type, sizeof(TFileVal)); // тип - число
                fs.write((char*)&tmp, sizeof(TTimeNum)); // значение
            }

            if (fs.fail()) { // удалось выполнить запись информации на текущей итерации?
				_wremove(saveFile->FileName.c_str()); // Удаление файла
				return fileSaveResult::Time;
            }
        }

        if (tabIn->RowHeights[1] == -1) { // таблица 1 "пуста", те первый набор скрыт?
            return success;
        }

		// Запись пар
		TStringGrid* tab; // объект из которого будет производится запись в файл
		if (tabInSortNum) { // сортировка проводилась, а значит копия таблицы 1 существует
			tab = new (nothrow) TStringGrid((TComponent*)nullptr); // временный объект
			if (!tab) { // недостаточно памяти
				_wremove(saveFile->FileName.c_str()); // Удаление файла
				return Memory;
			}
			tab->RowCount = tabIn->RowCount;
			tab->ColCount = tabIn->ColCount;
			restoreTab(tab, initDataTabCopy, tab->RowCount, 3, 1, 1); // сохраняем содержимое в буфер
		} else { // сортировки не было
			tab = tabIn;
        }

		for (uint32_t i = 1; i < tabIn->RowCount; i++) {
			for (uint8_t j = 1; j < 3; j++) {
				// Проверка конвертации
				if (checkCell(tab, i, j) != Good) {
					TFileVal type = cellStr; // данное значение является некорректным или недопустимым
					TReqWordLen strLen = tab->Cells[j][i].Length(); // длина некорректного или недопустимого значения

					fs.write((char*)&type, sizeof(TFileVal)); // тип - строка
					fs.write((char*)&strLen, sizeof(TTimeWordLen)); // длина строки
					fs.write((char*)AnsiString(tabIn->Cells[j][i]).c_str(),
							 strLen * sizeof(TChar)); // сама строка
				} else {
					TReqNum tmp = StrToInt(tab->Cells[j][i]);
					TFileVal type = cellNum; // данное значение является корректным

					fs.write((char*)&type, sizeof(TFileVal)); // тип - число
					fs.write((char*)&tmp, sizeof(TReqNum)); // значение
				}

				if (fs.fail()) { // удалось выполнить запись информации на текущей итерации?
					_wremove(saveFile->FileName.c_str()); // Удаление файла
					return Pair;
				}
			}
		}

		if (tabInSortNum) { // сортировка сделана, поэтому нужно освободить временный буфер
            tab->Free();
		}
	} __finally {
		fs.close();
	}
	return success;
}
//---------------------------------------------------------------------------
bool TformMain::saveData(bool showDialog)
{
	String tmp = saveFile->FileName;
	if (showDialog) {
		if (!saveFile->Execute()) {
			return false;
		}
	}

	fileSaveResult retCode = TrySaveDataToFile();
	if (retCode) {
		Application->MessageBox(Format(L"Ошибка сохранения. Код ошибки: %s",
                                    retCode == Opening ? String(L"Opening") : retCode == Sign ? String(L"Sign")
                                        : retCode == fileSaveResult::Time                     ? String(L"Time")
                                                                                              : String(L"Pair"))
                                    .c_str(),
            L"Сохранение файла", MB_OK | MB_ICONERROR);
        saveFile->FileName = tmp;
        return false;
    }
    saveCap->Enabled = false; // сохранение прошло успешно
    formMain->Caption = FORM_PROGRAMM_NAME + L" - " + ExtractFileName(saveFile->FileName);
    return true;
}
//---------------------------------------------------------------------------
bool TformMain::checkChangesAndSave()
{
    if (saveCap->Enabled) {
        String tmp = saveFile->FileName.IsEmpty() ? NONAME : saveFile->FileName;
        switch (Application->MessageBox(
            String(L"Сохранить изменения в файле \"" + ExtractFileName(tmp) + L"\"?").c_str(),
            L"Сохранение файла", MB_YESNOCANCEL | MB_ICONQUESTION | MB_DEFBUTTON1)) {
        case IDYES:
            return saveData(saveFile->FileName.IsEmpty());
        case IDCANCEL:
            return false;
        }
    }
    return true;
}
//---------------------------------------------------------------------------
void __fastcall TformMain::exitCapClick(TObject* Sender)
{
    // Сохранить изменения перед выходом из программы
    if (!checkChangesAndSave()) {
        return;
    }
    Application->Terminate();
}
//---------------------------------------------------------------------------

void TformMain::TryReadDataFromFile(ifstream& fs)
{
	fs.read(reinterpret_cast<char*>(&tabInSortNum), sizeof(tabInSortNum)); // попытка чтения состояния сортировки таблицы 2
	if (fs.fail()) {
		throw runtime_error("sortStateLoad");
	}

	TFileVal type; // переменная, хранящая значение флага, который указывает на тип значения для чтения
    while (true) {
        fs.read((char*)&type, sizeof(TFileVal)); // попытка чтения флага того, что перед нами
        if (fs.eof()) { // таблица 1 дб "пуста", те не содержать данных - первый набор скрыт
            tabIn->RowHeights[1] = -1; // скрывам первый набор
            tabIn->RowCount = 2;
            return;
		} else if (fs.fail()) {
			throw runtime_error("timeOperationTypeLoad");
		}
        if (abs(type) != 2) {
            fs.seekg(-sizeof(TFileVal), ios::cur); // смещаемся на позицию до чтения (далее идёт чтение ячеек таблицы)
            break;
        }

        if (type == timeStr) { // некорректное или недопустимое значение времени
            // Чтение длины строки
            TTimeWordLen timeStrLen;
            fs.read((char*)&timeStrLen, sizeof(TTimeWordLen));
            if (fs.fail()) {
                throw runtime_error("timeStrLenLoad");
            }

            // Пробуем выделить память под строку t
            AnsiString timeStr;
            try {
                timeStr.SetLength(timeStrLen);
            } catch (EOutOfMemory&) {
                throw runtime_error("timeStringInitMemory");
            }

            // Пробуем прочитать t в readStr
            fs.read((char*)timeStr.c_str(), timeStrLen * sizeof(TChar));
            if (fs.fail()) {
                throw runtime_error("timeStringRead");
            }
            timeEdit->Text += String(timeStr) + L" ";
            continue;
        }

        // Корректное значение времени
        TTimeNum time;
        fs.read((char*)&time, sizeof(TTimeNum));
        if (fs.fail()) {
            throw runtime_error("timeNumValRead");
        }
        timeEdit->Text += FloatToStr(time) + L" ";
	}

	// Наполняем таблицу 1
	for (uint32_t i = 1; true; i++) {
        for (uint8_t j = 1; j < 3; j++) {
            fs.read((char*)&type, sizeof(TFileVal)); // попытка чтения флага того, что перед нами
            if (fs.eof()) {
                if (i == 1) { // таблица 1 дб "пуста", те не содержать данных - первый набор скрыт
                    tabIn->RowHeights[1] = -1; // скрывам первый набор
                    tabIn->RowCount = 2;
				} else {
                    tabIn->RowHeights[1] = tabIn->DefaultRowHeight; // Если загруженная таблица 1 "была пустой" в файле (т.е. был скрыт 1 пара), то скрываем её, иначе - восстанавливаем
					tabIn->RowCount = i;
                }
                goto exit; // выходим из цикла
            } else if (fs.fail()) {
                throw runtime_error("tabOperationTypeLoad");
            }

            if (abs(type) != 1) { // Считанное значение флага соответствует -1 или 1?
                throw runtime_error("tabOperationTypeIncorrect");
            }

            tabIn->Cells[0][i] = IntToStr((__int64)i);
            if (type == cellStr) { // некорректное или недопустимое значение ячейки
                // Чтение длины значения ячейки
                TReqWordLen cellLen;
                fs.read((char*)&cellLen, sizeof(TReqWordLen));
                if (fs.fail()) {
                    throw runtime_error("cellLenRead");
                }

                // Выделение памяти под строку
                AnsiString cellStr;
				try {
                    cellStr.SetLength(cellLen);
				} catch (...) {
                    throw runtime_error("cellStringInitMemory");
                }

                // Чтение значения ячейки
                fs.read((char*)cellStr.c_str(), cellLen * sizeof(TChar));
                if (fs.fail()) {
                    throw runtime_error("cellStringRead");
				}
				tabIn->Cells[j][i] = cellStr.c_str(); // занесение значения в ячейку таблицы 1
				continue;
            }

            // Корректное значение ячейки
            TReqNum cellNum;
            fs.read((char*)&cellNum, sizeof(TReqNum));
            if (fs.fail()) {
                throw runtime_error("timeNumValRead");
			}
			tabIn->Cells[j][i] = IntToStr(cellNum);
		}
	}

	exit:
	if (tabInSortNum > 0) { // сортировка производилась по возрастанию?
		tabIn->Cells[tabInSortNum - 1][0] += L" ▲";
		initDataTabCopy = makeTabCopy(tabIn, 1, 1); // создаём изначальную (неотсортированную) версию таб. 1
		sortTabByCol(tabIn, tabInSortNum - 1, true);
	} else if (tabInSortNum < 0) { // или по убыванию
		tabIn->Cells[abs(tabInSortNum) - 1][0] += L" ▼";
		initDataTabCopy = makeTabCopy(tabIn, 1, 1); // создаём изначальную (неотсортированную) версию таб. 1
		sortTabByCol(tabIn, abs(tabInSortNum) - 1, false);
	}
}

void __fastcall TformMain::openCapClick(TObject* Sender)
{
	// Сохранить изменённые данные перед загрузкой новых?

	if (!checkChangesAndSave()) {
        return;
    }

    openFile->Tag = openFile->Options.Contains(ofReadOnly) ? 0 : 1; // Запоминаем, в каком режиме был открыт ранее файл
    do {
        openFile->Options >> ofReadOnly; // Отключаем "Только на чтение" (при повторном открытии файла)
        if (!openFile->Execute()) {
            return;
        } else if (!openFile->Options.Contains(ofReadOnly)) { // Открыт файл в режиме Чтение + редактирование
            break;
        }

        int ans = Application->MessageBox(L"Вы действительно хотите открыть файл в режиме \"Только чтение\"?",
            FORM_PROGRAMM_NAME.c_str(), MB_YESNOCANCEL | MB_ICONQUESTION | MB_DEFBUTTON2);
        // Cancel - повтор диалогового окна
        if (ans == IDYES) {
            break;
        } else if (ans == IDNO) {
            return;
        }
    } while (true);

    // Открытие потока + первичная проверка на целостность
    ifstream file; // поток для чтения
    fileOpenResult retCode = TryOpenFile(file);
    if (retCode == ZeroSize) {
        Application->MessageBox(L"Файл не содержит данных\nКод ошибки: zeroSize",
            FORM_PROGRAMM_NAME.c_str(), MB_OK | MB_ICONERROR);
        return;
    } else if (retCode > ZeroSize) {
		Application->MessageBox(Format(L"Ошибка открытия файла\nКод ошибки: %s",
									retCode == NoOpen ? String(L"NoOpen") :
														retCode == SignLoad ? String(L"SignLoad") :
																			  String(L"SignValue")).c_str(),
			FORM_PROGRAMM_NAME.c_str(), MB_OK | MB_ICONERROR);
        return;
	}

    // Начинаем чтение данных для заполнения из файла
    // Сначала создаем копии данных в случае восстановления
	uint32_t rows = tabIn->RowCount; // число строк для восстановления при ошибке загрузки
	int8_t sortState = tabInSortNum; // состояние сортировки текущей таблицы 1
	String timeCopy = timeEdit->Text; // копия содержимого timeEdit для возможного восстановления
	if (tabInSortNum == 0 && !initDataTabCopy) { // сортировка производилась не совсем, поэтому нужна копия
												 //	для восстановления таблицы 1
		initDataTabCopy = makeTabCopy(tabIn, 1, 1);
		if (!initDataTabCopy) { // недостаточно памяти
			Application->MessageBox(L"Недостаточно памяти", FORM_PROGRAMM_NAME.c_str(), MB_OK | MB_ICONERROR);
            return;
		}
	}

	// Подготовка таблицы 1 к чтению
    initDataTabClear();
    tabIn->RowHeights[1] = tabIn->DefaultRowHeight;
    timeEdit->Text = L""; // очищаем содержимое timeEdit

    try {
		TryReadDataFromFile(file);
    } catch (const runtime_error& e) {
        file.close(); // закрытие потока чтения
		restoreTab(tabIn, initDataTabCopy, rows, 3, 1, 1); // восстановление содержимого таблицы 1
        makeTabNumeration(tabIn);
		if (sortState > 0) { // сортировка была по возрастанию
			tabIn->Cells[sortState - 1][0] += L" ▲";
		} else if (sortState < 0) { // сортировка была по убыванию
			tabIn->Cells[abs(sortState) - 1][0] += L" ▼";
		}
		tabInSortNum = sortState; // восстанавливаем значение сортировки
        timeEdit->Text = timeCopy;
        openFile->Tag ? openFile->Options >> ofReadOnly : openFile->Options << ofReadOnly; // восстановление режима открытия файла

        Application->MessageBox(Format(L"Ошибка чтения\nКод ошибки: %s", ARRAYOFCONST((e.what()))).c_str(),
            FORM_PROGRAMM_NAME.c_str(), MB_OK | MB_ICONERROR);
        return;
	}
	if (tabInSortNum == 0) { // изначальная версия уже загружена.
        initDataTabCopy->Free(); // освобождение памяти из-под копии таблицы 1
		initDataTabCopy = nullptr;
	}
	timeCopy = L""; // освобождение ресурса для восстановлени timeEdit
    file.close(); // закрытие потока чтения

    // Смена иконки "Режим выделения"
    if (openFile->Options.Contains(ofReadOnly)) {
		butChangeIcon(1);
        tabIn->Options >> goEditing << goRangeSelect;
        // Выключаем кнопки для редактирования таблицы
        strNew->Enabled = false;
        strInsert->Enabled = false;
        strDel->Enabled = false;
        tabInClear->Enabled = false;
    } else {
		// Включаем кнопки для редактирования таблицы
        butChangeIcon(0);
		tabIn->Options << goEditing >> goRangeSelect;
        strNew->Enabled = true;
        strInsert->Enabled = true;
        strDel->Enabled = true;
        tabInClear->Enabled = true;
    }

    // Если до этого ранее были проделаны расчёты (найдено Qср), то освобождаем память из-под предыдущего QAvg
    if (QAvgM->Tag) {
        float* QAvg = reinterpret_cast<float*>(QAvgM->Tag);
        delete QAvg; // освобождаем память, выделенную ранее под QAvg
        QAvgM->Tag = NULL; // Приводим свойство к стандартному состоянию (оно будет как фиктивное)
	}

    // Если до этого ранее была проделана сортировка табл.2, то освобождаем память из-под копии исходной табл. 2
	if (tabQ->Tag) {
        TStringList* procDataTabCopy = reinterpret_cast<TStringList*>(tabQ->Tag);
		procDataTabCopy->Free(); // освобождаем память, выделенную копию исходной табл. 2
		tabQ->Tag = NULL; // Приводим свойство к стандартному состоянию (оно будет как фиктивное)
	}

    // Сбрасываем содержимое таблицы 2 до стандартного состояния
    tabQClearClick(Sender);
    QAvgM->Text = L"Здесь будут расположены полезные сведения при обработке"; // Сбрасываем содержимое QAvgM до состояния по умолчанию

    saveFile->FileName = openFile->FileName; // Сохраняем имя файла
    formMain->Caption = FORM_PROGRAMM_NAME + L" - " + ExtractFileName(saveFile->FileName);
    saveCap->Enabled = false;
	tabQSortNum = 0;
}
//---------------------------------------------------------------------------

fileOpenResult TformMain::TryOpenFile(ifstream& fs)
{
    fs.open(openFile->FileName.c_str(), ios::in | ios::binary | ios::ate);
    if (!fs.is_open()) {
        return NoOpen;
    }
    // Проверяем, что файл не пуст
    if (!fs.tellg()) {
        fs.close();
        return ZeroSize;
    }
    // Проверяем, что размер код-ключа файла соответствует указанному значению
    fs.seekg(0);
    int32_t sign;
    fs.read((char*)&sign, sizeof(int32_t));
    if (fs.fail()) {
        fs.close();
        return SignLoad;
    } else if (sign != SIGN) {
        fs.close();
        return SignValue;
    }
    return Opened;
}
//---------------------------------------------------------------------------
void __fastcall TformMain::newCapClick(TObject* Sender)
{
    // Сохранить изменённые данные перед созданием нового файла?
    if (!checkChangesAndSave()) {
        return;
    }

    openFile->Options >> ofReadOnly; // Убираем режим только чтения

    // Подгатавливаем таблицы к созданию нового файла исходных данных
    initDataTabClear();
    chanceDataTabClear();

    // Включаем кнопки редактирования + обработка
    strNew->Enabled = true;
    strInsert->Enabled = true;
    strDel->Enabled = true;
    calcQ->Enabled = true;

    saveFile->FileName = L""; // Безымянный файл ещё не имеет места в памяти
    timeEdit->Text = L""; // сбравсываем содержимое timeEdit
    formMain->Caption = FORM_PROGRAMM_NAME + L" - " + NONAME; // Обновляем название формы
    saveCap->Enabled = false; // новый файл ещё не редактировался
    tabInSortNum = 0; // сортировка ещё не проводилась
    tabQSortNum = 0;

    tabIn->Options >> goEditing; // отключаем редактирование, поскольку отсутствуют строки для заполнения

    // Если до этого ранее были проделаны расчёты, то освобождаем память из-под предыдущего QAvg
    if (QAvgM->Tag) {
        float* QAvg = reinterpret_cast<float*>(QAvgM->Tag);
        delete QAvg; // освобождаем память, выделенную ранее под QAvg
        QAvgM->Tag = NULL; // Приводим свойство к стандартному состоянию (оно будет как фиктивное)
    }
    QAvgM->Text = L"Здесь будут расположены полезные сведения при обработке"; // Сбрасываем содержимое QAvgM до состояния по умолчанию
}
//---------------------------------------------------------------------------

void __fastcall TformMain::saveAsCapClick(TObject* Sender)
{
    saveData(true);
}
//---------------------------------------------------------------------------

void __fastcall TformMain::strNewClick(TObject* Sender)
{
    if (openFile->Options.Contains(ofReadOnly)) {
        stBar->SimpleText = L"Редактирование таблицы в режиме \"Только чтение\" недоступно";
        return;
    }

    stBar->SimpleText = L"";
    // Если до этого момента в таблице 1 "не было" пар (первая была скрыта), то восстанавливаем её
    if (tabIn->RowHeights[1] == -1) {
        tabIn->RowHeights[1] = tabIn->DefaultRowHeight;
        tabIn->Options << goEditing; // включаем возможность редактирования. Появилась хотя бы одна строка для редактирования
        tabIn->Cells[0][1] = L"1";
    } else {
        // Добавляем новую строку в конец строкового редактора
        tabIn->RowCount++;
        tabIn->Cells[0][tabIn->RowCount - 1] = Format(L"%d", tabIn->RowCount - 1);

        // Выполняем перевод фокуса ввода
        tabIn->Row = tabIn->RowCount - 1;
        tabIn->SetFocus();
    }
    // Произошли изменения
    if (!saveCap->Enabled) {
        saveCap->Enabled = true;
        formMain->Caption += L" *";
    }
}
//---------------------------------------------------------------------------

void __fastcall TformMain::strInsertClick(TObject* Sender)
{
    if (openFile->Options.Contains(ofReadOnly)) {
        stBar->SimpleText = L"Редактирование таблицы в режиме \"Только чтение\" недоступно";
        return;
    }

    stBar->SimpleText = L"";
    // Если до этого момента в таблице 1 "не было" пар (первая была скрыта), то восстанавливаем её
    if (tabIn->RowHeights[1] == -1) {
		tabIn->RowHeights[1] = tabIn->DefaultRowHeight;
        tabIn->Options << goEditing; // включаем возможность редактирования. Появилась хотя бы одна строка для редактирования
        tabIn->Cells[0][1] = L"1";
    } else {
        // Сдвигаем все строки ниже текущей вниз
        for (size_t i = tabIn->RowCount - 1; i >= tabIn->Row; i--) {
            tabIn->Rows[i + 1] = tabIn->Rows[i];
            tabIn->Cells[0][i + 1] = String(i + 1);
        }
        tabIn->RowCount++; // Увеличиваем общее количество строк
        tabIn->Rows[tabIn->Row]->Clear(); // очищаем строку под вставляемую
        tabIn->Cells[0][tabIn->Row] = Format(L"%d", tabIn->Row); // ввод номер набора
    }
    // Созданы изменения:
	if (!saveCap->Enabled) {
		formMain->Caption += L" *";
		saveCap->Enabled = true;
	}
}
//---------------------------------------------------------------------------

void __fastcall TformMain::saveCapClick(TObject* Sender)
{
	saveData(saveFile->FileName.IsEmpty());
}
//---------------------------------------------------------------------------

void __fastcall TformMain::tabInSetEditText(TObject* Sender, System::LongInt ACol, System::LongInt ARow, const UnicodeString Value)
{
    TStringGrid* tab = dynamic_cast<TStringGrid*>(Sender);

    if (!tab->Tag) { // ошибка ввода обработана?
        if (tab->EditorMode) { // находимся в режиме редактирования? (не путать с кнопкой)
            // Проверка конвертации из строки в число
			switch (checkCell(tab, tabIn->Row, tabIn->Col)) {
            case Incorrect:
                stBar->SimpleText = Format(L"Введено некорректное значение \"%s\". Ячейка должна содержать число",
                    tabIn->Cells[tabIn->Col][tabIn->Row]);
                break;
            case BadRange:
                stBar->SimpleText = Format(L"Введено недопустимое значение \"%s\". Содержимое ячейки должно неотрицательным целым и не более 110",
                    tabIn->Cells[tabIn->Col][tabIn->Row]);
                break;
            default:
                stBar->SimpleText = L"";
            }
        }
    } else {
        tab->Tag = false;
    }

    // Уменьшение числа ложных срабатываний проверки на наличие несохраненных изменений
	if (!saveCap->Enabled && !tab->EditorMode && curCellText != Value) {
        formMain->Caption += L" *";
        saveCap->Enabled = true;
	}
}
//---------------------------------------------------------------------------

void __fastcall TformMain::tabInSelectCell(TObject* Sender, System::LongInt ACol, System::LongInt ARow, bool& CanSelect)
{

    if (openFile->Options.Contains(ofReadOnly)) {
        stBar->SimpleText = L"Редактирование таблицы в режиме \"Только чтение\" недоступно";
        return;
    }

    TStringGrid* tab = dynamic_cast<TStringGrid*>(Sender);
    if (!saveCap->Enabled && tab->EditorMode) { // уже есть несохраненные изменения?
        // пользователь находится в состоянии редактирования ячейки?
        if (curCellText != tab->Cells[tab->Col][tab->Row]) { // есть отличия при переходе в другую ячейку?
			if (!saveCap->Enabled) { // компонент "Сохранить" доступен?
				formMain->Caption += L" *";
				saveCap->Enabled = true;
            }
        }
    }

	// Проверка конвертации из строки в число
	switch (checkCell(tab, tabIn->Row, tabIn->Col)) {
	case Incorrect:
		stBar->SimpleText = Format(L"Введено некорректное значение \"%s\". Ячейка должна содержать число",
			tabIn->Cells[tab->Col][tab->Row]);
		break;
	case BadRange:
		stBar->SimpleText = Format(L"Введено недопустимое значение \"%s\". Число должно быть неотрицательным",
			tabIn->Cells[tab->Col][tab->Row]);
		break;
	default:
		stBar->SimpleText = L"";
	}
	tab->Tag = true;

	if (tab->EditorMode && tabInSortNum != 0 && tab->Col == abs(tabInSortNum) - 1 && curCellText != tab->Cells[tab->Col][tab->Row]) {
		int32_t j = abs(tabInSortNum) - 1; // индекс столбца (если по какому-то была произведена сортировка)
		tab->Cells[j][0] = tab->Cells[j][0].SubString(1, tab->Cells[j][0].Length() - 2); // убираем пометку сортировки
		tabInSortNum = 0; // как бы новое исходное состояние таблицы

		initDataTabCopy->Free(); // освобождение памяти из-под неактульной таблицы 1
		initDataTabCopy = makeTabCopy(tab, 1, 1); // создаём актуальную копию таблицы 1
		if (!initDataTabCopy) { // удалось создать копию?
			Application->MessageBox(L"Недостаточно памяти", FORM_PROGRAMM_NAME.c_str(), MB_OK | MB_ICONERROR);
		}
	}
    tab->Repaint();
}

void __fastcall TformMain::highModeButClick(TObject* Sender)
{
    // Если включен режим "Только чтение", то не даем изменять таблицу
    if (openFile->Options.Contains(ofReadOnly)) {
        stBar->SimpleText = L"Вы открыли файл в режиме \"Только чтение\". Редактирование недоступно";
        return;
    }

    butChangeIcon(tabIn->Options.Contains(goEditing)); // Изменяем иконку
        // goEditing есть - в выкл, иначе вкл
    highModeCap->Bitmap = highModeBut->Glyph;
    highModeCap->Checked = !highModeCap->Checked; // инвертируем состояние highModeCap

    if (tabIn->Options.Contains(goEditing)) { // включаем многострочное выделение
        tabIn->Options >> goEditing << goRangeSelect; // Включаем режим редактирования в табличном редакторе
        return;
    }
    tabIn->Options >> goRangeSelect << goEditing; // Выключаем режим редактирования в табличном редакторе
}
//---------------------------------------------------------------------------

void __fastcall TformMain::strDelClick(TObject* Sender)
{
    if (openFile->Options.Contains(ofReadOnly)) {
		stBar->SimpleText = L"Редактирование таблицы в режиме \"Только чтение\" недоступно";
		return;
	}

	if (tabIn->RowHeights[1] == -1) { // таблица 1 уже как бы "не содержит" ничего
		stBar->SimpleText = L"Таблица 1 не содержит пар";
		return;
	}

	// Берем диапазон выбранных ячеек (или ячейки)
	const uint32_t rowUp = tabIn->Selection.Top;
	const uint32_t rowDown = tabIn->Selection.Bottom;

	if (rowDown == rowUp) { // удаляем одну строку
        if (Application->MessageBox(Format(L"Вы действительно хотите удалить %d пару?", rowUp).c_str(),
				FORM_PROGRAMM_NAME.c_str(), MB_YESNO | MB_ICONQUESTION | MB_DEFBUTTON2) == IDNO) {
			return;
        }
    }

	else {
        if (Application->MessageBox(Format(L"Вы действительно хотите удалить с %d по %d пары?",
										ARRAYOFCONST((rowUp, rowDown))).c_str(),
                FORM_PROGRAMM_NAME.c_str(), MB_YESNO | MB_ICONQUESTION | MB_DEFBUTTON2) == IDNO) {
			return;
        }
	}

    // "Удаление" всех строк - очищение содержимого [1, n] строк + скрытие №1 строки
    if (rowUp == 1 && rowDown == tabIn->RowCount - 1) {
		tabIn->RowCount++; // увеличение числа строк для унификации уменьшения данного свойства
        tabIn->RowHeights[1] = -1;
        tabIn->Options >> goEditing;
        stBar->SimpleText = L"Таблица 1 больше не содержит пар";
	}

	// Теперь заполняем таблицу оставшимися значениями
	// leftStrStart - индекс начала оставшихся (неудалённых) строк
	for (uint32_t i = rowUp, leftStrStart = rowDown + 1; i < tabIn->RowCount - 1; i++, leftStrStart++) {
		tabIn->Rows[i] = tabIn->Rows[leftStrStart]; // копирование оставшихся строк на место удаляемых
		tabIn->Cells[0][i] = IntToStr((__int64)i); // Номер набора
	}
	for (uint32_t i = tabIn->RowCount - (rowDown - rowUp + 1) ; i < tabIn->RowCount; i++) { // удаление остаточных строк
		tabIn->Rows[i]->Clear();
	}
    // Уменьшаем число строк на разницу нижнего и верхнего индекса выделяемых строк
	tabIn->RowCount -= rowDown - rowUp + 1;

	// Созданы изменения:
	if (!saveCap->Enabled) {
		saveCap->Enabled = true;
		formMain->Caption += L" *";
	}
}
//---------------------------------------------------------------------------

void __fastcall TformMain::calcQClick(TObject* Sender)
{
	if (tabIn->RowHeights[1] == -1) { // в таблице 1 как бы "нету" никаких данных
        Application->MessageBox(L"Таблица 1 не содержит данных\nЗаполните её",
            FORM_PROGRAMM_NAME.c_str(), MB_OK | MB_ICONERROR);
        return;
    }

    // Перед расчётом Q надо убедиться, что все значения таблицы 1 допустимы и все ячейки заполнения не пусты
    for (uint32_t i = 1; i < tabIn->RowCount; i++) {
        for (uint8_t j = 1; j < 3; j++) {
            // Проверяем, что число в столбце допустимо и корректно (также содержит значение)
			convertResult retCode = checkCell(tabIn, i, j);
            if (retCode == Good) {
                continue;
            }

            tabIn->SetFocus(); // Перевод фокуса в ячейку
            tabIn->Row = i, tabIn->Col = j;
            switch (retCode) {
            case convertResult::Empty:
                Application->MessageBox(Format(L"Ячейка пуста\nНабор - %d\nСтолбец - %s",
                							   i, i == 1 ? L"μ1" : L"μ1").c_str(),
                    					FORM_PROGRAMM_NAME.c_str(), MB_OK | MB_ICONERROR);
                break;
            case Incorrect:
                Application->MessageBox(Format(L"Ячейка с содержимым \"%s\" должна быть числом\nНабор - %d\nCтолбец - %s",
											   tabIn->Cells[j][i], i, i == 1 ? L"μ1" : L"μ1").c_str(),
                    					FORM_PROGRAMM_NAME.c_str(), MB_OK | MB_ICONERROR);
                break;
            case BadRange:
				Application->MessageBox(Format(L"Содержимое ячейки \"%s\" должно неотрицательным целым и не более 110\nНабор - %d\nСтолбец - %s",
											   tabIn->Cells[j][i], i, i == 1 ? L"μ1" : L"μ1").c_str(),
                    					FORM_PROGRAMM_NAME.c_str(), MB_OK | MB_ICONERROR);
                break;
            }
            return;
        }
    }

    // Теперь надо проверить timeEdit
    DynamicArray<float> t; // временный массив под хранение значений t
    String subStr; // подстрока проверки
    String time = timeEdit->Text;
    uint16_t i = 0; // индекс очередного t (после следующего цикла - размерность массива t)
    uint32_t timeIndex = 0; // абсолютная позиция начала некорректного значения
    while (time != L"") {
        int blankIndex = PosEx(L" ", time);
        // Если не дошли до последнего элемента строки, то выделяем подстроки
        blankIndex > 0 ? subStr = time.SubString(1, blankIndex - 1 /*не включая символ пробела*/)
                       : subStr = time; // Дошли до последнего значения
		time = time.SubString(blankIndex + 1, time.Length() - subStr.Length()); // исключение подстроки из основной строки
        if (subStr == L"") { // Пользователь использовал несколько пробельных символов между значениями?
            continue;
        }

        float conv;
        // Проверка значения подстроки
        if (!TryStrToFloat(subStr, conv)) {
            Application->MessageBox(Format(L"Некорректное значение \"%s\".\nВремя должно быть числом",
                                        ARRAYOFCONST((subStr)))
                                        .c_str(),
                FORM_PROGRAMM_NAME.c_str(), MB_OK | MB_ICONERROR);
            // Установка фокуса на некорректное значение
            timeEdit->SetFocus();
            timeEdit->SelStart = timeIndex, timeEdit->SelLength = subStr.Length();
            return;
        } else if (conv <= 0) {
            Application->MessageBox(Format(L"Недопустимое значение \"%s\".\nВремя должно быть вещественным положительным",
                                        ARRAYOFCONST((subStr)))
                                        .c_str(),
                FORM_PROGRAMM_NAME.c_str(), MB_OK | MB_ICONERROR);
            // Установка фокуса на недопустимое значение
            timeEdit->SetFocus();
            timeEdit->SelStart = timeIndex, timeEdit->SelLength = subStr.Length();
            return;
        }

        // Попытка выделения памяти под очередное t
        try {
            t.Length++;
        } catch (...) {
            Application->MessageBox(L"Ошибка выделения памяти для расчёта вероятностей.\nКод ошибки: lowMemoryForTimeArrExt",
                FORM_PROGRAMM_NAME.c_str(), MB_OK | MB_ICONERROR);
            chanceDataTabClear();
            return;
        }
		t[i++] = conv;
        timeIndex += blankIndex;
    }
    if (i == 0) { // значения t вообще есть в timeEdit?
        Application->MessageBox(L"Отсутствуют общие t\nВведите хотя бы одно t",
            FORM_PROGRAMM_NAME.c_str(), MB_OK | MB_ICONERROR);
        return;
    }

    tabQClearClick(Sender); // подготовка таблицы 2 к выводу

    // Пройдя все проверки, можно начать рассчёт Q
    tabQ->RowCount = tabIn->RowCount + 1; // Число строк табл вх дан = числу строк табл обр дан + 1 (фикс стр под t)
    tabQ->ColCount += i; // добавляем доп столбцы под t
    tabQ->RowHeights[2] = tabQ->DefaultRowHeight; // восстанавливаем строку №1

    // Заполнение необходимой информации о t
    for (uint32_t j = 4; j < i + 4; j++) {
        tabQ->Cells[j][0] = L"t" + String(j - 3); // название столбцов t1, t2, ...
        tabQ->Cells[j][1] = FloatToStr(t[j - 4]).Length() < Format(L"%.3f", ARRAYOFCONST((t[j - 4]))) ? // выбираем наиболее короткую
            FloatToStr(t[j - 4])
                                                                                                      : // форму записи значений столбцов t1, t2 ...
            Format(L"%.3f", ARRAYOFCONST((t[j - 4])));
    }

    // Если до этого ранее были проделаны расчёты, то освобождаем память из-под предыдущего QAvg
    if (QAvgM->Tag) {
        float* QAvg = reinterpret_cast<float*>(QAvgM->Tag);
        delete QAvg; // освобождаем память, выделенную ранее под QAvg
        QAvgM->Tag = NULL; // Приводим свойство к стандартному состоянию (оно будет как фиктивное)
    }

    // Рассчитываем Q для каждой строки попутно заполняя таблицу + считаем Qср
    float* avg;
    try {
        avg = new float(0);
    } catch (...) {
        tabQClearClick(Sender); // приведение таблицы 2 к стандартному виду
        Application->MessageBox(L"Недостаточно памяти для рассчётов", FORM_PROGRAMM_NAME.c_str(), MB_OK | MB_ICONERROR);
        return;
    }

    QAvgM->Tag = reinterpret_cast<intptr_t>(avg); // храним Qср, пока оно нужно
    for (uint32_t i = 1; i < tabIn->RowCount; i++) {
        tabQ->Rows[i + 1] = tabIn->Rows[i]; // копирование пар
        tabQ->Cells[3][i + 1] = FloatToStr(((float)StrToFloat(tabIn->Cells[1][i]) + StrToFloat(tabIn->Cells[2][i])) / 2); // lambda
        // Заполнение столбцов с вероятностями
        for (uint32_t j = 4; j < tabQ->ColCount; j++) {
            tabQ->Cells[j][i + 1] = Format("%0.4e", findQ(t[j - 4], i));
            *avg += StrToFloat(tabQ->Cells[j][i + 1]); // ищем сумму
        }
    }
    *avg /= (tabQ->RowCount - 2) /*не вкл. фикс. ст.*/ * (tabQ->ColCount - 4) /*не вкл. стобц. исх. данных*/; // нашли Qср

    // Выводим значение Qср + доверительный интервал
    float downBorder = *avg * (1 - changeVariance->Tag / 100.0);
    float upBorder = *avg * (1 + changeVariance->Tag / 100.0);

    QAvgM->Text = Format(L"Qср = %0.4e\r\nДоверительный интервал - (%0.4e; %0.4e)",
        ARRAYOFCONST((*avg, downBorder, upBorder)));
    tabQ->Repaint(); // повторная закраска с учётом Qср

    // Включаем кнопки для в панеле "Результаты" для таб.2
    saveT2As->Enabled = true;
    tabQClear->Enabled = true;
}
//---------------------------------------------------------------------------

void __fastcall TformMain::tabQClearClick(TObject* Sender)
{
	tabQClear->Enabled = false; // также очищать нечего
    saveT2As->Enabled = false; // сохранять нечего

    float* QAvg = reinterpret_cast<float*>(QAvgM->Tag);
	delete QAvg; // освобождаем память, выделенную ранее под QAvg
	QAvgM->Tag = NULL; // Приводим свойство к стандартному состоянию (оно будет как фиктивное)

	TStringList* procDataTabCopy = reinterpret_cast<TStringList*>(tabQ->Tag);
	procDataTabCopy->Free(); // освобождаем память, выделенную копию исходной табл. 2
	tabQ->Tag = NULL; // Приводим свойство к стандартному состоянию (оно будет как фиктивное)

    chanceDataTabClear();
}
//---------------------------------------------------------------------------

void __fastcall TformMain::saveT2AsClick(TObject* Sender)
{
    if (!saveProcTab->Execute()) {
        return;
    }

    ofstream ofs;
    ofs.open(saveProcTab->FileName.c_str());
    if (!ofs.is_open()) {
        int error_code = errno;
        String errMes = L"Ошибка записи файла \"" + ExtractFileName(saveProcTab->FileName) + L"\"\n";

        switch (error_code) {
        case EFBIG:
            errMes += L"\nЗаписываемый файл слишком большой";
            break;
        case EACCES:
            errMes += L"\nЗапрет на запись. Проверьте права директории сохранения";
            break;
        case EPERM:
            errMes += L"\nОперация запрещена. Проверьте права доступа";
            break;
        default:
            errMes += L"\nОшибка. Попробуйте ещё раз";
            break;
        }

        Application->MessageBox(errMes.c_str(), FORM_PROGRAMM_NAME.c_str(), MB_OK | MB_ICONERROR);
        return;
    }

    DynamicArray<size_t> len; // Временный массив под длины столбцов выравнивания
    try {
        len.Length = tabQ->ColCount;
    } catch (...) {
        ofs.close();
        Application->MessageBox(L"Недостаточно памяти для форматированного вывода\nКод ошибки: tooFewMemForFormat",
            FORM_PROGRAMM_NAME.c_str(), MB_OK | MB_ICONERROR);
        return;
    }

    mxL(len); // Длина столбцов форматирования
    // Важное замечание: в нашей кодировке нет греческих букв, поэтому будем заменять их альтернативой (см. реализацию)
    // Запись t1, t2, t3 ...
    ofs << setw(len[0] + len[1] + len[2] + len[3] + len[4]) << "t1"; // Выводим t1 как опору
    for (uint32_t j = 5; j < tabQ->ColCount; j++) {
        ofs << setw(len[j]) << AnsiString(Format("t%d", j - 3)).c_str();
    }
    endl(ofs); // вторая строка

    ofs << setw(len[0] - 1) << "№";
    ofs << setw(len[1]) << "mu1";
    ofs << setw(len[2]) << "mu2";
    ofs << setw(len[3]) << "lambda";
    // Запись значений t1, t2, t3 ...
    for (uint32_t j = 4; j < tabQ->ColCount; j++) {
        ofs << setw(len[j]) << AnsiString(tabQ->Cells[j][1]).c_str();
    }
    endl(ofs);

    // Теперь оставшаяся таблица
    for (uint32_t i = 2; i < tabQ->RowCount; i++) {
        for (uint32_t j = 0; j < tabQ->ColCount; j++) {
            ofs << setw(len[j]) << AnsiString(tabQ->Cells[j][i]).c_str();
        }
        endl(ofs);
    }
    ofs.close();
}
//---------------------------------------------------------------------------

void __fastcall TformMain::tabInClearClick(TObject* Sender)
{
    for (uint32_t i = 1; i < tabIn->RowCount; i++) {
        tabIn->Rows[i]->Clear();
        tabIn->Cells[0][i] = IntToStr((__int64)i);
    }

    // Созданы изменения:
    if (!saveCap->Enabled) {
        saveCap->Enabled = true;
        formMain->Caption += L" *";
    }
}
//---------------------------------------------------------------------------

void __fastcall TformMain::FormCloseQuery(TObject* Sender, bool& CanClose)
{
    // Сохранить изменения перед выходом из программы
    CanClose = checkChangesAndSave();
}
//---------------------------------------------------------------------------

void __fastcall TformMain::FormCreate(TObject* Sender)
{
	// Заполняем универсальные колонки
    tabIn->Cells[0][0] = L"№", tabQ->Cells[0][1] = L"№";
    tabIn->Cells[0][1] = L"1", tabQ->Cells[0][2] = L"1";
    tabIn->Cells[1][0] = L"μ1", tabQ->Cells[1][1] = L"μ1";
    tabIn->Cells[2][0] = L"μ2", tabQ->Cells[2][1] = L"μ2";
    tabQ->Cells[3][1] = L"λ";

    // Таблица 2 как бы "пустая"
	tabQ->RowHeights[2] = -1;
	tabsSplitter->MinSize = tabQPanel->Constraints->MinWidth;
	resultSplitter->MinSize = QAvgM->Constraints->MinWidth;
    tabIn->EditorMode = true;
}
//---------------------------------------------------------------------------

void __fastcall TformMain::openFileShow(TObject* Sender)
{
    //
}
//---------------------------------------------------------------------------

void __fastcall TformMain::tabInDrawCell(TObject* Sender, System::LongInt ACol, System::LongInt ARow,
    TRect& Rect, TGridDrawState State)
{
	TStringGrid* tab = dynamic_cast<TStringGrid*>(Sender);

    String s;
    // Пользователь выделяет несколько ячеек
    if (State.Contains(gdSelected) && tab->Options.Contains(goRangeSelect)) {
        tab->Canvas->Font->Assign(tab->Font);
        tab->Canvas->Brush->Color = HIGHLIGHT_COLOR;
        tab->Canvas->Font->Color = clBlack;

        s = tab->Cells[ACol][ARow];
        TRect r = Rect;
        tab->Canvas->TextRect(r, r.Left + (tab->ColWidths[ACol] - tab->Canvas->TextWidth(s)) / 2, r.Top + 2, s);
        return;
    }

    // Закраска фиксированных строк и столбцов
    if (ARow == 0 || ACol == 0) {
        tab->Canvas->Font->Assign(tab->Font);
        s = tab->Cells[ACol][ARow];
        tab->Canvas->Brush->Color = FIXED_BACK_COLOR;

        TRect r = Rect;
        tab->Canvas->TextRect(r, r.Left + (tab->ColWidths[ACol] - tab->Canvas->TextWidth(s)) / 2, r.Top + 2, s);
        return;
	}

	// Закраска остальных ячеек
    s = tab->Cells[ACol][ARow];
    tab->Canvas->Font->Assign(tab->Font);
    switch (checkCell(tab, ARow, ACol)) {
    case convertResult::Empty:
        tab->Canvas->Brush->Color = EMPTY_COLOR;
        break;
    case BadRange:
    case Incorrect:
        tab->Canvas->Brush->Color = FAILED_COLOR;
        break;
    default:
        tab->Canvas->Brush->Color = GOOD_COLOR;
	}
    TRect r = Rect;
	tab->Canvas->TextRect(r, r.Left + (tab->ColWidths[ACol] - tab->Canvas->TextWidth(s)) / 2, r.Top + 2, s);

    if (ARow == tab->Row && ACol == tab->Col) { // пользователь выбрал текущую ячейку
		tab->Canvas->Pen->Color = CHOOSE_COLOR;
		tab->Canvas->Pen->Width = 2;
		tab->Canvas->Brush->Style = bsClear;
		tab->Canvas->Rectangle(Rect.Left - 1, Rect.Top - 1, Rect.Right + 1, Rect.Bottom + 1);
	}
}
//---------------------------------------------------------------------------

void __fastcall TformMain::tabInDblClick(TObject* Sender)
{
	TStringGrid* tab = dynamic_cast<TStringGrid*>(Sender);
	TPoint p = Mouse->CursorPos; // координаты мыши
    p = tab->ScreenToClient(p); // относительно таблицы

    if (GetCursor() == Screen->Cursors[crHSplit]) {
        TGridCoord tabCoord = tab->MouseCoord(p.X - 4, p.Y); // индексы строки и столбца
        int wide = CalcGridColWidth(tab, tabCoord.X); // оптимальная ширина
        if (tab->ColWidths[tabCoord.X] != wide) {
            tab->ColWidths[tabCoord.X] = wide;
        } else {
            tab->ColWidths[tabCoord.X] = MIN_COLUMN_WIDTH;
        }
    } else {
        TGridCoord tabCoord = tab->MouseCoord(p.X, p.Y);
        if (tabCoord.Y || tabCoord.X <= 0) { // находимся в фиксированном столбце или ячейке "№"?
            return; // ничего не делаем
        }

        if (openFile->Options.Contains(ofReadOnly)) {
            stBar->SimpleText = L"Файл открыт в режиме \"Только чтение\". Сортировка не допускается";
            return;
        }

		int32_t j = abs(tabInSortNum) - 1; // индекс столбца (если по какому-то была произведена сортировка)
		if (tabInSortNum != 0) { // сортировка была уже раньше?
			tab->Cells[j][0] = tab->Cells[j][0].SubString(1, tab->Cells[j][0].Length() - 2); // убираем пометку сортировки
		} else {
			initDataTabCopy->Free(); // освобождение памяти из-под неактульной таблицы 1
			initDataTabCopy = makeTabCopy(tab, 1, 1); // создаём актуальную копию таблицы 1
			if (!initDataTabCopy) { // удалось создать копию?
				Application->MessageBox(L"Недостаточно памяти для сортировки", FORM_PROGRAMM_NAME.c_str(), MB_OK | MB_ICONERROR);
				return;
			}
        }

        if (j != tabCoord.X) { // выполняем сортировку по другому столбцу
            tabInSortNum = tabCoord.X + 1; // делаем сортировку заново или по новому столбцу
        } else {
            tabInSortNum = tabInSortNum > 0 /*Сортировка по возрастанию уже была?*/ ? -tabInSortNum : // меняем направление сортировки на "по убыванию"
                0; // меняем направление сортировки на "отключено"
        }
        j = tabCoord.X;

		if (tabInSortNum > 0) { // переключаемся: "нет сортировки" -> "по возрастанию"
			tab->Cells[j][0] += L" ▲";
		} else if (tabInSortNum < 0) {
			tab->Cells[j][0] += L" ▼"; // переключаемся: "по возрастанию" -> "по убыванию"
		}
        if (tab->ColWidths[j] < CalcGridColWidth(tab, j)) { // текущая ширина меньше оптимальной?
            tab->ColWidths[j] = CalcGridColWidth(tab, j); // тогда может быть не видно значка сортировки
        }
        // Сортировка
		if (tabInSortNum == 0) { // приведение таблицы 1 к исходному виду
			restoreTab(tabIn, initDataTabCopy, tab->RowCount, 3, 1, 1);
            initDataTabCopy->Free(); // копия теперь не нужна
			initDataTabCopy = nullptr;
		} else {
			sortTabByCol(tab, j, tabInSortNum > 0); // сортировка по возрастанию или убыванию
            for (uint32_t i = 1; i < tab->RowCount; i++) {
				tab->Cells[0][i] = IntToStr(static_cast<__int64>(i)); // обновляем номера наборов
			}
        }

        // Произошли изменения
        if (!saveCap->Enabled) {
            saveCap->Enabled = true;
            formMain->Caption += L" *";
        }
    }
}
//---------------------------------------------------------------------------


void __fastcall TformMain::tabQDrawCell(TObject* Sender, System::LongInt ACol, System::LongInt ARow,
    TRect& Rect, TGridDrawState State)
{
    TStringGrid* tab = dynamic_cast<TStringGrid*>(Sender);

    String s;
    if (ACol >= 4 && ARow == 1 /*Значения под t1,t2,..*/ || ACol >= 1 && ACol <= 3 && ARow >= 2 /*Значения mu1,2,lambda*/) {
        s = tab->Cells[ACol][ARow];
        tab->Canvas->Brush->Color = s == L"" ? EMPTY_COLOR : FIXED_BACK_VAL_COLOR;
        tab->Canvas->Font->Assign(tab->Font);

        TRect r = Rect;
        tab->Canvas->TextRect(r, r.Left + (tab->ColWidths[ACol] - tab->Canvas->TextWidth(s)) / 2, r.Top + 2, s);
        return;
    } else if (ACol == 0 || ARow <= 1) { // Закраска фиксированных строк и столбцов (кроме значений t1,t2,...)
        tab->Canvas->Font->Assign(tab->Font);
        s = tab->Cells[ACol][ARow];
        tab->Canvas->Brush->Color = FIXED_BACK_COLOR;

        TRect r = Rect;
        tab->Canvas->TextRect(r, r.Left + (tab->ColWidths[ACol] - tab->Canvas->TextWidth(s)) / 2, r.Top + 2, s);
        return;
    } else if (ACol >= 4 && ARow >= 2) {
        // Закраска выполняется только в случае, когда найдено Qср - после всех подсчётов
        // а до тех пор мы не трогаем закраску значений
        if (QAvgM->Lines->Strings[0][1] != L'Q') {
            return;
        }

        // Закраска ячеек вероятностей
        s = tab->Cells[ACol][ARow];
        tab->Canvas->Font->Assign(tab->Font);
        float QAvg = *reinterpret_cast<float*>(QAvgM->Tag);
        if (StrToFloat(s) > QAvg * (1 - changeVariance->Tag / 100.0) && StrToFloat(s) < QAvg * (1 + changeVariance->Tag / 100.0)) {
            tab->Canvas->Brush->Color = GOOD_COLOR;
        } else {
            tab->Canvas->Brush->Color = NOT_IN_RANGE_NUMBER_COLOR;
        }
        TRect r = Rect;
		tab->Canvas->TextRect(r, r.Left + (tab->ColWidths[ACol] - tab->Canvas->TextWidth(s)) / 2, r.Top + 2, s);
	}
}
//---------------------------------------------------------------------------


void __fastcall TformMain::timeEditKeyPress(TObject* Sender, System::WideChar& Key)
{
    if (!(Key >= L'0' && Key <= L'9' || Key == L' ' || Key == L',' || Key == VK_BACK || Key == 3 /* Ctrl + C*/ || Key == 22 /*Ctrl + V*/ || Key == 24 /* Ctrl + X*/)) {
        stBar->SimpleText = L"Некорректный символ - \'" + String(Key) + L"\'. Введите цифру, запятую или пробел";
        Key = 0;
    }
}
//---------------------------------------------------------------------------

void __fastcall TformMain::timeEditChange(TObject* Sender)
{
    // Если пользователь изменил содержимое, то произошли изменения
    TEdit* edit = dynamic_cast<TEdit*>(Sender);
    if (!saveCap->Enabled && edit->Modified) {
        saveCap->Enabled = true;
        formMain->Caption += L" *";
    }

    // Проверяем ввод времени
    // Пользователь ввёл что-то? Да - выполняется подсчёт числа t
    if (edit->Text == L"") {
        stBar->SimpleText = L"";
        return;
    }
    String subStr;
    String time = edit->Text;
    while (time != L"") {
        int blankIndex = PosEx(L" ", time);
        // Если не дошли до последнего элемента строки, то выделяем подстроки
        blankIndex > 0 ? subStr = time.SubString(1, blankIndex - 1) /*не включая символ пробела*/
                       : subStr = time; // Дошли до последнего значения
        time = time.SubString(blankIndex + 1, time.Length() - subStr.Length()); // исключаем текущее значение из общей строки

        float conv;
        // Проверка значения подстроки
        if (subStr != L"" && !TryStrToFloat(subStr, conv)) {
            stBar->SimpleText = L"Некорректное значение \"" + subStr + L"\". Время должно быть числом";
            return;
        } else if (conv <= 0) {
            stBar->SimpleText = L"Недопустимое значение \"" + subStr + L"\". Время должно быть вещественным положительным";
            return;
        }
    }
    stBar->SimpleText = L"";
}
//---------------------------------------------------------------------------

void __fastcall TformMain::timeEditExit(TObject* Sender)
{
    // Проверяем ввод времени
    TEdit* edit = dynamic_cast<TEdit*>(Sender);

    String subStr; // подстрока
    String time = edit->Text; // строка timeEdit
    uint32_t timeIndex = 0; // абсолютная позиция начала некорректного значения
    while (time != L"") {
        int blankIndex = PosEx(L" ", time); // позиция пробельного символа
        // Если не дошли до последнего элемента строки, то выделяем подстроки
        blankIndex > 0 ? subStr = time.SubString(1, blankIndex - 1) /*кроме символа пробела*/
                       : subStr = time; // Подстрока сравнения
        time = time.SubString(blankIndex + 1, time.Length() - subStr.Length()); // исключаем текущее значение из общей строки
        float conv;
        // Значения подстроки можно конвертировать в число?
        if (subStr != L"" && !TryStrToFloat(subStr, conv)) {
            // Спрашиваем: будет ли исправлять ошибку
            stBar->SimpleText = L"Некорректное значение \"" + subStr + L"\". Время должно быть числом.";
            return;
        } else if (conv <= 0) {
            stBar->SimpleText = L"Недопустимое значение \"" + subStr + L"\". Время должно быть вещественным положительным.";
            return;
        }
        timeIndex += blankIndex;
    }
    stBar->SimpleText = L"";
}
//---------------------------------------------------------------------------

void TformMain::mxL(DynamicArray<size_t> format, const std::ios::fmtflags fmtfl, const std::streamsize& prec)
{
    if (format.Length == 0) {
        return;
    }

    // Находим максимальную длину значений среди всех столбцов для форматирования матрицы
    std::ostringstream oss;
    oss.flags(fmtfl);

    // Важное замечание: в нашей кодировке нет греческих букв, поэтому будем заменять их альтернативой (см. реализацию)
    for (size_t j = 0; j < tabQ->ColCount; j++) {
        format[j] = 0;
        oss.precision(prec);
        switch (j) {
        case 0:
            oss << "№";
            break;
        case 1:
            oss << "mu1";
            break;
        case 2:
            oss << "mu2";
            break;
        case 3:
            oss << "lambda";
            break;
        default:
            oss << AnsiString(tabQ->Cells[j][0]).c_str(); // остальные (нефиксировнные) столбцы
            format[j] = tabQ->Cells[j][0].Length() > (size_t)oss.tellp() + 2 ? tabQ->Cells[j][0].Length() : (size_t)oss.tellp() + 2;
            oss.str("");
            oss.clear();
            continue;
        }

        size_t len = oss.tellp();
        if (len + 2 > format[j])
            format[j] = len + 2;
        oss.str("");
        oss.clear();
    }

    for (size_t j = 0; j < tabQ->ColCount; j++) {
        for (size_t i = 2; i < tabQ->RowCount; i++) {
            oss.precision(prec);
            oss << AnsiString(tabQ->Cells[j][i]).c_str();
            size_t len = oss.tellp();
			if (len + 2 > format[j])
                format[j] = len + 2;
            oss.str("");
            oss.clear();
		}
    }
}

convertResult TformMain::checkCell(TStringGrid* tab, uint64_t m, uint64_t n)
{
	String numStr = tab->Cells[n][m];
    if (numStr == L"") {
		return convertResult::Empty;
    }

    // Попытка конвертации строки в число в соответствии с типом данных элемента структуры
    int64_t tempInt;
    if (!TryStrToInt64(numStr, tempInt)) {
        return Incorrect;
    } else if (tempInt < 0 || tempInt > 110) {
        return BadRange;
    }
    return Good;
}

void __fastcall TformMain::tabInGetEditText(TObject* Sender, System::LongInt ACol,
    System::LongInt ARow, UnicodeString& Value)
{
    curCellText = Value;
}
//---------------------------------------------------------------------------

void TformMain::butChangeIcon(const size_t index)
{
    TBitmap* bmt; // временный объект типа TBitMap*
    try {
        bmt = new TBitmap();
        changeModeImage->GetBitmap(index, bmt); // занесение адреса иконки в временный объект
        highModeBut->Glyph = bmt; // Изменение иконки
    } __finally {
        delete bmt;
    }
}

long double fact(long double n)
{
    if (n <= 1) {
        return 1;
    }
    for (long double i = n - 1; i > 1; i--) {
        n *= i;
    }
    return n;
}

long double TformMain::findQ(float t, size_t i)
{
    long double Q = 0;

    uint32_t mu1 = StrToUInt(tabIn->Cells[1][i]);
    uint32_t mu2 = StrToUInt(tabIn->Cells[2][i]);
    long double lambda = ((long double)mu1 + mu2) / 2;

    long double fac = fact(mu1);
    for (uint64_t k = mu1; k <= mu2; k++) {
        Q += pow(lambda * t, k) * exp(-lambda * t) / fac;
        fac *= k + 1;
    }
    return Q;
}

void __fastcall TformMain::tabInRowMoved(TObject* Sender, System::LongInt FromIndex,
    System::LongInt ToIndex)
{
    TStringGrid* tab = dynamic_cast<TStringGrid*>(Sender);
    uint64_t delta = FromIndex > ToIndex /*Перемещаем выше?*/ ? ToIndex : FromIndex;
    for (uint64_t i = delta; i < tab->RowCount; i++) {
        tab->Cells[0][i] = Format(L"%d", i);
    }

    if (!saveCap->Enabled) { // были изменения до этого
        saveCap->Enabled = true;
        formMain->Caption += L" *";
    }
}
//---------------------------------------------------------------------------

void __fastcall TformMain::tabQRowMoved(TObject* Sender, System::LongInt FromIndex,
    System::LongInt ToIndex)
{
    TStringGrid* tab = dynamic_cast<TStringGrid*>(Sender);
    uint64_t delta = FromIndex > ToIndex /*Перемещаем выше?*/ ? ToIndex : FromIndex;
    for (uint64_t i = delta; i < tab->RowCount; i++) {
        tab->Cells[0][i] = Format(L"%d", i - 1);
    }
}
//---------------------------------------------------------------------------

void __fastcall TformMain::tabQDblClick(TObject* Sender)
{
	TStringGrid* tab = dynamic_cast<TStringGrid*>(Sender);
	TPoint p = Mouse->CursorPos; // координаты мыши
    p = tab->ScreenToClient(p); // относительно таблицы

    if (GetCursor() == Screen->Cursors[crHSplit]) {
        TGridCoord tabCoord = tab->MouseCoord(p.X - 4, p.Y); // индексы строки и столбца
        int wide = CalcGridColWidth(tab, tabCoord.X); // оптимальная ширина
        if (tab->ColWidths[tabCoord.X] != wide) {
            tab->ColWidths[tabCoord.X] = wide;
        } else {
            tab->ColWidths[tabCoord.X] = MIN_COLUMN_WIDTH;
        }
    } else {
		TGridCoord tabCoord = tab->MouseCoord(p.X, p.Y);
        if (tabCoord.Y || tabCoord.X <= 0) { // находимся в фиксированном столбце или ячейке "№"?
            stBar->SimpleText = L"Для сортировки дважды кликните по первой строке соответствующего столбца";
            return; // ничего не делаем
        }
		stBar->SimpleText = L"";

		TStringList* procDataTabCopy = reinterpret_cast<TStringList*>(tabQ->Tag); // копия таблицы обработанных данных

        int32_t j = abs(tabQSortNum) - 1; // индекс столбца (если по какому-то была произведена сортировка)
        if (tabQSortNum != 0) { // сортировка была уже раньше?
			tab->Cells[j][tabCoord.Y] = tab->Cells[j][tabCoord.Y].SubString(1, tab->Cells[j][tabCoord.Y].Length() - 2); // убираем пометку сортировки
		} else {
			procDataTabCopy = makeTabCopy(tab, 2, 1); // создаём актуальную копию таблицы 2
			if (!procDataTabCopy) { // удалось создать копию?
				Application->MessageBox(L"Недостаточно памяти для сортировки", FORM_PROGRAMM_NAME.c_str(), MB_OK | MB_ICONERROR);
				return;
			}
			tabQ->Tag = reinterpret_cast<intptr_t>(procDataTabCopy);
        }

        if (j != tabCoord.X) { // выполняем сортировку по другому столбцу
            tabQSortNum = tabCoord.X + 1; // делаем сортировку заново или по новому столбцу
		} else {
            tabQSortNum = tabQSortNum > 0 /*Сортировка по возрастанию уже была?*/ ? -tabQSortNum : // меняем направление сортировки на "по убыванию"
                0; // меняем направление сортировки на "отключено"
        }
        j = tabCoord.X;

        if (tabQSortNum > 0) { // переключаемся: "нет сортировки" -> "по возрастанию"
            tab->Cells[j][tabCoord.Y] += L" ▲";
        } else if (tabQSortNum < 0) {
            tab->Cells[j][tabCoord.Y] += L" ▼"; // переключаемся: "по возрастанию" -> "по убыванию"
        }
        if (tab->ColWidths[j] < CalcGridColWidth(tab, j)) { // текущая ширина меньше оптимальной?
            tab->ColWidths[j] = CalcGridColWidth(tab, j); // тогда может быть не видно значка сортировки
		}

		if (tabQSortNum == 0) { // переключение "По убыванию" -> "Отключено" не требует копии таб. 2
			restoreTab(tab, procDataTabCopy, tab->RowCount, tab->ColCount, 2, 1); // восстановление табл. 2
			procDataTabCopy->Free(); // освобождение памяти из-под таблицы 2
			tabQ->Tag = NULL; // в свойстве не хранится неактульный адрес
		} else {
			sortTabByCol(tab, j, tabQSortNum > 0); // сортировка табл. 2
            makeTabNumeration(tab, 2);
		}
    }
}
//---------------------------------------------------------------------------

void __fastcall TformMain::changeVarianceClick(TObject* Sender)
{
    TMenuItem* cap = dynamic_cast<TMenuItem*>(Sender);
    String defVar = IntToStr(cap->Tag);
    do {
        if (!InputQuery(L"Изменение отклонения Q от Qср",
                L"Введите максимальное отклонение Q от Qср в процентах (P >= 0)", defVar)) {
            return;
        }

        int32_t tmp;
        if (!TryStrToInt(defVar, tmp)) {
            Application->MessageBox(Format(L"Некорректное значение \"%s\"\nЗначение должно быть числом", defVar).c_str(),
                FORM_PROGRAMM_NAME.c_str(), MB_ICONERROR | MB_OK);
            defVar = IntToStr(cap->Tag);
            continue;
        } else if (tmp < 0) {
            Application->MessageBox(Format(L"Некорректное значение \"%s\"\nЧисло должно быть неотрицательным", defVar).c_str(),
                FORM_PROGRAMM_NAME.c_str(), MB_ICONERROR | MB_OK);
            defVar = IntToStr(cap->Tag);
            continue;
        }
        cap->Tag = tmp; // Запоминаем процент максимального отклонения
        break;
    } while (true);

    if (tabQ->RowHeights[2] != -1) { // в таблице 2 уже есть расчёты
        float QAvg = *reinterpret_cast<float*>(QAvgM->Tag);
        QAvgM->Text = Format(L"Qср = %0.4e\r\nДоверительный интервал - (%0.4e; %0.4e)",
            ARRAYOFCONST((QAvg, QAvg * (1 - cap->Tag / 100.0),
                QAvg * (1 + cap->Tag / 100.0)))); // обновление полезной информации
        tabQ->Repaint(); // повторная закраска с учётом Qср в QAvgM
    }
}
//---------------------------------------------------------------------------
void __fastcall TformMain::tabInKeyPress(TObject *Sender, System::WideChar &Key)
{
	TStringGrid* tab = dynamic_cast<TStringGrid*>(Sender);
	if (!tab->Options.Contains(goEditing)) {
        return;
	}
    if (!(Key >= L'0' && Key <= L'9' || Key == VK_BACK /*Backspace*/ ||
          Key == 3 /* Ctrl + C*/ || Key == 22 /*Ctrl + V*/ || Key == 24 /* Ctrl + X*/ ||
          Key == vkEscape /*Escape*/ || Key == vkTab /*Tab*/ || Key == vkDelete /*Delete*/ ||
          Key == vkShift /*Shift*/ || Key == vkReturn /*Enter*/)) {
    	stBar->SimpleText = L"Некорректный символ - \'" + String(Key) + L"\'. Введите цифру";
        Key = 0;
        return;
	}
}
//---------------------------------------------------------------------------
void __fastcall TformMain::tabInKeyDown(TObject *Sender, WORD &Key, TShiftState Shift)
{
	TStringGrid* tab = dynamic_cast<TStringGrid*>(Sender);
	if (Key == vkDelete && !tab->EditorMode) { // пользователь хочет удалить значение ячейки
		if (!saveCap->Enabled && tab->Cells[tab->Col][tab->Row] != L"") { // Внесены изменения?
			formMain->Caption += L" *";
			saveCap->Enabled = true;
		}
		tab->Cells[tab->Col][tab->Row] = L"";
	}

    if (Key == vkEscape && tab->EditorMode) { // пользователь решил отменить ввод?
		tab->Cells[tab->Col][tab->Row] = curCellText;
        tab->EditorMode = false;
	}
}
//---------------------------------------------------------------------------



void __fastcall TformMain::tabInMouseWheelDown(TObject *Sender, TShiftState Shift,
          TPoint &MousePos, bool &Handled)
{
	TStringGrid* tab = dynamic_cast<TStringGrid*>(Sender);
	if (Shift.Contains(ssCtrl)) {
		if (scale / 1.05 > 0.10) { // масштабирование корректное
			scale /= 1.05;
		} else {
			return;
		}

        tab->Font->Size = 9 * scale;
		for (uint32_t i = 0; i < tab->RowCount; i++) {
			tab->RowHeights[i] = tab->DefaultRowHeight * scale;
		}
		for (uint32_t j = 0; j < tab->ColCount; j++) {
			tab->ColWidths[j] = tab->DefaultColWidth * scale;
		}

	}
}
//---------------------------------------------------------------------------

void __fastcall TformMain::tabInMouseWheelUp(TObject *Sender, TShiftState Shift, TPoint &MousePos,
          bool &Handled)
{
    TStringGrid* tab = dynamic_cast<TStringGrid*>(Sender);
	if (Shift.Contains(ssCtrl)) {
		scale *= 1.05;
        tab->Font->Size = 9 * scale;
		for (uint32_t i = 0; i < tab->RowCount; i++) {
			tab->RowHeights[i] = tab->DefaultRowHeight * scale;
		}
		for (uint32_t j = 0; j < tab->ColCount; j++) {
			tab->ColWidths[j] = tab->DefaultColWidth * scale;
		}

	}
}
//---------------------------------------------------------------------------