////////////////////////////////////////////////////////////////////////////////
//
// Step2_API7_2D.cpp -  2D
//
//	1:	CreateLineDimension( doc );				-   
//	2:	LineDimensionNavigation( doc );		-     
//	3:	EditLineDimension( doc );					-   
// 	4:	RadialDimensionWork( doc );				-     
//	5:	DiamrtralDimensionWork( doc );		-     
//	6:	AngleDimensionWork( doc );				-     
// 	7:	ArcDimensionWork( doc );					-      
// 	8:	BreakLineDimensionWork( doc );		-       
// 	9:	BreakRadialDimensionWork( doc );	-       
// 	10:	BreakAngleDimensionWork( doc );		-       
// 	11:	HeightDimensionWork( doc );				-     
// 
////////////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include <afxdllx.h>
#include "Step2_API7_2D.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif


//-------------------------------------------------------------------------------
//       DLL
// ---
static AFX_EXTENSION_MODULE Step2_API7_2DDLL = { NULL, NULL };
HINSTANCE g_hInstance = NULL;

//  
ksAPI7::IApplicationPtr newKompasAPI( NULL );               

void OnProcessDetach();                            //  


//-------------------------------------------------------------------------------
//   
//    DLL
// ---
extern "C" int APIENTRY
DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID lpReserved)
{
  g_hInstance = hInstance;

	if (dwReason == DLL_PROCESS_ATTACH)
	{
		TRACE0("STEP2_API7_2D.AWX Initializing!\n");

		AfxInitExtensionModule(Step2_API7_2DDLL, hInstance);

		new CDynLinkLibrary(Step2_API7_2DDLL);
	}
	else if (dwReason == DLL_PROCESS_DETACH)
	{
		TRACE0("STEP2_API7_2D.AWX Terminating!\n");
    OnProcessDetach();
		AfxTermExtensionModule(Step2_API7_2DDLL);
	}
	return 1;   // ok
}


//-------------------------------------------------------------------------------
//     API
// ---
void GetNewKompasAPI() 
{
  if ( !( ksAPI7::IApplication * )newKompasAPI ) 
  {
    CString filename;
    
    if( ::GetModuleFileName(NULL, filename.GetBuffer(255), 255) ) 
    {
      filename.ReleaseBuffer( 255 );
      CString libname;
      
      libname = LoadStr( IDR_API7 );    // kAPI7.dll
      filename.Replace( filename.Right(filename.GetLength() - (filename.ReverseFind('\\') + 1)), 
        libname );
      
      HINSTANCE hAppAuto = LoadLibrary( filename ); //  kAPI7.dll
      
      if(  hAppAuto ) 
      {
        //      KompasApplication  
        typedef LPDISPATCH ( WINAPI * FCreateKompasApplication )(); 
        
        FCreateKompasApplication pCreateKompasApplication = 
          (FCreateKompasApplication)GetProcAddress( hAppAuto, "CreateKompasApplication" );	
        
        if ( pCreateKompasApplication )
          newKompasAPI = IDispatchPtr ( pCreateKompasApplication(), false /*AddRef*/); //   Application
        FreeLibrary( hAppAuto );  
      }
    }
  }
}


//-------------------------------------------------------------------------------
//   
// ---
unsigned int WINAPI LIBRARYID()
{
  return IDR_LIBID;
}


//-------------------------------------------------------------------------------
//   
// ---
ksAPI7::IKompasDocument2DPtr GetCurrentDocument()
{
	ksAPI7::IKompasDocument2DPtr doc = NULL;

	//      IApplication  
  if ( !(bool)newKompasAPI )
		//    
    GetNewKompasAPI();

	//     IApplication  
  if ( newKompasAPI ) 
		//   
    doc = newKompasAPI->GetActiveDocument();
	
	return doc;
}


//-------------------------------------------------------------------------------
//   
// ---
void CreateLineDimension( ksAPI7::IKompasDocument2DPtr & doc );
void LineDimensionNavigation( ksAPI7::IKompasDocument2DPtr & doc );
void EditLineDimension( ksAPI7::IKompasDocument2DPtr & doc );
void RadialDimensionWork( ksAPI7::IKompasDocument2DPtr & doc );
void DiamrtralDimensionWork( ksAPI7::IKompasDocument2DPtr & doc );
void AngleDimensionWork( ksAPI7::IKompasDocument2DPtr & doc );
void ArcDimensionWork( ksAPI7::IKompasDocument2DPtr & doc );
void BreakLineDimensionWork( ksAPI7::IKompasDocument2DPtr & doc );
void BreakRadialDimensionWork( ksAPI7::IKompasDocument2DPtr & doc );
void BreakAngleDimensionWork( ksAPI7::IKompasDocument2DPtr & doc );
void HeightDimensionWork( ksAPI7::IKompasDocument2DPtr & doc );


