Нужны комментарии к коду

#include <vcl.h>
#include <fstream>
#include <string>
using namespace std;
 
#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//максимальное количество
const int LimitPoint   = 100;
const int LimitPoligon = 10;
 
const char *Roz = "::";
// структура координат
struct SMePoint{
    private :
        long int X,Y;
    public :
        SMePoint(){
            this->SetPoint(0, 0);
        };
        SMePoint(int NewX, int NewY){
            this->SetPoint(NewX, NewY);
        };
        void SetPoint(int NewX, int NewY){
            this->X = NewX;
            this->Y = NewY;
        };
        int GetX(void){return this->X;};
        int GetY(void){return this->Y;};
        ~SMePoint(){};
};
//класс - многоугольник
class TMePoligom{
    private :
        SMePoint Points[LimitPoint];
        TImage *Image;
        TColor Color[2];// 0  - полотно
        int CenterX, CenterY, Count;
 
        void AddCount(){this->Count++;};
        int GetValidCount(int pos){
            return (pos > this->GetCount())
                ? this->GetCount()
                : (pos < 0 )
                    ? 0
                    : pos;
        };
 
    public:
        int GetCenterX(void){return this->CenterX;};
        int GetCenterY(void){return this->CenterY;};
        TMePoligom(){this->Refresh();};
 
        void SetCenter(int NewCenterX, int NewCenterY){
            this->CenterX = NewCenterX;
            this->CenterY = NewCenterY;
        };
 
        SMePoint GetPoint(int pos){
            return this->Points[pos];
        }
 
        void SetPoint(SMePoint MePoint, int pos = 0){
            this->Points[pos] = MePoint;
        }
 
        int GetCount(void){return this->Count;};
 
        bool AddPoint(int NewX, int NewY){
            if (this->GetCount() > LimitPoint ) return false;
            SMePoint tmp;
            tmp.SetPoint(NewX, NewY);
            this->SetPoint(tmp, this->GetCount());
            this->AddCount();
            return true;
        };
        //координаты относительно
        int GetValidX(int i){
            return (this->GetCenterX() + this->Points[i].GetX());
        };
        int GetValidY(int i){
            return (this->GetCenterY() - this->Points[i].GetY());
        };
 
        void   SetImage(TImage *NewImage){this->Image = NewImage;};
        TImage *GetImage(void){return this->Image;};
        // сохнанение цветов
        void SetBrushColor(TColor NewColor){this->Color[0] = NewColor;};
        void SetPenColor(TColor NewColor){this->Color[1] = NewColor;}
        TColor GetBrushColor(void){return this->Color[0];};
        TColor GetPenColor(void){return this->Color[1];}
 
        //рисование
        void Draw(){
            int CenterX = this->GetImage()->Width / 2;
            int CenterY = this->GetImage()->Height / 2;
            this->SetCenter(CenterX, CenterY);
            TPoint *tmp = new TPoint[this->GetCount()+1];
            for (int i = 0; i <= this->GetCount(); i++) {
                tmp[i] = Point(this->GetValidX(i % this->GetCount()),
                                              this->GetValidY(i % this->GetCount()));
            };
            this->GetImage()->Canvas->Brush->Color = this->GetBrushColor();
            this->GetImage()->Canvas->Pen->Color   = this->GetPenColor();
            int count_ = this->GetCount();
            this->GetImage()->Canvas->Polygon(tmp, count_);
            delete tmp;
        };
        //загрузка с файла
        void LoadFromFile(string FileName){
                this->Refresh();
            ifstream file;
            file.open(FileName.c_str());
            char *string  = "";
            file.getline(string, 1024);
            file.close();
            this->Clear();
            char * tmp = strtok (string,Roz);
            bool p = false;
            int x = 0, y = 0;
            while (tmp != NULL){
                if (p == false) {
                    x = atoi(tmp);
                }else{
                    y = atoi(tmp);
                    this->AddPoint(x,y);
                };
                p = !p;
                tmp = strtok (NULL, Roz);
            };
            tmp    = "";
            string = "";
        };
        //сохранение
        void SaveToFile(string FileName){
            ofstream file;
            file.open(FileName.c_str(), ios::out);
            for (int i = 0; i < this->GetCount(); i++) {
                file << this->GetPoint(i).GetX() << Roz <<
                                                  this->GetPoint(i).GetY();
                if (i != this->GetCount() - 1 ) file  << Roz;
            }
            file.close();
        }
 
