Chip 2000 February/Chip_2000-02_cd.bin/zkuste/Delphi/navody/tt/numlists.txt

Text File | 1999-11-22 | 27KB | 968 lines

{*******************************************************}
{*                                                     *}
{*      Pro VCL Extensions Library                     *}
{*      Lists Unit                                     *}
{*                                                     *}
{*      Copyright (c) 1996-98 by Dmitry Barabash       *}
{*                                                     *}
{*******************************************************}

unit ProLists;

{$I PRO.INC}

interface

uses {$IFDEF WIN32} Windows, {$ELSE} WinTypes, {$ENDIF} SysUtils, Classes;

type

{ Exception classes }

  EIntegerListError = class(EListError);
  EFloatListError = class(EListError);

{ TIntegerList }

  PLongArray = ^TLongArray;
  TLongArray = array[0..MaxListSize - 1] of LongInt;

  TIntegerList = class(TPersistent)
  private
    { Variables for properties }
    FList : TList;
    FMin : LongInt;
    FMax : LongInt;
    FDuplicates : TDuplicates;
    FSorted : Boolean;
    { Property access methods }
    procedure SetMin(Value : LongInt);
    procedure SetMax(Value : LongInt);
    procedure SetSorted(Value : Boolean);
    function GetList : PLongArray;
    { Private methods }
    procedure ReadMin(Reader : TReader);
    procedure WriteMin(Writer : TWriter);
    procedure ReadMax(Reader : TReader);
    procedure WriteMax(Writer : TWriter);
    procedure ReadIntegers(Reader : TReader);
    procedure WriteIntegers(Writer : TWriter);
    procedure QuickSort(L, R : Integer);
  protected
    procedure Error; virtual;
    procedure DefineProperties(Filer : TFiler); override;
    { Property access methods }
    function GetCount : Integer; virtual;
    function Get(Index : Integer) : LongInt; virtual;
    procedure Put(Index : Integer; Value : LongInt); virtual;
  public
    constructor Create;
    destructor Destroy; override;
    function Add(Value : LongInt) : Integer; virtual;
    function AddIntegers(IntegerList : TIntegerList) : Integer; virtual;
    procedure Assign(Source : TPersistent); override;
    procedure Clear; virtual;
    procedure Delete(Index : Integer); virtual;
    function Find(Value : LongInt; var Index : Integer) : Boolean; virtual;
    function Equals(IntegerList : TIntegerList) : Boolean;
    procedure Exchange(Index1, Index2 : Integer); virtual;
    function IndexOf(Value : LongInt) : Integer; virtual;
    procedure Insert(Index : Integer; Value : LongInt); virtual;
    procedure Move(CurIndex, NewIndex : Integer); virtual;
    procedure Sort; virtual;
    property Count : Integer read GetCount;
    property Items[Index : Integer] : LongInt read Get write Put; default;
    property Min : LongInt read FMin write SetMin;
    property Max : LongInt read FMax write SetMax;
    property Duplicates: TDuplicates read FDuplicates write FDuplicates;
    property Sorted: Boolean read FSorted write SetSorted;
    property List : PLongArray read GetList;
  end;

{ TFloatList }

  TFloatList = class(TPersistent)
  private
    { Variables for properties }
    FList : TList;
    FMin : Extended;
    FMax : Extended;
    FDuplicates : TDuplicates;
    FSorted : Boolean;
    { Property access methods }
    procedure SetMin(Value : Extended);
    procedure SetMax(Value : Extended);
    procedure SetSorted(Value : Boolean);
    { Private methods }
    procedure ReadMin(Reader : TReader);
    procedure WriteMin(Writer : TWriter);
    procedure ReadMax(Reader : TReader);
    procedure WriteMax(Writer : TWriter);
    procedure ReadFloats(Reader : TReader);
    procedure WriteFloats(Writer : TWriter);
    procedure QuickSort(L, R : Integer);
  protected
    procedure Error; virtual;
    procedure DefineProperties(Filer : TFiler); override;
    { Property access methods }
    function GetCount : Integer; virtual;
    function Get(Index : Integer) : Extended; virtual;
    procedure Put(Index : Integer; Value : Extended); virtual;
  public
    constructor Create;
    destructor Destroy; override;
    function Add(Value : Extended) : Integer; virtual;
    function AddFloats(FloatList : TFloatList) : Integer; virtual;
    procedure Assign(Source : TPersistent); override;
    procedure Clear; virtual;
    procedure Delete(Index : Integer); virtual;
    function Find(Value : Extended; var Index : Integer) : Boolean; virtual;
    function Equals(FloatList : TFloatList) : Boolean;
    procedure Exchange(Index1, Index2 : Integer); virtual;
    function IndexOf(Value : Extended) : Integer; virtual;
    procedure Insert(Index : Integer; Value : Extended); virtual;
    procedure Move(CurIndex, NewIndex : Integer); virtual;
    procedure Sort; virtual;
    property Count : Integer read GetCount;
    property Items[Index : Integer] : Extended read Get write Put; default;
    property Min : Extended read FMin write SetMin;
    property Max : Extended read FMax write SetMax;
    property Duplicates: TDuplicates read FDuplicates write FDuplicates;
    property Sorted: Boolean read FSorted write SetSorted;
  end;