//-------------------------------------------------------------------------------
//   
// ---
void WINAPI LIBRARYENTRY( unsigned int comm )
{
	//   
	ksAPI7::IKompasDocument2DPtr doc( GetCurrentDocument() );
	
	if ( doc )
	{
		switch ( comm )
		{
			case 1:		CreateLineDimension( doc );				break;	//   
			case 2:		LineDimensionNavigation( doc );		break;	//     
			case 3:		EditLineDimension( doc );					break;	//   
			case 4:		RadialDimensionWork( doc );				break;	//     
			case 5:		DiamrtralDimensionWork( doc );		break;	//     
			case 6:		AngleDimensionWork( doc );				break;	//     
			case 7:		ArcDimensionWork( doc );					break;	//      
			case 8:		BreakLineDimensionWork( doc );		break;	//       
			case 9:		BreakRadialDimensionWork( doc );	break;	//       
			case 10:	BreakAngleDimensionWork( doc );		break;	//       
			case 11:	HeightDimensionWork( doc );				break;	//     
		}
	}
	else
	{
		MessageT( (LPTSTR)(LPCTSTR)LoadStr(IDS_NODOC) );
	}
}


//-------------------------------------------------------------------------------
//     2D
// ---
ksAPI7::ISymbols2DContainerPtr GetSymbols2DContainer( ksAPI7::IKompasDocument2DPtr & doc )
{
  if ( doc )
  {
    //        
    ksAPI7::IViewsAndLayersManagerPtr viewsMng( doc->GetViewsAndLayersManager() );
		
    if ( viewsMng )
    {
      //   
      ksAPI7::IViewsPtr views( viewsMng->GetViews() );
			
      if ( views )
      {
        //   
        return views->GetActiveView();
      }
    }
  }
  return NULL;
}


//-------------------------------------------------------------------------------
//   
// ---
void CreateLineDimension( ksAPI7::IKompasDocument2DPtr & doc )
{
	//    
  ksAPI7::ISymbols2DContainerPtr symbCont( GetSymbols2DContainer(doc) );

	if ( symbCont )
	{
		//    
    ksAPI7::ILineDimensionsPtr dimCol( symbCont->GetLineDimensions() );

		if ( dimCol )
		{
			//   
      ksAPI7::ILineDimensionPtr newDim( dimCol->Add() );

			if ( newDim )
			{
				//     
				newDim->X1 = 50;
				newDim->Y1 = 150;
				//     
				newDim->X2 = 100;
				newDim->Y2 = 150;
				//   
				newDim->X3 = 75;
				newDim->Y3 = 180;
				//    
				newDim->Orientation = ksLinDHorizontal;
				//  
				newDim->Update();
			}
		}
	}
}


//-------------------------------------------------------------------------------
//      
// ---
void GetLineDimensionParam( ksAPI7::ILineDimensionPtr & dim )
{
	if ( dim )
	{
		//     
		double x1 = dim->X1;
		double y1 = dim->Y1;
		//     
		double x2 = dim->X2;
		double y2 = dim->Y2;
		//     
		TCHAR buf[255];
		_stprintf( buf, (LPTSTR)(LPCTSTR)LoadStr(IDS_COORDS), x1, y1, x2, y2 );
		MessageT( buf );
	}
}


//-------------------------------------------------------------------------------
//     
// ---
void LineDimensionNavigation( ksAPI7::IKompasDocument2DPtr & doc )
{
	//    
  ksAPI7::ISymbols2DContainerPtr symbCont( GetSymbols2DContainer(doc) );

	if ( symbCont )
	{
		//    
    ksAPI7::ILineDimensionsPtr dimCol( symbCont->GetLineDimensions() );

		if ( dimCol )
		{
			for ( long i = 0; i < dimCol->Count; i++ )
			{
				_variant_t index = (long)i;
				//      
				ksAPI7::ILineDimensionPtr lineDim( dimCol->GetLineDimension(index) );

				if ( lineDim )
				{
					reference dimRef = lineDim->Reference;
					//  
					LightObj( dimRef, 1/* */ );
					//      
					GetLineDimensionParam( lineDim );
					//  
					LightObj( dimRef, 0/* */ );
				}
			}
		}
	}
}


//-------------------------------------------------------------------------------
//     
// ---
void ChangeLineDimensionParam( ksAPI7::ILineDimensionPtr & dim )
{
	if ( dim )
	{
		//    
		ksAPI7::IDimensionParamsPtr dimPar( dim );
		
		if ( dimPar )
		{
			//   - 
			dimPar->ShelfDirection = ksLSLeft;
			//   -  90 .
			dimPar->ArrowType1 = ksRightAngle;
			dimPar->ArrowType2 = ksRightAngle;
		}
		
		//    
		dim->ShelfX = 60;
		dim->ShelfY = 200;
	}
}


//-------------------------------------------------------------------------------
//     
// ---
void ChangeLineDimensionText( ksAPI7::ILineDimensionPtr & dim )
{
	if ( dim )
	{
		//    
		ksAPI7::IDimensionTextPtr dimText( dim );
		
		if ( dimText )
		{
			//   
			dimText->Rectangle = TRUE;
			//  
			dimText->Underline = TRUE;
			
			//      
			ksAPI7::ITextLinePtr prefix( dimText->Prefix );
			
			//  
			if ( prefix )
				prefix->Str = (LPTSTR)(LPCTSTR)LoadStr( IDS_DIM );
		}
	}
}


