////////////////////////////////////////////////////////////////////////////////
//
// Step2_API7_3D.cpp -  3D
//
//	1: CreateLineDimension3D( doc );				-    3D 
//	2: LineDimension3DNavigation( doc );		-      3D
//	3: EditLineDimension3D( doc );					-    3D
//	4: RadialDimension3DWork( doc );				-      3D
//	5: DiametralDimension3DWork( doc );			-      3D
//	6: AngleDimension3DWork( doc );					-      3D
//
////////////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include <afxdllx.h>
#include "Step2_API7_3D.h"

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


//-------------------------------------------------------------------------------
//       DLL
// ---
static AFX_EXTENSION_MODULE Step2_API7_3DDLL = { NULL, NULL };
HINSTANCE g_hInstance = NULL;
ksAPI7::IApplicationPtr newKompasAPI( NULL );               

void OnProcessDetach();                 //  

//  
int oType = o3d_edge;										//     


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

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

		AfxInitExtensionModule(Step2_API7_3DDLL, hInstance);

		new CDynLinkLibrary(Step2_API7_3DDLL);
	}
	else if (dwReason == DLL_PROCESS_DETACH)
	{
		TRACE0("STEP2_API7_3D.AWX Terminating!\n");
    OnProcessDetach();
		AfxTermExtensionModule(Step2_API7_3DDLL);
	}
	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::IKompasDocument3DPtr GetCurrentDocument()
{
	ksAPI7::IKompasDocument3DPtr doc = NULL;
	
	//      IApplication  
  if ( !(bool)newKompasAPI )
		//    
    GetNewKompasAPI();
	
	//     IApplication  
  if ( newKompasAPI ) 
		//   
    doc = newKompasAPI->GetActiveDocument();
	
	return doc;
}


//-------------------------------------------------------------------------------
//   
// ---
void CreateLineDimension3D( ksAPI7::IKompasDocument3DPtr & doc );
void LineDimension3DNavigation( ksAPI7::IKompasDocument3DPtr & doc );
void EditLineDimension3D( ksAPI7::IKompasDocument3DPtr & doc );
void RadialDimension3DWork( ksAPI7::IKompasDocument3DPtr & doc );
void DiametralDimension3DWork( ksAPI7::IKompasDocument3DPtr & doc );
void AngleDimension3DWork( ksAPI7::IKompasDocument3DPtr & doc );


//-------------------------------------------------------------------------------
//   
// ---
void WINAPI LIBRARYENTRY( unsigned int comm )
{
	//   
	ksAPI7::IKompasDocument3DPtr doc( GetCurrentDocument() );
	
	if ( doc )
	{
		switch ( comm )
		{
			case 1: CreateLineDimension3D( doc );				break;		//    3D 
			case 2: LineDimension3DNavigation( doc );		break;		//      3D
			case 3: EditLineDimension3D( doc );					break;		//    3D
			case 4: RadialDimension3DWork( doc );				break;		//      3D
			case 5: DiametralDimension3DWork( doc );		break;		//      3D
			case 6: AngleDimension3DWork( doc );				break;		//      3D
		}
	}
	else
		MessageT( (LPTSTR)(LPCTSTR)LoadStr(IDS_NODOC) );
}


//-------------------------------------------------------------------------------
//    3D
// ---
ksAPI7::ISymbols3DContainerPtr GetSymbols3DContainer( ksAPI7::IKompasDocument3DPtr & doc )
{
  if ( doc )
  {
    //    3D
    return doc->GetTopPart(); 
  }
  return NULL;
}


//-----------------------------------------------------------------------------
//  
// ---
BOOL __stdcall  UserFilterProc( IEntity * e)
{
  if( e && (!oType || e->GetType() == oType) )
    return TRUE;
  else
    return FALSE;
}


