unit Step22a;
//********************************************************************/
//*                (c)                       */
//*                -, 1991, 1996                       */
//*                 -   5.x                        */
//********************************************************************/
//*                                                */
//*                                 */
//*                                                                  */
//* 1.                             - StrIndefiniteArray   */
//* 2.               - PointIndefiniteArray */
//* 3.    ""           - TextIndefiniteArray  */
//* 4.               - AttrIndefiniteArray  */
//* 5.                         - PolyLineArray        */
//* 6.         - RectArray            */
//* 7.              - UserDataArray        */
//* 8.     - UserClassArray       */
//*                                                                  */
//********************************************************************/

interface

//-------------------------------------------------------------------------------
//   
// ---
  procedure  LIBRARYENTRY(comm: Word); pascal;
  function   LIBRARYID: Cardinal; pascal;

  procedure  StrIndefiniteArray;
  procedure  PointIndefiniteArray;
  procedure  TextIndefiniteArray;
  procedure  AttrIndefiniteArray;
  procedure  PolyLineArray;
  procedure  RectArray;
  procedure  UserArray;
  procedure  UserClassArr;

implementation

uses Windows, SysUtils, LtDefine, LibTool, LDefin2D;

////////////////////////////////////////////////////////////////////////////////
//  
// ---
type
  UserClass = class(TObject)
  private
    i: Integer;
    c: PChar;
    d: Double;
  public
    constructor Create(_i: Integer; _c: PChar; _d: Double);
    destructor Destroy; override;
    procedure Show;
  end;

//------------------------------------------------------------------------------
//   - 
// ---
constructor UserClass.Create(_i: Integer; _c: PChar; _d: Double);
begin
  i := _i;
  GetMem(c, StrLen(_c) + 1);
  StrCopy(c, _c);
  d := _d;
end;

//-------------------------------------------------------------------------------
//   - 
// ---
destructor UserClass.Destroy;
begin
  ksMessage(c);
  FreeMem(c);
end;

//-------------------------------------------------------------------------------
//   -  
// ---
procedure UserClass.Show;
var
  buf: string;
begin
  buf := Format('i=%d f=%f c=%s', [i, d, c]);
  ksMessage(PChar(buf));
end;


//----------------------------------------------------------------------------------------
//   
// ---
function LIBRARYID: Cardinal; pascal;
begin
  LIBRARYID := 100;
end;

//----------------------------------------------------------------------------------------
//   
// ---
procedure LIBRARYENTRY(comm: Word); pascal;
begin
  case Comm of
    1: StrIndefiniteArray;   // 
    2: PointIndefiniteArray; // 
    3: TextIndefiniteArray;  //   ""
    4: AttrIndefiniteArray;  //   
    5: PolyLineArray;        // 
    6: RectArray;            //  
    7: UserArray;            // 
    8: UserClassArr;         // 
  end;
end;

//--------------------------------------------------------------------------
//      
//--------------------------------------------------------------------------
procedure StrIndefiniteArray;
var
  rArString : Reference;    // 
  buf       : array [0..128] of Char;

  //--------------------------------------------------------------------------
  //    
  procedure ShowArray;
  var
    i : Integer;
    s : String;
    n : Integer;
  begin
    //  
    n := GetArrayCount( rArString );
    s := Format( 'count=%d', [n] );
    ksMessage( PChar(s) );
    //  
    for i:= 0 to n - 1 do
    begin
      //    
      GetArrayItem( rArString, i, @buf, SizeOf(buf) );
      ksMessage( buf );
    end;
  end;

begin
  //     
  rArString := CreateArray( CHAR_STR_ARR, nil );

  // 
  //  1- ,     
  StrCopy( buf, '12345' );
  AddArrayItem( rArString, -1, @buf, StrLen(buf) + 1 );

  //  2- ,     
  StrCopy( buf, '67890' );
  AddArrayItem( rArString, -1, @buf, StrLen(buf) + 1 );

  //  3- ,     
  StrCopy( buf, 'qwerty' );
  AddArrayItem( rArString, -1, @buf, StrLen(buf) + 1 );

  MessageBoxResult;
  // 
  ShowArray;
  ksMessage( ' 1- ' );
  //    1
  ExcludeArrayItem( rArString, 1 );
  // 
  ShowArray;
  MessageBoxResult;
  //  
  DeleteArray( rArString );