implementation

uses ProConst;

{ Utility routines }

procedure IntegerListError(Ident : Integer);
begin
  raise EIntegerListError.CreateRes(Ident);
end; { IntegerListError }

procedure FloatListError(Ident : Integer);
begin
  raise EFloatListError.CreateRes(Ident);
end; { FloatListError }


{ TIntegerList }

constructor TIntegerList.Create;
{ Overrides the constructor to initialize variables }
begin
  inherited Create;
  FList := TList.Create;
  FMin := -MaxLongInt;
  FMax := MaxLongInt;
  FDuplicates := dupAccept;
end; { TIntegerList.Create }

destructor TIntegerList.Destroy;
{ Overrides the destructor to uninitialize variables }
begin
  Clear;
  FList.Free;
  inherited Destroy;
end; { TIntegerList.Destroy }

procedure TIntegerList.Assign(Source : TPersistent);
begin
  if Source is TIntegerList then
  begin
    FMin := TIntegerList(Source).Min;
    FMax := TIntegerList(Source).Max;
    FDuplicates := TIntegerList(Source).Duplicates;
    FSorted := TIntegerList(Source).Sorted;
    Clear;
    AddIntegers(TIntegerList(Source));
  end
  else
    inherited Assign(Source);
end; { TIntegerList.Assign }

procedure TIntegerList.Error;
begin
  IntegerListError(SIntegerListIndexError);
end; { TIntegerList.Error }

procedure TIntegerList.DefineProperties(Filer : TFiler);
begin
  Filer.DefineProperty('Min', ReadMin, WriteMin, FMin <> -MaxLongInt);
  Filer.DefineProperty('Max', ReadMax, WriteMax, FMax <> MaxLongInt);
  Filer.DefineProperty('Integers', ReadIntegers, WriteIntegers, GetCount > 0);
end; { TIntegerList.DefineProperties }

procedure TIntegerList.ReadMin(Reader : TReader);
begin
  FMin := Reader.ReadInteger;
end; { TIntegerList.ReadMin }

procedure TIntegerList.WriteMin(Writer : TWriter);
begin
  Writer.WriteInteger(FMin);
end; { TIntegerList.WriteMin }

procedure TIntegerList.ReadMax(Reader : TReader);
begin
  FMax := Reader.ReadInteger;
end; { TIntegerList.ReadMax }

procedure TIntegerList.WriteMax(Writer : TWriter);
begin
  Writer.WriteInteger(FMax);
end; { TIntegerList.WriteMax }

procedure TIntegerList.ReadIntegers(Reader : TReader);
begin
  Reader.ReadListBegin;
  Clear;
  while not Reader.EndOfList do
    Add(Reader.ReadInteger);
  Reader.ReadListEnd;
end; { TIntegerList.ReadIntegers }

procedure TIntegerList.WriteIntegers(Writer : TWriter);
var
  I : Integer;
begin
  Writer.WriteListBegin;
  for I := 0 to GetCount - 1 do
    Writer.WriteInteger(Get(I));
  Writer.WriteListEnd;
end; { TIntegerList.WriteIntegers }

procedure TIntegerList.SetMin(Value : LongInt);
var
  I : Integer;