//-------------------------------------------------------------------------------
//      
// ---
bool SetLineDimObjectPlane( ksAPI7::ILineDimension3DPtr & dim, 
														ksAPI7::IKompasDocument3DPtr & doc )
{
	bool res = false;
	//   - 
	oType = o3d_edge;

	//    3D  API7  API5
	IDocument3DPtr doc3D( IUnknownPtr(ksTransferInterface( doc, ksAPI3DCom, 0/* */ ), false/*AddRef*/) );
	
	if ( doc3D )
	{
		//     - 
		IEntityPtr obj1( doc3D->UserSelectEntity(NULL, UserFilterProc, (LPTSTR)(LPCTSTR)LoadStr(IDS_OBJ1)), false/*AddRef*/ );

		if ( obj1 )
		{
			//   - 
			oType = o3d_face;
			//     - 
			IEntityPtr plane( doc3D->UserSelectEntity(NULL, UserFilterProc, (LPTSTR)(LPCTSTR)LoadStr(IDS_PLANE)), false/*AddRef*/ );

			if ( plane )
			{
				//       API5  API7
				ksAPI7::IModelObjectPtr mObj1( IUnknownPtr(ksTransferInterface( obj1, ksAPI7Dual, 0 ), false/*AddRef*/) );
				ksAPI7::IModelObjectPtr mPlane( IUnknownPtr(ksTransferInterface( plane, ksAPI7Dual, 0 ), false/*AddRef*/) );
				
				if ( (bool)mObj1 && (bool)mPlane && (bool)dim )
				{
					//     (   
					//    ,     )
					dim->Object1 = mObj1;
					//    
					dim->Plane = mPlane;
					res = TRUE;
				}
			}
		}
	}
	return res;
}


//-------------------------------------------------------------------------------
//    3D
// ---
void CreateLineDimension3D( ksAPI7::IKompasDocument3DPtr & doc )
{
	//    3D
	ksAPI7::ISymbols3DContainerPtr symbCont( GetSymbols3DContainer(doc) );

	if ( symbCont )
	{
		//     3D
		ksAPI7::ILineDimensions3DPtr dimsCol( symbCont->GetLineDimensions3D() );

		if ( dimsCol )
		{
			//     3D
			ksAPI7::ILineDimension3DPtr newDim( dimsCol->Add(o3d_lineDimension3D) );

			if ( newDim )
			{
				bool create = false;

				//        
				if ( SetLineDimObjectPlane(newDim, doc) )
				{
					//   
					newDim->Length = 30;
					//  
					create = (bool)!!newDim->Update();		
					
				}
				else
					//   "  "
					MessageT( (LPTSTR)(LPCTSTR)LoadStr(IDS_NOCREATE) );
				//    , 
				if ( !create )
				{
					ksAPI7::IFeature7Ptr obj( newDim );
					
					if ( obj )
						obj->Delete();
				}
			}
		}
	}
}


//-------------------------------------------------------------------------------
//       3D
// ---
void GetLineDimensionPar( ksAPI7::ILineDimension3DPtr & dim )
{
	if ( dim )
	{
		//   
		double lenght = dim->Length;
		double val = 0;

		//   
		ksAPI7::IDimensionTextPtr dimText( dim );

		if ( dimText )
			val = dimText->NominalValue;

		//  
		TCHAR buf[255], buf2[255];
		_tcscpy( buf, (LPTSTR)(LPCTSTR)LoadStr(IDS_LINEDIM3D) );	
		_stprintf( buf2, (LPTSTR)(LPCTSTR)LoadStr(IDS_LENGTH), lenght );
		_tcscat( buf, buf2 );
		_stprintf( buf2, (LPTSTR)(LPCTSTR)LoadStr(IDS_DIMVAL), val );
		_tcscat( buf, buf2 );
		MessageT( buf );
	}
}


