  // step3a.cpp : Defines the initialization routines for the DLL.
//

#include "stdafx.h"
#include "step3a.h"
#include <ldefin2d.h>

#ifdef __LIGHT_VERSION__
#include <klAPI5.h>
#else
#include <kAPI5.h>
#endif

#include <ksConstants.h>

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

//
//	Note!
//
//		If this DLL is dynamically linked against the MFC
//		DLLs, any functions exported from this DLL which
//		call into MFC must have the AFX_MANAGE_STATE macro
//		added at the very beginning of the function.
//
//		For example:
//
//		extern "C" BOOL PASCAL EXPORT ExportedFunction()
//		{
//			AFX_MANAGE_STATE(AfxGetStaticModuleState());
//			// normal function body here
//		}
//
//		It is very important that this macro appear in each
//		function, prior to any calls into MFC.  This means that
//		it must appear as the first statement within the 
//		function, even before any object variable declarations
//		as their constructors may generate calls into the MFC
//		DLL.
//
//		Please see MFC Technical Notes 33 and 58 for additional
//		details.
//

/////////////////////////////////////////////////////////////////////////////
// CStep3aApp

BEGIN_MESSAGE_MAP(CStep3aApp, CWinApp)
	//{{AFX_MSG_MAP(CStep3aApp)
		// NOTE - the ClassWizard will add and remove mapping macros here.
		//    DO NOT EDIT what you see in these blocks of generated code!
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CStep3aApp construction

CStep3aApp::CStep3aApp()
{
}

/////////////////////////////////////////////////////////////////////////////
// The one and only CStep3aApp object

CStep3aApp theApp;

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

KompasObject kompas( NULL );

void WorkContour( ksDocument2D& doc );
void TDemWork( ksDocument2D& doc );
void TableWork( ksDocument2D& doc );
void DrawViewPointer( ksDocument2D& doc );
void WorkStamp( ksDocument2D& doc );
void WorkTolerance( ksDocument2D& doc );
void DrawEquidistant( ksDocument2D& doc );
void DrawEllipse( ksDocument2D& doc );
void DrawPolyline( ksDocument2D& doc );
void DrawNurbs( ksDocument2D& doc );
void DrawInsFragment1( ksDocument2D& doc );
void DrawInsFragment2( ksDocument2D& doc );
void DrawSpecRough( ksDocument2D& doc );

//-------------------------------------------------------------------------------
//
// ---
void GetKompas() {
	if ( !kompas.m_lpDispatch ) {
		CString filename;
		if( ::GetModuleFileName(NULL, filename.GetBuffer(255), 255) ) {
			filename.ReleaseBuffer( 255 );
			CString libname;

      #ifdef __LIGHT_VERSION__
        libname.LoadString( IDS_STRING5 );  //klAPI5.dll
      #else
        libname.LoadString( IDS_STRING4 );  //kAPI5.dll
      #endif
      
			filename.Replace( filename.Right(filename.GetLength() - (filename.ReverseFind('\\') + 1)), 
												libname );

			HINSTANCE hAppAuto = LoadLibrary( filename ); //  kAPI5.dll
			if(  hAppAuto ) {
				typedef LPDISPATCH ( WINAPI *FCreateKompasObject )(); 
				FCreateKompasObject pCreateKompasObject = 
					(FCreateKompasObject)GetProcAddress( hAppAuto, "CreateKompasObject" );	
				if ( pCreateKompasObject ) 
					kompas = pCreateKompasObject();
				FreeLibrary( hAppAuto );
			}
		}
	}
}

//-------------------------------------------------------------------------------
//
// ---
void WINAPI LIBRARYENTRY( unsigned int comm ) {
	//      .exe ,     
	//   dll   define
	AFX_MANAGE_STATE(AfxGetStaticModuleState());

	GetKompas();
	if ( kompas.m_lpDispatch ) {
		ksDocument2D doc( kompas.ActiveDocument2D() );
		if ( doc.m_lpDispatch && doc.GetReference() ) {
			switch ( comm ) {
				case 1  : ::WorkContour( doc );      break; // 
				case 2  : ::TDemWork( doc );				 break; //  
				case 3  : ::DrawViewPointer( doc );  break; //  
				case 4  : ::WorkStamp( doc );				 break; //   
				case 5  : ::TableWork( doc );				 break; // 
				case 6  : ::DrawEquidistant( doc );  break; // 
				case 7  : ::DrawEllipse( doc );      break; // 
				case 8  : ::DrawPolyline( doc );     break; // 
				case 9  : ::DrawNurbs( doc );				 break; // nurbs
				case 10 : ::WorkTolerance( doc );		 break; //  
				case 11 : ::DrawSpecRough( doc );    break; //  
				case 12 : ::DrawInsFragment1( doc ); break; //    
				case 13 : ::DrawInsFragment2( doc ); break; //   
			}
		}
	}
}


