////////////////////////////////////////////////////////////////////////////////
//
//     
//
////////////////////////////////////////////////////////////////////////////////
unit Step2_API7_2D_1;

interface
uses
  Sysutils, LDefin2D, ksAuto, Libtool, Windows;

////////////////////////////////////////////////////////////////////////////////

  procedure  LIBRARYENTRY( command: WORD  ); Pascal;
  function   LIBRARYID   : Cardinal;         Pascal;
  function   LoadStr( ID : Integer ) : string;                     //    
  function   LibMessage( str : string; flags : integer ) : Integer;//   
  function   LibMessageByID( strId, flags : Integer ) : Integer;   //   
  procedure  GetNewKompasAPI;
  procedure  CreateLineDimension;
  procedure  LineDimensionNavigation;
  procedure  EditLineDimension;
  procedure  RadialDimensionWork;
  procedure  DiametralDimensionWork;
  procedure  AngleDimensionWork;
  procedure  ArcDimensionWork;
  procedure  BreakLineDimensionWork;
  procedure  BreakRadialDimensionWork;
  procedure  BreakAngleDimensionWork;
  procedure  HeightDimensionWork;

implementation

uses
  LtDefine,
  ksApi7,
  ksConstTLB,
  forms;

const
  IDS_NODOC       = 200;
  IDS_COORDS      = 201;
  IDS_DIM         = 202;
  IDS_COMMAND1    = 203;
  IDS_NOTDIM      = 204;
  IDS_COMMAND2    = 205;
  IDS_NOOBJ       = 206;
  IDS_NOTCREATE1  = 207;
  IDS_UNIT        = 208;
  IDS_EDIT        = 209;
  IDS_NOTCREATE2  = 210;
  IDS_COMMAND3    = 211;
  IDS_COMMAND4    = 212;
  IDS_NOOBJS      = 213;
  IDS_NOTCREATE3  = 214;
  IDS_COMMAND5    = 215;
  IDS_COMMAND6    = 216;
  IDS_NOTCREATE4  = 217;
  IDS_UNIT2       = 218;
  IDS_COMMAND7    = 219;
  IDS_NOTCREATE5  = 220;
  IDS_NOMINAL     = 221;
  IDS_COMMAND8    = 222;
  IDS_COMMAND9    = 223;
  IDS_COMMAND10   = 224;

var
  newKompasAPI : IApplication;                                //  Application 7
  doc : IKompasDocument2D;

//------------------------------------------------------------------------------
// LibraryId
//---
function LIBRARYID: UINT; pascal;
begin
  Result := 100;  // IDR_LIB
end;


//-------------------------------------------------------------------------------
//   
// ---
function GetCurrentDocument : IKompasDocument2D;

var
  kDoc : IKompasDocument;
begin
  Result := nil;

  if ( newKompasAPI <> nil ) then
     //   
     kDoc := newKompasAPI.ActiveDocument;
  Result := kDoc As IKompasDocument2D;
end;


//------------------------------------------------------------------------------
// LibraryEntry
//---
procedure LIBRARYENTRY( command: WORD ); pascal;

var
  mes : WideString;
begin
  Application.Handle := GetHWindow;
  GetNewKompasAPI;
  doc := GetCurrentDocument;

  if ( doc <> nil ) then
  begin
    case command of
      1   : CreateLineDimension;
      2   : LineDimensionNavigation;
      3   : EditLineDimension;
      4   : RadialDimensionWork;
      5   : DiametralDimensionWork;
      6   : AngleDimensionWork;
      7   : ArcDimensionWork;
      8   : BreakLineDimensionWork;
      9   : BreakRadialDimensionWork;
      10  : BreakAngleDimensionWork;
      11  : HeightDimensionWork;
    end;
    newKompasAPI := nil;
  end
  else
  begin
    mes := LoadStr( IDS_NODOC );
    ksMessageW( PWideChar(mes) );
  end;
end;


//-------------------------------------------------------------------------------
//     2D
// ---
function GetSymbols2DContainer : ISymbols2DContainer;

var
  viewsMng  : IViewsAndLayersManager;
  views     : IViews;
  view      : IView;
begin
  Result := nil;

  if ( doc <> nil ) then
  begin
    //        
    viewsMng := doc.ViewsAndLayersManager;

    if ( viewsMng <> nil ) then
    begin
      //   
      views := viewsMng.Views;

      if ( views <> nil ) then
      begin
        //   
        view := views.ActiveView;
        //  
        Result := view As ISymbols2DContainer;
      end;
    end
  end
end;


//-------------------------------------------------------------------------------
//   
// ---
procedure CreateLineDimension;

var
  symbCont  : ISymbols2DContainer;
  dimCol    : ILineDimensions;
  newDim    : ILineDimension;
begin
  //    
  symbCont := GetSymbols2DContainer;

  if ( symbCont <> nil ) then
  begin
    //    
    dimCol := symbCont.LineDimensions;

    if ( dimCol <> nil ) then
    begin
      //    
      newDim := dimCol.Add;

      if ( newDim <> nil ) then
      begin
        //     
        newDim.X1 := 50;
        newDim.Y1 := 150;
        //     
        newDim.X2 := 100;
        newDim.Y2 := 150;
        //   
        newDim.X3 := 75;
        newDim.Y3 := 180;
        //    
        newDim.Orientation := ksLinDHorizontal;
        //  
        newDim.Update;
      end;
    end;
  end;
