Первый раз пишу класс

unit uHexFile;
 
interface
 
uses
  //============================== Модули проекта ==============================
  uRoutines,
  //========================= Модули проекта с формами =========================
  //=============================== Левые модули ===============================
  //dwTypes, dwFiles,
  //=================== Системные модули, добавленные вручную ==================
  Math,
  //=================== Модули, добавленные IDE автоматически ==================
  Windows, Classes, Contnrs, SysUtils, Types, typinfo, Generics.Collections;
 
type
  //------------------------- Классы исключений --------------------------------
  EHexFileError = class(Exception);              // Общий предок (для идентификации on E: EHexFileError do)
  EHexInvalidSymbol = class(EHexFileError);      // Исключение - недопустимый символ в НЕХ-строке
  EHexIncorrectDataLen = class(EHexFileError);   // Исключение - Длина строки не соответствует обозначенной длине данных
  EHexIncorrectStringLen = class(EHexFileError); // Исключение - некорректная длина строки (< 11 символов)
  EHexIncorrectChecksum = class(EHexFileError);  // Исключение - Неверная КС
 
 
  THexStringKind =  // тип информации в НЕХ-строке (по 8 и 9 символам)
    (hskData,          // 0x00
     hskEOF,           // 0x01
     hskKey,           // 0x04 (данные = старшие 2 байта адреса ОЗУ)
     hskError,         // 0xED (defaced error)
     hskUnknown);      // 0x?? (остальные варианты)
 
  THexOptimizeResults = record
    OldFileSize: DWORD; // должен быть больше,
    NewFileSize: DWORD; // чем новый
    OldDataSize: DWORD; // должны быть равны
    NewDataSize: DWORD; // после оптимизации
    OldStrCount: int32; // исходное число строк
    NewStrCount: int32; // полученное число строк
    OldCRC32:    DWORD; // CRC32 данных должна совпасть
    NewCRC32:    DWORD; // с новой, если данные не изменились
  public
    function Ratio: Single;
    function Success: Boolean; // проверка по CRC32
  end;
 
{$REGION 'Класс для перевода НЕХ-строки в адрес/данные и обратно'}
type
  THexFile = class; // Заглушка для ссылки на объект-контейнер
 
  //---------- Класс для перевода НЕХ-строки в адрес/данные и обратно ----------
  THexString = class
  private
    FRAWText: string;                // весь текст целиком, включая ":" и КС
    FData: TBytes;                   // Данные - только они и нач адрес хранятся, остальное вычисляется
    FAddress: Word;                 // Начальный адрес данных
    FHexFile: THexFile;             // Ссылка на объект-контейнер
 
    // Функции доступа к полям
    procedure SetData(const ANew: TBytes);                // Запись данных
    function GetText: string;                             // Чтение НЕХ-текста
    function GetTextLength: Integer;                      // длина переменной FRAWText (кол-во символов)
    procedure SetText(const ANew: string);                // Установка НЕХ-текста
    function GetChecksum: Byte;                           // Расчёт КС
    function GetDataSize: Byte;                           // Расчёт длины данных в байтах
    procedure SetDataSize(const ANew: Byte);              // Установка новой длины данных (нужно перед записью)
    function GetEOF: Boolean;                             // Флаг конца файла
    function GetKind: THexStringKind;                     // Тип данных строки
  protected
    function GetRAWByte(const ByteNumber: Byte): Byte;    // 2 символа строки ---> байт данных
    function GetRAWWord(const WordNumber: Byte): Word;    // 4 символа строки ---> слово данных ("ABCD" ---> 0xABCD)
 
    function GetDataAsText: string;
    function GetCRC32: DWORD;
  public
    constructor Create(AHexFile: THexFile);
    destructor Destroy; override;
    procedure Roll(const Offset: Byte); // удаление offset байт слева и сдвиг адреса на +offset
 
    // Свойства
    property Data: TBytes read FData write SetData;                           // Данные
    property Text: string read GetText write SetText;                         // НЕХ-строка, составленная из данных
    property DataAsText: string read GetDataAsText;
    property CRC32: DWORD read GetCRC32;                                      // CRC32 только данных!
    property RAWText: string read FRAWText;                                   // НЕХ-строка, заданная изначально
    property TextLength: Integer read GetTextLength;                          // длина переменной FRAWText (кол-во символов)
    property DataSize: Byte read GetDataSize write SetDataSize;               // Длина данных в байтах
    property Checksum: Byte read GetChecksum;                                 // Контрольная сумма
    property Address: Word read FAddress write FAddress;                      // Начальный адрес данных
    property EOF: Boolean read GetEOF;                                        // Флаг конца файла
    property Kind: THexStringKind read GetKind;                               // Тип данных строки
    property HexFile: THexFile read FHexFile write FHexFile;                  // Ссылка на объект-контейнер
    property RAWByte[const ByteNumber: Byte]: Byte read GetRAWByte;
    property RAWWord[const WordNumber: Byte]: Word read GetRAWWord;
  end;
{$ENDREGION}
 