//-------------------------------------------------------------------------------
//      3D
// ---
void LineDimension3DNavigation( ksAPI7::IKompasDocument3DPtr & doc )
{
	if ( doc )
	{
		//    3D
		ksAPI7::ISymbols3DContainerPtr symbCont( GetSymbols3DContainer(doc) );
		
		if ( symbCont )
		{
			//     3D
			ksAPI7::ILineDimensions3DPtr dimsCol( symbCont->GetLineDimensions3D() );
			//    3D  API7  API5
			IDocument3DPtr doc3D( IUnknownPtr(ksTransferInterface( doc, ksAPI3DCom, 0/* */ ), false/*AddRef*/) );
			
			if ( doc3D )
			{
				//   
				ISelectionMngPtr selectMng( doc3D->GetSelectionMng() );

				if ( (bool)dimsCol && (bool)selectMng )
				{
					//    
					for ( long i = 0; i < dimsCol->Count; i++ )
					{	
						//      
						ksAPI7::ILineDimension3DPtr lineDim( dimsCol->GetLineDimension3D(i) );

						if ( lineDim )
						{
							//    3D  API7  API5
							IEntityPtr dimObj( IUnknownPtr(ksTransferInterface( lineDim, ksAPI3DCom, o3d_entity ), false/*AddRef*/) );

							if ( dimObj )
							{
								//  
								selectMng->Select( dimObj );
								//     
								GetLineDimensionPar( lineDim );
								//  
								selectMng->Unselect( dimObj );
							}
						}
					}
				}
			}
		}
	}
}


//-------------------------------------------------------------------------------
//    
// ---
bool SetNewPlane( ksAPI7::ILineDimension3DPtr & dim, IDocument3DPtr & doc3D )
{
	bool res = false;

	if ( (bool)dim && (bool)doc3D )
	{
		oType = o3d_face;
		//    
		IEntityPtr obj1( doc3D->UserSelectEntity(NULL, UserFilterProc, (LPTSTR)(LPCTSTR)LoadStr(IDS_NEWPLANE)), false/*AddRef*/ );

		if ( obj1 )
		{
			//     API5  API7
			ksAPI7::IModelObjectPtr plane( IUnknownPtr(ksTransferInterface( obj1, ksAPI7Dual, 0 ), false/*AddRef*/) );

			if ( plane )
			{
				//   
				dim->Plane = plane;
				res = true;
			}
		}
	}
	return res;
}


//-------------------------------------------------------------------------------
//     3D
// ---
void ChangeLineDimensionPar( ksAPI7::ILineDimension3DPtr & dim )
{
	if ( dim )
	{
		//    
		ksAPI7::IDimensionParamsPtr dimPars( dim );

		if ( dimPars )
		{
			//   - 
			dimPars->ArrowType1 = ksNotch;
			dimPars->ArrowType2 = ksNotch;
			//   - 
			dimPars->ArrowPos = ksDimArrowOutside;
			//   - 
			dimPars->ShelfDirection = ksLSRight;
			//  
			dimPars->ShelfLength = 10;
			//   
			dimPars->ShelfAngle = 45;
		}
	}
}


//-------------------------------------------------------------------------------
//    3D
// ---
void EditLineDimension3D( ksAPI7::IKompasDocument3DPtr & doc )
{
	if ( doc )
	{
		//    3D  API7  API5
		IDocument3DPtr doc3D( IUnknownPtr(ksTransferInterface( doc, ksAPI3DCom, 0/* */ ), false/*AddRef*/) );

		if ( doc3D )
		{
			oType = o3d_entity;
			//    
			IEntityPtr obj1( doc3D->UserSelectEntity(NULL, NULL, (LPTSTR)(LPCTSTR)LoadStr(IDS_DIM)), false/*AddRef*/ );

			if ( obj1 )
			{
				//     API5  API7
				ksAPI7::IModelObjectPtr mObj1( IUnknownPtr(ksTransferInterface( obj1, ksAPI7Dual, 0 ), false/*AddRef*/) );

				if ( (bool)mObj1 && mObj1->ModelObjectType == o3d_lineDimension3D )
				{
					//     3D
					ksAPI7::ILineDimension3DPtr lineDim( mObj1 );

					if ( lineDim )
					{
						//    
						if ( !SetNewPlane(lineDim, doc3D) )
							//   "     "
							MessageT( (LPTSTR)(LPCTSTR)LoadStr(IDS_NOTSETPLANE) );

						//   
						ChangeLineDimensionPar( lineDim );
						//   
						lineDim->Length = lineDim->Length - 10;
						//  
						lineDim->Update();
					}
				}
				else
					//   "    "
					MessageT( (LPTSTR)(LPCTSTR)LoadStr(IDS_NOTDIM) );
			}
		}
	}
}