end;


//-------------------------------------------------------------------------------
//      
// ---
procedure GetLineDimensionParam( dim : ILineDimension );

var
  x1, y1, x2, y2  : double;
  mes             : WideString;
begin
  if ( dim <> nil ) then
  begin
    //     
    x1 := dim.X1;
    y1 := dim.Y2;
    //     
    x2 := dim.X2;
    y2 := dim.Y2;
    //     
    mes := LoadStr( IDS_COORDS ) + #13#10 + 'X1 = ' + FormatFloat( '0.##', x1 ) + ', Y1 = ' + FormatFloat( '0.##', y1 ) + ', X2 = ' + FormatFloat( '0.##', x2 ) + ', Y2 = ' + FormatFloat( '0.##', y2 );
    ksMessageW( PWideChar(mes) );
  end;
end;


//-------------------------------------------------------------------------------
//     
// ---
procedure LineDimensionNavigation;

var
  symbCont  : ISymbols2DContainer;
  dimCol    : ILineDimensions;
  lineDim   : ILineDimension;
  i         : integer;
  dimRef    : reference;
begin
  //    
  symbCont := GetSymbols2DContainer;

  if ( symbCont <> nil ) then
  begin
    //    
    dimCol := symbCont.LineDimensions;

    if ( dimCol <> nil ) then
    begin
      for i := 0 to dimCol.Count - 1 do
      begin
        //      
        lineDim := dimCol.LineDimension[ i ];

        if ( lineDim <> nil ) then
        begin
          dimRef := lineDim.Reference;
          //  
          LightObj( dimRef, 1{ } );
          //      
          GetLineDimensionParam( lineDim );
          //  
          LightObj( dimRef, 0{ } );
        end;
      end;
    end;
  end;
end;


//-------------------------------------------------------------------------------
//     
// ---
procedure ChangeLineDimensionParam( dim : ILineDimension );

var
  dimPar : IDimensionParams;
begin
  if ( dim <> nil ) then
  begin
    //    
    dimPar := dim As IDimensionParams;

    if ( dimPar <> nil ) then
    begin
      //   - 
      dimPar.ShelfDirection := ksLSLeft;
      //   -  90 .
      dimPar.ArrowType1 := ksRightAngle;
      dimPar.ArrowType2 := ksRightAngle;
    end;
    //    
    dim.ShelfX := 60;
    dim.ShelfY := 200;
  end;
end;


//-------------------------------------------------------------------------------
//     
// ---
procedure CHangeLineDimensionText( dim : ILineDimension );

var
  dimText : IDimensionText;
  prefix  : ITextLine;
begin
  if ( dim <> nil ) then
  begin
    //    
    dimText := dim As IDimensionText;

    if ( dimText <> nil ) then
    begin
      //   
      dimText.Rectangle := true;
      //  
      dimText.Underline := true;
      //      
      prefix := dimText.Prefix;

      if ( prefix <> nil ) then
        //  
        prefix.Str := LoadStr( IDS_DIM );
    end;
  end;
end;


//-------------------------------------------------------------------------------
//   
// ---
procedure LineDimChange( dim : ILineDimension );
begin
  if ( dim <> nil ) then
  begin
    //   
    ChangeLineDimensionParam( dim );
    //   
    ChangeLineDimensionText( dim );
    //  
    dim.Update;
  end;
end;


//-------------------------------------------------------------------------------
//   
// ---
procedure EditLineDimension;

var
  info    : RequestInfoW;
  x, y    : double;
  pObj    : reference;
  lineDim : ILineDimension;
  mes     : WideString;
begin
  //      
  FillChar( info, SizeOf(info), 0 );
  //   
  mes := LoadStr(IDS_COMMAND1);
  info.commands := PWideChar( mes );

  //    
  if ( ksCursorExW(@info, x, y, nil, nil) <> 0 ) then
  begin
    //     
    pObj := FindObj( x, y, ksGetCursorLimit );

    //    , 
    if ( GetObjParam(pObj, nil, 0, 0) = LDIMENSION_OBJ ) then
    begin
      //       
      lineDim := IUnknown(ksTransferReference( pObj, ksGetCurrentDocument(0{ }))) As ILineDimension;
      //   
      LineDimChange( lineDim );
      lineDim._Release;
    end

    else
    begin
      mes := LoadStr( IDS_NOTDIM );
      ksMessageW( PWideChar(mes) );
    end;
  end;
end;


//-------------------------------------------------------------------------------
//   
// ---
procedure CreateRadDimension( dim : IRadialDimension );

var
  info    : RequestInfoW;
  x, y    : double;
  pObj    : reference;
  par     : CircleParam;
  circle  : IDrawingObject;
  mes     : WideString;
begin
  if ( dim <> nil ) then
  begin
    //      
    FillChar( info, SizeOf(info), 0 );
    //   
    mes := LoadStr(IDS_COMMAND2);
    info.commands := PWideChar( mes );

    //    
    if ( ksCursorExW(@info, x, y, nil, nil) <> 0 ) then
    begin
      //     
      pObj := FindObj( x, y, ksGetCursorLimit );

      //    
      if ( GetObjParam(pObj, @par, SizeOf(par), ALLPARAM_W) = CIRCLE_OBJ ) then
      begin
        //      
        circle := IUnknown(ksTransferReference( pObj, ksGetCurrentDocument(0{ }))) As IDrawingObject;

        if ( circle <> nil ) then
        begin
          //    
          dim.BaseObject := circle;
          //    ,     
          dim.Xc := par.xc;
          dim.Yc := par.yc;
          //   ,     
          dim.Radius := par.rad;
          //   -  
          dim.DimensionType := true;
          //    
          dim.Angle := 30;
          //  
          dim.Update;
          circle._Release;
        end

        else
        begin
          mes := LoadStr(IDS_NOOBJ);
          ksMessageW( PWideChar(mes) );
        end;
      end

      else
      begin
        mes := LoadStr(IDS_NOTCREATE1);
        ksMessageW( PWideChar(mes) );
      end;
    end;
  end;
