ВИХІДНИЙ КОД ПРОГРАМИ

4. ВИХІДНИЙ КОД ПРОГРАМИ

4.1. Клас головної форми

Тут описана більшість візуальних ефектів, структура програми, та її взаємодія з користувачем.

#pragma once

#include "OpenGLView.h"

#include "GLPoint.h"

#include "GLSegment.h"

#include "GLRectangle.h"

#include "FancyButton.h"

#include "TextBoxValidator.h"

#include "FileReader.h"

namespace SegmentsIntersection {

using namespace System;

using namespace System::ComponentModel;

using namespace System::Collections;

using namespace System::Windows::Forms;

using namespace System::Data;

using namespace System::Drawing;

public ref class MainForm : public System::Windows::Forms::Form

{

public:

MainForm(void)

{

InitializeComponent();

PostInit();

}

protected:

~MainForm()

{

if (components)

{

delete components;

}

}

private: bool Dragging = false;

private: Point MouseDragStart;

private: System::Drawing::Image^ ImgCloseNormal;

private: System::Drawing::Image^ ImgCloseDark;

private: System::Drawing::Image^ ImgHomeNormal;

private: System::Drawing::Image^ ImgHomeDark;

private: System::Drawing::Image^ ImgBackNormal;

private: System::Drawing::Image^ ImgBackDark;

private: System::Drawing::Image^ ImgChecked;

private: System::Drawing::Image^ ImgUnchecked;

private: Constants::FormState formState;

private: Constants::FormState prevFormState;

private: FancyButton^ ButtonInputState;

private: FancyButton^ ButtonLoadState;

private: FancyButton^ ButtonManualState;

private: FancyButton^ ButtonCheckSegments;

private: DataGridViewSelectedRowCollection^ PointsTableSelection;

private: DataGridViewSelectedRowCollection^ SegmentsTableSelection;

private: bool NeedReselectionPoints;

private: bool NeedReselectionSegments;

private: System::Collections::Generic::List<GLPoint^>^ rectanglePoints;

private: bool *IsValidInput;

private: cli::array<TextBoxValidator^>^ TextBoxArray;

private: SegmentProcessor^ sProc;

private: GLPoint^ answPoint;

private: GLRectangle^ answRect;

private: String^ CrossAnswer;

private: OpenGLView^ OpenGL;

private: FileReader^ SegmentReader;

private: System::Windows::Forms::PictureBox^ ButtonClose;

private: System::Windows::Forms::Panel^ TopPanel;

private: System::Windows::Forms::Label^ Title;

private: System::Windows::Forms::PictureBox^ ButtonHome;

private: System::Windows::Forms::Panel^ PanelHome;

private: System::Windows::Forms::Panel^ PanelInput;

private: System::Windows::Forms::ImageList^ imageList;

private: System::Windows::Forms::Label^ lblSegment1;

private: System::Windows::Forms::Label^ lblCheckBox;

private: System::Windows::Forms::PictureBox^ cbIsFlat;

private: System::Windows::Forms::Label^ lblSegment2Z;

private: System::Windows::Forms::Label^ lblSegment2Y;

private: System::Windows::Forms::Label^ lblSegment2X;

private: System::Windows::Forms::Label^ lblSegment1Z;

private: System::Windows::Forms::Label^ lblSegment1Y;

private: System::Windows::Forms::Label^ lblSegment1X;

private: System::Windows::Forms::Label^ lblPoint2;

private: System::Windows::Forms::Panel^ tbX1Border;

private: System::Windows::Forms::Panel^ tbX1BorderBot;

private: System::Windows::Forms::TextBox^ tbX1;

private: System::Windows::Forms::Panel^ tbY1Border;

private: System::Windows::Forms::Panel^ tbY1BorderBot;

private: System::Windows::Forms::TextBox^ tbY1;

private: System::Windows::Forms::Panel^ tbZ1Border;

private: System::Windows::Forms::Panel^ tbZ1BorderBot;

private: System::Windows::Forms::TextBox^ tbZ1;

private: System::Windows::Forms::Panel^ tbX2Border;

private: System::Windows::Forms::Panel^ tbX2BorderBot;

private: System::Windows::Forms::TextBox^ tbX2;

private: System::Windows::Forms::Panel^ tbY2Border;

private: System::Windows::Forms::Panel^ tbY2BorderBot;

private: System::Windows::Forms::TextBox^ tbY2;

private: System::Windows::Forms::Panel^ tbZ2Border;

private: System::Windows::Forms::Panel^ tbZ2BorderBot;

private: System::Windows::Forms::TextBox^ tbZ2;

private: System::Windows::Forms::Panel^ PanelResult;

private: System::Windows::Forms::Panel^ DebugOpenGL;

private: System::Windows::Forms::Label^ lblResult;

private: System::Windows::Forms::Label^ lblAnswer;

private: System::Windows::Forms::PictureBox^ ButtonResultBack;

private: System::Windows::Forms::Label^ lblResultBack;

private: System::Windows::Forms::Panel^ DebugButonCheckSegments;

private: System::Windows::Forms::Label^ lblInputError;

private: System::Windows::Forms::WebBrowser^ wbManual;

private: System::Windows::Forms::DataGridView^ ResultPointsTable;

private: System::Windows::Forms::DataGridViewTextBoxColumn^ colPoint;

private: System::Windows::Forms::DataGridView^ SegmentInputTable;

private: System::Windows::Forms::DataGridViewTextBoxColumn^ dataGridViewTextBoxColumn1;

private: System::Windows::Forms::Button^ btnClearSegment;

private: System::Windows::Forms::Button^ btnDeleteSegment;

private: System::Windows::Forms::Button^ btnAddSegment;

private: System::Windows::Forms::Label^ lblSegmentTable;

private: System::Windows::Forms::Button^ btnCreateRectangle;

private: System::Windows::Forms::Label^ lblErrorRectangle;

private: System::ComponentModel::IContainer^ components;

private:

//оголошення функцій, реалізація яких винесена поза класс

private: void PostInit();

private: void HomePageInit();

private: void InputPageInit();

private: void ResultPageInit();

private: void ManualPageInit();

private: void InitializeOpenGL();

private: void HomePageVisibility(bool visible);

private: void InputPageVisibility(bool visible);

private: void ResultPageVisibility(bool visible);

private: void ManualPageVisibility(bool visible);

private: void LoadPageVisibility(bool visible);

private: System::Void btnAddSegment_Click(System::Object^ sender, System::EventArgs^ e);

private: System::Void btnDeleteSegment_Click(System::Object^ sender, System::EventArgs^ e);

private: System::Void btnClearSegment_Click(System::Object^ sender, System::EventArgs^ e);

private: System::Void btnCreateRectangle_Click(System::Object^ sender, System::EventArgs^ e);

private: System::Void ButtonCheckSegments_Click(System::Object^ sender, System::EventArgs^ e);

private: System::Void rbIsFlat_Click(System::Object^ sender, System::EventArgs^ e);

private: System::Void lblCheckBox_Click(System::Object^ sender, System::EventArgs^ e) {

rbIsFlat_Click(sender, e);

}

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

//ОБРОБКА СТАНУ ФОРМИ

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

private: property Constants::FormState MainForm::FormState

{

void set(Constants::FormState value)

{

if (this->formState == value)

return;

switch (this->formState)

{

case Constants::FormState::EMPTY:

break;

case Constants::FormState::HOME:

HomePageVisibility(false);

break;

case Constants::FormState::INPUT:

InputPageVisibility(false);

break;

case Constants::FormState::LOAD:

LoadPageVisibility(false);

break;

case Constants::FormState::RESULT:

ResultPageVisibility(false);

break;

case Constants::FormState::MANUAL:

ManualPageVisibility(false);

break;

}

switch (value)

{

case Constants::FormState::EMPTY:

break;

case Constants::FormState::HOME:

HomePageVisibility(true);

break;

case Constants::FormState::INPUT:

InputPageVisibility(true);

break;

case Constants::FormState::LOAD:

LoadPageVisibility(true);

break;

case Constants::FormState::RESULT:

this->OpenGL->UpdateOrthoSystem();

ResultPageVisibility(true);

break;

case Constants::FormState::MANUAL:

ManualPageVisibility(true);

break;

}

this->prevFormState = this->formState;

this->formState = value;

}

Constants::FormState get()

{

return formState;

}

}

private: System::Void ButtonInputState_Click(System::Object^ sender, System::EventArgs^ e) {

//якщо вхід відбувається з головної панелі, очищаємо поля вводу

if (this->formState == Constants::FormState::HOME)

for each(auto tb in TextBoxArray)

tb->ClearText();

if (this->OpenGL->FlatView)

rbIsFlat_Click(sender, e);

this->lblInputError->Visible = false;

this->FormState = Constants::FormState::INPUT;

}

private: System::Void ButtonLoadState_Click(System::Object^ sender, System::EventArgs^ e) {

this->LoadPageVisibility(true);

}

private: System::Void ButtonManualState_Click(System::Object^ sender, System::EventArgs^ e) {

this->FormState = Constants::FormState::MANUAL;

}

//Повертаємось до страртового виду

private: System::Void ButtonHome_Click(System::Object^ sender, System::EventArgs^ e) {

this->FormState = Constants::FormState::HOME;

}

private: System::Void ButtonClose_Click(System::Object^ sender, System::EventArgs^ e) {

Application::Exit();

}

//повертаємось назад

private: System::Void ButtonResultBack_Click(System::Object^ sender, System::EventArgs^ e) {

this->FormState = this->prevFormState;

}

private: System::Void lblResultBack_Click(System::Object^ sender, System::EventArgs^ e) {

this->ButtonResultBack_Click(sender, e);

}

//при натисканні кнопки Enter при активній компоненті вводу відбувається натиск кнопки обробки результату

void InputDone(System::Object^ sender, System::Windows::Forms::PreviewKeyDownEventArgs^ e)

{

if (e->KeyCode != System::Windows::Forms::Keys::Enter)

return;

this->ButtonCheckSegments_Click(this, gcnew System::EventArgs());

}

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

//ОБРОБКА ПЕРЕМІЩЕННЯ ФОРМИ

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

private: System::Void TopPanel_MouseDown(System::Object^ sender, System::Windows::Forms::MouseEventArgs^ e) {

if (e->Button != System::Windows::Forms::MouseButtons::Left)

return;

Dragging = true;

MouseDragStart = e->Location;

}

private: System::Void TopPanel_MouseUp(System::Object^ sender, System::Windows::Forms::MouseEventArgs^ e) {

if (Dragging)

Dragging = false;

}

private: System::Void TopPanel_MouseMove(System::Object^ sender, System::Windows::Forms::MouseEventArgs^ e) {

if (Dragging)

this->Location = Point(this->Location.X + e->Location.X - MouseDragStart.X, this->Location.Y + e->Location.Y - MouseDragStart.Y);

}

private: System::Void Title_MouseDown(System::Object^ sender, System::Windows::Forms::MouseEventArgs^ e) {

if (e->Button != System::Windows::Forms::MouseButtons::Left)

return;

Dragging = true;

MouseDragStart = e->Location;

}

private: System::Void Title_MouseUp(System::Object^ sender, System::Windows::Forms::MouseEventArgs^ e) {

if (Dragging)

Dragging = false;

}

private: System::Void Title_MouseMove(System::Object^ sender, System::Windows::Forms::MouseEventArgs^ e) {

if (Dragging)

this->Location = Point(this->Location.X + e->Location.X - MouseDragStart.X, this->Location.Y + e->Location.Y - MouseDragStart.Y);

}

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

//ПІДСВІТКА КНОПОК ПРИ НАВЕДЕННІ

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

private: System::Void ButtonHome_MouseEnter(System::Object^ sender, System::EventArgs^ e) {

this->ButtonHome->BackgroundImage = ImgHomeDark;

}

private: System::Void ButtonHome_MouseLeave(System::Object^ sender, System::EventArgs^ e) {

this->ButtonHome->BackgroundImage = ImgHomeNormal;

}

private: System::Void ButtonClose_MouseEnter(System::Object^ sender, System::EventArgs^ e) {

this->ButtonClose->BackgroundImage = ImgCloseDark;

}

private: System::Void ButtonClose_MouseLeave(System::Object^ sender, System::EventArgs^ e) {

this->ButtonClose->BackgroundImage = ImgCloseNormal;

}

private: System::Void ButtonResultBack_MouseEnter(System::Object^ sender, System::EventArgs^ e) {

this->ButtonResultBack->BackgroundImage = ImgBackDark;

}

private: System::Void ButtonResultBack_MouseLeave(System::Object^ sender, System::EventArgs^ e) {

this->ButtonResultBack->BackgroundImage = ImgBackNormal;

}

private: System::Void SegmentInputTable_PreviewKeyDown(System::Object^ sender, System::Windows::Forms::PreviewKeyDownEventArgs^ e) {

if (e->KeyCode == System::Windows::Forms::Keys::Delete)

{

btnDeleteSegment_Click(sender, e);

}

}

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

//ВИДІЛЕННЯ РЯДКІВ ТАБЛИЦІ

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

//запам'ятовування виділених комірок

private: System::Void ResultPointsTable_CellMouseClick(System::Object^ sender, System::Windows::Forms::DataGridViewCellMouseEventArgs^ e) {

if (e->Button != System::Windows::Forms::MouseButtons::Left)

return;

if (ResultPointsTable->SelectedRows->Count <= 1 && ResultPointsTable[e->ColumnIndex, e->RowIndex]->OwningRow->Selected)

ResultPointsTable[e->ColumnIndex, e->RowIndex]->OwningRow->Selected = false;

ResultPointsTable[e->ColumnIndex, e->RowIndex]->OwningRow->Selected =

!ResultPointsTable[e->ColumnIndex, e->RowIndex]->OwningRow->Selected;

PointsTableSelection = ResultPointsTable->SelectedRows;

//якщо рядок вибрали, занести до списку, інакше видалити

GLPoint^ selectedPoint = GLPoint::FromString(ResultPointsTable[0, e->RowIndex]->Value->ToString());

for each(GLPoint^ pt in rectanglePoints)

if (selectedPoint->Equal(pt))

selectedPoint = pt;

if (ResultPointsTable[e->ColumnIndex, e->RowIndex]->OwningRow->Selected)

rectanglePoints->Add(selectedPoint);

else

rectanglePoints->Remove(selectedPoint);

NeedReselectionPoints = true;

}

//оновлення виділених комірок

private: System::Void ResultPointsTable_SelectionChanged(System::Object^ sender, System::EventArgs^ e) {

if (!NeedReselectionPoints)

return;

NeedReselectionPoints = false;

ResultPointsTable->ClearSelection();

for each(DataGridViewRow^ row in PointsTableSelection)

row->Selected = true;

}

//запам'ятовування виділених комірок

private: System::Void SegmentInputTable_CellMouseClick(System::Object^ sender, System::Windows::Forms::DataGridViewCellMouseEventArgs^ e) {

if (e->Button != System::Windows::Forms::MouseButtons::Left)

return;

if (SegmentInputTable->SelectedRows->Count <= 1 && SegmentInputTable[e->ColumnIndex, e->RowIndex]->OwningRow->Selected)

SegmentInputTable[e->ColumnIndex, e->RowIndex]->OwningRow->Selected = false;

SegmentInputTable[e->ColumnIndex, e->RowIndex]->OwningRow->Selected =

!SegmentInputTable[e->ColumnIndex, e->RowIndex]->OwningRow->Selected;

SegmentsTableSelection = SegmentInputTable->SelectedRows;

NeedReselectionSegments = true;

}

//оновлення виділених комірок

private: System::Void SegmentInputTable_SelectionChanged(System::Object^ sender, System::EventArgs^ e) {

if (!NeedReselectionSegments)

return;

NeedReselectionSegments = false;

SegmentInputTable->ClearSelection();

for each(DataGridViewRow^ row in SegmentsTableSelection)

if(row->Index >= 0)

row->Selected = true;

}

};

}