{$REGION 'Класс для загрузки из- и сохранения в НЕХ-файл'}
  TOptimizeProgressEvent = procedure (Sender: THexFile; const AProgress: int32) of object;
  //------------ Класс для загрузки из- и сохранения в НЕХ-файл ----------------
  THexFile = class(TObjectList<THexString>)
  private
    FFileName: string;
    //FChanged: TDateTime;
    FLastStringDataMaxSize: DWORD;                                              // последний рассчитанный максимальный размер данных среди строк
    FOnOptimizeProgress: TOptimizeProgressEvent;                                // событие для обновления ProgressBar при оптимизации
    // Функции для доступа к полям
    function GetFileSize: DWORD;                                                // размер файла (текста)
    function GetDataSize: Cardinal;                                             // Количество данных в байтах
    function GetDataPercent: Single;                                            // % данных в файле
    function GetCRC32: DWORD;                                                   // хэш ВСЕХ данных!
  public
    constructor Create; reintroduce;
    // Методы
    function New(const AData: TBytes; const AAddress: Word): THexString;        // Добавление НЕХ-строки
    procedure LoadFromStream(AStream: TStream);                                 // Загрузка из стрима
    function LoadFromFile(const AFileName: string): Boolean;                    // Загрузка из файла
    procedure SaveToStream(AStream: TStream);                                   // Сохранение в стрим
    function SaveToFile(const AFileName: string): Boolean;                      // Сохранение в файл
    function GetStringDataMaxSize: DWORD;                                       // максимальная длина данных среди строк в файле
    function Optimize(const MaxDataPerLine: Byte): THexOptimizeResults;         // оптимизация (перераспределение памяти)
    procedure ShowAsStrings(AStrings: TStrings);                                // копирование в текстовый список
 
    // Свойства
    property FileName: string read FFileName;
    property FileSize: DWORD read GetFileSize;                                  // размер файла (текста)
    property DataSize: DWORD read GetDataSize;                                  // Количество данных в байтах
    property DataPercent: Single read GetDataPercent;                           // % данных в файле
    property LastStringDataMaxSize: DWORD read FLastStringDataMaxSize;          // последний рассчитанный максимальный размер данных среди строк
    property CRC32: DWORD read GetCRC32;                                        // хэш ВСЕХ данных!
 
    // события
    property OnOptimizeProgress: TOptimizeProgressEvent read FOnOptimizeProgress write FOnOptimizeProgress;
  end;
{$ENDREGION}
 
{  THexStringInfo = record
    HexString: THexString;
    ID: Integer;
  end;
  PHexStringInfo = ^THexStringInfo;     }
 
const
//  HEXSTRINGINFO_SIZE = SizeOf(THexStringInfo);
  NOT_AVAILABLE = 'n/a';
 
function KindToStr(const AKind: THexStringKind): string; inline;
function MemToHex(const AData; const ASize: UInt32): string;
 
// результат слияния двух НЕХ-строк
type
  THexMergeResult =
    (hmrImpossible, // слияние невозможно
     hmrPartial,    // слияние частичное (данные перераспределены)
     hmrFull);      // слияния полное (строка 2 влезла в первую полностью)
 
function HexMerge(hs0, hs1: THexString; const MaxDataPerLine: Byte = 255): THexMergeResult;
 
implementation
 
const
  HEX_DIGITS_SET: TSysCharSet = ['0'..'9', 'A'..'F', 'a'..'f']; // 16-чные цифры
  HEX_DIGITS: array[$0..$F] of Char = '0123456789ABCDEF';
 
{$REGION 'service'}
function KindToStr(const AKind: THexStringKind): string; inline;
begin
  Result:= Copy(GetEnumName(TypeInfo(THexStringKind), int32(AKind)), 4, 16);
end;
 
function MemToHex(const AData; const ASize: UInt32): string;
var
  idx: int32;
  p: PByte;// absolute AData;