end;


//-------------------------------------------------------------------------------
//       
// ---
procedure ChangeRadialDimensionParamText( dim : IRadialDimension );

var
  dimPar  : IDimensionParams;
  dimText : IDimensionText;
  tUnit   : ITextLine;
begin
  if ( dim <> nil ) then
  begin
    //    
    dimPar := dim As IDimensionParams;

    if ( dimPar <> nil ) then
    begin
      //   - 
      dimPar.ShelfDirection := ksLSRight;
      //   
      dimPar.ShelfAngle := 180;
      //  
      dimPar.ShelfLength := 30;
      //   - 
      dimPar.ArrowType1 := ksNotch;
    end;

    //    
    dimText := dim As IDimensionText;

    if ( dimText <> nil ) then
    begin
      //    - 
      dimText.Sign := 3;

      //     
      tUnit := dimText.Unit_;
      //  
      if ( tUnit <> nil ) then
        tUnit.Str := LoadStr( IDS_UNIT );
    end;
  end;
end;


//-------------------------------------------------------------------------------
//   
// ---
procedure EditRadialDimension( dim : IRadialDimension );
begin
  if ( dim <> nil ) then
  begin
    //   -   
    dim.DimensionType := false;
    //     
    ChangeRadialDimensionParamText( dim );
    //  
    dim.Update;
  end;
end;


//-------------------------------------------------------------------------------
//     
// ---
procedure RadialDimensionWork;

var
  symbCont              : ISymbols2DContainer;
  radCol                : IRadialDimensions;
  radDim, radDimension  : IRadialDimension;
  dimRef                : reference;
  mes                   : WideString;
begin
  //    
  symbCont := GetSymbols2DContainer;

  if ( symbCont <> nil ) then
  begin
    //    
    radCol := symbCont.RadialDimensions;

    if ( radCol <> nil ) then
    begin
      //     
      radDim := radCol.Add;

      if ( radDim <> nil ) then
      begin
        //   
        CreateRadDimension( radDim );
        //   
        dimRef := radDim.Reference;
        mes := LoadStr(IDS_EDIT);

        if ( YesNoW(PWideChar(mes)) = 1 ) then
        begin
          //      
          radDimension := radCol.RadialDimension[ dimRef ];
          //   
          EditRadialDimension( radDimension );
        end;
      end;
    end;
  end;
end;


//-------------------------------------------------------------------------------
//   
// ---
procedure CreateDiametralDimension( dim : IDiametralDimension );

var
  info    : RequestInfoW;
  x, y    : double;
  mes     : WideString;
  pObj    : reference;
  par     : CircleParam;
  circle  : IDrawingObject;
begin
  if ( dim <> nil ) then
  begin
    //      
    FillChar( info, SizeOf(info), 0 );
    mes := LoadStr( IDS_COMMAND2 );
    //   
    info.commands := PWideChar( mes );

    //    
    if ( ksCursorExW(@info, x, y, nil, nil) <> 0 ) then
    begin
      //     
      pObj := FindObj( x, y, ksGetCursorLimit );

      //    
      if ( GetObjParam(pObj, @par, SizeOf(par), ALLPARAM_W) = CIRCLE_OBJ ) then
      begin
        //      
        circle := IUnknown(ksTransferReference( pObj, ksGetCurrentDocument(0{ }))) As IDrawingObject;

        if ( circle <> nil ) then
        begin
          //    
          dim.BaseObject := circle;
          //    ,     
          dim.Xc := par.xc;
          dim.Yc := par.yc;
          //   ,     
          dim.Radius := par.rad;
          //   -   
          dim.DimensionType := true;
          //    
          dim.Angle := 45;
          //  
          dim.Update;
          circle._Release;
        end

        else
        begin
          mes := LoadStr( IDS_NOOBJ );
          ksMessageW( PWideChar(mes) );
        end;
      end

      else
      begin
        mes := LoadStr( IDS_NOTCREATE2 );
        ksMessageW( PWideChar(mes) );
      end;
    end;
  end;
end;


//-------------------------------------------------------------------------------
//       
// ---
procedure ChangeDiametralDimensionParamText( dim : IDiametralDimension );

var
  dimPar  : IDimensionParams;
  dimText : IDimensionText;
  suffix  : ITextLine;
begin
  if ( dim <> nil ) then
  begin
    //    
    dimPar := dim As IDimensionParams;

    if ( dimPar <> nil ) then
    begin
      //   - 
      dimPar.ShelfDirection := ksLSRight;
      //  
      dimPar.ShelfLength := 20;
      //   - 
      dimPar.ArrowType1 := ksPoint;
      dimPar.ArrowType2 := ksPoint;
    end;

    //    
    dimText := dim As IDimensionText;

    if ( dimText <> nil ) then
    begin
      //    - 
      dimText.Sign := 1;
      // 
      dimText.Underline := true;

      //     
      suffix := dimText.Suffix;

      //  
      if ( suffix <> nil ) then
        suffix.Str := LoadStr( IDS_UNIT );
    end;
  end;