//-------------------------------------------------------------------------------
//    3D
// ---
bool CreateRadDimension3D( ksAPI7::IRadialDimension3DPtr & dim,
													 ksAPI7::IKompasDocument3DPtr & doc )
{
	bool res = false;

	if ( dim )
	{
		//    3D  API7  API5
		IDocument3DPtr doc3D( IUnknownPtr(ksTransferInterface( doc, ksAPI3DCom, 0/* */ ), false/*AddRef*/) );

		if ( doc3D )
		{
			oType = o3d_edge;
			//     - 
			IEntityPtr edge( doc3D->UserSelectEntity(NULL, UserFilterProc, (LPTSTR)(LPCTSTR)LoadStr(IDS_OBJ1)), false/*AddRef*/ );

			if ( edge )
			{
				//    
				IEdgeDefinitionPtr edgeDef( edge->GetDefinition() );

				// ,    
				if ( (bool)edgeDef && edgeDef->IsCircle() )
				{
					//     API5  API7
					ksAPI7::IModelObjectPtr mObj1( IUnknownPtr(ksTransferInterface( edge, ksAPI7Dual, 0 ), false/*AddRef*/) );

					if ( mObj1 )
						//  
						dim->Object1 = mObj1;

					//    
					ksAPI7::IDimensionParamsPtr dimPars( dim );

					if ( dimPars )
					{
						//   - 
						dimPars->ShelfDirection = ksLSLeft;
						//  
						dimPars->ShelfLength = 15;
						//   
						dimPars->ShelfAngle = 30;
					}

					//   -   
					dim->DimensionType = FALSE;
					//  
					dim->Update();
					res = true;
				}
				else
					//   "   "
					MessageT( (LPTSTR)(LPCTSTR)LoadStr(IDS_NOTCIRCLE) );
			}
		}
	}
	return res;
} 


//-------------------------------------------------------------------------------
//    3D
// ---
void EditRadDimension3D( ksAPI7::IRadialDimension3DPtr & dim )
{
	if ( dim )
	{
		//   -  
		dim->DimensionType = TRUE;

		//    
		ksAPI7::IDimensionParamsPtr dimPars( dim );

		if ( dimPars )
			//  
			dimPars->ShelfDirection = ksLSNone;

		//    
		ksAPI7::IDimensionTextPtr dimText( dim );

		if ( dimText )
		{
			//  
			dimText->Tolerance = _T("h6");

			//  
			dimText->ToleranceOn = TRUE;

			//     
			ksAPI7::ITextLinePtr lowDev( dimText->LowDeviation );
			
			//   
			if ( lowDev )
				lowDev->Str = _T("+0.021");
		}
		//  
		dim->Update();
	}
}


//-------------------------------------------------------------------------------
//      3D
// ---
void RadialDimension3DWork( ksAPI7::IKompasDocument3DPtr & doc )
{
	//    3D
	ksAPI7::ISymbols3DContainerPtr symbCont( GetSymbols3DContainer(doc) );

	if ( symbCont )
	{
		//     3D
		ksAPI7::IRadialDimensions3DPtr dimsCol( symbCont->GetRadialDimensions3D() );

		if ( dimsCol )
		{
			//     3D
			ksAPI7::IRadialDimension3DPtr newDim( dimsCol->Add() );

			if ( newDim )
			{
				//    3D
				if ( CreateRadDimension3D(newDim, doc) )
				{	
					_bstr_t name = _T("");
					//     
					ksAPI7::IFeature7Ptr feature( newDim );
          				
					//   
					if ( feature )
						name = feature->Name;

					if ( YesNoT((LPTSTR)(LPCTSTR)LoadStr(IDS_EDIT)) == 1 )
					{
						//      
						ksAPI7::IRadialDimension3DPtr radDim( dimsCol->GetRadialDimension3D(name) );
						//  
						EditRadDimension3D( radDim );
					}
				}
				else
					//   "  "
					MessageT( (LPTSTR)(LPCTSTR)LoadStr(IDS_NOCREATE) );
			}
		}
	}
}