begin
  if FMin <> Value then
  begin
    if Value > FMax then IntegerListError(SIntegerMinValueError);
    for I := 0 to GetCount - 1 do
      if Get(I) < Value then IntegerListError(SIntegerMinValueError);
    FMin := Value;
  end;
end; { TIntegerList.SetMin }

procedure TIntegerList.SetMax(Value : LongInt);
var
  I : Integer;
begin
  if FMax <> Value then
  begin
    if Value < FMin then IntegerListError(SIntegerMaxValueError);
    for I := 0 to GetCount - 1 do
      if Get(I) > Value then IntegerListError(SIntegerMaxValueError);
    FMax := Value;
  end;
end; { TIntegerList.SetMax }

procedure TIntegerList.QuickSort(L, R : Integer);
var
  I, J : Integer;
  P : LongInt;
begin
  I := L;
  J := R;
  P := LongInt(FList[(L + R) shr 1]);
  repeat
    while LongInt(FList[I]) < P do Inc(I);
    while LongInt(FList[J]) > P do Dec(J);
    if I <= J then
    begin
      FList.Exchange(I, J);
      Inc(I);
      Dec(J);
    end;
  until I > J;
  if L < J then QuickSort(L, J);
  if I < R then QuickSort(I, R);
end; { TIntegerList.QuickSort }

procedure TIntegerList.SetSorted(Value : Boolean);
begin
  if FSorted <> Value then
  begin
    if Value then Sort;
    FSorted := Value;
  end;
end; { TIntegerList.SetSorted }

function TIntegerList.GetList : PLongArray;
begin
  Result := PLongArray(FList.List);
end; { TIntegerList.GetList }

function TIntegerList.GetCount : Integer;
begin
  Result := FList.Count;
end; { TIntegerList.GetCount }

function TIntegerList.Get(Index : Integer) : LongInt;
begin
  if (Index < 0) or (Index >= GetCount) then Error;
  Result := LongInt(FList[Index]);
end; { TIntegerList.Get }

procedure TIntegerList.Put(Index : Integer; Value : LongInt);
begin
  if (Index < 0) or (Index >= GetCount) then Error;
  if (Value < FMin) or (Value > FMax) then IntegerListError(SIntegerListValueError);
  FList[Index] := Pointer(Value);
  if FSorted then Sort;
end; { TIntegerList.Put }

function TIntegerList.Add(Value : LongInt) : Integer;
begin
  if FDuplicates = dupAccept then
  begin
    Result := GetCount;
    Insert(Result, Value);
  end
  else if Find(Value, Result) then
    case FDuplicates of
      dupIgnore : Result := GetCount;
      dupError  : IntegerListError(SIntegerDuplicatesError);
    end;
end; { TIntegerList.Add }

function TIntegerList.AddIntegers(IntegerList : TIntegerList) : Integer;
begin
  for Result := 0 to IntegerList.Count - 1 do
    Add(IntegerList[Result]);
end; { TIntegerList.AddIntegers }

procedure TIntegerList.Clear;
begin
  FList.Clear;
end; { TIntegerList.Clear }

procedure TIntegerList.Delete(Index : Integer);
begin
  if (Index < 0) or (Index >= GetCount) then Error;
  FList.Delete(Index);
end; { TIntegerList.Delete }

function TIntegerList.Find(Value : LongInt; var Index : Integer) : Boolean;
begin
  Index := 0;
  while (Index < GetCount) and (Get(Index) <> Value) do Inc(Index);
  Result := Index < GetCount;
end; { TIntegerList.Find }

function TIntegerList.Equals(IntegerList : TIntegerList) : Boolean;
var
  I : Integer;
begin
  Result := GetCount = IntegerList.Count;
  if Result then
    for I := 0 to GetCount - 1 do
      if Get(I) <> IntegerList[I] then
      begin
        Result := False;
        Break;
      end;
end; { TIntegerList.Equals }

procedure TIntegerList.Exchange(Index1, Index2 : Integer);
begin
  if (Index1 < 0) or (Index1 >= GetCount) or
    (Index2 < 0) or (Index2 >= GetCount) then Error;
  FList.Exchange(Index1, Index2);
  FSorted := False;
end; { TIntegerList.Exchange }

function TIntegerList.IndexOf(Value : LongInt) : Integer;
begin
  while (Result < GetCount) and (Get(Result) <> Value) do Inc(Result);
  if Result = GetCount then Result := -1;