end;


//-------------------------------------------------------------------------------
//   
// ---
procedure EditDiametralDimension( dim : IDiametralDimension );
begin
  if ( dim <> nil ) then
  begin
    //   -    
    dim.DimensionType := false;
    //    
    dim.Angle := 90;
    //     
    ChangeDiametralDimensionParamText( dim );
    //  
    dim.Update;
  end;
end;


//-------------------------------------------------------------------------------
//     
// ---
procedure DiametralDimensionWork;

var
  symbCont                : ISymbols2DContainer;
  diamCol                 : IDiametralDimensions;
  diamDim, diamDimension  : IDiametralDimension;
  dimRef                  : reference;
  mes                     : WideString;
begin
  //    
  symbCont := GetSymbols2DContainer;

  if ( symbCont <> nil ) then
  begin
    //    
    diamCol := symbCont.DiametralDimensions;

    if ( diamCol <> nil ) then
    begin
      //     
      diamDim := diamCol.Add;

      if ( diamDim <> nil ) then
      begin
        //   
        CreateDiametralDimension( diamDim );
        //   
        dimRef := diamDim.Reference;
        mes := LoadStr( IDS_EDIT );

        if ( YesNoW( PWideChar(mes) ) = 1 ) then
        begin
          //      
          diamDimension := diamCol.DiametralDimension[ dimRef ];
          //   
          EditDiametralDimension( diamDimension );
        end;
      end;
    end;
  end;
end;


//-------------------------------------------------------------------------------
//   
// ---
procedure CreateAngleDimension( dim : IAngleDimension );

var
  {info                : RequestInfoW;
  x, y                : double;
  pObj1, pObj2        : reference;
  type1, type2        : integer;
  mes                 : WideString;}
  line1, line2        : reference;
  baseObj1, baseObj2  : IDrawingObject;
  dimPar              : IDimensionParams;
begin
  if ( dim <> nil ) then
  begin

    {//    ,   
    //      
    FillChar( info, SizeOf(info), 0 );
    mes := LoadStr( IDS_COMMAND3 );
    //   
    info.commands := PWideChar( mes );

    //      
    if ( ksCursorExW(@info, x, y, nil, nil) <> 0 ) then
    begin
      //     
      pObj1 := FindObj( x, y, ksGetCursorLimit );
      //    
      type1 := GetObjParam( pObj1, nil, 0, 0 );

      //       
      if ( type1 = LINESEG_OBJ ) or ( type1 = POLYLINE_OBJ ) or ( type1 = RECTANGLE_OBJ) then
      begin
        //   
        LightObj( pObj1, 1 );
        mes := LoadStr( IDS_COMMAND4 );
        info.commands := PWideChar( mes );

        //      
        if ( ksCursorExW(@info, x, y, nil, nil) <> 0 ) then
        begin
          //     
          pObj2 := FindObj( x, y, ksGetCursorLimit );
          //    
          type2 := GetObjParam( pObj2, nil, 0, 0 );

          //       
          if ( type2 = LINESEG_OBJ ) or ( type2 = POLYLINE_OBJ ) or ( type2 = RECTANGLE_OBJ) then
          begin
            //   
            LightObj( pObj2, 1 );
            //      
            baseObj1 := IUnknown(ksTransferReference( pObj1, ksGetCurrentDocument(0))) As IDrawingObject;
            baseObj2 := IUnknown(ksTransferReference( pObj2, ksGetCurrentDocument(0))) As IDrawingObject;

            if ( baseObj1 <> nil ) and ( baseObj2 <> nil ) then
            begin
              //    
              dim.BaseObject1 := baseObj1;
              dim.BaseObject2 := baseObj2;
              //  
              dim.Radius := 20;
              //  
              dim.Update;
              //   
              LightObj( pObj2, 0 );
            end

            else
            begin
              mes := LoadStr( IDS_NOOBJS );
              ksMessageW( PWideChar(mes) );
            end;
            //   
            LightObj( pObj1, 0 );
          end

          else
          begin
            mes := LoadStr( IDS_NOTCREATE3 );
            ksMessageW( PWideChar(mes) );
          end;
        end;
      end

      else
      begin
        mes := LoadStr( IDS_NOTCREATE3 );
        ksMessageW( PWideChar(mes) );
      end;
    end;}

    //     
    //    
    line1 := LineSeg( 80, 120, 100, 120, 1 );
    baseObj1 := IUnknown(ksTransferReference( line1, ksGetCurrentDocument(0))) As IDrawingObject;
    //    
    line2 := LineSeg( 80, 120, 120, 160, 1 );
    baseObj2 := IUnknown(ksTransferReference( line2, ksGetCurrentDocument(0))) As IDrawingObject;

    if ( baseObj1 <> nil ) and ( baseObj2 <> nil ) then
    begin
      //   
      dim.BaseObject1 := baseObj1;
      dim.BaseObject2 := baseObj2;
      //  
      dim.Xc := 90;
      dim.Yc := 150;
      //  
      dim.Radius := 25;
      //    
      dim.Angle1 := 45;
      //    
      dim.Angle2 := 30;
      //      
      dim.X1 := 80;
      dim.Y1 := 120;
      //      
      dim.X2 := 100;
      dim.Y2 := 160;
      //   -   () 
      dim.DimensionType := ksADMinAngle;

      //  
      dimPar := dim As IDimensionParams;

      if ( dimPar <> nil ) then
        //   - 
        dimPar.ShelfDirection := ksLSRight;

      //   
      dim.ShelfX := 160;
      dim.ShelfY := 140;
      //    -   
      dim.Direction := false;
      //      
      dim.X3 := 140;
      dim.Y3 := 120;
      //  
      dim.Update;
      baseObj1._Release;
      baseObj2._Release;
    end;
  end;