end;

//--------------------------------------------------------------------------
//          MathPointParam
//--------------------------------------------------------------------------
procedure PointIndefiniteArray;
var
  rArMathPoint : Reference;
  par          : MathPointParam;

  //--------------------------------------------------------------------------
  //    
  procedure ShowPointArray;
  var
    s   : String;
    n, i: Integer;
  begin
    n := GetArrayCount(rArMathPoint);
    s := Format('count=%d ', [n]);
    ksMessage(PChar(s));

    for i := 0 to n - 1 do
    begin
      GetArrayItem(rArMathPoint, i, @par, SizeOf(MathPointParam));
      s := Format('i=%d  x=%5.1f y=%5.1f',[i, par.x, par.y]);
      ksMessage(PChar(s));
    end;
  end;

  //--------------------------------------------------------------------------
  //   
  procedure SetPointItem(index: Integer; x, y: Double);
  begin
    par.x := x;
    par.y := y;
    SetArrayItem(rArMathPoint, index, @par, SizeOf(MathPointParam));
  end;

  //--------------------------------------------------------------------------
  //     
  procedure AddPointItem(x, y: Double);
  begin
    par.x := x;
    par.y := y;
    AddArrayItem(rArMathPoint, -1, @par, SizeOf(MathPointParam));
  end;

begin
  // 
  rArMathPoint := CreateArray(POINT_ARR, nil);
  // 
  AddPointItem(10, 10);
  AddPointItem(20, 20);
  AddPointItem(30, 30);
  //,   
  MessageBoxResult;
  // 
  ShowPointArray;

  ksMessage('  1- ');
  SetPointItem(1, 50, 50);

  ksMessage('  0- ');
  SetPointItem(0, 50, 50);
  // 
  ShowPointArray;
  //,   
  MessageBoxResult;
  // 
  DeleteArray(rArMathPoint);
end;

//------------------------------------------------------------------------------
//          ,
//       ,    
//    ,   
//  ( ,  ,   . .)
//------------------------------------------------------------------------------
procedure TextIndefiniteArray;
var
  pLine, p1: reference;
  par : TextLineParam;
  par1: TextItemParam;
  s: string;

  //--------------------------------------------------------------------------
  //   
  procedure ShowItemtArray(arr: reference);
  var
    n1, j: Integer;
    s: string;
  begin
    n1 := GetArrayCount(arr);
    s  := Format('  = %d', [n1]);
    ksMessage(PChar(s));
    //    
    for  j := 0 to n1 - 1 do
    begin
      GetArrayItem(arr, j, @par1, SizeOf(TextItemParam));
      s := Format('j=%d h=%5.1f  s=%s ', [j, par1.font.height, par1.s]);
      ksMessage(PChar(s));
    end;
  end;

  //--------------------------------------------------------------------------
  //   
  procedure ShowTextArray;
  var
    n, i: Integer;
    s: string;
  begin
    // 
    n := GetArrayCount(pLine);
    s := Format(' =%d', [n]);
    ksMessage(PChar(s));
    //    
    for i :=0 to n - 1 do //   
    begin
      GetArrayItem(pLine, i, @par, SizeOf(TextLineParam));
      s := Format('i=%d style=%d', [i, par.style]);
      ksMessage(PChar(s));
      ShowItemtArray(par.pTextItem);
    end;
  end;

  //--------------------------------------------------------------------------
  //      ,  
  procedure AddTextItem(h, ksu: Double; color: DWord; bitvector: Cardinal; s: PChar);
  begin
    par1.font.height    := h;         // 
    par1.font.ksu       := ksu;       // 
    par1.font.color     := color;     //
    par1.font.bitVector := bitvector; //  (, , ,   (, ,   ))
    StrCopy(par1.s, s);
    //    
    AddArrayItem(p1, -1, @par1, SizeOf(TextItemParam));
  end;

  //--------------------------------------------------------------------------
  //      ,  
  procedure SetTextItem(index: Integer; h, ksu: Double; color: DWord; bitvector: Cardinal; s: PChar);
  begin
    par1.font.height    := h;         // 
    par1.font.ksu       := ksu;       // 
    par1.font.color     := color;     //
    par1.font.bitVector := bitvector; //  (, , ,   (, ,   ))
    StrCopy(par1.s, s);
    //    
    SetArrayItem(par.pTextItem, index, @par1, SizeOf(TextItemParam));
  end;