using namespace SegmentsIntersection;

//-------------------------------------------// ІНІЦІАЛІЗАЦІЯ ФОРМИ

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

void MainForm::PostInit()

{

this->sProc = gcnew SegmentProcessor();

this->SegmentReader = gcnew FileReader();

this->rectanglePoints = gcnew System::Collections::Generic::List<GLPoint^>();

this->answRect = gcnew GLRectangle();

this->answRect->Color = Constants::Colors::AccentYellow;

this->IsValidInput = new bool[Constants::INPUT_COUNT];

for (int i = 0; i < Constants::INPUT_COUNT; i++)

this->IsValidInput[i] = false;

this->TopPanel->BackColor = Constants::Colors::HighlightingBrown;

this->Title->ForeColor = Constants::Colors::DarkBlue;

this->BackColor = Constants::Colors::BackgroundWhite;

this->ImgCloseNormal = this->ButtonClose->BackgroundImage;

this->ImgCloseDark = this->ButtonClose->InitialImage;

this->ImgHomeNormal = this->ButtonHome->BackgroundImage;

this->ImgHomeDark = this->ButtonHome->InitialImage;

this->ImgBackNormal = this->ButtonResultBack->BackgroundImage;

this->ImgBackDark = this->ButtonResultBack->InitialImage;

this->ImgUnchecked = this->cbIsFlat->BackgroundImage;

this->ImgChecked = this->cbIsFlat->InitialImage;

this->ButtonHome->Visible = false;

this->formState = Constants::FormState::HOME;

this->prevFormState = Constants::FormState::HOME;

HomePageInit();

InputPageInit();

ResultPageInit();

ManualPageInit();

InitializeOpenGL();

HomePageVisibility(true);

}