end;


//-------------------------------------------------------------------------------
//   
// ---
procedure EditAngleDimension( dim : IAngleDimension );
begin
  if ( dim <> nil ) then
  begin
    //   -   () 
    dim.DimensionType := ksADMaxAngle;
    //    -   
    dim.Direction := true;
    //   
    dim.ShelfX := 150;
    dim.ShelfY := 170;
    //  
    dim.Radius := 40;
    //  
    dim.Update;
  end;
end;


//-------------------------------------------------------------------------------
//     
// ---
procedure AngleDimensionWork;

var
  symbCont              : ISymbols2DContainer;
  angCol                : IAngleDimensions;
  angDim, angDimension  : IAngleDimension;
  dimRef                : reference;
  mes                   : WideString;
begin
  //    
  symbCont := GetSymbols2DContainer;

  if ( symbCont <> nil ) then
  begin
    //    
    angCol := symbCont.AngleDimensions;

    if ( angCol <> nil ) then
    begin
      //     
      angDim := angCol.Add( ksDrADimension );

      if ( angDim <> nil ) then
      begin
        //   
        CreateAngleDimension( angDim );
        //   
        dimRef := angDim.Reference;
        mes := LoadStr( IDS_EDIT );

        if ( YesNoW(PWideChar(mes)) = 1 ) then
        begin
          //      
          angDimension := angCol.AngleDimension[ dimRef ];
          //   
          EditAngleDimension( angDimension );
        end;
      end;
    end;
  end;
end;


//-------------------------------------------------------------------------------
//    
// ---
procedure CreateArcDimension( dim : IArcDimension );

var
  info  : RequestInfoW;
  x, y  : double;
  par   : ArcParam1;
  pObj  : reference;
  arc   : IDrawingObject;
  mes   : WideString;
begin
  if ( dim <> nil ) then
  begin
    //      
    FillChar( info, SizeOf(info), 0 );
    mes := LoadStr( IDS_COMMAND5 );
    //   
    info.commands := PWideChar( mes );

    //    
    if ( ksCursorExW(@info, x, y, nil, nil) <> 0 ) then
    begin
      //     
      pObj := FindObj( x, y, ksGetCursorLimit );

      //    
      if ( GetObjParam(pObj, @par, SizeOf(par), POINT_ARC_PARAM) = ARC_OBJ ) then
      begin
        //      
        arc := IUnknown(ksTransferReference( pObj, ksGetCurrentDocument(0{ }))) As IDrawingObject;

        if ( arc <> nil ) then
        begin
          //    
          dim.BaseObject := arc;
          //  
          dim.Xc := par.xc;
          dim.Yc := par.yc;
          //    
          dim.X1 := par.x1;
          dim.Y1 := par.y1;
          //    
          dim.X2 := par.x2;
          dim.Y2 := par.y2;
          mes := LoadStr( IDS_COMMAND6 );
          info.commands := PWideChar( mes );

          //    
          if ( ksCursorExW(@info, x, y, nil, nil) <> 0 ) then
          begin
            dim.X3 := x;
            dim.Y3 := y;
          end;

          //   
          dim.Direction := true;
          //   -   
          dim.DimensionType := false;
          //     
          dim.TextPointer := true;
          //  
          dim.Update;
          arc._Release;
        end

        else
        begin
          mes := LoadStr( IDS_NOOBJ );
          ksMessageW( PWideChar(mes) );
        end;
      end

      else
      begin
        mes := LoadStr( IDS_NOTCREATE4 );
        ksMessageW( PWideChar(mes) );
      end;
    end;
  end;
end;


//-------------------------------------------------------------------------------
//    
// ---
procedure EditArcDimension( dim : IArcDimension );

var
  dimPar  : IDimensionParams;
  dimText : IDimensionText;
  tUnit   : ITextLine;
begin
  if ( dim <> nil ) then
  begin
    //   -    
    dim.DimensionType := true;
    //      
    dim.TextPointer := false;
    //    -   
    dim.Direction := not dim.Direction;

    //    
    dimPar := dim As IDimensionParams;

    if ( dimPar <> nil ) then
    begin
      //  
      dimPar.ArrowType1 := ksLeaderPoint;
      dimPar.ArrowType2 := ksLeaderPoint;
      //   - 
      dimPar.ShelfDirection := ksLSDown;
      //   
      dimPar.ShelfAngle := 180;
    end;

    //    
    dimText := dim As IDimensionText;

    if ( dimText <> nil ) then
    begin
      //     
      dimText.AutoNominalValue := false;
      //    
      dimText.NominalValue := 50;

      //     
      tUnit := dimText.Unit_;

      //   
      if ( tUnit <> nil ) then
        tUnit.Str := LoadStr( IDS_UNIT2 );
    end;

    //  
    dim.Update;
  end;
end;


