////////////////////////////////////////////////////////////////////////////////
//
// Step3_API7_2D.cpp -  2D
//
// 	1:	LeaderWork( doc );				-      
// 	2:	MarkLeaderWork( doc );		-     
// 	3:	ChangeLeaderWork( doc );	-     
// 	4:	BrandLeaderWork( doc );		-     
// 	5:	RoughWork( doc );					-     
// 	6:	BaseWork( doc );					-     
// 	7:	CutLineWork( doc );				-     /
// 	8:	ViewPointerWork( doc );		-      
// 	9:	ToleranceWork( doc );			-     
// 	10:	ObjectsNavigation( doc );	-    
//
////////////////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include <afxdllx.h>
#include "Step3_API7_2D.h"

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


//-------------------------------------------------------------------------------
//       DLL
// ---
static AFX_EXTENSION_MODULE Step3_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("STEP3_API7_2D.AWX Initializing!\n");

		AfxInitExtensionModule(Step3_API7_2DDLL, hInstance);

		new CDynLinkLibrary(Step3_API7_2DDLL);
	}
	else if (dwReason == DLL_PROCESS_DETACH)
	{
		TRACE0("STEP3_API7_2D.AWX Terminating!\n");
    OnProcessDetach();
		AfxTermExtensionModule(Step3_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 );  
      }
    }
  }
}

//-------------------------------------------------------------------------------
//  
// ---
void LeaderWork( ksAPI7::IKompasDocument2DPtr & doc );
void MarkLeaderWork( ksAPI7::IKompasDocument2DPtr & doc );
void ChangeLeaderWork( ksAPI7::IKompasDocument2DPtr & doc );
void BrandLeaderWork( ksAPI7::IKompasDocument2DPtr & doc );
void RoughWork( ksAPI7::IKompasDocument2DPtr & doc );
void BaseWork( ksAPI7::IKompasDocument2DPtr & doc );
void CutLineWork( ksAPI7::IKompasDocument2DPtr & doc );
void ViewPointerWork( ksAPI7::IKompasDocument2DPtr & doc );
void ToleranceWork( ksAPI7::IKompasDocument2DPtr & doc );
void ObjectsNavigation( ksAPI7::IKompasDocument2DPtr & doc );