//-------------------------------------------------------------------------------
//  
// ---
void WorkContour( ksDocument2D& doc ) {
  if( doc.ksContour(1) ) {
    doc.ksLineSeg( 20, 30, 50, 30, 1 );
    doc.ksArcByPoint( 50, 20, 10, 50,30, 50, 10, -1, 1 );
    // 
    doc.ksContour( 2 );
      doc.ksLineSeg( 50, 10, 20, 10, 1 );
      doc.ksArcByPoint( 20, 20, 10, 20,10, 20, 30, -1, 1 );
    doc.ksEndObj();
    reference _contour = doc.ksEndObj();

    doc.ksLightObj( _contour, 1 );
    kompas.ksMessage( "" );
    doc.ksLightObj( _contour, 1 );
    reference g = doc.ksNewGroup( 0 );
    doc.ksEndGroup();
    doc.ksAddObjGroup( g, _contour );
    doc.ksMoveObj( g, 10, 10 );
    kompas.ksMessage( " " );
  }
}

//-------------------------------------------------------------------------------
//   
// ---
void TDemWork( ksDocument2D& doc ) {
	ksDynamicArray pGab( kompas.GetDynamicArray(RECT_ARR) );
  //     
  ksRectParam      par ( kompas.GetParamStruct(ko_RectParam) );
	ksMathPointParam pBot( kompas.GetParamStruct(ko_MathPointParam) );
	ksMathPointParam pTop( kompas.GetParamStruct(ko_MathPointParam) );
	if ( pGab.m_lpDispatch && par.m_lpDispatch && pBot.m_lpDispatch && pTop.m_lpDispatch ) {
		pBot.Init();
		pTop.Init();

		pTop.SetX( 415 );
		pTop.SetY( 80 );
		par.SetpTop( pTop );
		pBot.SetX( 230 );
		pBot.SetY( 65 );
		par.SetpBot( pBot );
		pGab.ksAddArrayItem( -1, par );

		pTop.SetX( 230 );
		pTop.SetY( 60 );
		par.SetpTop( pTop );
		pBot.SetX( 45 );
		pBot.SetY( 15 );
		par.SetpBot( pBot );
		pGab.ksAddArrayItem( -1, par );

		if( doc.ksOpenTechnicalDemand(pGab, 0) ) {
	    ksTextItemParam itemParam( kompas.GetParamStruct(ko_TextItemParam) );
		  if ( itemParam.m_lpDispatch ) {
			  itemParam.Init(); 
		        
				ksTextItemFont itemFont( itemParam.GetItemFont() );
				if ( itemFont.m_lpDispatch ) {
					itemFont.Init();
				 	itemFont.SetBitVectorValue( NEW_LINE, true );
          itemParam.SetS( CString("1111111") );
					doc.ksTextLine( itemParam );

					itemFont.Init();
				 	itemFont.SetBitVectorValue( NEW_LINE, true );
					itemParam.SetS( CString("2222222") );
					doc.ksTextLine( itemParam );

					itemFont.Init();
				 	itemFont.SetBitVectorValue( NEW_LINE, true );
					itemParam.SetS( CString("3333333") );
					doc.ksTextLine( itemParam );

					itemFont.Init();
				 	itemFont.SetBitVectorValue( NEW_LINE, true );
					itemParam.SetS( CString("4444444") );
					doc.ksTextLine( itemParam );

					itemFont.Init();
				 	itemFont.SetBitVectorValue( NEW_LINE, true );
					itemParam.SetS( CString("5555555") );
					doc.ksTextLine( itemParam );

					itemFont.Init();
				 	itemFont.SetBitVectorValue( NEW_LINE, true );
					itemParam.SetS( CString("6666666") );
					doc.ksTextLine( itemParam );
				}
			}

			doc.ksCloseTechnicalDemand();
		}
	}
}