begin
  p:= @AData;
  SetLength(Result, ASize * 2);
  for idx:= 1 to ASize do
    begin
      Result[2 * idx - 1]:= HEX_DIGITS[p^ shr 4];
      Result[2 * idx - 0]:= HEX_DIGITS[p^ and $F];
      inc(p);
    end;
end;
 
function HexMerge(hs0, hs1: THexString; const MaxDataPerLine: Byte = 255): THexMergeResult;
var
  partsize: int32;
begin
  // проверки потом объединить в одну большую if (.....) then Exit(hmrImpossible);
 
  // проверка, что обе строки - это строки с данными
  if (hs0.Kind <> hskData) or (hs1.Kind <> hskData)
    then Exit(hmrImpossible);
 
  // проверка, что обе строки непустые.
  // Надо ли? на всякий случай, удалить не трудно.
  if (hs0.DataSize = 0) or (hs1.DataSize = 0) or
     (hs0.DataSize >= MaxDataPerLine) // или строка 0 заполнена до предела
    then Exit(hmrImpossible);
 
  // проверка того что адрес второй строки больше адреса первой
  // ровно на длину данных первой строки.
  if (hs1.Address - hs0.Address <> hs0.DataSize)
    then Exit(hmrImpossible);
 
  // строка 0 полностью поместится в строку 1
  if hs0.DataSize + hs1.DataSize <= MaxDataPerLine
    then begin
           hs0.Data:= hs0.Data + hs1.Data;
           Result:= hmrFull;
         end
    // строка 0 влезает в строку 1 только частично ----> перераспределение данных
    else begin
           partsize:= MaxDataPerLine - hs0.DataSize; // столько байт влезет в конец hs0
           hs0.Data:= hs0.Data + Copy(hs1.Data, 0, partsize);
           hs1.Roll(partsize); // сдвиг адресе с потерей данных, которые были скопированы в пред. строке
           Result:= hmrPartial;
         end;
end;
{$ENDREGION}
 
{$REGION 'THexOptimizeResults'}
{ THexOptimizeResults }
 
function THexOptimizeResults.Ratio: Single;
begin
  result:= NewFileSize / OldFileSize;
end;
{$ENDREGION}
 
{$REGION 'THexString'}
function THexOptimizeResults.Success: Boolean;
begin
  Result:= OldCRC32 = NewCRC32;
end;
 
{ THexString }
 
constructor THexString.Create(AHexFile: THexFile);
begin
  FHexFile:= AHexFile; // Ссылка на объект-контейнер
  SetLength(FData, 0);
  FAddress:= $0000;
end;
 
destructor THexString.Destroy;
begin
  SetLength(FData, 0); // возможная
  FData:= nil;         // очистка памяти
  inherited;
end;
 
function THexString.GetChecksum: Byte;
var
  Index: Integer;
begin
  // Расчёт КС
  if Self.DataSize <> 0
    then Result:= (Self.DataSize and $FF)   + // Длина данных
                  ((Address shr 8) and $FF) + // Ст. байт адреса
                  (Address and $FF)           // Мл. байт адреса
    else begin // EOF (:00000001FF)
           Result:= $FF;
           Exit;
         end;
 
  // Плюс тип строки (байт перед массивом данных)
  Inc(Result, RAWByte[3]); // он всегда 3-й от нуля
 
  // Плюс сумма данных
  for Index:= 0 to Self.DataSize - 1 do
    Inc(Result, FData[Index]);
 
  Result:= Byte($100 - Result); // Перевод в доп. код.
end;
 
function THexString.GetCRC32: DWORD;
begin
  Result:= AnyToCRC32(FData, Length(FData));
end;
 
function THexString.GetDataAsText: string;
begin
  if Self.DataSize = 0
    then Exit('');
  Result:= MemToHex(Self.FData[0], Self.DataSize);
end;
 
function THexString.GetDataSize: Byte;
begin
  // Расчёт длины данных в байтах
  Result:= Length(FData) and $FF;
end;
 
function THexString.GetEOF: Boolean;
begin
  // Флаг конца файла
  //Result:= Self.DataSize = 0;
  Result:= Self.Kind = hskEOF;
end;
 
function THexString.GetKind: THexStringKind;
begin
  case RAWByte[3] of
    $00: Result:= hskData;
    $01: Result:= hskEOF;
    $04: Result:= hskKey;
    $ED: Result:= hskError;
  else   Result:= hskUnknown;
  end;