//-------------------------------------------------------------------------------
//   
// ---
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 WINAPI LIBRARYENTRY( unsigned int comm )
{
	//   
	ksAPI7::IKompasDocument2DPtr doc( GetCurrentDocument() );
	
	if ( doc )
	{
		switch ( comm )
		{
			case 1:		LeaderWork( doc );				break;	//      
			case 2:		MarkLeaderWork( doc );		break;	//     
			case 3:		ChangeLeaderWork( doc );	break;	//     
			case 4:		BrandLeaderWork( doc );		break;	//     
			case 5:		RoughWork( doc );					break;	//     
			case 6:		BaseWork( doc );					break;	//     
			case 7:		CutLineWork( doc );				break;	//     /
			case 8:		ViewPointerWork( doc );		break;	//      
			case 9:		ToleranceWork( doc );			break;	//     
			case 10:	ObjectsNavigation( 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;
}


//-------------------------------------------------------------------------------
//   SAFEARRAY  double
// ---
bool NewSafeArray( double * dv, int count, _variant_t & buf )
{
  bool res = false;
  SAFEARRAYBOUND sabNewArray;
	
  sabNewArray.cElements = count;
  sabNewArray.lLbound = 0;
	
  SAFEARRAY * pSafe = ::SafeArrayCreate( VT_R8, 1, &sabNewArray );
	
  if( pSafe )
  {
    for ( long i = 0; i < count; i++ )
    {
      HRESULT  hr = ::SafeArrayPutElement( pSafe, (long*)&i, (void*)&dv[i] );
			
      if ( FAILED(hr) ) 
        break;
    }
		
    V_VT(&buf) = VT_ARRAY | VT_R8;
    V_ARRAY(&buf) = pSafe;
    res = true;
  }
  return res;
}


//-------------------------------------------------------------------------------
//    
// ---
void CreateLeader( ksAPI7::ILeaderPtr & leader )
{
	if ( leader )
	{
		//   - 
		leader->ShelfDirection = ksLSRight;

		//   
		ksAPI7::IBranchsPtr branchs( leader );

		if ( branchs )
		{
			//      
			branchs->X0 = 100;
			branchs->Y0 = 150;
			//   
			branchs->AddBranchByPoint( -1, 60, 120 );
			branchs->AddBranchByPoint( -1, 65, 105 );
		}

		//     
		ksAPI7::ITextPtr txtOnSh( leader->TextOnShelf );

		if ( txtOnSh )
			//  
			txtOnSh->Str = _T("1");

		//     
		ksAPI7::ITextPtr txtUnderSh( leader->TextUnderShelf );

		if ( txtUnderSh )
			//  
			txtUnderSh->Str = _T("2");

		//     
		ksAPI7::ITextPtr txtOnBr( leader->TextOnBranch );
		
		if ( txtOnBr )
			//  
			txtOnBr->Str = _T("3");

		//     
		ksAPI7::ITextPtr txtUnderBr( leader->TextUnderBranch );
		
		if ( txtUnderBr )
			//  
			txtUnderBr->Str = _T("4");

		//     
		ksAPI7::ITextPtr txtAfterSh( leader->TextAfterShelf );
		
		if ( txtAfterSh )
			//  
			txtAfterSh->Str = _T("5");

		ksAPI7::IBaseLeaderPtr baseLeader( leader );

		if ( baseLeader )
			//  
			baseLeader->Update();
	}
}


//-------------------------------------------------------------------------------
//   
// ---
void AddTextItem( ksAPI7::ITextLinePtr & line, _bstr_t str, ksTextItemEnum type )
{
	if ( line )
	{
		//    
		ksAPI7::ITextItemPtr item( line->Add() );
		
		if ( item )
		{
			//   
			item->Str = str;
			//  
			item->ItemType = type;
			//  
			item->Update();
		}
	}
}


//-------------------------------------------------------------------------------
//   
// ---
void EditLeader( ksAPI7::ILeaderPtr & leader )
{
	if ( leader )
	{
		//   -  
		leader->SignType = ksLGlueSign;
		//     
		leader->Arround = TRUE;

		//   
		ksAPI7::IBranchsPtr branchs( leader );
		
		if ( branchs )
			//   
			branchs->AddBranchByPoint( -1, 140, 120 );

		//    -   
		leader->BranchBegin[2] = FALSE;

		//    
		ksAPI7::ITextPtr txt( leader->TextOnShelf );

		if ( txt )
		{
			txt->Str = _T("");

			ksAPI7::ITextLinePtr line( txt->Add() );

			if ( line )
			{
				//  
				AddTextItem( line, _T("1"), ksTItString );
				//   
				AddTextItem( line, _T("1"), ksTItNumerator );
				//   
				AddTextItem( line, _T("1"), ksTItDenominator );
				//  
				AddTextItem( line, _T("1"), ksTItFractionEnd );
			}
		}

		ksAPI7::IBaseLeaderPtr baseLeader( leader );
		
		if ( baseLeader )
			//  
			baseLeader->Update();
	}
}


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

	if ( symbCont )
	{
		//    
		ksAPI7::ILeadersPtr leadersCol( symbCont->GetLeaders() );

		if ( leadersCol )
		{
			//    
			ksAPI7::ILeaderPtr leader( leadersCol->Add(ksDrLeader) );

			if ( leader )
			{
				//   
				CreateLeader( leader );

				//   
				ksAPI7::IBaseLeaderPtr bLeader( leader );
				reference refr = 0;

				if ( bLeader )
					refr = bLeader->Reference; 
				
				//   
				LightObj( refr, 1/* */ );

				if ( YesNoT((LPTSTR)(LPCTSTR)LoadStr(IDS_EDIT)) == 1 )
				{		
					_variant_t index = (long)refr;
					//      
					ksAPI7::ILeaderPtr lead( leadersCol->GetLeader( index ) );				
					//   
					EditLeader( lead );
				}
				LightObj( refr, 0/* */ );
			}
		}
	}
}


//-------------------------------------------------------------------------------
//   
// ---
void CreateMarkLeader( ksAPI7::IMarkLeaderPtr & markLeader )
{
	if ( markLeader )
	{
		//   
		ksAPI7::IBranchsPtr branchs( markLeader );
		
		if ( branchs )
		{
			//   
			branchs->X0 = 100;
			branchs->Y0 = 190;
			//   
			branchs->AddBranchByPoint( -1, 60, 120 );
		}

		//    
		ksAPI7::ITextPtr des( markLeader->Designation );

		if ( des )
			//  
			des->Str = (LPTSTR)(LPCTSTR)LoadStr( IDS_MARK );

		//     
		ksAPI7::ITextPtr textOnBranch( markLeader->TextOnBranch );

		if ( textOnBranch )
			//  
			textOnBranch->Str = _T("2");

		//     
		ksAPI7::ITextPtr textUnderBranch( markLeader->TextUnderBranch );
		
		if ( textUnderBranch )
			//  
			textUnderBranch->Str = _T("3");

		//     
		ksAPI7::IBaseLeaderPtr baseLeader( markLeader );

		if ( baseLeader )
			//  
			baseLeader->Update();
	}
}


//-------------------------------------------------------------------------------
//   
// ---
void EditMarkLeader( ksAPI7::IMarkLeaderPtr & markLeader )
{
	if ( markLeader )
	{
		//   
		ksAPI7::IBranchsPtr branchs( markLeader );

		if ( branchs )
			//   
			branchs->AddBranchByPoint( -1, 70, 110 );

		//     
		ksAPI7::IBaseLeaderPtr baseLeader( markLeader );

		if ( baseLeader )
		{
			//  
			baseLeader->ArrowType = ksLeaderArrow;
			//  
			baseLeader->Update();
		}
	}
}


//-------------------------------------------------------------------------------
//     
// ---
void MarkLeaderWork( ksAPI7::IKompasDocument2DPtr & doc )
{
	//    
	ksAPI7::ISymbols2DContainerPtr symbCont( GetSymbols2DContainer(doc) );
	
	if ( symbCont )
	{
		//    
		ksAPI7::ILeadersPtr leadersCol( symbCont->GetLeaders() );
		
		if ( leadersCol )
		{
			//   
			ksAPI7::IMarkLeaderPtr mLeader( leadersCol->Add(ksDrMarkerLeader) );
			
			if ( mLeader )
			{
				//   
				CreateMarkLeader( mLeader );
				
				//   
				ksAPI7::IBaseLeaderPtr bLeader( mLeader );
				reference refr = 0;
				
				if ( bLeader )
					refr = bLeader->Reference;
				
				//   
				LightObj( refr, 1/* */ );
				
				if ( YesNoT((LPTSTR)(LPCTSTR)LoadStr(IDS_EDIT)) == 1 )
				{
					_variant_t index = (long)refr;
					//      
					ksAPI7::IMarkLeaderPtr markLead( leadersCol->GetLeader( index ) );				
					//   
					EditMarkLeader( markLead );
				}
				LightObj( refr, 0/* */ );
			}
		}
	}
}


//-------------------------------------------------------------------------------
//   
// ---
void CreateChangeLeader( ksAPI7::IChangeLeaderPtr & changeLeader )
{
	if ( changeLeader )
	{
		//   - 
		changeLeader->SignType = ksCLSSquare;

		//   
		ksAPI7::IBranchsPtr branchs( changeLeader );

		if ( branchs )
		{
			//  
			branchs->X0 = 70;
			branchs->Y0 = 150;
			//  
			branchs->AddBranchByPoint( -1, 40, 130 );
		}

		//    
		ksAPI7::ITextPtr des( changeLeader->Designation );
		
		if ( des )
			//  
			des->Str = _T("1");

		//     
		ksAPI7::IBaseLeaderPtr baseLeader( changeLeader );

		if ( baseLeader )
			//  
			baseLeader->Update();
	}
}


//-------------------------------------------------------------------------------
//   
// ---
void EditChangeLeader( ksAPI7::IChangeLeaderPtr & changeLeader )
{
	if ( changeLeader )
	{
		//   - 
		changeLeader->SignType = ksCLSCircle;
		//    
		changeLeader->FullLeaderLength = FALSE;
		//  
		changeLeader->LeaderLength = 5;

		//     
		ksAPI7::IBaseLeaderPtr baseLeader( changeLeader );
		
		if ( baseLeader )
			//  
			baseLeader->Update();
	}
}


//-------------------------------------------------------------------------------
//     
// ---
void ChangeLeaderWork( ksAPI7::IKompasDocument2DPtr & doc )
{
	//    
	ksAPI7::ISymbols2DContainerPtr symbCont( GetSymbols2DContainer(doc) );
	
	if ( symbCont )
	{
		//    
		ksAPI7::ILeadersPtr leadersCol( symbCont->GetLeaders() );
		
		if ( leadersCol )
		{
			//   
			ksAPI7::IChangeLeaderPtr chLeader( leadersCol->Add(ksDrChangeLeader) );
			
			if ( chLeader )
			{
				//   
				CreateChangeLeader( chLeader );
				
				//   
				ksAPI7::IBaseLeaderPtr bLeader( chLeader );
				reference refr = 0;
				
				if ( bLeader )
					refr = bLeader->Reference;
				
				//   
				LightObj( refr, 1/* */ );
				
				if ( YesNoT((LPTSTR)(LPCTSTR)LoadStr(IDS_EDIT)) )
				{
					_variant_t index = (long)refr;
					//      
					ksAPI7::IChangeLeaderPtr changeLead( leadersCol->GetLeader( index ) );				
					//   
					EditChangeLeader( changeLead );
				}
				LightObj( refr, 0/* */ );
			}
		}
	}
}


//-------------------------------------------------------------------------------
//   
// ---
void CreateBrandLeader( ksAPI7::IBrandLeaderPtr & brandLeader )
{
	if ( brandLeader )
	{
		// 
		brandLeader->Direction = FALSE;

		//    
		ksAPI7::ITextPtr des( brandLeader->Designation );

		if ( des )
			//  
			des->Str = (LPTSTR)(LPCTSTR)LoadStr( IDS_MARK2 );

		//   
		ksAPI7::IBranchsPtr branchs( brandLeader );

		if ( branchs )
		{
			//  
			branchs->X0 = 100;
			branchs->Y0 = 150;
			//  
			branchs->AddBranchByPoint( -1, 60, 110 );
		}

		//     
		ksAPI7::IBaseLeaderPtr baseLeader( brandLeader );
		
		if ( baseLeader )
			//  
			baseLeader->Update();
	}
}


//-------------------------------------------------------------------------------
//   
// ---
void EditBrandLeader( ksAPI7::IBrandLeaderPtr & brandLeader )
{
	if ( brandLeader )
	{
		// 
		brandLeader->Direction = TRUE;

		//     
		ksAPI7::ITextPtr textOn( brandLeader->TextOnBranch );
		
		if ( textOn )
			//  
			textOn->Str = _T("2");
		
		//     
		ksAPI7::ITextPtr textUnder( brandLeader->TextUnderBranch );
		
		if ( textUnder )
			//  
			textUnder->Str = _T("3");

		//    
		ksAPI7::ITextPtr des( brandLeader->Designation );
		
		if ( des )
			//  
			des->Str = (LPTSTR)(LPCTSTR)LoadStr( IDS_MARK3 );

		//     
		ksAPI7::IBaseLeaderPtr baseLeader( brandLeader );
		
		if ( baseLeader )
			//  
			baseLeader->Update();
	}
}


//-------------------------------------------------------------------------------
//     
// ---
void BrandLeaderWork( ksAPI7::IKompasDocument2DPtr & doc )
{
	//    
	ksAPI7::ISymbols2DContainerPtr symbCont( GetSymbols2DContainer(doc) );
	
	if ( symbCont )
	{
		//    
		ksAPI7::ILeadersPtr leadersCol( symbCont->GetLeaders() );
		
		if ( leadersCol )
		{
			//   
			ksAPI7::IBrandLeaderPtr brLeader( leadersCol->Add(ksDrBrandLeader) );
			
			if ( brLeader )
			{
				//   
				CreateBrandLeader( brLeader );
				
				//   
				ksAPI7::IBaseLeaderPtr bLeader( brLeader );
				reference refObj = 0;
				
				if ( bLeader )
					refObj = bLeader->Reference;
				
				//   
				LightObj( refObj, 1/* */ );
				
				if ( YesNoT((LPTSTR)(LPCTSTR)LoadStr(IDS_EDIT)) == 1 )
				{
					_variant_t index = (long)refObj;
					//      
					ksAPI7::IBrandLeaderPtr brandLead( leadersCol->GetLeader( index ) );				
					//   
					EditBrandLeader( brandLead );
				}
				LightObj( refObj, 0/* */ );
			}
		}
	}
}


//-------------------------------------------------------------------------------
//   
// ---
bool CreateRough( ksAPI7::IRoughPtr & rough )
{
	bool res = false;

	if ( rough )
	{
		//     
		RequestInfoT info;
		memset( &info, 0, sizeof(info) );
		info.commands = MAKEINTRESOURCE( IDS_COMMAND1 );
		info.cursor   = MAKEINTRESOURCE( OCR_CATCH    );
		double x, y;

		//  
		SnapOptions sOpt;
		ksGetSysOptions( SNAP_OPTIONS, &sOpt, sizeof(sOpt) );
		sOpt.commonOpt = FALSE;
		ksSetSysOptions( SNAP_OPTIONS, &sOpt, sizeof(sOpt) );

		//   
		if ( CursorExT(&info, &x, &y, NULL, NULL) )
		{
			//     
			reference pObj = FindObj( x, y, ksGetCursorLimit() );
			//  
			LightObj( pObj, 1/* */ );
			//      
			ksAPI7::IDrawingObjectPtr baseObj( IUnknownPtr(ksTransferReference(pObj, ksGetCurrentDocument(0)), false/*AddRef*/) );
			info.commands = MAKEINTRESOURCE( IDS_COMMAND2 );
			info.cursor = 0;

			//   , 
			if ( !sOpt.commonOpt )
			{
				sOpt.commonOpt = TRUE;
				ksSetSysOptions( SNAP_OPTIONS, &sOpt, sizeof(sOpt) );
			}

			//   
			if ( CursorExT(&info, &x, &y, NULL, NULL) )
			{
				if ( baseObj )
					//  
					rough->BaseObject = baseObj;
				//  
				rough->X0 = x;
				rough->Y0 = y;
				
				ksAPI7::IRoughParamsPtr roughPar( rough );

				if ( roughPar )
				{
					roughPar->ShelfDirection = ksLSRight;
					rough->Update();
					//    
					roughPar->ProcessingByContour = TRUE;
					//   
					roughPar->LeaderLength = 20;
					//    
					roughPar->LeaderAngle = 45;

					//     
					ksAPI7::ITextPtr txt1( roughPar->RoughParamText );

					if ( txt1 )
						txt1->Str = _T("1");
					
					//      
					ksAPI7::ITextPtr txt2( roughPar->ProcessText );
					
					if ( txt2 )
						txt2->Str = _T("2");

					//     
					ksAPI7::ITextPtr txt3( roughPar->BaseLengthText );
					
					if ( txt3 )
						txt3->Str = _T("3");
				}

				//  
				rough->Update();
				res = true;
			}
			else
				MessageT( (LPTSTR)(LPCTSTR)LoadStr(IDS_NOPOINT) );

			LightObj( pObj, 0/* */ );
		}
		else
			MessageT( (LPTSTR)(LPCTSTR)LoadStr(IDS_NOOBJ) );

		//   , 
		if ( !sOpt.commonOpt )
		{
			sOpt.commonOpt = TRUE;
			ksSetSysOptions( SNAP_OPTIONS, &sOpt, sizeof(sOpt) );
		}
	}
	return res;
}


//-------------------------------------------------------------------------------
//   
// ---
void EditRough( ksAPI7::IRoughPtr & rough )
{
	if ( rough )
	{
		//    
		ksAPI7::IRoughParamsPtr roughPar( rough );

		if ( roughPar )
		{
			//  
			roughPar->ArrowType = ksWithoutArrow;
			//    
			roughPar->ProcessingByContour = FALSE;
		}
		//  
		rough->Update();
	}
}


//-------------------------------------------------------------------------------
//     
// ---
void RoughWork( ksAPI7::IKompasDocument2DPtr & doc )
{
	//    
	ksAPI7::ISymbols2DContainerPtr symbCont( GetSymbols2DContainer(doc) );
	
	if ( symbCont )
	{
		//    
		ksAPI7::IRoughsPtr roughsCol( symbCont->GetRoughs() );
		
		if ( roughsCol )
		{
			//   
			ksAPI7::IRoughPtr newRough( roughsCol->Add() );
			
			if ( newRough )
			{
				//   
				if ( CreateRough(newRough) )
				{				
					//   
					reference objRef = newRough->Reference;
					//   
					LightObj( objRef, 1/* */ );
					
					if ( YesNoT((LPTSTR)(LPCTSTR)LoadStr(IDS_EDIT)) )
					{
						_variant_t index = (long)objRef;
						//      
						ksAPI7::IRoughPtr rough( roughsCol->GetRough( index ) );				
						//   
						EditRough( rough );
					}
					LightObj( objRef, 0/* */ );
				}
			}
		}
	}
}


//-------------------------------------------------------------------------------
//   
// ---
bool CreateBase( ksAPI7::IBasePtr & base )
{
	bool res = false;

	if ( base )
	{
		//     
		RequestInfoT info;
		memset( &info, 0, sizeof(info) );
		info.commands = MAKEINTRESOURCE( IDS_COMMAND1 );
		info.cursor   = MAKEINTRESOURCE( OCR_CATCH    );
		double x, y;

		//  
		SnapOptions sOpt;
		ksGetSysOptions( SNAP_OPTIONS, &sOpt, sizeof(sOpt) );
		sOpt.commonOpt = FALSE;
		ksSetSysOptions( SNAP_OPTIONS, &sOpt, sizeof(sOpt) );
		
		//   
		if ( CursorExT(&info, &x, &y, NULL, NULL) )
		{
			//     
			reference pObj = FindObj( x, y, ksGetCursorLimit() );
			//  
			LightObj( pObj, 1/* */ );
			//      
			ksAPI7::IDrawingObjectPtr baseObj( IUnknownPtr(ksTransferReference(pObj, ksGetCurrentDocument(0)), false/*AddRef*/) );
			info.commands = MAKEINTRESOURCE( IDS_COMMAND2 );
			info.cursor = 0;

			//   , 
			if ( !sOpt.commonOpt )
			{
				sOpt.commonOpt = TRUE;
				ksSetSysOptions( SNAP_OPTIONS, &sOpt, sizeof(sOpt) );
			}
			
			//   
			if ( CursorExT(&info, &x, &y, NULL, NULL) )
			{
				if ( baseObj )
					//  
					base->BaseObject = baseObj;

				//   
				base->X0 = x;
				base->Y0 = y;
				//   -   
				base->DrawType = TRUE;
				//  
				base->Update();
				res = true;
			}
			else
				MessageT( (LPTSTR)(LPCTSTR)LoadStr(IDS_NOPOINT) );

			LightObj( pObj, 0/* */ );
		}
		else
			MessageT( (LPTSTR)(LPCTSTR)LoadStr(IDS_NOOBJ) );

		//   , 
		if ( !sOpt.commonOpt )
		{
			sOpt.commonOpt = TRUE;
			ksSetSysOptions( SNAP_OPTIONS, &sOpt, sizeof(sOpt) );
		}
	}
	return res;
}


//-------------------------------------------------------------------------------
//   
// ---
void EditBase( ksAPI7::IBasePtr & base )
{
	if ( base )
	{
		//   - 
		base->DrawType = FALSE;
		//  
		base->AutoSorted = FALSE;
		//   
		base->BranchX = base->X0 + 10;
		base->BranchY = base->Y0 + 10;

		//     
		ksAPI7::ITextPtr txt( base->Text );

		if ( txt )
			//  
			txt->Str = _T("B");

		//  
		base->Update();
	}
}


//-------------------------------------------------------------------------------
//     
// ---
void BaseWork( ksAPI7::IKompasDocument2DPtr & doc )
{
	//    
	ksAPI7::ISymbols2DContainerPtr symbCont( GetSymbols2DContainer(doc) );
	
	if ( symbCont )
	{
		//    
		ksAPI7::IBasesPtr basesCol( symbCont->GetBases() );
		
		if ( basesCol )
		{
			//   
			ksAPI7::IBasePtr newBase( basesCol->Add() );
			
			if ( newBase )
			{
				//   
				if ( CreateBase(newBase) )
				{			
					//   
					reference objRef = newBase->Reference;
					//   
					LightObj( objRef, 1/* */ );
					
					if ( YesNoT((LPTSTR)(LPCTSTR)LoadStr(IDS_EDIT)) == 1 )
					{
						_variant_t index = (long)objRef;
						//      
						ksAPI7::IBasePtr base( basesCol->GetBase( index ) );				
						//   
						EditBase( base );
					}
					LightObj( objRef, 0/* */ );
				}
			}
		}
	}
}


//-------------------------------------------------------------------------------
//      
// ---
void SetTextSmallFont( ksAPI7::ITextPtr & txt, _bstr_t str, double size )
{
	if ( txt )
	{
		//    
		ksAPI7::ITextLinePtr line( txt->Add() );

		if ( line )
		{
			//    
			ksAPI7::ITextItemPtr item( line->Add() );

			if ( item )
			{
				//   
				ksAPI7::ITextFontPtr font( item );

				if ( font )
					//   
					font->Height = size;

				//   
				item->Str = str;
				//  
				item->Update();
			}
		}
	}
}


//-------------------------------------------------------------------------------
//   /
// ---
void CreateCutLine( ksAPI7::ICutLinePtr & cutLine )
{
	if ( cutLine )
	{
		//   
		cutLine->X1 = 80;
		cutLine->Y1 = 165;
		//   
		cutLine->X2 = 120;
		cutLine->Y2 = 200;
		//   - 
		cutLine->ArrowPos = TRUE;
		//    -   
		cutLine->AdditionalTextPos = TRUE;

		//     
		double points[4];
		points[0] = 80;
		points[1] = 165;
		points[2] = 120;
		points[3] = 200;
		_variant_t pointsArray;
		
		if ( NewSafeArray(points, 4, pointsArray) )
			//     
			cutLine->Points = pointsArray;


		//    
		ksAPI7::ITextPtr adText( cutLine->AdditionalText );
		
		if ( adText )
			SetTextSmallFont( adText, _T("(1)"), 7 );

		//  
		cutLine->Update();
	}
}


//-------------------------------------------------------------------------------
//   /
// ---
void EditCutLine( ksAPI7::ICutLinePtr & cutLine )
{
	if ( cutLine )
	{
		//   -    
		cutLine->ArrowPos = FALSE;
		//    -   
		cutLine->AdditionalTextPos = FALSE;
		//  
		cutLine->AutoSorted = FALSE;

		//     
		double points[6];
		points[0] = 80;
		points[1] = 165;
		points[2] = 115;
		points[3] = 165;
		points[4] = 120;
		points[5] = 200;
		_variant_t pointsArray;

		if ( NewSafeArray(points, 6, pointsArray) )
			//     
			cutLine->Points = pointsArray;

		//  
		cutLine->Update();
	}
}


//-------------------------------------------------------------------------------
//     /
// ---
void CutLineWork( ksAPI7::IKompasDocument2DPtr & doc )
{
	//    
	ksAPI7::ISymbols2DContainerPtr symbCont( GetSymbols2DContainer(doc) );
	
	if ( symbCont )
	{
		//    /
		ksAPI7::ICutLinesPtr cutCol( symbCont->GetCutLines() );
		
		if ( cutCol )
		{
			//   /
			ksAPI7::ICutLinePtr newCut( cutCol->Add() );
			
			if ( newCut )
			{
				//   /
				CreateCutLine( newCut );
				
				//   
				reference objRef = newCut->Reference;
				//   
				LightObj( objRef, 1/* */ );
				
				if ( YesNoT((LPTSTR)(LPCTSTR)LoadStr(IDS_EDIT)) == 1 )
				{
					_variant_t index = (long)objRef;
					//      
					ksAPI7::ICutLinePtr cutLine( cutCol->GetCutLine( index ) );				
					//   /
					EditCutLine( cutLine );
				}
				LightObj( objRef, 0/* */ );
			}
		}
	}
}


//-------------------------------------------------------------------------------
//    
// ---
void CreateViewPointer( ksAPI7::IViewPointerPtr & viewPointer )
{
	if ( viewPointer )
	{
		//   
		viewPointer->X1 = 100;
		viewPointer->Y1 = 150;
		//   
		viewPointer->X2 = 120;
		viewPointer->Y2 = 160;
		//  
		viewPointer->Update();
	}
}


//-------------------------------------------------------------------------------
//    
// ---
void EditViewPointer( ksAPI7::IViewPointerPtr & viewPointer )
{
	if ( viewPointer )
	{
		//   
		viewPointer->X2 = 90;
		viewPointer->Y2 = 140;
		//  
		viewPointer->AutoSorted = TRUE;

		//      
		ksAPI7::ITextPtr adText( viewPointer->AdditionalText );
		
		if ( adText )
			//  
			SetTextSmallFont( adText, _T("(1)"), 7 );
		
		//  
		viewPointer->Update();
	}
}


//-------------------------------------------------------------------------------
//      
// ---
void ViewPointerWork( ksAPI7::IKompasDocument2DPtr & doc )
{
	//    
	ksAPI7::ISymbols2DContainerPtr symbCont( GetSymbols2DContainer(doc) );
	
	if ( symbCont )
	{
		//     
		ksAPI7::IViewPointersPtr viewPointsCol( symbCont->GetViewPointers() );
		
		if ( viewPointsCol )
		{
			//    
			ksAPI7::IViewPointerPtr newPointer( viewPointsCol->Add() );
			
			if ( newPointer )
			{
				//    
				CreateViewPointer( newPointer );
				
				//   
				reference objRef = newPointer->Reference;
				//   
				LightObj( objRef, 1/* */ );
				
				if ( YesNoT((LPTSTR)(LPCTSTR)LoadStr(IDS_EDIT)) == 1 )
				{
					_variant_t index = (long)objRef;
					//      
					ksAPI7::IViewPointerPtr viewPointer( viewPointsCol->GetViewPointer( index ) );				
					//    
					EditViewPointer( viewPointer );
				}
				LightObj( objRef, 0/* */ );
			}
		}
	}
}


//-------------------------------------------------------------------------------
//      
// ---
void SetToleranceText( ksAPI7::IToleranceParamPtr & tolPar )
{
	if ( tolPar )
	{
		//       
		ksAPI7::ITablePtr tolTable( tolPar->Table );
		
		if ( tolTable )
		{
			//  3  (1  )
			tolTable->AddColumn( -1, TRUE/**/ );
			tolTable->AddColumn( -1, TRUE/**/ );
			tolTable->AddColumn( -1, TRUE/**/ );
			
			//    1- 
			ksAPI7::ITableCellPtr cell( tolTable->GetCell(0, 0) );
			ksAPI7::ITextLinePtr txt = NULL;
			
			if ( cell )
			{
				txt = cell->Text;
				
				if ( txt )
					txt->Str = _T("@22~");
			}
			
			//    2- 
			cell = tolTable->GetCell( 0, 1 );
			
			if ( cell )
			{
				txt = cell->Text;
				
				if ( txt )
					txt->Str = "@2~";
			}

			//    3- 
			cell = tolTable->GetCell( 0, 2 );
			
			if ( cell )
			{
				txt = cell->Text;
				
				if ( txt )
					txt->Str = "B";
			}

			//    4- 
			cell = tolTable->GetCell( 0, 3 );
			
			if ( cell )
			{
				txt = cell->Text;
				
				if ( txt )
					txt->Str = "@30~";
			}
		}
	}
}


//-------------------------------------------------------------------------------
//   
// ---
void CreateTolerance( ksAPI7::ITolerancePtr & tolerance )
{
	if ( tolerance )
	{
		//   
		ksAPI7::IBranchsPtr branchs( tolerance );

		if ( branchs )
		{
			//   
			branchs->X0 = 100;
			branchs->Y0 = 150;
			//  2 
			branchs->AddBranchByPoint( -1, 100, 120 );
			branchs->AddBranchByPoint( -1, 50, 155 );
		}

		//     
		ksAPI7::IToleranceParamPtr tolPar( tolerance );
		
		if ( tolPar )
		{
			//    
			SetToleranceText( tolPar );
			//      -  
			tolPar->BasePointPos = ksTPBottomCenter;
		}
		//   1-  - 
		tolerance->PutArrowType( 0, FALSE );
		//  1-    -  
		tolerance->PutBranchPos( 0, ksTPBottomCenter );
		//   2-  - 
		tolerance->PutArrowType( 1, TRUE );
		//  2-    -  
		tolerance->PutBranchPos( 1, ksTPLeftCenter );
		//  
		tolerance->Update();
	}
}


//-------------------------------------------------------------------------------
//   
// ---
void EditTolerance( ksAPI7::ITolerancePtr & tolerance )
{	
	if ( tolerance )
	{
		//    
		ksAPI7::IToleranceParamPtr tolPar( tolerance );

		if ( tolPar )
		{
			//       
			ksAPI7::ITablePtr tolTable( tolPar->Table );
			
			if ( tolTable )
			{
				//    2- 
				ksAPI7::ITableCellPtr cell( tolTable->GetCell(0, 1) );
				
				if ( cell )
				{
					ksAPI7::ITextLinePtr txt( cell->Text );
					
					if ( txt)
						txt->Str = _T("@2~15");
				}
			}
			//   
			tolPar->Vertical = TRUE;
		}

		//   
		ksAPI7::IBranchsPtr branchs( tolerance );

		if ( branchs )
		{
			//  
			branchs->DeleteBranch( 0 );
			//   
			branchs->AddBranchByPoint( -1, 130, 120 );
		}
		tolerance->PutArrowType( 1, FALSE );
		tolerance->PutBranchPos( 1, ksTPBottomCenter );
		//  
		tolerance->Update();
	}
}


//-------------------------------------------------------------------------------
//     
// ---
void ToleranceWork( ksAPI7::IKompasDocument2DPtr & doc )
{
	//    
	ksAPI7::ISymbols2DContainerPtr symbCont( GetSymbols2DContainer(doc) );
	
	if ( symbCont )
	{
		//    
		ksAPI7::ITolerancesPtr tolerancesCol( symbCont->GetTolerances() );
		
		if ( tolerancesCol )
		{
			//   
			ksAPI7::ITolerancePtr newTol( tolerancesCol->Add() );
			
			if ( newTol )
			{
				//   
				CreateTolerance( newTol );
				
				//   
				reference objRef = newTol->Reference;
				//   
				LightObj( objRef, 1/* */ );
				
				if ( YesNoT((LPTSTR)(LPCTSTR)LoadStr(IDS_EDIT)) == 1 )
				{
					_variant_t index = (long)objRef;
					//      
					ksAPI7::ITolerancePtr tolerance( tolerancesCol->GetTolerance( index ) );				
					//   
					EditTolerance( tolerance );
				}
				LightObj( objRef, 0/* */ );
			}
		}
	}
}


//-------------------------------------------------------------------------------
//    
// ---
ksAPI7::IDrawingContainerPtr GetDrawingContainer( ksAPI7::IKompasDocument2DPtr & doc )
{
	if ( doc )
	{
		//     
		ksAPI7::IViewsAndLayersManagerPtr mng( doc->GetViewsAndLayersManager() );

		if ( mng )
		{
			//   
			ksAPI7::IViewsPtr viewsCol( mng->GetViews() );

			if ( viewsCol )
			{
				//   
				ksAPI7::IViewPtr view = viewsCol->GetActiveView();

				if ( view )
				{
					//    
					ksAPI7::IDrawingContainerPtr drawCont( view );
					return drawCont;
				}
			}
		}
	}
	return NULL;
}


//-------------------------------------------------------------------------------
//       
// ---
void GetLeaderPar( ksAPI7::ILeaderPtr & leader )
{
	if ( leader )
	{
		double x0, y0;

		//    
		ksAPI7::IBranchsPtr branchs( leader );

		if ( branchs )
		{
			x0 = branchs->X0;
			y0 = branchs->Y0;
		}
		TCHAR buf[255];
		TCHAR buf2[255];

		//    
		// "  "
		_tcscpy( buf, (LPTSTR)(LPCTSTR)LoadStr(IDS_LEADER) );
		// "\n :\nX0 = %4.2f, Y0 = %4.2f"
		_stprintf( buf2, (LPTSTR)(LPCTSTR)LoadStr(IDS_POINT), x0, y0 );
		_tcscat( buf, buf2 );
		// "\n   : "
		_tcscat( buf, (LPTSTR)(LPCTSTR)LoadStr(IDS_ARROUND) );

		if ( leader->Arround )
			// ""
			_tcscat( buf, (LPTSTR)(LPCTSTR)LoadStr(IDS_ON) );
		else
			// ""
			_tcscat( buf, (LPTSTR)(LPCTSTR)LoadStr(IDS_OFF) );

		// "\n : "
		_tcscat( buf, (LPTSTR)(LPCTSTR)LoadStr(IDS_BRANCHBEGIN) );

		if ( leader->BranchBegin[0] )
			// "  "
			_tcscat( buf, (LPTSTR)(LPCTSTR)LoadStr(IDS_BEGINSHELF) );
		else
			// "  "
			_tcscat( buf, (LPTSTR)(LPCTSTR)LoadStr(IDS_ENDSHELF) );

		// "\n  : "
		_tcscat( buf, (LPTSTR)(LPCTSTR)LoadStr(IDS_PARALLEL) );

		if ( leader->ParallelBranch )
			// ""
			_tcscat( buf, (LPTSTR)(LPCTSTR)LoadStr(IDS_ON) );
		else
			// ""
			_tcscat( buf, (LPTSTR)(LPCTSTR)LoadStr(IDS_OFF) );
		
		//   
		MessageT( buf );
	}
}


//-------------------------------------------------------------------------------
//      
// ---
void GetMarkLeaderPar( ksAPI7::IMarkLeaderPtr & markLeader )
{
	if ( markLeader )
	{
		double x0, y0;
		long count;
	
		ksAPI7::IBranchsPtr branchs( markLeader );
		
		if ( branchs )
		{
			//    
			x0 = branchs->X0;
			y0 = branchs->Y0;
			//   
			count = branchs->BranchCount;
		}
		TCHAR buf[255];
		TCHAR buf2[255];

		//    
		// " "
		_tcscpy( buf, (LPTSTR)(LPCTSTR)LoadStr(IDS_MARKLEADER) );
		// "\n :\nX0 = %4.2f, Y0 = %4.2f"
		_stprintf( buf2, (LPTSTR)(LPCTSTR)LoadStr(IDS_POINT), x0, y0 );
		_tcscat( buf, buf2 );
		// "\n : %d"
		_stprintf( buf2, (LPTSTR)(LPCTSTR)LoadStr(IDS_BRANCHCOUNT), count );
		_tcscat( buf, buf2 );

		//   
		MessageT( buf );
	}
}


//-------------------------------------------------------------------------------
//      
// ---
void GetBrandLeaderPar( ksAPI7::IBrandLeaderPtr & brandLeader )
{
	if ( brandLeader )
	{
		//  
		TCHAR buf[255];
		_tcscpy( buf, (LPTSTR)(LPCTSTR)LoadStr(IDS_BRANDLEADER) );
		//   
		MessageT( buf );
	}
}


//-------------------------------------------------------------------------------
//      
// ---
void GetChangeLeaderPar( ksAPI7::IChangeLeaderPtr & changeLeader )
{
	if ( changeLeader )
	{
		//  
		TCHAR buf[255];
		_tcscpy( buf, (LPTSTR)(LPCTSTR)LoadStr(IDS_CHANLEADER) );
		//   
		MessageT( buf );
	}
}


//-------------------------------------------------------------------------------
//      
// ---
void GetRoughPar( ksAPI7::IRoughPtr & rough )
{
	if ( rough )
	{
		//  
		TCHAR buf[255];
		_tcscpy( buf, (LPTSTR)(LPCTSTR)LoadStr(IDS_ROUGH) );
		//   
		MessageT( buf );
	}
}


//-------------------------------------------------------------------------------
//      
// ---
void GetBasePar( ksAPI7::IBasePtr & base )
{
	if ( base )
	{
		//  
		TCHAR buf[255];
		_tcscpy( buf, (LPTSTR)(LPCTSTR)LoadStr(IDS_BASE) );
		//   
		MessageT( buf );
	}
}


//-------------------------------------------------------------------------------
//      /
// ---
void GetCutLinePar( ksAPI7::ICutLinePtr & cutLine )
{
	if ( cutLine )
	{
		//  
		TCHAR buf[255];
		_tcscpy( buf, (LPTSTR)(LPCTSTR)LoadStr(IDS_CUTLINE) );
		//   
		MessageT( buf );
	}
}


//-------------------------------------------------------------------------------
//       
// ---
void GetViewPointerPar( ksAPI7::IViewPointerPtr & viewPointer )
{
	if ( viewPointer )
	{
		//  
		TCHAR buf[255];
		_tcscpy( buf, (LPTSTR)(LPCTSTR)LoadStr(IDS_VIEWPOINTER) );
		//   
		MessageT( buf );
	}
}


//-------------------------------------------------------------------------------
//      
// ---
void GetTolerancePar( ksAPI7::ITolerancePtr & tolerance )
{
	if ( tolerance )
	{
		//  
		TCHAR buf[255];
		_tcscpy( buf, (LPTSTR)(LPCTSTR)LoadStr(IDS_TOLERANCE) );
		//   
		MessageT( buf );
	}
}


//-------------------------------------------------------------------------------
//     
// ---
void ObjectsNavigation( ksAPI7::IKompasDocument2DPtr & doc )
{
	//    
	ksAPI7::IDrawingContainerPtr drawCont( GetDrawingContainer(doc) );

	if ( drawCont )
	{
		//  0 -  
		_variant_t objType = (long)0;
		//   SafeArray 
		_variant_t arr = drawCont->GetObjects( objType );
		LPDISPATCH pObj;
		
		//       
		if ( V_VT(&arr) != VT_EMPTY && arr.parray )
		{
			//   
			long arCount = arr.parray->rgsabound[0].cElements - arr.parray->rgsabound[0].lLbound;     
			
			for ( long j = 0; j < arCount; j++ )
			{
				//    
				HRESULT hr = ::SafeArrayGetElement( arr.parray, &j, &pObj );
				
				if ( pObj )
				{
					//    
					ksAPI7::IDrawingObjectPtr pDrawObj( pObj );
					
					if ( pDrawObj )
					{
						//   
						long type = pDrawObj->GetDrawingObjectType();
						//   
						reference objRef = pDrawObj->Reference;
						//  
						LightObj( objRef, 1/**/ );

						//          
						switch( type )
						{
							//   
							case ksDrLeader:
							{
								ksAPI7::ILeaderPtr leader( pDrawObj );
								GetLeaderPar( leader );
								break;
							}

							//  
							case ksDrMarkerLeader:
							{
								ksAPI7::IMarkLeaderPtr markLeader( pDrawObj );
								GetMarkLeaderPar( markLeader );
								break;
							}

							//  
							case ksDrBrandLeader:
							{
								ksAPI7::IBrandLeaderPtr brandLeader( pDrawObj );
								GetBrandLeaderPar( brandLeader );
								break;
							}

							//  
							case ksDrChangeLeader:
							{
								ksAPI7::IChangeLeaderPtr changeLeader( pDrawObj );
								GetChangeLeaderPar( changeLeader );
								break;
							}

							//  
							case ksDrRough:
							{
								ksAPI7::IRoughPtr rough( pDrawObj );
								GetRoughPar( rough );
								break;
							}

							//  
							case ksDrBase:
							{
								ksAPI7::IBasePtr base( pDrawObj );
								GetBasePar( base );
								break;
							}

							//  /
							case ksDrCut:
							{
								ksAPI7::ICutLinePtr cutLine( pDrawObj );
								GetCutLinePar( cutLine );
								break;
							}

							//   
							case ksDrWPointer:
							{
								ksAPI7::IViewPointerPtr viewPointer( pDrawObj );
								GetViewPointerPar( viewPointer );
								break;
							}

							//  
							case ksDrTolerance:
							{
								ksAPI7::ITolerancePtr tolerance( pDrawObj );
								GetTolerancePar( tolerance );
								break;
							}
						}
						//  
						LightObj( objRef, 0/**/ );
					} 
				}
				// SafeArrayGetElement  AddRef. 
				if ( pObj )
					pObj->Release();
				pObj = NULL;
			}
		}
	}
}


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


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