//-------------------------------------------------------------------------------
//  
// ---
void TableWork( ksDocument2D& doc ) {
  doc.ksTable();
    doc.ksLineSeg( 50, 50, 90, 50, 1 );
    doc.ksLineSeg( 50, 40, 90, 40, 1 );
    doc.ksLineSeg( 50, 30, 90, 30, 1 );
    doc.ksLineSeg( 50, 50, 50, 30, 1 );
    doc.ksLineSeg( 70, 50, 70, 30, 1 );
    doc.ksLineSeg( 90, 50, 90, 30, 1 );

    doc.ksText( 52, 48, 0, 5, 1, 0, "1" );
    doc.ksText( 72, 48, 0, 5, 1, 0, "2" );
    doc.ksText( 52, 38, 0, 5, 1, 0, "3" );
    doc.ksText( 72, 38, 0, 5, 1, 0, "4" );
  doc.ksEndObj();
}

//-------------------------------------------------------------------------------
//   
// ---
void DrawViewPointer( ksDocument2D& doc ) {
  ksViewPointerParam par( kompas.GetParamStruct(ko_ViewPointerParam) );
	if ( par.m_lpDispatch ) {
		par.Init();
		par.SetX1( 55 ); 
		par.SetY1( 50 );   //  ( ) 
		par.SetX2( 40 ); 
		par.SetY2( 50 );   //    
		par.SetXt( 40 ); 
		par.SetYt( 52 );   //  
		par.SetType( 0 );
		par.SetStr( "A" ); // 

		reference  p = doc.ksViewPointer( par ); // " "
		if ( doc.ksExistObj(p) )
			doc.ksLightObj( p, 1 );
	}
}

//-------------------------------------------------------------------------------
//   
// ---
void WorkStamp( ksDocument2D& doc ) {
	ksStamp stamp( doc.GetStamp() );
	if ( stamp.m_lpDispatch ) {
		if ( stamp.ksOpenStamp() ) {
			stamp.ksColumnNumber( 2 );

	    ksTextItemParam itemParam( kompas.GetParamStruct(ko_TextItemParam) );
		  if ( itemParam.m_lpDispatch ) {
			  itemParam.Init(); 
		       
				ksTextItemFont itemFont( itemParam.GetItemFont() );
				if ( itemFont.m_lpDispatch ) {
				 	itemFont.SetBitVectorValue( NEW_LINE, true );
					itemParam.SetS( CString("1111111") );
					doc.ksTextLine( itemParam );
				}
			}
	
		  stamp.ksCloseStamp();
		}
  }
}

//-------------------------------------------------------------------------------
//  
// ---
void WorkTolerance( ksDocument2D& doc ) {
	ksToleranceParam  par     ( kompas.GetParamStruct(ko_ToleranceParam) );
	ksMathPointParam  parPoint( kompas.GetParamStruct(ko_MathPointParam) );
	if ( par.m_lpDispatch && parPoint.m_lpDispatch ) {

		par.Init();
		parPoint.Init();

		ksDynamicArray    branchArr  ( par.GetBranchArr() );
		ksToleranceBranch tolBran    ( kompas.GetParamStruct(ko_ToleranceBranch) );
		tolBran.Init();
		if ( branchArr.m_lpDispatch && tolBran.m_lpDispatch ) {

			ksDynamicArray    arr    ( tolBran.GetpMathPoint() );
			if ( arr.m_lpDispatch ) {
				//   1- 
				parPoint.SetX( 40 );
				parPoint.SetY( 10 );
				arr.ksAddArrayItem( -1, parPoint );
				tolBran.SetArrowType( 2 );
				tolBran.SetTCorner( 1 );
				branchArr.ksAddArrayItem( -1, tolBran );

				//   2- 
				arr.ksClearArray();
				parPoint.SetX( 100 );
				parPoint.SetY( 50 );
				arr.ksAddArrayItem( -1, parPoint );
				parPoint.SetX( 100 );
				parPoint.SetY( 10 );
				arr.ksAddArrayItem( -1, parPoint );
				tolBran.SetArrowType( 1 );
				tolBran.SetTCorner( 5 );
				branchArr.ksAddArrayItem( -1, tolBran );

				par.SetX( 40 );
				par.SetY( 40 );
				par.SetType( 0 );

				//    
				if ( doc.ksTolerance(par) ) {
					ksTextItemParam itemParam( kompas.GetParamStruct(ko_TextItemParam) );
					if ( itemParam.m_lpDispatch ) {
						itemParam.Init(); 
				   
						ksTextItemFont itemFont( itemParam.GetItemFont() );
						if ( itemFont.m_lpDispatch ) {
							doc.ksColumnNumber( 1 );
			 				itemFont.SetBitVectorValue( SPECIAL_SYMBOL, true );
							itemParam.SetType( SPECIAL );
							itemParam.SetISNumb( 26 );
							doc.ksTextLine( itemParam );

							itemParam.Init(); 
							doc.ksColumnNumber( 2 );
					 		itemFont.SetBitVectorValue( NEW_LINE, true );
							itemParam.SetS( CString("2222") );
							doc.ksTextLine( itemParam );

							doc.ksColumnNumber( 3 );
					 		itemFont.SetBitVectorValue( NEW_LINE, true );
							itemParam.SetS( CString("2222") );
							doc.ksTextLine( itemParam );

							itemParam.Init(); 
							doc.ksColumnNumber( 11 );
			 				itemFont.SetBitVectorValue( SPECIAL_SYMBOL, true );
							itemParam.SetType( SPECIAL );
							itemParam.SetISNumb( 23 );
							doc.ksTextLine( itemParam );

							itemParam.Init(); 
							doc.ksColumnNumber( 12 );
					 		itemFont.SetBitVectorValue( NEW_LINE, true );
							itemParam.SetS( CString("444") );
							doc.ksTextLine( itemParam );
              doc.ksColumnNumber( 13 );
              itemFont.SetBitVectorValue( NEW_LINE, true );
							itemParam.SetS( CString("555") );
							doc.ksTextLine( itemParam );
						}
					}
				}
				
				reference p = doc.ksEndObj(); //    
				doc.ksLightObj( p, 1 );
			}
			arr.ksDeleteArray();
			branchArr.ksDeleteArray();
		}
	}
}