void MainForm::HomePageInit()

{

this->PanelHome->Visible = false;

this->PanelHome->Location = System::Drawing::Point(0, 40);

//button1

this->ButtonInputState = gcnew FancyButton(this->PanelHome);

this->ButtonInputState->Title = L"Нові дані";

this->ButtonInputState->Image = this->imageList->Images[(int)Constants::ImageIndex::INPUT];

this->ButtonInputState->Location = System::Drawing::Point(50, 50);

this->ButtonInputState->Size = System::Drawing::Size(200, 300);

this->ButtonInputState->IdleColor = Constants::Colors::MainBrown;

this->ButtonInputState->ActiveColor = Constants::Colors::HighlightingBrown;

this->ButtonInputState->IdleTextColor = Constants::Colors::DarkBlue;

this->ButtonInputState->ActiveTextColor = Constants::Colors::AccentRed;

this->ButtonInputState->ClickEvent(gcnew System::EventHandler(this, &MainForm::ButtonInputState_Click));

//button2

this->ButtonLoadState = gcnew FancyButton(this->PanelHome);

this->ButtonLoadState->Title = L"Зчитати з файлу";

this->ButtonLoadState->Image = this->imageList->Images[(int)Constants::ImageIndex::OPEN];

this->ButtonLoadState->Location = System::Drawing::Point(300, 50);

this->ButtonLoadState->Size = System::Drawing::Size(200, 300);

this->ButtonLoadState->IdleColor = Constants::Colors::MainBrown;

this->ButtonLoadState->ActiveColor = Constants::Colors::HighlightingBrown;

this->ButtonLoadState->IdleTextColor = Constants::Colors::DarkBlue;

this->ButtonLoadState->ActiveTextColor = Constants::Colors::AccentRed;

this->ButtonLoadState->ClickEvent(gcnew System::EventHandler(this, &MainForm::ButtonLoadState_Click));

//button3

this->ButtonManualState = gcnew FancyButton(this->PanelHome);

this->ButtonManualState->Title = L"Довідка";

this->ButtonManualState->Image = this->imageList->Images[(int)Constants::ImageIndex::MANUAL];

this->ButtonManualState->Location = System::Drawing::Point(550, 50);

this->ButtonManualState->Size = System::Drawing::Size(200, 300);

this->ButtonManualState->IdleColor = Constants::Colors::MainBrown;

this->ButtonManualState->ActiveColor = Constants::Colors::HighlightingBrown;

this->ButtonManualState->IdleTextColor = Constants::Colors::DarkBlue;

this->ButtonManualState->ActiveTextColor = Constants::Colors::AccentRed;

this->ButtonManualState->ClickEvent(gcnew System::EventHandler(this, &MainForm::ButtonManualState_Click));

}