//-------------------------------------------------------------------------------
//   
// ---
void LineDimChange( ksAPI7::ILineDimensionPtr & dim )
{
	if ( dim )
	{
		//   
		ChangeLineDimensionParam( dim );
		//   
		ChangeLineDimensionText( dim );
		//  
		dim->Update();
	}
}


//-------------------------------------------------------------------------------
//   
// ---
void EditLineDimension( ksAPI7::IKompasDocument2DPtr & doc )
{
	//     
	RequestInfoT info;
  memset( &info, 0, sizeof(info) );
  info.commands = (LPTSTR)IDS_COMMAND1;
  double x, y;
	
	//    
	if ( CursorExT(&info, &x, &y, NULL, NULL) )
  {
		//     
    reference pObj = FindObj( x, y, ksGetCursorLimit() );
		
		//    , 
    if ( GetObjParam(pObj, 0, 0, 0) == LDIMENSION_OBJ )
    {
			//       
			ksAPI7::ILineDimensionPtr lineDim( IUnknownPtr(ksTransferReference(pObj, ksGetCurrentDocument(0/* */)), false/*AddRef*/) );
			//   
			LineDimChange( lineDim );
    }
    else
      MessageT( (LPTSTR)(LPCTSTR)LoadStr(IDS_NOTDIM) );
  } 
}


//-------------------------------------------------------------------------------
//   
// ---
void CreateRadDimension( ksAPI7::IRadialDimensionPtr & dim )
{
	if ( dim )
	{
		//     
		RequestInfoT info;
		memset( &info, 0, sizeof(info) );
		info.commands = (LPTSTR)IDS_COMMAND2;
		double x, y;
		
		//    
		if ( CursorExT(&info, &x, &y, NULL, NULL) )
		{
			//     
			reference pObj = FindObj( x, y, ksGetCursorLimit() );
			//   
			CircleParam par;
			
			//    
			if ( GetObjParam(pObj, &par, sizeof(par), ALLPARAM_T ) == CIRCLE_OBJ )
			{
				//      
				ksAPI7::IDrawingObjectPtr circle( IUnknownPtr(ksTransferReference(pObj, ksGetCurrentDocument(0)), false/*AddRef*/) );
				
				if ( circle )
				{
					//    
					dim->BaseObject = circle;
					//    ,     
					dim->Xc = par.xc;
					dim->Yc = par.yc;
					//   ,     
					dim->Radius = par.rad;
					//   -  
					dim->DimensionType = TRUE;
					//    
					dim->Angle = 30;
					//  
					dim->Update();
				}
				else
					MessageT( (LPTSTR)(LPCTSTR)LoadStr(IDS_NOOBJ) );
			}
			else
				MessageT( (LPTSTR)(LPCTSTR)LoadStr(IDS_NOTCREATE1) );
		} 
	}
}


//-------------------------------------------------------------------------------
//       
// ---
void ChangeRadialDimensionParamText( ksAPI7::IRadialDimensionPtr & dim )
{
	if ( dim )
	{
		//    
		ksAPI7::IDimensionParamsPtr dimPar( dim );

		if ( dimPar )
		{
			//   - 
			dimPar->ShelfDirection = ksLSRight;
			//   
			dimPar->ShelfAngle = 180;
			//  
			dimPar->ShelfLength = 30;
			//   - 
			dimPar->ArrowType1 = ksNotch;
		}

		//    
		ksAPI7::IDimensionTextPtr dimText( dim );

		if ( dimText )
		{
			//    - 
			dimText->Sign = 3;

			//     
			ksAPI7::ITextLinePtr unit( dimText->Unit );

			//   
			if ( unit )
				unit->Str = (LPTSTR)(LPCTSTR)LoadStr( IDS_UNIT );
		}
	}
}


//-------------------------------------------------------------------------------
//   
// ---
void EditRadialDimension( ksAPI7::IRadialDimensionPtr & dim )
{
	if ( dim )
	{
		//   -   
		dim->DimensionType = FALSE;
		//     
		ChangeRadialDimensionParamText( dim );
		//  
		dim->Update();
	}
}


//-------------------------------------------------------------------------------
//     
// ---
void RadialDimensionWork( ksAPI7::IKompasDocument2DPtr & doc )
{
	//    
	ksAPI7::ISymbols2DContainerPtr symbCont( GetSymbols2DContainer(doc) );

	if ( symbCont )
	{
		//    
		ksAPI7::IRadialDimensionsPtr radCol( symbCont->GetRadialDimensions() );

		if ( radCol )
		{
			//     
			ksAPI7::IRadialDimensionPtr radDim( radCol->Add() );

			if ( radDim )
			{
				//   
				CreateRadDimension( radDim );
				//   
				reference dimRef = radDim->Reference;

				if ( YesNoT((LPTSTR)(LPCTSTR)LoadStr(IDS_EDIT)) )
				{
					_variant_t index = (long)dimRef;
					//      
					ksAPI7::IRadialDimensionPtr radDimension( radCol->GetRadialDimension( index ) );
					//   
					EditRadialDimension( radDimension );
				}
			}
		}
	}
}