end;
 
function THexString.GetRAWByte(const ByteNumber: Byte): Byte;
var
  bytecount: int32;
begin
  bytecount:= (TextLength - 1) div 2;
  Result:= $ED; // default (dafaced error)
  if ByteNumber < bytecount
    then Result:= StrToIntDef('$' + Copy(FRAWText, 2 + 2 * ByteNumber, 2), Result);
end;
 
function THexString.GetRAWWord(const WordNumber: Byte): Word;
var
  wordcount: int32;
begin
  wordcount:= (TextLength - 1) div 4;
  Result:= $ACED; // default (dafaced error)
  if WordNumber < wordcount
    then Result:= StrToIntDef('$' + Copy(FRAWText, 2 + 4 * WordNumber, 4), Result);
end;
 
function THexString.GetText: string;
var
  Index: Integer;
begin
  if Self.DataSize = 0
    then Result:= ':00000001FF' // EOF
    else begin
           Result:= ':' +                                  // Префикс
                    IntToHex(Self.DataSize and $FF, 2) +   // Длина данных
                    IntToHex(Self.FAddress, 4) +           // Адрес
                    IntToHex(Self.RAWByte[3], 2);          // Тип строки
                    //'00';                                  // Тип строки
 
           for Index:= 0 to Self.DataSize - 1 do           // Данные
             Result:= Result + IntToHex(FData[Index], 2);
 
           Result:= Result + IntToHex(Self.Checksum, 2);   // КС
         end;
end;
 
function THexString.GetTextLength: Integer;
begin
  Result:= FRAWText.Length;
end;
 
procedure THexString.Roll(const Offset: Byte);
var
  count: Byte;
begin
  // удаление offset байт слева и сдвиг адреса на +offset
  count:= min(Offset, Self.DataSize);
  inc(FAddress, count);
  Delete(FData, 0, count);
end;
 
procedure THexString.SetText(const ANew: string);
var
  Index, Len, dLen: Integer;
  dChecksum: Byte;         // Для подсчёта суммы
  rChecksum: Byte;         // Сумма, взятая из НЕХ-строки для сравнение с расчётной
  Digits: string;