//-------------------------------------------------------------------------------
//   
// ---
bool CreateDiamDimension3D( ksAPI7::IDiametralDimension3DPtr & dim,
														ksAPI7::IKompasDocument3DPtr & doc )
{
	bool res = false;
	
	if ( dim )
	{
		//    3D  API7  API5
		IDocument3DPtr doc3D( IUnknownPtr(ksTransferInterface( doc, ksAPI3DCom, 0/* */ ), false/*AddRef*/) );
		
		if ( doc3D )
		{
			oType = o3d_edge;
			//     - 
			IEntityPtr edge( doc3D->UserSelectEntity(NULL, UserFilterProc, (LPTSTR)(LPCTSTR)LoadStr(IDS_OBJ1)), false/*AddRef*/ );
			
			if ( edge )
			{
				//    
				IEdgeDefinitionPtr edgeDef( edge->GetDefinition() );
				
				// ,    
				if ( (bool)edgeDef && edgeDef->IsCircle() )
				{
					//     API5  API7
					ksAPI7::IModelObjectPtr mObj1( IUnknownPtr(ksTransferInterface( edge, ksAPI7Dual, 0 ), false/*AddRef*/) );
					
					if ( mObj1 )
						//  
						dim->Object1 = mObj1;
					
					//  
					dim->Update();
					res = true;
				}
				else
					//   "   "
					MessageT( (LPTSTR)(LPCTSTR)LoadStr(IDS_NOTCIRCLE) );
			}
		}
	}
	return res;
}


//-------------------------------------------------------------------------------
//   
// ---
void EditDiamDimension3D( ksAPI7::IDiametralDimension3DPtr & dim )
{
	if ( dim )
	{
		//   -  
		dim->DimensionType = TRUE;

		//    
		ksAPI7::IDimensionTextPtr dimText( dim );

		if ( dimText )
		{
			//      
			ksAPI7::ITextPtr txtUnder( dimText->TextUnder );
			
			//   
			if ( txtUnder )
				txtUnder->Str = (LPTSTR)(LPCTSTR)LoadStr( IDS_DIMTEXT );

			//  
			dimText->Underline = TRUE;
		}
		//  
		dim->Update();
	}
}


//-------------------------------------------------------------------------------
//      3D
// ---
void DiametralDimension3DWork( ksAPI7::IKompasDocument3DPtr & doc )
{
	//    3D
	ksAPI7::ISymbols3DContainerPtr symbCont( GetSymbols3DContainer(doc) );
	
	if ( symbCont )
	{
		//     3D
		ksAPI7::IDiametralDimensions3DPtr dimsCol( symbCont->GetDiametralDimensions3D() );
		
		if ( dimsCol )
		{
			//     3D
			ksAPI7::IDiametralDimension3DPtr newDim( dimsCol->Add() );
			
			if ( newDim )
			{
				//    3D
				if ( CreateDiamDimension3D(newDim, doc) )
				{	
					_bstr_t name = _T("");
					//     
					ksAPI7::IFeature7Ptr feature( newDim );
					
					//   
					if ( feature )
						name = feature->Name;
					
					if ( YesNoT((LPTSTR)(LPCTSTR)LoadStr(IDS_EDIT)) == 1 )
					{
						//      
						ksAPI7::IDiametralDimension3DPtr diamDim( dimsCol->GetDiametralDimension3D(name) );
						//  
						EditDiamDimension3D( diamDim );
					}
				}
				else
					//   "  "
					MessageT( (LPTSTR)(LPCTSTR)LoadStr(IDS_NOCREATE) );
			}
		}
	}
}