//-------------------------------------------------------------------------------
//   
// ---
void CreateDiamrtralDimension( ksAPI7::IDiametralDimensionPtr & dim )
{
	if ( dim )
	{
		//     
		RequestInfoT info;
		memset( &info, 0, sizeof(info) );
		info.commands = (LPTSTR)IDS_COMMAND2;
		double x, y;
		
		//    
		if ( CursorExT(&info, &x, &y, NULL, NULL) )
		{
			//     
			reference pObj = FindObj( x, y, ksGetCursorLimit() );
			//   
			CircleParam par;
			
			//    
			if ( GetObjParam(pObj, &par, sizeof(par), ALLPARAM_T ) == CIRCLE_OBJ )
			{
				//      
				ksAPI7::IDrawingObjectPtr circle( IUnknownPtr(ksTransferReference(pObj, ksGetCurrentDocument(0)), false/*AddRef*/) );
				
				if ( circle )
				{
					//    
					dim->BaseObject = circle;
					//    ,     
					dim->Xc = par.xc;
					dim->Yc = par.yc;
					//   ,     
					dim->Radius = par.rad;
					//   -   
					dim->DimensionType = TRUE;
					//    
					dim->Angle = 45;
					//  
					dim->Update();
				}
				else
					MessageT( (LPTSTR)(LPCTSTR)LoadStr(IDS_NOOBJ) );
			}
			else
				MessageT( (LPTSTR)(LPCTSTR)LoadStr(IDS_NOTCREATE2) );
		}
	}
}


//-------------------------------------------------------------------------------
//       
// ---
void ChangeDiametralDimensionParamText( ksAPI7::IDiametralDimensionPtr & dim )
{
	if ( dim )
	{
		//    
		ksAPI7::IDimensionParamsPtr dimPar( dim );
		
		if ( dimPar )
		{
			//   - 
			dimPar->ShelfDirection = ksLSRight;
			//  
			dimPar->ShelfLength = 20;
			//   - 
			dimPar->ArrowType1 = ksPoint;
			dimPar->ArrowType2 = ksPoint;
		}
		
		//    
		ksAPI7::IDimensionTextPtr dimText( dim );
		
		if ( dimText )
		{
			//    - 
			dimText->Sign = 1;
			// 
			dimText->Underline = TRUE;
			
			//     
			ksAPI7::ITextLinePtr suffix( dimText->Suffix );
			
			//   
			if ( suffix )
				suffix->Str = (LPTSTR)(LPCTSTR)LoadStr( IDS_UNIT );
		}
	}
}


//-------------------------------------------------------------------------------
//   
// ---
void EditDiametralDimension( ksAPI7::IDiametralDimensionPtr & dim )
{
	if ( dim )
	{
		//   -    
		dim->DimensionType = FALSE;
		//    
		dim->Angle = 90;
		//     
		ChangeDiametralDimensionParamText( dim );
		//  
		dim->Update();
	}
}


//-------------------------------------------------------------------------------
//     
// ---
void DiamrtralDimensionWork( ksAPI7::IKompasDocument2DPtr & doc )
{
	//    
	ksAPI7::ISymbols2DContainerPtr symbCont( GetSymbols2DContainer(doc) );

	if ( symbCont )
	{
		//    
		ksAPI7::IDiametralDimensionsPtr diamCol( symbCont->GetDiametralDimensions() );
		
		if ( diamCol )
		{
			//     
			ksAPI7::IDiametralDimensionPtr diamDim( diamCol->Add() );
			
			if ( diamDim )
			{
				//   
				CreateDiamrtralDimension( diamDim );
				//   
				reference dimRef = diamDim->Reference;
				
				if ( YesNoT((LPTSTR)(LPCTSTR)LoadStr(IDS_EDIT)) )
				{
					_variant_t index = (long)dimRef;
					//      
					ksAPI7::IDiametralDimensionPtr diamDimension( diamCol->GetDiametralDimension( index ) );
					//   
					EditDiametralDimension( diamDimension );
				}
			}
		}
	}
}