begin
  // Установка текста
 
  { Формат НЕХ-строки:
 
    :0100230032AA
    :00000001FF
 
    01 - длина данных
    0023 - начальный адрес
    00 - тип строки
    32 - данные
    AA - контрольная сумма.
 
    :|01|0023|00|32|AA
    :|08|0013|00|C2AF020AF1D2AF32|C4 }
 
  // Длина строки должна быть = длина данных (закодирована во 2-м и 3-м символах) * 2 + 11,
  // начинаться на ":", состоять из 16-чных символов, начиная со 2-го символа,
  // и КС (закодирована 2-мя последними символами) должна совпадать с расчётной
  // по байтам, закодированным со 2-го по N-2-й символами.
 
  Len:= Length(ANew);
 
  if Len < 11
    then raise EHexIncorrectStringLen.Create('Некорректная длина строки (< 11 символов).');
 
  if ANew[1] <> ':'
    then raise EHexInvalidSymbol.Create('Недопустимый символ "' + ANew[1] + '" в позиции 1.');
 
  // Проверка на 16-чные цифры
  for Index:= 2 to Len do
    if not CharInSet(ANew[Index], HEX_DIGITS_SET)
      then raise EHexInvalidSymbol.Create('Недопустимый символ "' + ANew[Index] + '" в позиции ' + IntToStr(Index) + '.');
 
  // Проверка длины строки на соответствие указанной длине данных (закодирована во 2-м и 3-м символах)
  dLen:= StrToInt('$' + Copy(ANew, 2, 2));
  if dLen * 2 + 11 <> Len
    then raise EHexIncorrectDataLen.Create('Длина строки не соответствует обозначенной длине данных.');
 
  // Вычисление и проверка КС
  Digits:= Copy(ANew, 2, Len - 3); // Копирую всё, кроме ":" и КС (последнего байта)
  dChecksum:= $00;
  for Index:= 1 to Length(Digits) div 2 do
    Inc(dChecksum, StrToInt('$' + Copy(Digits, (Index * 2) - 1, 2))); // 1, 3, 5,...
  dChecksum:= Byte($100 - dChecksum);
 
  rChecksum:= Byte(StrToInt('$' + Copy(ANew, Len - 1, 2)));
  if dChecksum <> rChecksum
    then raise EHexIncorrectChecksum.Create('Неверная контрольная сумма (0x' + IntToHex(rChecksum, 2) +
                                     ').'#13#10'Ожидалось 0x' + IntToHex(dChecksum, 2));
 
  // Ну, и наконец, если все проверки не выявили ошибок,
  // выделяю начальный адрес и данные
  FAddress:= Word(StrToInt('$' + Copy(ANew, 4, 4))); // адрес
  Digits:= Copy(ANew, 10, dLen * 2); // Кусок строки с данными
  SetLength(FData, dLen);
  for Index:= 1 to Length(Digits) div 2 do
    FData[Index - 1]:= StrToInt('$' + Copy(Digits, (Index * 2) - 1, 2));
 
  FRAWText:= ANew; // оригинал строки
end;
 
procedure THexString.SetDataSize(const ANew: Byte);
begin
  // Установка новой длины данных (нужно перед записью)
  SetLength(FData, ANew);
end;
 
 
procedure THexString.SetData(const ANew: TBytes);
begin
  // Запись данных
  // Self.DataSize:= Cardinal(Length(AData)); // Проверить, нужно ли выделение памяти или оно автоматическое!!!
  Self.FData:= Copy(ANew); // Копирование, именно копирование!
  FRAWText:= GetText(); // переформирование буфера с сырым текстом
end;
{$ENDREGION}
 
{$REGION 'THexFile'}
{ THexFile }
 
function THexFile.New(const AData: TBytes; const AAddress: Word): THexString;
begin
  // Добавление НЕХ-строки
  Result:= THexString.Create(Self);
  Result.Address:= AAddress;
  Result.Data:= AData;
  Self.Add(Result);
end;
 
 
function THexFile.Optimize(const MaxDataPerLine: Byte): THexOptimizeResults;
var
  idx, progress, old_progress: int32;
begin
  // оптимизация. Возвращает абсолютный коэффициент сжатия (Single)
  ZeroMemory(@result, sizeof(result));
 
  idx:= 0;
  old_progress:= 0;
  result.OldFileSize:= Self.FileSize;
  result.OldDataSize:= Self.DataSize;
  result.OldStrCount:= Self.Count;
  result.OldCRC32:= Self.CRC32;
 
  while idx < Count - 1 do
    begin
      case HexMerge(Self[idx], Self[idx + 1], MaxDataPerLine) of
        hmrImpossible: inc(idx);
        hmrFull:       Self.Delete(idx + 1);
      else inc(idx);  // hmrPartial
      end;
 
      // прогресс выполнения
      if Assigned(FOnOptimizeProgress)
        then begin
               progress:= Round(100.0 * idx / count);
               if old_progress <> progress
                 then begin
                        FOnOptimizeProgress(Self, progress);
                        old_progress:= progress;
                      end;
             end;
    end;
 
  result.NewFileSize:= Self.FileSize;
  result.NewDataSize:= Self.DataSize;
  result.NewStrCount:= Self.Count;
  result.NewCRC32:=    Self.CRC32;
 
  //Assert(result.OldDataSize = result.NewDataSize);
end;
 
constructor THexFile.Create;
begin
  inherited Create(true);
end;
 
function THexFile.GetCRC32: DWORD;
var
  ms: TMemoryStream;
  idx: int32;
begin
  ms:= TMemoryStream.Create();
  try
    for idx:= 0 to Count - 1 do
      if Self[idx].Kind = hskData
        then ms.WriteData(Self[idx].Data, Self[idx].DataSize);
 
    Result:= AnyToCRC32(ms.Memory, ms.Size);
  finally
    ms.Free();
  end;
end;
 
function THexFile.GetDataPercent: Single;
var
  fs: DWORD;
begin
  fs:= GetFileSize();
  if fs <> 0
    then Result:= 100 * Self.DataSize / fs
    else Result:= 0;
end;
 
function THexFile.GetDataSize: Cardinal;
var
  Index: Integer;
begin
  // Количество данных в байтах
  Result:= 0;
  for Index:= 0 to Self.Count - 1 do
    if Self[Index].Kind = hskData //<> hskKey
      then Inc(Result, Self[Index].DataSize);
end;
 
function THexFile.GetFileSize: DWORD;
var
  item: THexString;
begin
  Result:= 0;
 
  if Count = 0
    then Exit;
 
  for item in Self do
    inc(Result, item.TextLength);
  inc(Result, (Count - 1) * 2);
end;
 
function THexFile.GetStringDataMaxSize: DWORD;
var
  hs: THexString;
begin
  Result:= 0;
  for hs in Self do
    Result:= max(hs.DataSize, Result);
  FLastStringDataMaxSize:= Result;
end;
 
function THexFile.LoadFromFile(const AFileName: string): Boolean;
var
  fs: TFileStream;
begin
  Result:= true;
  try
    fs:= TFileStream.Create(AFileName, fmOpenRead or fmShareDenyWrite);
    try
      Self.LoadFromStream(fs);
      Self.FFileName:= AFileName;
    finally
      fs.Free();
    end;
  except on E: Exception do
    begin
      Result:= false;
      ShowExceptionDlg(E);
    end;
  end;
end;
 
procedure THexFile.LoadFromStream(AStream: TStream);
var
  Index: Integer;
  List: TStringList;
  Item: THexString;
begin
  // Загрузка из стрима
  Self.Clear();
  List:= TStringList.Create();
  try
    List.LoadFromStream(AStream);
 
    for Index:= 0 to List.Count - 1 do
      begin
        Item:= THexString.Create(Self);
        Item.Text:= List[Index];
        Self.Add(Item);
      end;
 
    FFileName:= '';
  finally
    List.Free();
  end;
end;
 
function THexFile.SaveToFile(const AFileName: string): Boolean;
var
  fs: TFileStream;
begin
  Result:= true;
  try
    fs:= TFileStream.Create(AFileName, fmCreate or fmShareExclusive);
    try
      Self.SaveToStream(fs);
      Self.FFileName:= AFileName;
    finally
      fs.Free();
    end;
  except on E: Exception do
    begin
      Result:= false;
      ShowExceptionDlg(E);
    end;
  end;
end;
 
procedure THexFile.SaveToStream(AStream: TStream);
var
  Index: Integer;
  List: TStringList;
begin
  // Сохранение
  List:= TStringList.Create();
  try
    for Index:= 0 to Self.Count - 1 do
      List.Add(Self[Index].Text);
 
    List.SaveToStream(AStream);
  finally
    List.Free();
  end;
end;
 
procedure THexFile.ShowAsStrings(AStrings: TStrings);
var
  idx: int32;
begin
  AStrings.BeginUpdate();
  try
    AStrings.Clear();
    for idx:= 0 to Count - 1 do
      AStrings.Add(Self[idx].Text);
  finally
    AStrings.EndUpdate();
  end;
end;
 
{$ENDREGION}
end.

unit Unit2;
 
interface
 
type
      TMyClass = class(TObject)
        protected
           IntItemIndex:Integer;
           IntCountNumbers:Integer;
        public
           constructor Create;
        protected
           procedure SetItemIndex(Value:Integer);
        public
           property ItemIndex:Integer write SetItemIndex;
      end;
 
implementation
 
uses
        SysUtils,
        Unit1;
 
constructor TMyClass.Create;
begin
        Inherited Create;
        Self.IntItemIndex:=0;
        Self.IntCountNumbers:=0;
end;
 
procedure TMyClass.SetItemIndex(Value: Integer);
begin
  if Self.IntItemIndex=Value then
        exit;
 
        Self.IntItemIndex:=Value;
        inc(Self.IntCountNumbers,Self.IntItemIndex);
        Form1.Edit1.Text:=IntToStr(Self.IntItemIndex);
        Form1.Edit2.Text:=IntToStr(Self.IntCountNumbers);
end;
 
end.

unit Unit1;
 
interface
 
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;
 
type
  TForm1 = class(TForm)
    ComboBox1: TComboBox;
    Edit1: TEdit;
    Edit2: TEdit;
    procedure FormCreate(Sender: TObject);
    procedure ComboBox1Change(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }
  end;
 
var
  Form1: TForm1;
 
implementation
 
{$R *.dfm}
 
uses
        Unit2;
 
var
        MyClass:TMyClass;
 
procedure TForm1.FormCreate(Sender: TObject);
begin
        Form1.Edit1.Text:='0';
        Form1.Edit2.Text:='0';
end;
 
procedure TForm1.ComboBox1Change(Sender: TObject);
begin
        MyClass.ItemIndex:=Form1.ComboBox1.ItemIndex;
end;
 
initialization
 
        MyClass:=TMyClass.Create;
 
finalization
 
        FreeAndNil(MyClass);
 
end.