        void Refresh(){this->Count = 0;};
        //очистка канвы
        void Clear(){
            int CenterX = this->GetImage()->Width / 2;
            int CenterY = this->GetImage()->Height / 2;
 
            this->GetImage()->Canvas->Brush->Color = clWhite;
            this->GetImage()->Canvas->Pen->Color   = clBlack;
 
            this->GetImage()->Canvas->Rectangle(0, 0, this->GetImage()
                                               ->Width, this->GetImage()->Height);
 
                this->GetImage()->Canvas->Rectangle(0, CenterY, CenterX * 2, CenterY + 1);
                this->GetImage()->Canvas->Rectangle(CenterX, 0, CenterX + 1, CenterY * 2);
        }
        // сдвиг
        void Landslide(int x = 0, int y = 0){
            try{
                for (int i = 0; i < this->GetCount(); i++) {
        this->Points[i].SetPoint(this->Points[i].GetX() + x, this->Points[i].GetY() +y);
                }
            }catch(...){}
        }
        //отображение
        void Mirrov(){
            for (int i = 0; i < this->GetCount(); i++) {
                this->Points[i].SetPoint(-this->Points[i].GetX(), -this->Points[i].GetY());
            }
        };
};
//структура - массив с обектов
struct SMePoligom{
    private :
        long int Count, CenterX, CenterY;
    public :
 
    int Length;
    TMePoligom Poligoms[LimitPoligon];
    SMePoligom(){this->Length = 0;};
    //добавление нового полинома
    void AddNewPoligom(TComboBox *ComboBox){
        if(this->Count < LimitPoligon){
            ComboBox->Clear();
            this->Poligoms[this->Length++].SetImage(Form1->Image1);
            for (int i = 0; i < this->Length; i++) {
                char *tmp  = "";
                itoa(i+1, tmp, 10);
                ComboBox->Items->Add(tmp);
                tmp ="";
            };
        };
    };
};
//---------------------------------------------------------------------------
int position = 0;
SMePoligom MePoligoms;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
    : TForm(Owner){}
//---------------------------------------------------------------------------
void __fastcall TForm1::Exit1Click(TObject *Sender){
//закрытие формы
    try{
        Form1->Close();
    }catch(...){
        Application->Terminate();
    }
 
}
//---------------------------------------------------------------------------
void __fastcall TForm1::FormCreate(TObject *Sender){
//создание формы
    MePoligoms.AddNewPoligom(Form1->ComboBox1);
    MePoligoms.Poligoms[position].Clear();
    Form1->Timer1->Interval = 75;
    Form1->ColorBox1->ItemIndex = 0;
    Form1->ColorBox2->ItemIndex = 1;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::SpeedButton1Click(TObject *Sender){
// читать с файла
    if (Form1->OpenDialog1->Execute()) {
        char *tmp = "";
        tmp = AnsiString(Form1->OpenDialog1->FileName).c_str();
        MePoligoms.Poligoms[position].LoadFromFile(tmp);
        tmp = "";
    }
}
//---------------------------------------------------------------------------
void __fastcall TForm1::SpeedButton2Click(TObject *Sender){
// сохранение в файл
    if (Form1->OpenDialog1->Execute()) {
        char *tmp = "";
        tmp = AnsiString(Form1->OpenDialog1->FileName).c_str();
        MePoligoms.Poligoms[position].SaveToFile(tmp);
        tmp = "";
    }
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Timer1Timer(TObject *Sender){
    if (Form1->ComboBox1->ItemIndex == -1 && Form1->ComboBox1->Items->Count  > 0) {
        Form1->ComboBox1->ItemIndex = 0;
    }
    if (Form1->ColorBox1->ItemIndex < 0) {
        Form1->ColorBox1->ItemIndex = 0;
    }
    if (Form1->ColorBox2->ItemIndex < 0) {
        Form1->ColorBox2->ItemIndex = 1;
    }
    position = Form1->ComboBox1->ItemIndex;
 
}
//---------------------------------------------------------------------------
 
 
void __fastcall TForm1::SpeedButton3Click(TObject *Sender)
{
//создание нового многоугольника
    MePoligoms.AddNewPoligom(Form1->ComboBox1);
}
//---------------------------------------------------------------------------
 
void __fastcall TForm1::SpeedButton4Click(TObject *Sender){
//изменение цвета
    TColor Colors[2];
 
    Colors[0] = Form1->ColorBox1->Selected;
    Colors[1] = Form1->ColorBox2->Selected;
 
    MePoligoms.Poligoms[position].SetBrushColor(Colors[0]);
    MePoligoms.Poligoms[position].SetPenColor(Colors[1]);
}
//---------------------------------------------------------------------------
 
void __fastcall TForm1::SpeedButton5Click(TObject *Sender){
//отрисовка
    MePoligoms.Poligoms[0].Clear();
    for (int i = 0; i < MePoligoms.Length; i++) {
        MePoligoms.Poligoms[i].Draw();
    }
}
//---------------------------------------------------------------------------
 
 
 
 
void __fastcall TForm1::SpeedButton6Click(TObject *Sender)
{
//сдвиг
    MePoligoms.Poligoms[position].Landslide(atoi(AnsiString(Form1->Edit1->Text).c_str()),
                                                atoi(AnsiString(Form1->Edit2->Text).c_str()));
}
//---------------------------------------------------------------------------
 
void __fastcall TForm1::SpeedButton7Click(TObject *Sender){
//отображение
    MePoligoms.Poligoms[position].Mirrov();
}
//---------------------------------------------------------------------------