end; { TIntegerList.IndexOf }

procedure TIntegerList.Insert(Index : Integer; Value : LongInt);
begin
  if (Index < 0) or (Index > GetCount) then Error;
  if (Value < FMin) or (Value > FMax) then IntegerListError(SIntegerListValueError);
  FList.Expand.Insert(Index, Pointer(Value));
  FSorted := False;
end; { TIntegerList.Insert }

procedure TIntegerList.Move(CurIndex, NewIndex : Integer);
begin
  if (CurIndex < 0) or (CurIndex >= GetCount) or
    (NewIndex < 0) or (NewIndex >= GetCount) then Error;
  FList.Move(CurIndex, NewIndex);
  FSorted := False;
end; { TIntegerList.Move }

procedure TIntegerList.Sort;
begin
  if not FSorted and (GetCount > 1) then
    QuickSort(0, GetCount - 1);
end; { TIntegerList.Sort }


{ TFloatList }

constructor TFloatList.Create;
{ Overrides the constructor to initialize variables }
begin
  inherited Create;
  FList := TList.Create;
  FMin := 3.4e-4932;
  FMax := 1.1e4932;
  FDuplicates := dupAccept;
end; { TFloatList.Create }

destructor TFloatList.Destroy;
{ Overrides the destructor to uninitialize variables }
begin
  Clear;
  FList.Free;
  inherited Destroy;
end; { TFloatList.Destroy }

procedure TFloatList.Assign(Source : TPersistent);
begin
  if Source is TFloatList then
  begin
    FMin := TFloatList(Source).Min;
    FMax := TFloatList(Source).Max;
    FDuplicates := TFloatList(Source).Duplicates;
    FSorted := TFloatList(Source).Sorted;
    Clear;
    AddFloats(TFloatList(Source));
  end
  else
    inherited Assign(Source);
end; { TFloatList.Assign }

procedure TFloatList.Error;
begin
  FloatListError(SFloatListIndexError);
end; { TFloatList.Error }

procedure TFloatList.DefineProperties(Filer : TFiler);
begin
  Filer.DefineProperty('Min', ReadMin, WriteMin, FMin <> 3.4e-4932);
  Filer.DefineProperty('Max', ReadMax, WriteMax, FMax <> 1.1e4932);
  Filer.DefineProperty('Floats', ReadFloats, WriteFloats, GetCount > 0);
end; { TFloatList.DefineProperties }

procedure TFloatList.ReadMin(Reader : TReader);
begin
  FMin := Reader.ReadFloat;
end; { TFloatList.ReadMin }

procedure TFloatList.WriteMin(Writer : TWriter);
begin
  Writer.WriteFloat(FMin);
end; { TFloatList.WriteMin }

procedure TFloatList.ReadMax(Reader : TReader);
begin
  FMax := Reader.ReadFloat;
end; { TFloatList.ReadMax }

procedure TFloatList.WriteMax(Writer : TWriter);
begin
  Writer.WriteFloat(FMax);
end; { TFloatList.WriteMax }

procedure TFloatList.ReadFloats(Reader : TReader);
begin
  Reader.ReadListBegin;
  Clear;
  while not Reader.EndOfList do
    Add(Reader.ReadFloat);
  Reader.ReadListEnd;
end; { TFloatList.ReadFloats }

procedure TFloatList.WriteFloats(Writer : TWriter);
var
  I : Integer;
begin
  Writer.WriteListBegin;
  for I := 0 to GetCount - 1 do
    Writer.WriteFloat(Get(I));
  Writer.WriteListEnd;
end; { TFloatList.WriteFloats }

procedure TFloatList.SetMin(Value : Extended);
var
  I : Integer;
begin
  if FMin <> Value then
  begin
    if Value > FMax then FloatListError(SFloatMinValueError);
    for I := 0 to GetCount - 1 do
      if Get(I) < Value then FloatListError(SFloatMinValueError);
    FMin := Value;
  end;
end; { TFloatList.SetMin }

procedure TFloatList.SetMax(Value : Extended);
var
  I : Integer;
begin
  if FMax <> Value then
  begin
    if Value < FMin then FloatListError(SFloatMaxValueError);
    for I := 0 to GetCount - 1 do
      if Get(I) > Value then FloatListError(SFloatMaxValueError);
    FMax := Value;
  end;