//-------------------------------------------------------------------------------
//   
// ---
void CreateAngleDimension( ksAPI7::IAngleDimensionPtr & dim )
{
	if ( dim )
	{
		//    ,   
	/*	//     
		RequestInfoT info;
		memset( &info, 0, sizeof(info) );
		info.commands = (LPTSTR)IDS_COMMAND3;
		double x, y;
		
		//      
		if ( CursorExT(&info, &x, &y, NULL, NULL) )
		{
			//     
			reference pObj1 = FindObj( x, y, 1 );
			//    
			long type1 = GetObjParam( pObj1, 0, 0, 0 );

			if ( type1 == LINESEG_OBJ || type1 == POLYLINE_OBJ || type1 == RECTANGLE_OBJ )
			{
				//   
				LightObj( pObj1, 1 );
				info.commands = (LPTSTR)IDS_COMMAND4;
				
				//      
				if ( CursorExT(&info, &x, &y, NULL, NULL) )
				{
					//     
					reference pObj2 = FindObj( x, y, 1 );
					//    
					long type2 = GetObjParam( pObj2, 0, 0, 0 );

					if ( type1 == LINESEG_OBJ || type1 == POLYLINE_OBJ || type1 == RECTANGLE_OBJ )
					{
						//   
						LightObj( pObj2, 1 );
						//      
						ksAPI7::IDrawingObjectPtr baseObj1( IUnknownPtr(ksTransferReference(pObj1, ksGetCurrentDocument(0))), false );
						ksAPI7::IDrawingObjectPtr baseObj2( IUnknownPtr(ksTransferReference(pObj2, ksGetCurrentDocument(0))), false );

						if ( (bool)baseObj1 && (bool)baseObj2 )
						{
							//    
							dim->BaseObject1 = baseObj1;
							dim->BaseObject2 = baseObj2;
							//  
							dim->Radius = 20;
							//  
							dim->Update();
							//   
							LightObj( pObj2, 0 );
						}
						else
							MessageT( (LPTSTR)(LPCTSTR)LoadStr(IDS_NOOBJS) );
						
						//   
						LightObj( pObj1, 0 );
					}
					else
						MessageT( (LPTSTR)(LPCTSTR)LoadStr(IDS_NOTCREATE3) );
				}
			}
			else
				MessageT( _T("      .") );
		}*/
		
		//     		
		//    
		reference line1 = LineSeg( 80, 120, 100, 120, 1 );
		ksAPI7::IDrawingObjectPtr baseObj1 = IUnknownPtr( ksTransferReference(line1, ksGetCurrentDocument(0)), false/*AddRef*/ );
		//    
		reference line2 = LineSeg( 80, 120, 120, 160, 1 );
		ksAPI7::IDrawingObjectPtr baseObj2 = IUnknownPtr( ksTransferReference(line2, ksGetCurrentDocument(0)),false/*AddRef*/ );
		
		if ( (bool)baseObj1 && (bool)baseObj2 )
		{
			//   
			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;
			
			//  
			ksAPI7::IDimensionParamsPtr dimPar( dim );
			
			if ( dimPar )
				//   - 
				dimPar->ShelfDirection = ksLSRight;
					
			//   
			dim->ShelfX = 160;
			dim->ShelfY = 140;
			//    -   
			dim->Direction = FALSE;
			//      
			dim->X3 = 140;
			dim->Y3 = 120;
			//  
			dim->Update();
		}	
	}
}


//-------------------------------------------------------------------------------
//   
// ---
void EditAngleDimension( ksAPI7::IAngleDimensionPtr & dim )
{
	if (dim )
	{
		//   -   () 
		dim->DimensionType = ksADMaxAngle;
		//     -   
		dim->Direction = TRUE;
		//   
		dim->ShelfX = 150;
		dim->ShelfY = 170;
		//  
		dim->Radius = 40;
		//  
		dim->Update();
	}
}


//-------------------------------------------------------------------------------
//     
// ---
void AngleDimensionWork( ksAPI7::IKompasDocument2DPtr & doc )
{
	//    
	ksAPI7::ISymbols2DContainerPtr symbCont( GetSymbols2DContainer(doc) );
	
	if ( symbCont )
	{
		//    
		ksAPI7::IAngleDimensionsPtr angCol( symbCont->GetAngleDimensions() );
		
		if ( angCol )
		{
			//     
			ksAPI7::IAngleDimensionPtr angDim( angCol->Add(ksDrADimension) );
			
			if ( angDim )
			{
				//   
				CreateAngleDimension( angDim );
				//   
				reference dimRef = angDim->Reference;
				
				if ( YesNoT((LPTSTR)(LPCTSTR)LoadStr(IDS_EDIT)) )
				{
					_variant_t index = (long)dimRef;
					//      
					ksAPI7::IAngleDimensionPtr angDimension( angCol->GetAngleDimension( index ) );
					//   
					EditAngleDimension( angDimension );
				}
			}
		}
	}
}