begin
  //   
  pLine := CreateArray(TEXT_LINE_ARR, nil);
  s := Format( 'pLine=%d', [pLine] );
  ksMessage( PChar(s) );
  //   
  p1 := CreateArray(TEXT_ITEM_ARR, nil);
  s:=Format('p1=%d', [p1]);
  ksMessage(PChar(s));
  //   
  // 1-     
  AddTextItem(10{h}, 1{ksu}, 1000{color}, 1{bitvector}, '1  1 '{ s });
  // 2-     
  AddTextItem(20{h}, 2{ksu}, 2000{color}, 2{bitvector}, '2  1 '{ s });
  par.style := 1;
  par.pTextItem := p1;
  s := Format('par.pTextItem=%d', [par.pTextItem]);
  ksMessage(PChar(s));
  // 1-          
  //   
  AddArrayItem(pLine, -1, @par, SizeOf(TextLineParam));
  //   ,     
  //  
  ClearArray(p1);
  //   
  // 1-     
  AddTextItem(30{h}, 3{ksu}, 3000{color}, 3{bitvector}, '1  2 '{ s });
  // 2-     
  AddTextItem(40{h}, 4{ksu}, 4000{color}, 4{bitvector}, '2  2 '{ s });
  par.style := 2;
  par.pTextItem := p1;
  // 2-          
  //   
  AddArrayItem(pLine, -1, @par, SizeOf(TextLineParam));
  MessageBoxResult; //     
  //    
  ShowTextArray;
  // ShowItemtArray(p1);
  ksMessage('     ');
  //  
  GetArrayItem(pLine, 0, @par, SizeOf(TextLineParam));
  // 
  SetTextItem(1{index}, 50{h}, 1{ksu}, 1000{color}, 1{bitvector}, ' 2 . 1 .'{ s });
  par.style := 3;
  // 
  SetArrayItem(pLine, 0, @par, SizeOf(TextLineParam));

  ksMessage('     ');
  //  
  GetArrayItem(pLine, 1, Addr(par), SizeOf(TextLineParam));
  // 
  SetTextItem(0{index}, 60{h}, 1{ksu}, 1000{color}, 1{bitvector}, ' 1 . 2 .'{ s });
  par.style := 4;
  // 
  SetArrayItem(pLine, 1, @par, SizeOf(TextLineParam));
  //    
  ShowTextArray;
  //     
  MessageBoxResult;
  //  
  DeleteArray(p1);
  //  
  DeleteArray(pLine);
end;

//--------------------------------------------------------------------------
//         ,
//       
//---------------------------------------------------------------------------
procedure AttrIndefiniteArray;
var
  pCol, pStruct: reference ; //    ,    
  pEnum: reference ;         //     
  parCol1, parCol2, parCol3, parStruct: ColumnInfo;
  buf : array[0..128] of Char;

  //--------------------------------------------------------------------------
  //   
  procedure ShowColumns(pCol : reference; fl : Integer);
  var
    par: ColumnInfo;
    mes: string;
    s: array [0..10] of Char;
    i, n, n1, i1: Integer;
  begin
    if  fl>0 then
      StrCopy(s, '')
    else
      StrCopy(s, ' ');

    par.columns := CreateArray(ATTR_COLUMN_ARR, nil);
    par.fieldEnum := CreateArray(CHAR_STR_ARR, nil);
    n := GetArrayCount(pCol);

    for  i := 0 to n - 1 do
    begin
      if GetArrayItem(pCol, i, @par, SizeOf(par)) = 0 then
      MessageBoxResult  //     
      else
      begin
        //    
        mes := Format('%s i=%d header=%s type=%d def=%s flagEnum=%d',
                      [s,i,par.header, par._type, par.def, par.flagEnum ]);
        ksMessage(PChar(mes));
        if par._type = RECORD_ATTR_TYPE then  //
          ShowColumns(par.columns, 1)
        else
        begin
          if par.flagEnum > 0 then //  
          begin
            n1 := GetArrayCount(par.fieldEnum);
            ksMessage(' ');
            for i1 := 0 to n1 - 1 do
              if GetArrayItem(par.fieldEnum, i1, @buf, SizeOf(buf)) = 0 then
                MessageBoxResult  //     
              else
                ksMessage(buf);
          end;
        end;
      end;
    end;
    DeleteArray(par.columns);
    DeleteArray(par.fieldEnum);
  end;