end; { TFloatList.SetMax }

procedure TFloatList.QuickSort(L, R : Integer);
var
  I, J : Integer;
  P : PExtended;
begin
  I := L;
  J := R;
  P := FList[(L + R) shr 1];
  repeat
    while Extended(FList[I]^) < P^ do Inc(I);
    while Extended(FList[J]^) > P^ do Dec(J);
    if I <= J then
    begin
      FList.Exchange(I, J);
      Inc(I);
      Dec(J);
    end;
  until I > J;
  if L < J then QuickSort(L, J);
  if I < R then QuickSort(I, R);
end; { TFloatList.QuickSort }

procedure TFloatList.SetSorted(Value : Boolean);
begin
  if FSorted <> Value then
  begin
    if Value then Sort;
    FSorted := Value;
  end;
end; { TFloatList.SetSorted }

function TFloatList.GetCount : Integer;
begin
  Result := FList.Count;
end; { TFloatList.GetCount }

function TFloatList.Get(Index : Integer) : Extended;
begin
  if (Index < 0) or (Index >= GetCount) then Error;
  Result := Extended(FList[Index]^);
end; { TFloatList.Get }

procedure TFloatList.Put(Index : Integer; Value : Extended);
begin
  if (Index < 0) or (Index >= GetCount) then Error;
  if (Value < FMin) or (Value > FMax) then FloatListError(SFloatListValueError);
  Extended(FList[Index]^) := Value;
  if FSorted then Sort;
end; { TFloatList.Put }

function TFloatList.Add(Value : Extended) : Integer;
begin
  if FDuplicates = dupAccept then
  begin
    Result := GetCount;
    Insert(Result, Value);
  end
  else if Find(Value, Result) then
    case FDuplicates of
      dupIgnore : Result := GetCount;
      dupError  : FloatListError(SFloatDuplicatesError);
    end;
end; { TFloatList.Add }

function TFloatList.AddFloats(FloatList : TFloatList) : Integer;
begin
  for Result := 0 to FloatList.Count - 1 do
    Add(FloatList[Result]);
end; { TFloatList.AddFloats }

procedure TFloatList.Clear;
var
  I : Integer;
begin
  for I := 0 to FList.Count - 1 do
    FreeMem(FList[I], SizeOf(Extended));
  FList.Clear;
end; { TFloatList.Clear }

procedure TFloatList.Delete(Index : Integer);
begin
  if (Index < 0) or (Index >= GetCount) then Error;
  Dispose(PExtended(FList[Index]));
  FList.Delete(Index);
end; { TFloatList.Delete }

function TFloatList.Find(Value : Extended; var Index : Integer) : Boolean;
begin
  Index := 0;
  while (Index < GetCount) and (Get(Index) <> Value) do Inc(Index);
  Result := Index < GetCount;
end; { TFloatList.Find }

function TFloatList.Equals(FloatList : TFloatList) : Boolean;
var
  I : Integer;
begin
  Result := GetCount = FloatList.Count;
  if Result then
    for I := 0 to GetCount - 1 do
      if Get(I) <> FloatList[I] then
      begin
        Result := False;
        Break;
      end;
end; { TFloatList.Equals }

procedure TFloatList.Exchange(Index1, Index2 : Integer);
begin
  if (Index1 < 0) or (Index1 >= GetCount) or
    (Index2 < 0) or (Index2 >= GetCount) then Error;
  FList.Exchange(Index1, Index2);
  FSorted := False;
end; { TFloatList.Exchange }

function TFloatList.IndexOf(Value : Extended) : Integer;
begin
  while (Result < GetCount) and (Get(Result) <> Value) do Inc(Result);
  if Result = GetCount then Result := -1;
end; { TFloatList.IndexOf }

procedure TFloatList.Insert(Index : Integer; Value : Extended);
var
  P : PExtended;
begin
  if (Index < 0) or (Index > GetCount) then Error;
  if (Value < FMin) or (Value > FMax) then FloatListError(SFloatListValueError);
  New(P);
  P^ := Value;
  FList.Expand.Insert(Index, P);
  FSorted := False;
end; { TFloatList.Insert }