void MainForm::InputPageInit()

{

this->PanelInput->Location = System::Drawing::Point(0, 40);

this->PanelInput->Visible = false;

this->ButtonCheckSegments = gcnew FancyButton(this->PanelInput);

this->ButtonCheckSegments->Title = L"Перевірити";

this->ButtonCheckSegments->Location = System::Drawing::Point(475, 300);

this->ButtonCheckSegments->Size = System::Drawing::Size(250, 75);

this->ButtonCheckSegments->IdleColor = Constants::Colors::MainBrown;

this->ButtonCheckSegments->ActiveColor = Constants::Colors::HighlightingBrown;

this->ButtonCheckSegments->IdleTextColor = Constants::Colors::DarkBlue;

this->ButtonCheckSegments->ActiveTextColor = Constants::Colors::AccentRed;

this->ButtonCheckSegments->ClickEvent(gcnew System::EventHandler(this, &MainForm::ButtonCheckSegments_Click));

this->lblInputError->Visible = false;

this->lblInputError->ForeColor = Constants::Colors::ErrorRed;

this->lblCheckBox->ForeColor = Constants::Colors::DarkBlue;

this->lblSegment1->ForeColor = Constants::Colors::DarkBlue;

this->lblPoint1->ForeColor = Constants::Colors::DarkBlue;

this->lblPoint2->ForeColor = Constants::Colors::DarkBlue;

this->lblSegment1X->ForeColor = Constants::Colors::DarkBlue;

this->lblSegment1Y->ForeColor = Constants::Colors::DarkBlue;

this->lblSegment1Z->ForeColor = Constants::Colors::DarkBlue;

this->lblSegment2X->ForeColor = Constants::Colors::DarkBlue;

this->lblSegment2Y->ForeColor = Constants::Colors::DarkBlue;

this->lblSegment2Z->ForeColor = Constants::Colors::DarkBlue;

this->TextBoxArray = gcnew cli::array<TextBoxValidator^>(Constants::INPUT_COUNT);

this->TextBoxArray[0] = gcnew TextBoxValidator(this->tbX1Border, this->tbX1BorderBot, this->tbX1);

this->TextBoxArray[1] = gcnew TextBoxValidator(this->tbY1Border, this->tbY1BorderBot, this->tbY1);

this->TextBoxArray[2] = gcnew TextBoxValidator(this->tbZ1Border, this->tbZ1BorderBot, this->tbZ1);

this->TextBoxArray[3] = gcnew TextBoxValidator(this->tbX2Border, this->tbX2BorderBot, this->tbX2);

this->TextBoxArray[4] = gcnew TextBoxValidator(this->tbY2Border, this->tbY2BorderBot, this->tbY2);

this->TextBoxArray[5] = gcnew TextBoxValidator(this->tbZ2Border, this->tbZ2BorderBot, this->tbZ2);

this->btnAddSegment->BackColor = Constants::Colors::HighlightingBrown;

this->btnAddSegment->ForeColor = Constants::Colors::DarkBlue;

this->btnDeleteSegment->BackColor = Constants::Colors::HighlightingBrown;

this->btnDeleteSegment->ForeColor = Constants::Colors::DarkBlue;

this->btnClearSegment->BackColor = Constants::Colors::HighlightingBrown;

this->btnClearSegment->ForeColor = Constants::Colors::DarkBlue;

this->SegmentInputTable->BackgroundColor = Constants::Colors::HighlightingBrown;

this->SegmentInputTable->GridColor = Constants::Colors::DarkBlue;

System::Windows::Forms::DataGridViewCellStyle^ style = this->SegmentInputTable->DefaultCellStyle;

style->BackColor = Constants::Colors::HighlightingBrown;

style->ForeColor = Constants::Colors::DarkBlue;

style->SelectionBackColor = Constants::Colors::AccentBlue;

style->SelectionForeColor = Constants::Colors::HighlightingBrown;

this->SegmentInputTable->DefaultCellStyle = style;

}