//-------------------------------------------------------------------------------
//    3D
// ---
bool CreateAngleDimension3D( ksAPI7::IAngleDimension3DPtr & dim,
														 ksAPI7::IKompasDocument3DPtr & doc )
{
	bool res = false;

	if ( (bool)dim && (bool)doc )
	{
		//    3D  API7  API5
		IDocument3DPtr doc3D( IUnknownPtr(ksTransferInterface( doc, ksAPI3DCom, 0/* */ ), false/*AddRef*/) );
		
		if ( doc3D )
		{
			//    1- 
			IEntityPtr obj1( doc3D->UserSelectEntity(NULL, NULL, (LPTSTR)(LPCTSTR)LoadStr(IDS_OBJECT1)), false/*AddRef*/ );
			//    2- 
			IEntityPtr obj2( doc3D->UserSelectEntity(NULL, NULL, (LPTSTR)(LPCTSTR)LoadStr(IDS_OBJECT2)), false/*AddRef*/ );

			if ( (bool)obj1 && (bool)obj2 )
			{
				//     API5  API7
				ksAPI7::IModelObjectPtr mObj1( IUnknownPtr(ksTransferInterface( obj1, ksAPI7Dual, 0 ), false/*AddRef*/) );
				ksAPI7::IModelObjectPtr mObj2( IUnknownPtr(ksTransferInterface( obj2, ksAPI7Dual, 0 ), false/*AddRef*/) );

				if ( (bool)mObj1 && (bool)mObj2 )
				{
					// 1- 
					dim->Object1 = mObj1;
					// 2- 
					dim->Object2 = mObj2;
					//   
					dim->Length = 20;
					//  
					dim->Update();
					res = true;
				}
			}
		}
	}
	return res;
}


//-------------------------------------------------------------------------------
//    3D
// ---
void EditAngleDimension3D( ksAPI7::IAngleDimension3DPtr & dim )
{
	if ( dim )
	{
		//   -   () 
		dim->DimensionType = ksADMaxAngle;
		//    
		dim->Length = dim->Length + 10;

		//    
		ksAPI7::IDimensionParamsPtr dimPars( dim );

		if ( dimPars )
			//    - ,   
			dimPars->TextOnLine = ksDimTextParallelInCut;

		//    
		ksAPI7::IDimensionTextPtr dimText( dim );

		if ( dimText )
			//      
			dimText->TextFormat = ksDimTextFormatGDD;

		//  
		dim->Update();
	}
}


//-------------------------------------------------------------------------------
//      3D
// ---
void AngleDimension3DWork( ksAPI7::IKompasDocument3DPtr & doc )
{
	//    3D
	ksAPI7::ISymbols3DContainerPtr symbCont( GetSymbols3DContainer(doc) );
	
	if ( symbCont )
	{
		//     3D
		ksAPI7::IAngleDimensions3DPtr dimsCol( symbCont->GetAngleDimensions3D() );
		
		if ( dimsCol )
		{
			//     3D
			ksAPI7::IAngleDimension3DPtr newDim( dimsCol->Add() );
			
			if ( newDim )
			{
				//    3D
				if ( CreateAngleDimension3D(newDim, doc) )
				{	
					_bstr_t name = _T("");
					//     
					ksAPI7::IFeature7Ptr feature( newDim );
					
					//   
					if ( feature )
						name = feature->Name;
					
					if ( YesNoT((LPTSTR)(LPCTSTR)LoadStr(IDS_EDIT)) == 1 )
					{
						//      
						ksAPI7::IAngleDimension3DPtr angDim( dimsCol->GetAngleDimension3D(name) );
						//  
						EditAngleDimension3D( angDim );
					}
				}
				else
					//   "  "
					MessageT( (LPTSTR)(LPCTSTR)LoadStr(IDS_NOCREATE) );
			}
		}
	}
}


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


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