//-------------------------------------------------------------------------------
//      
// ---
procedure ArcDimensionWork;
var
  symbCont              : ISymbols2DContainer;
  arcCol                : IArcDimensions;
  arcDim, arcDimension  : IArcDimension;
  dimRef                : reference;
  mes                   : WideString;
begin
  //    
  symbCont := GetSymbols2DContainer;

  if ( symbCont <> nil ) then
  begin
    //     
    arcCol := symbCont.ArcDimensions;

    if ( arcCol <> nil ) then
    begin
      //      
      arcDim := arcCol.Add;

      if ( arcDim <> nil ) then
      begin
        //    
        CreateArcDimension( arcDim );
        //   
        dimRef := arcDim.Reference;
        mes := LoadStr( IDS_EDIT );

        if ( YesNoW(PWideChar(mes)) = 1 ) then
        begin
          //      
          arcDimension := arcCol.ArcDimension[ dimRef ];
          //    
          EditArcDimension( arcDimension );
        end;
      end;
    end;
  end;
end;


//-------------------------------------------------------------------------------
//     
// ---
procedure CreateBreakLineDim( dim : IBreakLineDimension );
var
  info    : RequestInfoW;
  x, y    : double;
  par     : LineSegParam;
  pObj    : reference;
  lineSeg : IDrawingObject;
  mes     : WideString;
begin
  if ( dim <> nil ) then
  begin
    //      
    FillChar( info, SizeOf(info), 0 );
    mes := LoadStr( IDS_COMMAND7 );
    //   
    info.commands := PWideChar( mes );

    //    
    if ( ksCursorExW(@info, x, y, nil, nil) <> 0 ) then
    begin
      //     
      pObj := FindObj( x, y, ksGetCursorLimit );

      //    
      if ( GetObjParam(pObj, @par, SizeOf(par), ALLPARAM_W) = LINESEG_OBJ ) then
      begin
        //   
        LightObj( pObj, 1 );
        //      
        lineSeg := IUnknown(ksTransferReference( pObj, ksGetCurrentDocument(0{ }))) As IDrawingObject;

        if ( lineSeg <> nil ) then
        begin
          //    
          dim.BaseObject := lineSeg;
          mes := LoadStr( IDS_COMMAND6 );
          info.commands := PWideChar( mes );

          //    
          if ( ksCursorExW(@info, x, y, nil, nil) <> 0 ) then
          begin
            dim.X1 := par.x1;
            dim.Y1 := par.y1;
            dim.X2 := par.x2;
            dim.Y2 := par.Y2;
            dim.X3 := x;
            dim.Y3 := y;
          end;

          //  
          dim.Update;
          lineSeg._Release;
        end

        else
        begin
          mes := LoadStr( IDS_NOOBJ );
          ksMessageW( PWideChar(mes) );
        end;
      end

      else
      begin
        mes := LoadStr( IDS_NOTCREATE5 );
        ksMessageW( PWideChar(mes) );
      end;

      //   
      LightObj( pObj, 0 );
    end;
  end;
end;


//-------------------------------------------------------------------------------
//     
// ---
procedure EditBreakLineDim( dim : IBreakLineDimension );

var
  dimPar          : IDimensionParams;
  dimText         : IDimensionText;
  prefix, nominal : ITextLine;
begin
  if ( dim <> nil ) then
	begin
		//    
		dimPar := dim As IDimensionParams;

		if ( dimPar <> nil ) then
			//  
			dimPar.ArrowType1 := ksLeftNotch;

		//    
		dimText := dim As IDimensionText;

		if ( dimText <> nil ) then
		begin
			//    
			prefix := dimText.Prefix;

			if ( prefix <> nil ) then
				//  
				prefix.Str := LoadStr( IDS_DIM );

			//    
			nominal := dimText.NominalText;

			if ( nominal <> nil ) then
				//  
				nominal.Str := LoadStr( IDS_NOMINAL );
		end;
		//  
		dim.Update();
	end;
end;


//-------------------------------------------------------------------------------
//       
// ---
procedure BreakLineDimensionWork;

var
  symbCont                  : ISymbols2DContainer;
  breakCol                  : IBreakLineDimensions;
  breakDim, breakDimension  : IBreakLineDimension;
  dimRef                    : reference;
  mes                       : WideString;
begin
	//    
	symbCont := GetSymbols2DContainer;
	
	if ( symbCont <> nil ) then
	begin
		//      
		breakCol := symbCont.BreakLineDimensions;
		
		if ( breakCol <> nil ) then
		begin
			//       
			breakDim := breakCol.Add;

			if ( breakDim <> nil ) then
			begin
				//     
				CreateBreakLineDim( breakDim );
				//   
				dimRef := breakDim.Reference;
        mes := LoadStr( IDS_EDIT );
				
				if ( YesNoW(PWideChar(mes)) = 1 ) then
				begin
					//      
					breakDimension := breakCol.BreakLineDimension[ dimRef ];
					//     
					EditBreakLineDim( breakDimension );
				end;
			end;
		end;
	end;
end;


//-------------------------------------------------------------------------------
//     
// ---
procedure CreateBreakRadialDim( dim : IBreakRadialDimension );

var
  info    : RequestInfoW;
  mes     : WideString;
  x, y    : double;
  pObj    : reference;
  par     : CircleParam;
  circle  : IDrawingObject;