//-------------------------------------------------------------------------------
//  
// ---
void DrawEquidistant( ksDocument2D& doc ) {
  ksEquidistantParam par( kompas.GetParamStruct(ko_EquidParam) );
	ksRequestInfo      info( kompas.GetParamStruct(ko_RequestInfo) );
	if ( par.m_lpDispatch && info.m_lpDispatch ) {
		par.SetSide( 2 );     // ,     
			                    // 0-  , 1-  , 2-  
		par.SetCutMode( 0 );  //    
			                    // 0- , 1-  
		par.SetDegState( 0 ); //     
			                    // 0-  , 1-  
		par.SetRadRight( 5 ); //  
		par.SetRadLeft( 3 );  //  
		par.SetStyle( 1 );    //  
		info.SetCommandsString( " " );
		double x, y;
		//  
		int j;
		reference p1;
		do {
			j = doc.ksCursor( info, &x ,&y, NULL );
	    if ( j ) {
				par.SetGeoObj( doc.ksFindObj(x, y, 1e6) );
		    if ( doc.ksExistObj(par.GetGeoObj()) ) {
			    if ( (p1 = doc.ksEquidistant(par)) != 0 ) { //  

					  doc.ksLightObj( p1, 1 );
						kompas.ksMessage( "" );
			      doc.ksLightObj( p1, 0 );
		      }
			    else
				    kompas.ksMessageBoxResult();
				}
				else
					kompas.ksError( "  " );
			}
		} while( j );
	}
}

//-------------------------------------------------------------------------------
//  
// ---
void DrawEllipse( ksDocument2D& doc ) {
  ksEllipseParam par( kompas.GetParamStruct(ko_EllipseParam) );
	if ( par.m_lpDispatch ) {
		par.Init();
		par.SetXc( 50 );
		par.SetYc( 40 );
		par.SetA( 20 );
		par.SetB( 10 );
		par.SetStyle( 1 );
		reference p = doc.ksEllipse( par );
		doc.ksLightObj( p, 1 );
		kompas.ksMessage( "" );
		doc.ksLightObj( p, 0 );
	}
}

//-------------------------------------------------------------------------------
//  
// ---
void DrawPolyline( ksDocument2D& doc ) {
  //    
  ksPolylineParam  par( kompas.GetParamStruct(ko_PolylineParam) );
	ksMathPointParam pr ( kompas.GetParamStruct(ko_MathPointParam) );
	if ( par.m_lpDispatch && pr.m_lpDispatch ) {
		par.Init();
		pr.Init();

		ksDynamicArray arr( par.GetpMathPoint() );
		if ( arr.m_lpDispatch ) {
			pr.SetX( 10 );
			pr.SetY( 10 );
			arr.ksAddArrayItem( -1, pr );
			pr.SetX( 20 );
			pr.SetY( 20 );
			arr.ksAddArrayItem( -1, pr );
			pr.SetX( 30 );
			pr.SetY( 10 );
			arr.ksAddArrayItem( -1, pr );
			pr.SetX( 40 );
			pr.SetY( 20 );
			arr.ksAddArrayItem( -1, pr );

			par.SetStyle( 2 );
			reference p = doc.ksPolylineByParam( par );
			doc.ksLightObj( p, 1 );
			kompas.ksMessage( "" );
			doc.ksLightObj( p, 0 );

			arr.ksDeleteArray();
		}
	}
}