void MainForm::ResultPageInit()

{

this->PanelResult->Location = System::Drawing::Point(0, 40);

this->PanelResult->Visible = false;

this->lblResult->ForeColor = Constants::Colors::DarkBlue;

this->lblAnswer->ForeColor = Constants::Colors::DarkBlue;

this->lblAnswer->BackColor = Constants::Colors::HighlightingBrown;

this->lblResultBack->ForeColor = Constants::Colors::DarkBlue;

this->ResultPointsTable->BackgroundColor = Constants::Colors::HighlightingBrown;

this->ResultPointsTable->GridColor = Constants::Colors::DarkBlue;

System::Windows::Forms::DataGridViewCellStyle^ style = this->ResultPointsTable->DefaultCellStyle;

style->BackColor = Constants::Colors::HighlightingBrown;

style->ForeColor = Constants::Colors::DarkBlue;

style->SelectionBackColor = Constants::Colors::AccentBlue;

style->SelectionForeColor = Constants::Colors::HighlightingBrown;

this->ResultPointsTable->DefaultCellStyle = style;

this->btnCreateRectangle->BackColor = Constants::Colors::HighlightingBrown;

this->btnCreateRectangle->ForeColor = Constants::Colors::DarkBlue;

this->lblErrorRectangle->Visible = false;

this->lblErrorRectangle->ForeColor = Constants::Colors::ErrorRed;

}