begin
	if ( dim <> nil ) then
	begin
		//     
		FillChar( info, SizeOf(info), 0 );
    mes := LoadStr( IDS_COMMAND2 );
		info.commands := PWideChar( mes );
		
		//    
		if ( ksCursorExW(@info, x, y, nil, nil) <> 0 ) then
		begin
			//     
			pObj := FindObj( x, y, ksGetCursorLimit );
			
			//    
			if ( GetObjParam(pObj, @par, SizeOf(par), ALLPARAM_W ) = CIRCLE_OBJ ) then
			begin
				//      
				circle := IUnknown(ksTransferReference( pObj, ksGetCurrentDocument(0{ }))) As IDrawingObject;

				if ( circle <> nil ) then
				begin
					//    
					dim.BaseObject := circle;
					//    ,     
					dim.Xc := par.xc;
					dim.Yc := par.yc;
					//   ,     
					dim.Radius := par.rad;
					//    
					dim.Angle := 45;
					//  
					dim.BreakLength := 3;
					//   
					dim.TextOnLine := ksDimTextParallelOnLine;
					//  
					dim.Update;
          circle._Release;
				end

				else
        begin
          mes := LoadStr( IDS_NOOBJ );
					ksMessageW( PWideChar(mes) );
        end;
			end

			else
      begin
        mes := LoadStr( IDS_NOTCREATE1 );
				ksMessageW( PWideChar(mes) );
      end;
		end;
	end;
end;


//-------------------------------------------------------------------------------
//     
// ---
procedure EditBreakRadialDim( dim : IBreakRadialDimension  );

var
  dimText : IDimensionText;
begin
	if ( dim <> nil ) then
	begin
		//    
		dim.Angle := 90;
		//  
		dim.BreakLength := 1;
		//   
		dim.TextOnLine := ksDimTextParallelInCut;
	  //    
	  dimText := dim As IDimensionText;

	  if ( dimText <> nil ) then
		  //   
		  dimText.Sign := 0;

	  //  
	  dim.Update;
  end;
end;


//-------------------------------------------------------------------------------
//       
// ---
procedure BreakRadialDimensionWork;

var
  symbCont                  : ISymbols2DContainer;
  breakCol                  : IBreakRadialDimensions;
  breakDim, breakDimension  : IBreakRadialDimension;
  dimRef                    : reference;
  mes                       : WideString;
begin
	//    
	symbCont := GetSymbols2DContainer;
	
	if ( symbCont <> nil ) then
	begin
		//      
		breakCol := symbCont.BreakRadialDimensions;
		
		if ( breakCol <> nil ) then
		begin
			//       
			breakDim := breakCol.Add;

			if ( breakDim <> nil ) then
			begin
				//     
				CreateBreakRadialDim( breakDim );
				//   
				dimRef := breakDim.Reference;
        mes := LoadStr( IDS_EDIT );

				if ( YesNoW(PWideChar(mes)) = 1 ) then
				begin
					//      
					breakDimension := breakCol.BreakRadialDimension[ dimRef ];
					//     
					EditBreakRadialDim( breakDimension );
				end;
			end;
		end;
	end;
end;


//-------------------------------------------------------------------------------
//     
// ---
procedure CreateBreakAngleDim( dim : IBreakAngleDimension );

var
  line1, line2 : reference;
  baseObj1, baseObj2 : IDrawingObject;
begin
	if ( dim <> nil ) then
	begin
		//    
		line1 := LineSeg( 80, 120, 120, 160, 1 );
    baseObj1 := IUnknown(ksTransferReference( line1, ksGetCurrentDocument(0{ }))) As IDrawingObject;
		//    
		line2 := LineSeg( 80, 120, 100, 120, 1 );
		baseObj2 := IUnknown(ksTransferReference( line2, ksGetCurrentDocument(0{ }))) As IDrawingObject;

		if ( baseObj1 <> nil ) and ( baseObj2 <> nil ) then
		begin
			//   
			dim.BaseObject1 := baseObj1;
			dim.BaseObject2 := baseObj2;
			//  
			dim.Xc := 80;
			dim.Yc := 120;
			//  
			dim.Radius := 20;
			//     
			dim.Angle1 := 45;
			//     
			dim.Angle2 := 30;
			//      
			dim.X1 := 120;
			dim.Y1 := 160;
			//      
			dim.X2 := 100;
			dim.Y2 := 160;
			//   -   () 
			dim.DimensionType := ksADMinAngle;
			//    -   
			dim.Direction := true;
			//      
			dim.X3 := 165;
			dim.Y3 := 140;
			//  
			dim.Update;
      baseObj1._Release;
      baseObj2._Release;
		end;
	end;
end;


//-------------------------------------------------------------------------------
//     
// ---
procedure EditBreakAngleDim( dim : IBreakAngleDimension  );

var
  dimPar  : IDimensionParams;
  dimText : IDimensionText;
begin
	if ( dim <> nil ) then
	begin
		//  
		dimPar := dim As IDimensionParams;

		if ( dimPar <> nil ) then
			//   - 
			dimPar.ShelfDirection := ksLSRight;
		
		//   
		dim.ShelfX := 167;
		dim.ShelfY := 177;

		//    
		dimText := dim As IDimensionText;

    if ( dimText <> nil ) then
		begin
			//   
			dimText.TextAlign := ksDimALowerBoundary;
			//    
			dimText.Brackets := ksDimBrackets;
		end;
		//  
		dim.Update;
	end;
end;