begin
//    3 
//     int    (100, 200, 300)
//   -   
// struct
//   Double    123456789
//   long      1000000
//   Char      10
//       "text"

  pCol    := CreateArray(ATTR_COLUMN_ARR, nil);
  pStruct := CreateArray(ATTR_COLUMN_ARR, nil);
  pEnum   := CreateArray(CHAR_STR_ARR,    nil);
  //  
  StrCopy(parCol1.header, 'int');    // o- 
  parCol1._type := INT_ATTR_TYPE;    //     - .
  parCol1.key := 0;                  //  ,        
  StrCopy(parCol1.def, '100');       //   
  parCol1.flagEnum :=1;              //   ,    
                                     //       1  0 
  parCol1.fieldEnum := pEnum;        //     ()
  parCol1.columns := 0;              //        
  //      
  StrCopy(buf, '100');
  AddArrayItem(pEnum, -1, @buf, StrLen(buf) + 1);
  StrCopy(buf, '200');
  AddArrayItem(pEnum, -1, @buf, StrLen(buf) + 1);
  StrCopy(buf, '300');
  AddArrayItem(pEnum, -1, @buf, StrLen(buf) + 1);
  MessageBoxResult;  //     

  AddArrayItem(pCol, -1, @parCol1, SizeOf(parCol1));
  MessageBoxResult;  //     
  //  
  StrCopy(parCol2.header, 'struct'); // o- 
  parCol2._type := RECORD_ATTR_TYPE; //     - .
  parCol2.key := 0;                  //  ,        
  StrCopy(parCol2.def,' ');          //   
  parCol2.flagEnum := 0;             //   ,    
                                     //       1  0 
  parCol2.fieldEnum := 0;            //     ()
  parCol2.columns := pStruct;        //        

  //    
  //    
  StrCopy(parStruct.header, 'Double');  // o- 
  parStruct._type := Double_ATTR_TYPE;  //     - .
  parStruct.key := 0;                   //  ,        
  StrCopy(parStruct.def,'123456789');   //   
  parStruct.flagEnum :=0;               //   ,    
                                        //       1  0 
  parStruct.fieldEnum := 0;             //     ()
  parStruct.columns := 0;               //        

  AddArrayItem(pStruct, -1, @parStruct, SizeOf(parStruct));
  MessageBoxResult;  //     

  //   
  StrCopy(parStruct.header, 'long');   // o- 
  parStruct._type := LINT_ATTR_TYPE;   //     - .
  parStruct.key := 0;                  //  ,        
  StrCopy(parStruct.def, '1000000');   //   
  parStruct.flagEnum :=0;              //   ,    
                                       //       1  0 
  parStruct.fieldEnum := 0;            //     ()
  parStruct.columns := 0;              //        

  AddArrayItem(pStruct, -1, @parStruct, SizeOf(parStruct));
  MessageBoxResult;  //     

  //   
  StrCopy(parStruct.header, 'Char');   // o- 
  parStruct._type := Char_ATTR_TYPE;   //     - .
  parStruct.key := 0;                  //  ,        
  StrCopy(parStruct.def, '10');        //   
  parStruct.flagEnum := 0;             //   ,    
                                       //       1  0 
  parStruct.fieldEnum := 0;            //     ()
  parStruct.columns := 0;              //        

  AddArrayItem(pStruct, -1, @parStruct, SizeOf(parStruct));
  MessageBoxResult;  //     

  AddArrayItem(pCol, -1, @parCol2, SizeOf(parCol2));
  MessageBoxResult;  //     

  //   
  StrCopy(parCol3.header, 'string');   // o- 
  parCol3._type := STRING_ATTR_TYPE;   //     - .
  parCol3.key := 0;                    //  ,        
  StrCopy(parCol3.def, 'text');        //   
  parCol3.flagEnum :=0;                //   ,    
                                       //       1  0 
  parCol3.fieldEnum := 0;              //     ()
  parCol3.columns := 0;                //        
  AddArrayItem(pCol, -1, @parCol3, SizeOf(parCol3));

  MessageBoxResult;  //     
  //  
  ShowColumns(pCol, 0); //  

  MessageBoxResult;  //     
  //    2->1 1->3 3->2
  SetArrayItem(pCol, 0, @parCol2, SizeOf(parCol2));
  SetArrayItem(pCol, 2, @parCol1, SizeOf(parCol2));
  SetArrayItem(pCol, 1, @parCol3, SizeOf(parCol2));
  //  
  ShowColumns(pCol, 0); //  

  MessageBoxResult;  //     

  DeleteArray(pCol);
  DeleteArray(pStruct);
  DeleteArray(pEnum);