void MainForm::ManualPageInit()

{

this->wbManual->Visible = false;

this->wbManual->Location = System::Drawing::Point(0, 40);

this->wbManual->Url = gcnew System::Uri(System::String::Format("file:///{0}/Manual.html", System::IO::Directory::GetCurrentDirectory()));

}

void MainForm::InitializeOpenGL()

{

//створюємо компонент

try

{

this->OpenGL = gcnew OpenGLView(this->PanelResult);

}

catch (MyException::GLInitException^)

{

MessageBox::Show("Не вдалося створити компонент OpenGL. Виконання програми буде зупинено.", "Помилка ініціалізації",

System::Windows::Forms::MessageBoxButtons::OK, System::Windows::Forms::MessageBoxIcon::Error);

Application::Exit();

}

this->OpenGL->Location = System::Drawing::Point(410, 10);

this->OpenGL->SetSize(System::Drawing::Size(380, 380));

this->OpenGL->FlatView = false;

this->answPoint = gcnew GLPoint();

this->answPoint->Color = Constants::Colors::ErrorRed;

}

//зміна панелі вводу для випадків на площині та у просторі

System::Void MainForm::rbIsFlat_Click(System::Object^ sender, System::EventArgs^ e) {

this->OpenGL->FlatView = !this->OpenGL->FlatView;

this->lblSegment1Z->Visible = !this->OpenGL->FlatView;

this->TextBoxArray[2]->Visible = !this->OpenGL->FlatView;

this->lblSegment2Z->Visible = !this->OpenGL->FlatView;

this->TextBoxArray[5]->Visible = !this->OpenGL->FlatView;

if (this->OpenGL->FlatView)

this->cbIsFlat->Image = this->ImgChecked;

else

this->cbIsFlat->Image = this->ImgUnchecked;

sProc->PrintSegments(SegmentInputTable);

}

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

//ФУНКЦІЇ ОБРОБКИ ПЕРЕХОДІВ

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

void MainForm::HomePageVisibility(bool visible)

{

this->PanelHome->Visible = visible;

this->ButtonHome->Visible = !visible;

//зтираємо всі значення при поверненні на головну сторінку

if (visible)

{

this->sProc->Clear();

this->OpenGL->ClearScene();

this->SegmentInputTable->RowCount = 0;

}

}

void MainForm::InputPageVisibility(bool visible)

{

this->PanelHome->Visible = false;

this->PanelInput->Visible = visible;

this->ButtonHome->Visible = visible;

}

void MainForm::ResultPageVisibility(bool visible)

{

this->PanelHome->Visible = false;

this->PanelResult->Visible = visible;

this->ButtonHome->Visible = visible;

if (visible)

{

//виводимо точки на екран

sProc->PrintPoints(ResultPointsTable);

if (OpenGL->Contains(answRect))

OpenGL->RemoveFromScene(answRect);

this->lblErrorRectangle->Text = "Виберіть чотири точки для побудови читирикутника";

this->lblErrorRectangle->Visible = true;

}

else

{

this->lblErrorRectangle->Visible = false;

rectanglePoints->Clear();

}

if (ResultPointsTable->RowCount)

ResultPointsTable->ClearSelection();

}

void MainForm::ManualPageVisibility(bool visible)

{

this->PanelHome->Visible = false;

this->wbManual->Visible = visible;

this->ButtonHome->Visible = visible;

}

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

//ФУНКЦІЇ ОБРАХУВАННЯ РЕЗУЛЬТАТІВ

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

void MainForm::LoadPageVisibility(bool visible)