//-------------------------------------------------------------------------------
//       
// ---
procedure BreakAngleDimensionWork;

var
  symbCont                  : ISymbols2DContainer;
  breakCol                  : IAngleDimensions;
  breakDim, breakDimension  : IBreakAngleDimension;
  dimRef                    : reference;
  mes                       : WideString;
begin
	//    
	symbCont := GetSymbols2DContainer;
	
	if ( symbCont <> nil ) then
	begin
		//      
		breakCol := symbCont.AngleDimensions;

		if ( breakCol <> nil ) then
		begin
			//       
			breakDim := breakCol.Add( ksDrABreakDimension ) As IBreakAngleDimension;
			
			if ( breakDim <> nil ) then
			begin
				//     
				CreateBreakAngleDim( breakDim );
				//   
				dimRef := breakDim.Reference;
        mes := LoadStr( IDS_EDIT );
				
				if ( YesNoW(PWideChar(mes)) = 1 ) then
				begin
					//      
					breakDimension := breakCol.AngleDimension[ dimRef ] As IBreakAngleDimension;
					//     
					EditBreakAngleDim( breakDimension );
				end;
			end;
		end;
	end;
end;


//-------------------------------------------------------------------------------
//   
// ---
procedure CreateHeightDimension( dim : IHeightDimension  );

var
  info                  : RequestInfoW;
  mes                   : WideString;
  x, y, x1, y1, x2, y2  : double;
begin
	if ( dim <> nil ) then
	begin
		//      
    FillChar( info, SizeOf(info), 0 );
    mes := LoadStr( IDS_COMMAND8 );
    //   
    info.commands := PWideChar( mes );

		//    
		if ( ksCursorExW(@info, x, y, nil, nil) <> 0 ) then
		begin
      mes := LoadStr( IDS_COMMAND9 );
      info.commands := PWideChar( mes );

			//    
			if ( ksCursorExW(@info, x1, y1, nil, nil) <> 0 ) then
			begin
        mes := LoadStr( IDS_COMMAND10 );
        info.commands := PWideChar( mes );
				
				//    
				if ( ksCursorExW(@info, x2, y2, nil, nil) <> 0 ) then
				begin
					//   
					dim.X := x;
					dim.Y := y;
					//   
					dim.X1 := x1;
					dim.Y1 := y1;
					//   
					dim.X2 := x2;
					dim.Y2 := y2;
					//  
					dim.Update;
				end;
			end;
		end;
	end;
end;


//-------------------------------------------------------------------------------
//   
// ---
procedure EditHeightDimension( dim : IHeightDimension  );

var
  dimText : IDimensionText;
  nominal : ITextLine;
begin
	if ( dim <> nil ) then
	begin
		//  
		dim.DimensionType := ksHDTopViewLeader;

		//    
		dimText := dim As IDimensionText;

		if ( dimText <> nil ) then
		begin
			//   - 
			dimText.Sign := 2;
			//    
			nominal := dimText.NominalText;
			
			if ( nominal <> nil )then
				//  
				nominal.Str := LoadStr( IDS_NOMINAL );
		end;
		//  
		dim.Update;
	end;
end;


//-------------------------------------------------------------------------------
//     
// ---
procedure HeightDimensionWork;

var
  symbCont                    : ISymbols2DContainer;
  heightCol                   : IHeightDimensions;
  heightDim, heightDimension  : IHeightDimension;
  dimRef                      : reference;
  mes                         : WideString;
begin
	//    
	symbCont := GetSymbols2DContainer;
	
	if ( symbCont <> nil ) then
	begin
		//      
		heightCol := symbCont.HeightDimensions;
		
		if ( heightCol <> nil ) then
		begin
			//       
			heightDim := heightCol.Add;
			
			if ( heightDim <> nil ) then
			begin
				//     
				CreateHeightDimension( heightDim );
				//   
				dimRef := heightDim.Reference;
        mes := LoadStr( IDS_EDIT );
				
				if ( YesNoW(PWideChar(mes)) = 1 ) then
				begin
					//      
					heightDimension := heightCol.HeightDimension[ dimRef ];
					//     
					EditHeightDimension( heightDimension );
				end;
			end;
		end;
	end;
end;


//-------------------------------------------------------------------------------
//     API
// ---
procedure GetNewKompasAPI;
var
  disp : IDispatch;
begin
	if newKompasAPI = nil then
  begin
    disp := IDispatch(CreateKompasApplication);
    newKompasAPI := disp As IApplication;
  end;
end;


//----------------------------------------------------------------------------------------------
//    
//---
function LoadStr( ID : Integer ) : string;
var
  buf : array [0..255] of char;
begin
  ksConvertLangStrEx( hInstance, ID, buf, 255 );
  Result := buf;
end;


//------------------------------------------------------------------------------
//  
// ---
function LibMessage( str : string; flags : integer ) : Integer;
var
 enabse : Integer;
begin
  enabse := IsEnableTaskAccess();  //  
  if enabse <> 0 then             //     
    EnableTaskAccess(0);          //  

    //                                      
  Result := Application.MessageBox( PChar(str), PChar(LoadStr(LIBRARYID)), flags );

  if enabse <> 0 then                         //      
    EnableTaskAccess(1);              //    

end;


//------------------------------------------------------------------------------
//  
// ---
function LibMessageByID( strId, flags : Integer ) : Integer;
begin
  Result := LibMessage( LoadStr(strId), flags );
end;

end.