//-------------------------------------------------------------------------------
//    
// ---
void CreateArcDimension( ksAPI7::IArcDimensionPtr & dim )
{
	if ( dim )
	{
		//     
		RequestInfoT info;
		memset( &info, 0, sizeof(info) );
		info.commands = (LPTSTR)IDS_COMMAND5;
		double x, y;
		
		//    
		if ( CursorExT(&info, &x, &y, NULL, NULL) )
		{
			//     
			reference pObj = FindObj( x, y, 1 );
			//   
			LightObj( pObj, 1 );
			//   
			ArcParam1 par;
			
			//    
			if ( GetObjParam(pObj, &par, sizeof(par), POINT_ARC_PARAM ) == ARC_OBJ )
			{
				//      
				ksAPI7::IDrawingObjectPtr arc( IUnknownPtr(ksTransferReference(pObj, ksGetCurrentDocument(0)), false/*AddRef*/) );
				
				if ( arc )
				{
					//  
					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;
					
					info.commands = (LPTSTR)IDS_COMMAND6;					
					//    
					if ( CursorExT(&info, &x, &y, NULL, NULL) )
					{
						dim->X3 = x;
						dim->Y3 = y;
					}

					//   
					dim->Direction = TRUE;
					//   -   
					dim->DimensionType = FALSE;
					//     
					dim->TextPointer = TRUE;
					//  
					dim->Update();
				}
				else
					MessageT( (LPTSTR)(LPCTSTR)LoadStr(IDS_NOOBJ) );
			}
			else
				MessageT( (LPTSTR)(LPCTSTR)LoadStr(IDS_NOTCREATE4) );

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


//-------------------------------------------------------------------------------
//    
// ---
void EditArcDimension( ksAPI7::IArcDimensionPtr & dim )
{
	if ( dim )
	{
		//   -    
		dim->DimensionType = TRUE;
		//     
		dim->TextPointer = FALSE;
		//    -   
		dim->Direction = !dim->Direction;

		//    
		ksAPI7::IDimensionParamsPtr dimPar( dim );

		if ( dimPar )
		{
			//  
			dimPar->ArrowType1 = ksLeaderPoint;
			dimPar->ArrowType2 = ksLeaderPoint;
			//   - 
			dimPar->ShelfDirection = ksLSDown;
			//   
			dimPar->ShelfAngle = 180;
		}

		dim->Update();

		//    
		ksAPI7::IDimensionTextPtr dimText( dim );

		if ( dimText )
		{
			//     
			dimText->AutoNominalValue = FALSE;
			//    
			dimText->NominalValue = 50;
			
			//     
			ksAPI7::ITextLinePtr unit( dimText->Unit );
			
			//   
			if ( unit )
				unit->Str = (LPTSTR)(LPCTSTR)LoadStr( IDS_UNIT2 );
		}
		//  
		dim->Update();
	}
}


//-------------------------------------------------------------------------------
//      
// ---
void ArcDimensionWork( ksAPI7::IKompasDocument2DPtr & doc )
{
	//    
	ksAPI7::ISymbols2DContainerPtr symbCont( GetSymbols2DContainer(doc) );
	
	if ( symbCont )
	{
		//     
		ksAPI7::IArcDimensionsPtr arcCol( symbCont->GetArcDimensions() );
		
		if ( arcCol )
		{
			//      
			ksAPI7::IArcDimensionPtr arcDim( arcCol->Add() );
			
			if ( arcDim )
			{
				//    
				CreateArcDimension( arcDim );
				//   
				reference dimRef = arcDim->Reference;
				
				if ( YesNoT((LPTSTR)(LPCTSTR)LoadStr(IDS_EDIT)) )
				{
					_variant_t index = (long)dimRef;
					//      
					ksAPI7::IArcDimensionPtr arcDimension( arcCol->GetArcDimension( index ) );
					//    
					EditArcDimension( arcDimension );
				}
			}
		}
	}	
}


//-------------------------------------------------------------------------------
//     
// ---
void CreateBreakLineDim( ksAPI7::IBreakLineDimensionPtr & dim )
{
	if ( dim )
	{
		//     
		RequestInfoT info;
		memset( &info, 0, sizeof(info) );
		info.commands = (LPTSTR)IDS_COMMAND7;
		double x, y;
		
		//    
		if ( CursorExT(&info, &x, &y, NULL, NULL) )
		{
			//     
			reference pObj = FindObj( x, y, ksGetCursorLimit() );
			//   
			LineSegParam par;
			
			//    
			if ( GetObjParam(pObj, &par, sizeof(par), ALLPARAM_T ) == LINESEG_OBJ )
			{
				//   
				LightObj( pObj, 1 );
				//      
				ksAPI7::IDrawingObjectPtr lineSeg( IUnknownPtr(ksTransferReference(pObj, ksGetCurrentDocument(0)), false/*AddRef*/) );
				
				if ( lineSeg )
				{
					//  
					dim->BaseObject = lineSeg;
					info.commands = (LPTSTR)IDS_COMMAND6;					
					
					//    
					if ( CursorExT(&info, &x, &y, NULL, NULL) )
					{
						//     -    
						dim->X1 = par.x1;
						dim->Y1 = par.y1;
						//     -    
						dim->X2 = par.x2;
						dim->Y2 = par.y2;
						//    -  
						dim->X3 = x;
						dim->Y3 = y;
					}
					//  
					dim->Update();
				}
				else
					MessageT( (LPTSTR)(LPCTSTR)LoadStr(IDS_NOOBJ) );
			}
			else
				MessageT( (LPTSTR)(LPCTSTR)LoadStr(IDS_NOTCREATE5) );
			
			//   
			LightObj( pObj, 0 );
		}
	}	
}


//-------------------------------------------------------------------------------
//     
// ---
void EditBreakLineDim( ksAPI7::IBreakLineDimensionPtr & dim )
{
	if ( dim )
	{
		//    
		ksAPI7::IDimensionParamsPtr dimPar( dim );

		if ( dimPar )
		{
			//  			
			dimPar->ArrowType1 = ksLeftNotch;
		}

		//    
		ksAPI7::IDimensionTextPtr dimText( dim );

		if ( dimText )
		{
			//    
			ksAPI7::ITextLinePtr prefix = dimText->Prefix;

			if ( prefix )
				//  
				prefix->Str = (LPTSTR)(LPCTSTR)LoadStr( IDS_DIM );

			//    
			ksAPI7::ITextLinePtr nominal = dimText->NominalText;
			
			if ( nominal )
				//  
				nominal->Str = (LPTSTR)(LPCTSTR)LoadStr( IDS_NOMINAL );
		}
		//  
		dim->Update();
	}
}


//-------------------------------------------------------------------------------
//       
// ---
void BreakLineDimensionWork( ksAPI7::IKompasDocument2DPtr & doc )
{
	//    
	ksAPI7::ISymbols2DContainerPtr symbCont( GetSymbols2DContainer(doc) );
	
	if ( symbCont )
	{
		//      
		ksAPI7::IBreakLineDimensionsPtr breakCol( symbCont->GetBreakLineDimensions() );
		
		if ( breakCol )
		{
			//       
			ksAPI7::IBreakLineDimensionPtr breakDim( breakCol->Add() );
			
			if ( breakDim )
			{
				//     
				CreateBreakLineDim( breakDim );
				//   
				reference dimRef = breakDim->Reference;
				
				if ( YesNoT((LPTSTR)(LPCTSTR)LoadStr(IDS_EDIT)) )
				{
					_variant_t index = (long)dimRef;
					//      
					ksAPI7::IBreakLineDimensionPtr breakDimension( breakCol->GetBreakLineDimension( index ) );
					//     
					EditBreakLineDim( breakDimension );
				}
			}
		}
	}	
}


//-------------------------------------------------------------------------------
//     
// ---
void CreateBreakRadialDim( ksAPI7::IBreakRadialDimensionPtr & dim )
{
	if ( dim )
	{
		//     
		RequestInfoT info;
		memset( &info, 0, sizeof(info) );
		info.commands = (LPTSTR)IDS_COMMAND2;
		double x, y;
		
		//    
		if ( CursorExT(&info, &x, &y, NULL, NULL) )
		{
			//     
			reference pObj = FindObj( x, y, ksGetCursorLimit() );
			//   
			CircleParam par;
			
			//    
			if ( GetObjParam(pObj, &par, sizeof(par), ALLPARAM_T ) == CIRCLE_OBJ )
			{
				//      
				ksAPI7::IDrawingObjectPtr circle( IUnknownPtr(ksTransferReference(pObj, ksGetCurrentDocument(0)), false/*AddRef*/) );
				
				if ( circle )
				{
					//    
					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();
				}
				else
					MessageT( (LPTSTR)(LPCTSTR)LoadStr(IDS_NOOBJ) );
			}
			else
				MessageT( (LPTSTR)(LPCTSTR)LoadStr(IDS_NOTCREATE1) );
		} 
	}
}


//-------------------------------------------------------------------------------
//     
// ---
void EditBreakRadialDim( ksAPI7::IBreakRadialDimensionPtr & dim )
{
	if ( dim )
	{
		//    
		dim->Angle = 90;
		//  
		dim->BreakLength = 1;
		//   
		dim->TextOnLine = ksDimTextParallelInCut;
	
		//    
		ksAPI7::IDimensionTextPtr dimText( dim );

		if ( dimText )
		{
			//   
			dimText->Sign = 0;
		}
		//  
		dim->Update();
	}
}


//-------------------------------------------------------------------------------
//       
// ---
void BreakRadialDimensionWork( ksAPI7::IKompasDocument2DPtr & doc )
{
	//    
	ksAPI7::ISymbols2DContainerPtr symbCont( GetSymbols2DContainer(doc) );
	
	if ( symbCont )
	{
		//      
		ksAPI7::IBreakRadialDimensionsPtr breakCol( symbCont->GetBreakRadialDimensions() );
		
		if ( breakCol )
		{
			//       
			ksAPI7::IBreakRadialDimensionPtr breakDim( breakCol->Add() );
			
			if ( breakDim )
			{
				//     
				CreateBreakRadialDim( breakDim );
				//   
				reference dimRef = breakDim->Reference;
				
				if ( YesNoT((LPTSTR)(LPCTSTR)LoadStr(IDS_EDIT)) )
				{
					_variant_t index = (long)dimRef;
					//      
					ksAPI7::IBreakRadialDimensionPtr breakDimension( breakCol->GetBreakRadialDimension( index ) );
					//     
					EditBreakRadialDim( breakDimension );
				}
			}
		}
	}		
}


//-------------------------------------------------------------------------------
//     
// ---
void CreateBreakAngleDim( ksAPI7::IBreakAngleDimensionPtr & dim )
{
	if ( dim )
	{
		//    
		reference line1 = LineSeg( 80, 120, 120, 160, 1 );
		ksAPI7::IDrawingObjectPtr baseObj1 = IUnknownPtr( ksTransferReference(line1, ksGetCurrentDocument(0)), false/*AddRef*/ );
		//    
		reference line2 = LineSeg( 80, 120, 100, 120, 1 );
		ksAPI7::IDrawingObjectPtr baseObj2 = IUnknownPtr( ksTransferReference(line2, ksGetCurrentDocument(0)),false/*AddRef*/ );
		
		if ( (bool)baseObj1 && (bool)baseObj2 )
		{
			//   
			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();
		}	
	}
}


//-------------------------------------------------------------------------------
//     
// ---
void EditBreakAngleDim( ksAPI7::IBreakAngleDimensionPtr & dim )
{
	if ( dim )
	{
		//  
		ksAPI7::IDimensionParamsPtr dimPar( dim );
		
		if ( dimPar )
			//   - 
			dimPar->ShelfDirection = ksLSRight;
		
		//   
		dim->ShelfX = 167;
		dim->ShelfY = 177;

		//    
		ksAPI7::IDimensionTextPtr dimText( dim );

		if ( dimText )
		{
			//   
			dimText->TextAlign = ksDimALowerBoundary;
			//    
			dimText->Brackets = ksDimBrackets;
		}
		//  
		dim->Update();
	}
}


//-------------------------------------------------------------------------------
//       
// ---
void BreakAngleDimensionWork( ksAPI7::IKompasDocument2DPtr & doc )
{
	//    
	ksAPI7::ISymbols2DContainerPtr symbCont( GetSymbols2DContainer(doc) );
	
	if ( symbCont )
	{
		//      
		ksAPI7::IAngleDimensionsPtr breakCol( symbCont->GetAngleDimensions() );
		
		if ( breakCol )
		{
			//       
			ksAPI7::IBreakAngleDimensionPtr breakDim( breakCol->Add(ksDrABreakDimension) );
			
			if ( breakDim )
			{
				//     
				CreateBreakAngleDim( breakDim );
				//   
				reference dimRef = breakDim->Reference;
				
				if ( YesNoT((LPTSTR)(LPCTSTR)LoadStr(IDS_EDIT)) )
				{
					_variant_t index = (long)dimRef;
					//      
					ksAPI7::IBreakAngleDimensionPtr breakDimension( breakCol->GetAngleDimension( index ) );
					//     
					EditBreakAngleDim( breakDimension );
				}
			}
		}
	}	
}


//-------------------------------------------------------------------------------
//   
// ---
void CreateHeightDimension( ksAPI7::IHeightDimensionPtr & dim )
{
	if ( dim )
	{
		//     
		RequestInfoT info;
		memset( &info, 0, sizeof(info) );
		info.commands = (LPTSTR)IDS_COMMAND8;
		double x, y;
		
		//    
		if ( CursorExT(&info, &x, &y, NULL, NULL) )
		{
			info.commands = (LPTSTR)IDS_COMMAND9;
			double x1, y1;

			//    
			if ( CursorExT(&info, &x1, &y1, NULL, NULL) )
			{
				info.commands = (LPTSTR)IDS_COMMAND10;
				double x2, y2;
				
				//    
				if ( CursorExT(&info, &x2, &y2, NULL, NULL) )
				{
					//   
					dim->X = x;
					dim->Y = y;
					//   
					dim->X1 = x1;
					dim->Y1 = y1;
					//   
					dim->X2 = x2;
					dim->Y2 = y2;
					//  
					dim->Update();
				}
			}
		}
	}
}


//-------------------------------------------------------------------------------
//   
// ---
void EditHeightDimension( ksAPI7::IHeightDimensionPtr & dim )
{
	if ( dim )
	{
		//  
		dim->DimensionType = ksHDTopViewLeader;

		//    
		ksAPI7::IDimensionTextPtr dimText( dim );

		if ( dimText )
		{
			//   - 
			dimText->Sign = 2;
			//    
			ksAPI7::ITextLinePtr nominal = dimText->NominalText;
			
			if ( nominal )
				//  
				nominal->Str = (LPTSTR)(LPCTSTR)LoadStr( IDS_NOMINAL );
		}
		//  
		dim->Update();
	}
}


//-------------------------------------------------------------------------------
//     
// ---
void HeightDimensionWork( ksAPI7::IKompasDocument2DPtr & doc )
{
	//    
	ksAPI7::ISymbols2DContainerPtr symbCont( GetSymbols2DContainer(doc) );
	
	if ( symbCont )
	{
		//    
		ksAPI7::IHeightDimensionsPtr heightCol( symbCont->GetHeightDimensions() );
		
		if ( heightCol )
		{
			//     
			ksAPI7::IHeightDimensionPtr heightDim( heightCol->Add() );
			
			if ( heightDim )
			{
				//   
				CreateHeightDimension( heightDim );
				//   
				reference dimRef = heightDim->Reference;
				
				if ( YesNoT((LPTSTR)(LPCTSTR)LoadStr(IDS_EDIT)) )
				{
					_variant_t index = (long)dimRef;
					//      
					ksAPI7::IHeightDimensionPtr heightDimension( heightCol->GetHeightDimension( index ) );
					//   
					EditHeightDimension( heightDimension );
				}
			}
		}
	}	
}


//-------------------------------------------------------------------------------
//  
// ---
void OnProcessDetach()
{
  newKompasAPI = NULL;
}


//------------------------------------------------------------------------------
//    
// ---
CString LoadStr( int strID ) 
{
	TCHAR temp[_MAX_PATH];
	LoadString( Step2_API7_2DDLL.hModule, strID, temp, _MAX_PATH ); 
	return temp;
}