{

if (!visible)

return;

HomePageVisibility(false);

InputPageVisibility(false);

ResultPageVisibility(false);

ManualPageVisibility(false);

sProc->Clear();

OpenGL->ClearScene();

this->SegmentInputTable->RowCount = 0;

System::String^ errorLines = gcnew System::String("");

int i = 0;

try

{

if (!this->SegmentReader->ShowDialog())

{

HomePageVisibility(true);

this->prevFormState = Constants::FormState::HOME;

this->formState = Constants::FormState::HOME;

return;

}

//перевірка розмірності файлу

if (this->SegmentReader->Lines() > Constants::MAX_FILE_LINES)

{

auto dResult = MessageBox::Show("У файлі забагато записів. Обробка потребуватиме багато часу. Продовжити", "Помилка зчитування",

System::Windows::Forms::MessageBoxButtons::YesNoCancel, System::Windows::Forms::MessageBoxIcon::Warning);

switch (dResult)

{

case System::Windows::Forms::DialogResult::Yes:

break;

default:

HomePageVisibility(true);

this->prevFormState = Constants::FormState::HOME;

this->formState = Constants::FormState::HOME;

return;

}

}

//виконуємо цикл, поки не закінчиться потік даних

while(true)

{

GLSegment^ segment = gcnew GLSegment(gcnew GLPoint(), gcnew GLPoint());

try

{

i++;

this->SegmentReader->ReadSegment(segment);

}

catch (MyException::CoruptedLineException^) //пропускаємо пошкоджені рядки

{

errorLines += i + " ";

continue;

}

catch (MyException::ValueOverflowException^ e)

{

errorLines += i + " ";

continue;

}

//перевіряємо, чи не є введений відрізок точкою

if (segment->Point[0]->X != segment->Point[1]->X ||

segment->Point[0]->Y != segment->Point[1]->Y ||

segment->Point[0]->Z != segment->Point[1]->Z)

{

sProc->AddSegment(segment);

OpenGL->AddToScene(segment);

OpenGL->AddToScene(segment->Point[0]);

OpenGL->AddToScene(segment->Point[1]);

}

else

{

errorLines += i + " ";

continue;

}

}

}

catch (System::IO::EndOfStreamException^)

{

//вихід з циклу відбувається при обробці винятку

}

finally

{

this->SegmentReader->CloseFile();

}

GLSegment::CrossAnswer ^answer;

try

{

//після зчитування відразу переходимо до результатів

this->OpenGL->FlatView = this->SegmentReader->IsFlat();

answer = sProc->CrossAll();

}

catch (MyException::NotEnoughObjectsException^)

{

MessageBox::Show("Не достатня кількість записів. Або частина записів не коректна.", "Помилка зчитування",

System::Windows::Forms::MessageBoxButtons::OK, System::Windows::Forms::MessageBoxIcon::Warning);

HomePageVisibility(true);

OpenGL->ClearScene();

this->prevFormState = Constants::FormState::HOME;

this->formState = Constants::FormState::HOME;

return;

}

//якщо з'являється додаткова дочка відображуємо її на сцені

if (OpenGL->Contains(answPoint))

OpenGL->RemoveFromScene(answPoint);

if (answer->Type == GLSegment::CrossAnswer::CrossType::POINT)

{

answPoint = answer->Point1;

answPoint->Color = Constants::Colors::AccentRed;

OpenGL->AddToScene(answPoint);

}

this->CrossAnswer = answer->Answer;

this->lblAnswer->Text = CrossAnswer;

this->OpenGL->UpdateOrthoSystem();

this->formState = Constants::FormState::LOAD;

this->FormState = Constants::FormState::RESULT;

if(errorLines != "")

MessageBox::Show("Знайдено пошкоджені рядки: " + errorLines + ". Їх зчитування не відбулося.", "Помилка зчитування",

System::Windows::Forms::MessageBoxButtons::OK, System::Windows::Forms::MessageBoxIcon::Warning);

}

//додаємо відрізок до списку

System::Void MainForm::btnAddSegment_Click(System::Object^ sender, System::EventArgs^ e) {

//перевыряємо корекність даних

for (int i = 0; i < Constants::INPUT_COUNT; i++)

if (!TextBoxArray[i]->IsValid())

{

//якщо вибраний вид на площині, не враховувати координату Z

if (OpenGL->FlatView && i % 3 == 2)

continue;

this->lblInputError->Text = "Не всі поля заповнені, або містять не коректні дані!";

this->lblInputError->Visible = true;

return;

}

GLSegment^ segment = gcnew GLSegment(gcnew GLPoint(), gcnew GLPoint());

segment->Point[0]->X = TextBoxArray[0]->Value();

segment->Point[0]->Y = TextBoxArray[1]->Value();

segment->Point[0]->Z = TextBoxArray[2]->Value();

segment->Point[1]->X = TextBoxArray[3]->Value();

segment->Point[1]->Y = TextBoxArray[4]->Value();

segment->Point[1]->Z = TextBoxArray[5]->Value();

//якщо відрізок є однією точкою

if (segment->Point[0]->X == segment->Point[1]->X &&

segment->Point[0]->Y == segment->Point[1]->Y &&

(OpenGL->FlatView || segment->Point[0]->Z == segment->Point[1]->Z))

{

this->lblInputError->Text = "Tочки початку та кінця відрізку не можуть збігатися!";

this->lblInputError->Visible = true;

return;

}

this->lblInputError->Visible = false;

for (int i = 0; i < Constants::INPUT_COUNT; i++)

TextBoxArray[i]->ClearText();

segment->Color = Constants::Colors::AccentBlue;

segment->Point[0]->Color = Constants::Colors::MainBrown;

segment->Point[1]->Color = Constants::Colors::MainBrown;

//додаємо запис до всіх необхідних контейнерів

OpenGL->AddToScene(segment);

OpenGL->AddToScene(segment->Point[0]);

OpenGL->AddToScene(segment->Point[1]);

sProc->AddSegment(segment);

cli::array<System::String^>^ row = gcnew cli::array<System::String^>(1); row[0] = segment->ToString();

SegmentInputTable->Rows->Add(row);

SegmentInputTable->ClearSelection();

}