end;

//------------------------------------------------------------------------------
//         
//-------------------------------------------------------------------------------
procedure UserArray;
type
  PUserData = ^UserData;
  UserData = record
    i: Integer;
    c: PChar;
    f: Double;
  end;

var
  userArr: reference;
  i, n: Integer;
  p: Pointer;

  //--------------------------------------------------------------------------
  //    UserData   
  function CreateUserItem(arr: reference; i: Integer; c: PChar; f: Double): Integer;
  var
    newdata: PUserData;
  begin
    GetMem(newdata, SizeOf(UserData));
    newdata^.i := i;
    GetMem(newdata^.c, StrLen(c) + 1);
    StrCopy(newdata^.c, c);
    newdata^.f := f;
    Result := AddArrayItem(arr, -1, newdata, 0);
  end;

  //--------------------------------------------------------------------------
  //     UserData
  procedure ShowUserItem(p: PUserData);
  var
    buf: string;
  begin
    buf := Format('i=%d f=%f c=%s', [p^.i, p^.f, p^.c]);
    ksMessage(PChar(buf));
  end;

  //    User_Data  
  procedure DelUserFunc(p: Pointer); pascal;
  begin
    ksMessage(PUserData(p)^.c);
    FreeMem(PUserData(p)^.c);
    FreeMem(p);
  end;

begin
  //  
  userArr := CreateArray(USER_ARR, @DelUserFunc);
  //  
  if CreateUserItem(userArr, 1, '', 31.0) = 0 then
    MessageBoxResult;

  if CreateUserItem(userArr, 2, '', 29.0) = 0 then
    MessageBoxResult;

  if CreateUserItem(userArr, 3, '', 31.0) = 0 then
    MessageBoxResult;

  n := GetArrayCount(userArr);
  //  
  for i := 0 to n - 1 do
  begin
    GetUserArrayItem(userArr, i, p);
    ShowUserItem(PUserData(p));
  end;
  ksMessage(' ');
  DeleteArray(userArr);
end;


//------------------------------------------------------------------------------
//         
//-------------------------------------------------------------------------------
procedure UserClassArr;
var
  userArr: reference;
  i, n: Integer;
  p: Pointer;

  //--------------------------------------------------------------------------
  //    User_Data   
  function AddUserItem(arr: reference; i: Integer; c: PChar; d: Double): Integer;
  var
    newclass: UserClass;
  begin
    newclass := UserClass.Create(i, c, d);
    Result := AddArrayItem(arr, -1, newclass, 0);
  end;

  //--------------------------------------------------------------------------
  //    User_Data  
  procedure DeletUserItem(p: Pointer); pascal;
  begin
    if p <> nil then
    begin
//      ksMessage(PChar(UserClass(p).c));
      UserClass(p).Free;
    end;
  end;

begin
  //  
  userArr := CreateArray(USER_ARR, @DeletUserItem);
  //  
  if AddUserItem(userArr, -10, 'first', 10031.0) = 0 then
    MessageBoxResult;

  if AddUserItem(userArr, -20, 'second', 10029.0) = 0 then
    MessageBoxResult;

  if AddUserItem(userArr, -30, 'third', 10031.0) = 0 then
    MessageBoxResult;

  n := GetArrayCount(userArr);
  // 
  for i := 0 to n - 1 do
  begin
    GetUserArrayItem(userArr, i, p);
    if p <> nil then
      UserClass(p).Show;
  end;
  ksMessage(' ');
  DeleteArray(userArr);
end;