//-------------------------------------------------------------------------------
//   Nurbs - 
// ---
void DrawNurbs( ksDocument2D& doc ) {
	ksNurbsPointParam par( kompas.GetParamStruct(ko_NurbsPointParam) );
	if ( par.m_lpDispatch ) {
		par.Init();
		// Nurbs     
		doc.ksNurbs( 3, 0, 1 );
			par.SetX( 0 );
			par.SetY( 0 );
			par.SetWeight( 1 );
			doc.ksNurbsPoint( par );
			par.SetX( 20 );
			par.SetY( 20 );
			par.SetWeight( 1 );
			doc.ksNurbsPoint( par );
			par.SetX( 50 );
			par.SetY( 10 );
			par.SetWeight( 1 );
			doc.ksNurbsPoint( par );
			par.SetX( 70 );
			par.SetY( 20 );
			par.SetWeight( 1 );
			doc.ksNurbsPoint( par );
			par.SetX( 100 );
			par.SetY( 0 );
			par.SetWeight( 1 );
			doc.ksNurbsPoint( par );
			par.SetX( 50 );
			par.SetY( -50 );
			par.SetWeight( 1 );
			doc.ksNurbsPoint( par );
		reference p = doc.ksEndObj();
		doc.ksLightObj( p, 1 );
		kompas.ksMessage( "NURBS" );
		doc.ksLightObj( p, 0 );
	}
}

//-------------------------------------------------------------------------------
//   
// ---
void DrawInsFragment1( ksDocument2D& doc ) {
	ksFragment frg( doc.GetFragment() );
	if ( frg.m_lpDispatch ) {
		//    
		reference pDefFrg = frg.ksFragmentDefinition( "c:\\1.frw", //   
																									"frw1",      //  
																									1 );         //   1 -  
		if ( pDefFrg ) {
			ksPlacementParam par( kompas.GetParamStruct(ko_PlacementParam) );
			if ( par.m_lpDispatch ) {
				par.SetAngle( 45 );
				par.SetScale_( 2 );
				par.SetXBase( 30 );
				par.SetYBase( 40 );
		    //   " "
				reference p = frg.ksInsertFragment( pDefFrg,     //    
											              				false,       //     false -    
															              par );       //  
		    doc.ksLightObj( p, 1 );
			  kompas.ksMessage( "  " );
				doc.ksLightObj( p, 0 );
			}
		}
	}
}

//-------------------------------------------------------------------------------
//   
// ---
void DrawInsFragment2( ksDocument2D& doc ) {
	//    
	ksFragment frg( doc.GetFragment() );
	if ( frg.m_lpDispatch ) {
		reference pDefFrg;
		//   
	  if ( frg.ksLocalFragmentDefinition("local") ) {
	    doc.ksLineSeg( 0, 0, 10, 0,  1 );
		  doc.ksLineSeg( 0, 0,  0, 10, 1 );
			doc.ksArcByPoint( 0, 0, 10, 10, 0, 0, 10, -1, 1 );
			pDefFrg = frg.ksCloseLocalFragmentDefinition();
		  if ( pDefFrg ) {
				ksPlacementParam par( kompas.GetParamStruct(ko_PlacementParam) );
				if ( par.m_lpDispatch ) {
					par.SetAngle( 45 );
					par.SetScale_( 2 );
					par.SetXBase( 30 );
					par.SetYBase( 40 );
			    //   " "
					reference p = frg.ksInsertFragment( pDefFrg,     //    
												              				false,       //     false -    
																              par );       //  
			    doc.ksLightObj( p, 1 );
				  kompas.ksMessage( "  " );
					doc.ksLightObj( p, 0 );
				}
			}
		}
	}
}

//-------------------------------------------------------------------------------
//
// ---
void DrawSpecRough( ksDocument2D& doc ) {
	ksSpecRoughParam par( kompas.GetParamStruct(ko_SpecRoughParam) );
	if ( par.m_lpDispatch ) {
		par.Init();
		par.SetT( 1 );
		par.SetS( "Rz40" );
		par.SetSign( 2 );
		par.SetStyle( 1 );
		doc.ksSpecRough( par );
	}
}