System::Void MainForm::btnDeleteSegment_Click(System::Object^ sender, System::EventArgs^ e) {

for each (System::Windows::Forms::DataGridViewRow^ row in SegmentInputTable->SelectedRows)

{

int idx = SegmentInputTable->Rows->IndexOf(row);

GLSegment^ segment = sProc->GetSegment(idx);

OpenGL->RemoveFromScene(segment->Point[0]);

OpenGL->RemoveFromScene(segment->Point[1]);

OpenGL->RemoveFromScene(segment);

sProc->RemoveSegmentAt(idx);

SegmentInputTable->Rows->RemoveAt(idx);

}

SegmentInputTable->ClearSelection();

}

System::Void MainForm::btnClearSegment_Click(System::Object^ sender, System::EventArgs^ e) {

this->sProc->Clear();

this->OpenGL->ClearScene();

this->SegmentInputTable->RowCount = 0;

}

//кнопка обробки результату

System::Void MainForm::ButtonCheckSegments_Click(System::Object^ sender, System::EventArgs^ e) {

if (Constants::SEGMENT_COUNT < 2)

{

this->lblInputError->Text = "Для подальшої роботи необхідно додати не менше двох відрізків!";

this->lblInputError->Visible = true;

return;

}

//отримуємо відповідь

GLSegment::CrossAnswer ^answer = sProc->CrossAll();

//якщо з'являється додаткова точка відображуємо її на сцені

if (OpenGL->Contains(answPoint))

OpenGL->RemoveFromScene(answPoint);

if (answer->Type == GLSegment::CrossAnswer::CrossType::POINT)

{

answPoint = answer->Point1;

answPoint->Color = Constants::Colors::ErrorRed;

OpenGL->AddToScene(answPoint);

}

this->CrossAnswer = answer->Answer;

this->lblAnswer->Text = CrossAnswer;

OpenGL->UpdateOrthoSystem();

this->FormState = Constants::FormState::RESULT;

this->lblInputError->Visible = false;

}

//створюємо чотирикутник з вибраних точок

System::Void MainForm::btnCreateRectangle_Click(System::Object^ sender, System::EventArgs^ e) {

if (rectanglePoints->Count != 4)

{

//додаткова перевірка таблиці

if (ResultPointsTable->SelectedRows->Count == 4)

{

rectanglePoints->Clear();

for each(DataGridViewRow^ row in ResultPointsTable->SelectedRows)

{

GLPoint^ selectedPoint = GLPoint::FromString(ResultPointsTable[0, row->Index]->Value->ToString());

rectanglePoints->Add(selectedPoint);

}

}

else

{

lblErrorRectangle->Text = "Для побудови необхідно вибрати 4 точки.";

lblErrorRectangle->Visible = true;

return;

}

}

try {

answRect->Set(rectanglePoints->ToArray());

}

catch (MyException::InvalidRectangleException^)

{

lblErrorRectangle->Text = "Вибрані точки не можуть збігатися.";

lblErrorRectangle->Visible = true;

return;

}

lblErrorRectangle->Visible = false;

if (answRect->IsOnPlane() && !Double::IsNaN(answRect->Square()) && answRect->Square() > 0)

{

if (Constants::ENABLE_ANSWER_ROUNDING)

lblAnswer->Text = CrossAnswer +

String::Format("\nПериметр: {0} см\nПлоща: {1} см^2", Math::Round(answRect->Perimeter(), Constants::ANSWER_PRESITION), Math::Round(answRect->Square(), Constants::ANSWER_PRESITION));

else

lblAnswer->Text = CrossAnswer +

String::Format("\nПериметр: {0} см\nПлоща: {1} см^2", answRect->Perimeter(), answRect->Square());

if (!OpenGL->Contains(answRect))

OpenGL->AddToScene(answRect);

}

else if(Double::IsNaN(answRect->Square()) || answRect->Square() <= 0)

{

lblAnswer->Text = CrossAnswer + "\nВибрані точки лежать на одній прямій. Не можна побудувати чотирикутник";

if (OpenGL->Contains(answRect))

OpenGL->RemoveFromScene(answRect);

}

else

{

lblAnswer->Text = CrossAnswer + "\nВибрані точки не лежать у одній площині. Не можна побудувати чотирикутник";

if (OpenGL->Contains(answRect))

OpenGL->RemoveFromScene(answRect);

}

}