procedure TFloatList.Move(CurIndex, NewIndex : Integer);
begin
  if (CurIndex < 0) or (CurIndex >= GetCount) or
    (NewIndex < 0) or (NewIndex >= GetCount) then Error;
  FList.Move(CurIndex, NewIndex);
  FSorted := False;
end; { TFloatList.Move }

procedure TFloatList.Sort;
begin
  if not FSorted and (GetCount > 1) then
    QuickSort(0, GetCount - 1);
end; { TFloatList.Sort }

end.




*************************

{*******************************************************}
{*                                                     *}
{*      Pro VCL Extensions Library                     *}
{*      Controls and Components Constants Unit         *}
{*                                                     *}
{*      Copyright (c) 1996-98 by Dmitry Barabash       *}
{*                                                     *}
{*******************************************************}

unit ProConst;

{$I PRO.INC}

interface

const

{ ProLists }

  SIntegerListIndexError = 30000;
  SIntegerListValueError = 30001;
  SIntegerMinValueError = 30002;
  SIntegerMaxValueError = 30003;
  SIntegerDuplicatesError = 30004;

  SFloatListIndexError = 30010;
  SFloatListValueError = 30011;
  SFloatMinValueError = 30012;
  SFloatMaxValueError = 30013;
  SFloatDuplicatesError = 30014;

{ ProCtrls }

  SOKButton = 30100;
  SCancelButton = 30101;
  SHelpButton = 30102;
  SYesButton = 30103;
  SNoButton = 30104;
  SCloseButton = 30105;
  SAbortButton = 30106;
  SRetryButton = 30107;
  SIgnoreButton = 30108;
  SAllButton = 30109;
  SDoneButton = 30110;
  SPrevButton = 30111;
  SNextButton = 30112;
  SFinishButton = 30113;

  SCancelButtonRus = 30130;
  SHelpButtonRus = 30131;
  SYesButtonRus = 30132;
  SNoButtonRus = 30133;
  SCloseButtonRus = 30134;
  SAbortButtonRus = 30135;
  SRetryButtonRus = 30136;
  SIgnoreButtonRus = 30137;
  SAllButtonRus = 30138;
  SDoneButtonRus = 30139;
  SPrevButtonRus = 30140;
  SNextButtonRus = 30141;
  SFinishButtonRus = 30142;

  SCancelButtonUkr = 30160;
  SHelpButtonUkr = 30161;
  SYesButtonUkr = 30162;
  SNoButtonUkr = 30163;
  SCloseButtonUkr = 30164;
  SAbortButtonUkr = 30165;
  SRetryButtonUkr = 30166;
  SIgnoreButtonUkr = 30167;
  SAllButtonUkr = 30168;
  SDoneButtonUkr = 30169;
  SPrevButtonUkr = 30170;
  SNextButtonUkr = 30171;
  SFinishButtonUkr = 30172;

{ ProDlgs }

  SSelectDirCap = 30200;
  SDirNameCap = 30201;
  SDirsCap = 30202;
  SDrivesCap = 30203;
  SDirConfirmCaption = 30204;
  SDirConfirmCondition = 30205;
  SDirConfirmQuestion = 30206;
  SConfirmCap = 30207;
  SWarningCap = 30208;
  SInfoCap = 30209;
  SstopCap = 30210;
  SPasswordCap = 30211;
  SEnterPasswordCap = 30212;
  SLoginCap = 30213;
  SUserNameCap = 30214;
  SPromptPasswordCap = 30215;
  SImageViewCap = 30216;

  SSelectDirCapRus = 30230;
  SDirNameCapRus = 30231;
  SDirsCapRus = 30232;
  SDrivesCapRus = 30233;
  SDirConfirmCaptionRus = 30234;
  SDirConfirmConditionRus = 30235;
  SDirConfirmQuestionRus = 30236;
  SConfirmCapRus = 30237;
  SWarningCapRus = 30238;
  SInfoCapRus = 30239;
  SstopCapRus = 30240;
  SPasswordCapRus = 30241;
  SEnterPasswordCapRus = 30242;
  SLoginCapRus = 30243;
  SUserNameCapRus = 30244;
  SPromptPasswordCapRus = 30245;
  SImageViewCapRus = 30246;

  SSelectDirCapUkr = 30260;
  SDirNameCapUkr = 30261;
  SDirsCapUkr = 30262;
  SDrivesCapUkr = 30263;
  SDirConfirmCaptionUkr = 30264;
  SDirConfirmConditionUkr = 30265;
  SDirConfirmQuestionUkr = 30266;
  SConfirmCapUkr = 30267;
  SWarningCapUkr = 30268;
  SInfoCapUkr = 30269;
  SstopCapUkr = 30270;
  SPasswordCapUkr = 30271;
  SEnterPasswordCapUkr = 30272;
  SLoginCapUkr = 30273;
  SUserNameCapUkr = 30274;
  SPromptPasswordCapUkr = 30275;
  SImageViewCapUkr = 30276;