//-------------------------------------------------------------------------------
//       
//-------------------------------------------------------------------------------
procedure PolyLineArray;
var
  p, pPoly: reference;
  buf: string;
  par: PointParam;

  //--------------------------------------------------------------------------
  //   
  procedure ShowArrPoint(p: reference);
  var
    n, i : Integer;
  begin
    n := GetArrayCount(p);
    buf := Format('  = %d', [n]);
    ksMessage(PChar(buf));
    for i := 0 to n - 1 do
    begin
      GetArrayItem(p, i, @par, SizeOf(PointParam));
      buf := Format('i=%d x=%5.1f y=%5.1f', [i, par.x, par.y]);
      ksMessage(PChar(buf));
    end;
  end;

  //--------------------------------------------------------------------------
  //   
  procedure ShowArrPolyline;
  var
    n, i: Integer;
  begin
    n := GetArrayCount(pPoly);
    buf := Format('  = %d',[n]);
    ksMessage(PChar(buf));

    for i := 0 to n - 1 do
    begin
      GetArrayItem(pPoly, i, @p, SizeOf(p));
      // i-   
      ShowArrPoint(p);
    end;
  end;

  //--------------------------------------------------------------------------
  //   
  procedure FillArrPoint(x1, y1, x2, y2, x3, y3: Double; index: Integer);
  begin
    ClearArray(p);
    //  
    par.x := x1;
    par.y := y1;
    AddArrayItem(p, -1, @par, SizeOf(PointParam));
    par.x := x2;
    par.y := y2;
    AddArrayItem(p, -1, @par, SizeOf(PointParam));
    par.x := x3;
    par.y := y3;
    AddArrayItem(p, -1, @par, SizeOf(PointParam));
    //     
    if index = -1 then
      AddArrayItem(pPoly, index, @p, SizeOf(p))
    else
      SetArrayItem(pPoly, index, @p, SizeOf(p));
//    MessageBoxResult;
//    ShowArrPoint(p);
  end;

begin
  //  
  p := CreateArray(POINT_ARR, nil);
  //  
  pPoly := CreateArray(POLYLINE_ARR, nil);
  //  
  FillArrPoint(10, 10, 100, 100, 1000, 1000, -1);
  //  
  FillArrPoint(20, 20, 200, 200, 2000, 2000, -1);
  //  
  FillArrPoint(30, 30, 300, 300, 3000, 3000, -1);
  // 
  ShowArrPolyline;

  ksMessage('    2- ');
  //  
  FillArrPoint(50, 50, 500, 500, 5000, 5000, 1);
  // 
  ShowArrPolyline;

  MessageBoxResult;
  // 
  DeleteArray(p);
  DeleteArray(pPoly);
end;

//--------------------------------------------------------------------------------
//     -( RectParam)
//--------------------------------------------------------------------------------
procedure RectArray;
var
  p: reference;
  buf: string;
  par: RectParam;

  //--------------------------------------------------------------------------
  //  
  procedure ShowArrRect;
  var
    n, i: Integer;
  begin
    n := GetArrayCount(p);
    buf := Format('  = %d',[n]);
    ksMessage(PChar(buf));
    for i := 0 to n - 1 do
    begin
      GetArrayItem(p, i, @par, SizeOf(RectParam));
      buf := Format('i=%d  xTop=%5.1f yTop=%5.1f, xBot=%5.1f yBot=%5.1f',
                    [i,par.pTop.x, par.pTop.y,par.pBot.x, par.pBot.y]);
      ksMessage(PChar(buf));
    end;
  end;

  //--------------------------------------------------------------------------
  //     
  procedure AddOrSetItem(xTop, yTop,xBot,yBot : Double; index : Integer);
  begin
    // 
    par.pTop.x := xTop;
    par.pTop.y := yTop;
    par.pBot.x := xBot;
    par.pBot.y := yBot;
    if index = -1 then
      AddArrayItem(p, -1, @par, SizeOf(RectParam))
    else
      SetArrayItem(p, index, @par, SizeOf(RectParam));
  end;

begin
  // 
  p := CreateArray(RECT_ARR, nil);
  // 
  AddOrSetItem(10, 10, 20, -10, -1);
  AddOrSetItem(20, 50, 50, 10, -1);
  AddOrSetItem(20, 150, 50, 110, -1);

  MessageBoxResult;
  // 
  ShowArrRect;
  // 
  AddOrSetItem(-20, -50, 20, -10, 1);
  AddOrSetItem(0, 0, 10, -20, 0);
  AddOrSetItem(5, 5, 25, 0, -1);
  // 
  ShowArrRect;

  MessageBoxResult;
  // 
  DeleteArray(p);
end;

end.