{ ProCalc }

  SCalcCapRus = 30300;
  SCalcErrorRus = 30301;
  SCalcStayOnTopRus = 30302;
  SCalcCloseRus = 30303;

  SCalcCapUkr = 30320;
  SCalcErrorUkr = 30321;
  SCalcStayOnTopUkr = 30322;
  SCalcCloseUkr = 30323;

implementation

{$R PROCONST.RES}

end.

/*/*/*/*/*/*/**/
//*****************************************************//
//                                                     //
//      Pro VCL Extensions Library                     //
//      ProConst Resource File                         //
//                                                     //
//      Copyright (c) 1996-98 by Dmitry Barabash       //
//                                                     //
//*****************************************************//

#include "ProConst.pas"

STRINGTABLE
{

// ProLists

  SIntegerListIndexError, "Integer list index out of bounds"
  SIntegerListValueError, "Integer list value out of ranges"
  SIntegerMinValueError, "Unable to set new minimum integer list value"
  SIntegerMaxValueError, "Unable to set new maximum integer list value"
  SIntegerDuplicatesError, "Integer list does not allow duplicates"

  SFloatListIndexError, "Float list index out of bounds"
  SFloatListValueError, "Float list value out of ranges"
  SFloatMinValueError, "Unable to set new minimum integer list value"
  SFloatMaxValueError, "Unable to set new maximum integer list value"
  SFloatDuplicatesError, "Float list does not allow duplicates"

// ProCtlrs

  SOKButton, "OK"
  SCancelButton, "Cancel"
  SHelpButton, "&Help"
  SYesButton, "&Yes"
  SNoButton, "&No"
  SCloseButton, "&Close"
  SAbortButton, "Abort"
  SRetryButton, "&Retry"
  SIgnoreButton, "&Ignore"
  SAllButton, "&All"
  SDoneButton, "&Done"
  SPrevButton, "< &Back"
  SNextButton, "&Next >"
  SFinishButton, "&Finish"

  SCancelButtonRus, "╬≥∞σφα"
  SHelpButtonRus, "&╤∩αΓΩα"
  SYesButtonRus, "&─α"
  SNoButtonRus, "&═σ≥"
  SCloseButtonRus, "&╟αΩ√≥ⁿ"
  SAbortButtonRus, "╤&≥ε∩"
  SRetryButtonRus, "╧&εΓ≥ε"
  SIgnoreButtonRus, "&╧ε∩≤±≥Φ≥ⁿ"
  SAllButtonRus, "&┬±╕"
  SDoneButtonRus, "&├ε≥εΓε"
  SPrevButtonRus, "< &═αταΣ"
  SNextButtonRus, "&─αδσσ >"
  SFinishButtonRus, "&╟αΩεφ≈Φ≥ⁿ"

  SCancelButtonUkr, "┬iΣ∞iφα"
  SHelpButtonUkr, "&─εΓiΣΩα"
  SYesButtonUkr, "&╥αΩ"
  SNoButtonUkr, "&═i"
  SCloseButtonUkr, "╟&αΩΦ≥Φ"
  SAbortButtonUkr, "╤≥&ε∩"
  SRetryButtonUkr, "╧εΓ≥ε&"
  SIgnoreButtonUkr, "&╧ε∩≤±≥Φ≥Φ"
  SAllButtonUkr, "&┬±σ"
  SDoneButtonUkr, "&╟εßδσφε"
  SPrevButtonUkr, "< &═αταΣ"
  SNextButtonUkr, "─α&δi >"
  SFinishButtonUkr, "&╟αΩiφ≈Φ≥Φ"

// ProDlgs

  SSelectDirCap, "Select Directory"
  SDirNameCap, "Directory &Name:"
  SDirsCap, "&Directories:"
  SDrivesCap, "Dri&ves:"
  SDirConfirmCaption, "Confirm"
  SDirConfirmCondition, "This directory does not exist:"
  SDirConfirmQuestion, "Do you wish to create this directory?"
  SConfirmCap, "Confirmation"
  SWarningCap, "Warning"
  SInfoCap, "Information"
  SStopCap, "Stop"
  SPasswordCap, "Password"
  SEnterPasswordCap, "&Enter password:"
  SLoginCap, "Login"
  SUserNameCap, "&User Name:"
  SPromptPasswordCap, "&Password:"
  SImageViewCap, "Image View"

  SSelectDirCapRus, "┬√ßε Ωα≥αδεπα"
  SDirNameCapRus, "&╚∞  Ωα≥αδεπα:"
  SDirsCapRus, "&╩α≥αδεπΦ:"
  SDrivesCapRus, "&─Φ±ΩΦ:"
  SDirConfirmCaptionRus, "╧εΣ≥ΓσµΣσφΦσ"
  SDirConfirmConditionRus, "╥αΩεπε Ωα≥αδεπα φσ ±≤∙σ±≥Γ≤σ≥:"
  SDirConfirmQuestionRus, "╤ετΣα≥ⁿ?"
  SConfirmCapRus, "╧εΣ≥ΓσµΣσφΦσ"
  SWarningCapRus, "╧σΣ≤∩σµΣσφΦσ"
  SInfoCapRus, "╚φ⌠ε∞α÷Φ "
  SStopCapRus, "╤≥ε∩"
  SPasswordCapRus, "┬ΓεΣ ∩αεδ "
  SEnterPasswordCapRus, "&┬ΓσΣΦ≥σ ∩αεδⁿ:"
  SLoginCapRus, "┬ΓεΣ ∩αεδ  Σε±≥≤∩α"
  SUserNameCapRus, "&╚∞  ∩εδⁿτεΓα≥σδ :"
  SPromptPasswordCapRus, "&╧αεδⁿ:"
  SImageViewCapRus, "╧ε±∞ε≥ ΦτεßαµσφΦ "

  SSelectDirCapUkr, "┬Φßi Ωα≥αδεπ≤"
  SDirNameCapUkr, "&╚∞'  Ωα≥αδεπ≤:"
  SDirsCapUkr, "&╩α≥αδεπΦ:"
  SDrivesCapUkr, "─Φ&±ΩΦ:"
  SDirConfirmCaptionUkr, "╧iΣ≥Γσµσφφ "
  SDirConfirmConditionUkr, "╥αΩεπε Ωα≥αδεπ≤ φσ τφαΘΣσφε:"
  SDirConfirmQuestionUkr, "╤≥ΓεΦ≥Φ?"
  SPasswordCapUkr, "┬ΓiΣ ∩αεδ■"
  SConfirmCapUkr, "╧iΣ≥ΓσΣµσφφ "
  SWarningCapUkr, "╧ε∩σσΣµσφφ "
  SInfoCapUkr, "Iφ⌠ε∞α÷i "
  SstopCapUkr, "╤≥ε∩"
  SEnterPasswordCapUkr, "&┬ΓσΣΦ≥σ ∩αεδⁿ:"
  SLoginCapUkr, "┬ΓiΣ ∩αεδ■ Σε±≥≤∩≤"
  SUserNameCapUkr, "&╚∞'  ΩεΦ±≥≤Γα≈α:"
  SPromptPasswordCapUkr, "&╧αεδⁿ:"
  SImageViewCapUkr, "╧σσπδ Σ εßατ≤"

// ProCalc

  SCalcCapRus, "╩αδⁿΩ≤δ ≥ε"
  SCalcErrorRus, "╬°ΦßΩα"
  SCalcStayOnTopRus, "&╧εΓσ⌡ Σ≤πΦ⌡ εΩεφ"
  SCalcCloseRus, "&╟αΩ√≥ⁿ"
  SCalcCapUkr, "╩αδⁿΩ≤δ ≥ε"
  SCalcErrorUkr, "╧ε∞ΦδΩα"
  SCalcStayOnTopUkr, "&╧εΓσ⌡ iφ°Φ⌡ ΓiΩεφ"
  SCalcCloseUkr, "╟&αΩΦ≥Φ"
}