//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include <windows.h>
#include <stdio.h>

#include <ldefin2d.h>
#include <ldefin3d.h>
#include <ksConstants.h>

#ifdef __LIGHT_VERSION__
#include <Kl_TLB.h>
#else
#include <Ks_TLB.h>
#endif
//---------------------------------------------------------------------------
//   Important note about DLL memory management when your DLL uses the
//   static version of the RunTime Library:
//
//   If your DLL exports any functions that pass String objects (or structs/
//   classes containing nested Strings) as parameter or function results,
//   you will need to add the library MEMMGR.LIB to both the DLL project and
//   any other projects that use the DLL.  You will also need to use MEMMGR.LIB
//   if any other projects which use the DLL will be performing new or delete
//   operations on any non-TObject-derived classes which are exported from the
//   DLL. Adding MEMMGR.LIB to your project will change the DLL and its calling
//   EXE's to use the BORLNDMM.DLL as their memory manager.  In these cases,
//   the file BORLNDMM.DLL should be deployed along with your DLL.
//
//   To avoid using BORLNDMM.DLL, pass string information using "char *" or
//   ShortString parameters.
//
//   If your DLL uses the dynamic version of the RTL, you do not need to
//   explicitly add MEMMGR.LIB as this will be done implicitly for you
//---------------------------------------------------------------------------

#pragma argsused
int WINAPI DllEntryPoint(HINSTANCE hinst, unsigned long reason, void* lpReserved)
{
  return 1;
}
//---------------------------------------------------------------------------

//------------------------------------------------------------------------------
//
// ---
extern "C" IDispatch* far __export WINAPI CreateKompasObject();


KompasObject* kompas = NULL;

extern "C" unsigned int far __export __pascal LibraryId(){
	return 100;
}


void CreateExtrusion( ksDocument3D * doc );
void OperationRotated( ksDocument3D * doc );
void OperationLoft( ksDocument3D * doc );
void CreateFilletAndChamfer( ksDocument3D * doc );

//------------------------------------------------------------------------------
//
// ---
extern "C" void far __export __pascal  LibraryEntry( UINT Comm ) {
  kompas = (KompasObject*)::CreateKompasObject();
  if ( kompas ) {
    ksDocument3D* doc = (ksDocument3D*)kompas->ActiveDocument3D();
    if ( doc )
      switch ( Comm ) {
        case 1: CreateExtrusion( doc );        break; //   
        case 2: OperationRotated( doc );       break; //  
        case 3: OperationLoft( doc );  	       break; //   
        case 4: CreateFilletAndChamfer( doc ); break; //    
      }
    else
      kompas->ksError( StringToOleStr("3D   ") );
    kompas->Release();
  }
}

//-------------------------------------------------------------------------------
//      
// ---
/*
void ClearCurrentSketch( ksDocument2D * sketchEdit ) {
  //         
  ksIterator * iter = (ksIterator*)kompas->GetIterator();
	if ( iter ) {
		if ( iter->ksCreateIterator(ALL_OBJ, 0) ) {
			reference ref;
			if ( ref = iter->ksMoveIterator(StringToOleStr("F")) ) { //       
				//              
        do {
          if ( sketchEdit->ksExistObj(ref) )
						sketchEdit->ksDeleteObj( ref );      //     
        } while ( ref = iter->ksMoveIterator(StringToOleStr("N")) );
			}

			iter->ksDeleteIterator(); //  
		}
	}
}
*/
//------------------------------------------------------------------------------
//   
// ---
void CreateExtrusion( ksDocument3D * doc ) {
	ksPart * part = (ksPart*)doc->GetPart(pNew_Part); //  
	if ( part ) {
    ksEntity * entitySketch = (ksEntity*)part->NewEntity(o3d_sketch);
		if ( entitySketch ) {
			//   
			ksSketchDefinition * sketchDef = (ksSketchDefinition*)entitySketch->GetDefinition();
			if ( sketchDef ) {
				//     XOY
				ksEntity * basePlane = (ksEntity*)part->GetDefaultEntity(o3d_planeXOY);
				sketchDef->SetPlane( basePlane ); //   XOY   
  			sketchDef->set_angle( 45 );        //   
				entitySketch->Create();           //  

				//   
				ksDocument2D * sketchEdit = (ksDocument2D*)sketchDef->BeginEdit();
        if ( sketchEdit ) {
          //    - 
   				sketchEdit->ksCircle( 0, 0, 100, 1 );
  				sketchDef->EndEdit();                   //   
        }

				ksEntity * entityExtr = (ksEntity*)part->NewEntity(o3d_baseExtrusion);
				if ( entityExtr ) {
					//     
					ksBaseExtrusionDefinition * extrusionDef = (ksBaseExtrusionDefinition*)entityExtr->GetDefinition(); //    
					if ( extrusionDef ) {
						extrusionDef->set_directionType( dtNormal );         //  
						extrusionDef->SetSideParam( true/* */, etBlind/*  */, 200, 0, false );
						extrusionDef->SetThinParam( true, dtBoth, 10, 10 ); //     
						extrusionDef->SetSketch( entitySketch ); //   
						entityExtr->Create();                    //  

					  kompas->ksMessage( StringToOleStr("   ") );

						extrusionDef->SetSideParam( false/* */, etBlind/*  */, 150, 0, false );
					  extrusionDef->set_directionType( dtBoth/*  */ ); //  
						entityExtr->_Update(); //  

/*						kompas->ksMessage( StringToOleStr(" ") );

						sketchEdit->DetachDispatch();
						//   
						sketchEdit->AttachDispatch( sketchDef->BeginEdit() );

							//         
							ClearCurrentSketch( sketchEdit );
							//    
       				sketchEdit->ksCircle( 0, 0, 100, 1 );

						sketchDef->EndEdit();   //   
						entitySketch->_Update(); //   
						entityExtr->_Update();   //    
 */
						kompas->ksMessage( StringToOleStr(" ") );

						//   
						ksEntity * entitySketch2 = (ksEntity*)part->NewEntity(o3d_sketch);
						if ( entitySketch2 ) {
							//   
							ksSketchDefinition * sketchDef2 = (ksSketchDefinition*)entitySketch2->GetDefinition();
							if ( sketchDef2 ) {
								sketchDef2->SetPlane( basePlane ); //  
								sketchDef2->set_angle( 45 );        //    45 .
								entitySketch2->Create();           //  

								//   
								ksDocument2D * sketchEdit2 = (ksDocument2D*)sketchDef2->BeginEdit();
									sketchEdit2->ksCircle( 0, 0, 150, 1 );
								sketchDef2->EndEdit(); //   

								//  
								ksEntity * entityBossExtr = (ksEntity*)part->NewEntity(o3d_bossExtrusion);
								if ( entityBossExtr ) {
									ksBossExtrusionDefinition * bossExtrDef = (ksBossExtrusionDefinition*)entityBossExtr->GetDefinition();
									if ( bossExtrDef ) {
										ksExtrusionParam * extrProp = (ksExtrusionParam*)bossExtrDef->ExtrusionParam(); //    
										ksThinParam * thinProp = (ksThinParam*)bossExtrDef->ThinParam();      //     
										if ( extrProp && thinProp ) {
											bossExtrDef->SetSketch( entitySketch2 ); //   

											extrProp->set_direction( dtNormal );      //   ()
											extrProp->set_typeNormal( etBlind );      //   (    )
											extrProp->set_depthNormal( 100 );         //  

											thinProp->set_thin( false );              //   

											entityBossExtr->Create();                //  
										}
									}
								}

								//   
								ksEntity * entitySketch3 = (ksEntity*)part->NewEntity(o3d_sketch);
								if ( entitySketch3 ) {
									//   
									ksSketchDefinition * sketchDef3 = (ksSketchDefinition*)entitySketch3->GetDefinition();
									if ( sketchDef3 ) {
										sketchDef3->SetPlane( basePlane ); //  
										sketchDef3->set_angle( 45 );        //    45 .
										entitySketch3->Create();           //  

										//   
										ksDocument2D * sketchEdit3 = (ksDocument2D *)sketchDef3->BeginEdit();
											//    - 
											sketchEdit3->ksLineSeg(  50,  50, -50,  50, 1 );
											sketchEdit3->ksLineSeg(  50, -50, -50, -50, 1 );

											sketchEdit3->ksLineSeg(  50, -50,  50,  50, 1 );
											sketchEdit3->ksLineSeg( -50, -50, -50,  50, 1 );
										sketchDef3->EndEdit(); //   

										//  
										ksEntity * entityCutExtr = (ksEntity*)part->NewEntity(o3d_cutExtrusion);
										if ( entityCutExtr ) {
											ksCutExtrusionDefinition * cutExtrDef = (ksCutExtrusionDefinition*)entityCutExtr->GetDefinition();
											if ( cutExtrDef ) {
												cutExtrDef->SetSketch( entitySketch3 ); //   
												cutExtrDef->set_directionType( dtNormal );
  											cutExtrDef->SetSideParam( true/* */,  etBlind/*etThroughAll*/, 50, 0, false );
												cutExtrDef->SetThinParam( false, 0, 0, 0 );
											}

											entityCutExtr->Create(); //    
										}
									}
								}
							}
						}
					}
				}
			}
		}
	}
}

//------------------------------------------------------------------------------
//  
// ---
void OperationRotated( ksDocument3D * doc ) {
	ksPart * part = (ksPart*)doc->GetPart(pNew_Part) ; //  
  if ( part ) {
    ksEntity * entitySketch = (ksEntity*)part->NewEntity(o3d_sketch);
    if ( entitySketch ) {
      ksSketchDefinition * sketchDef = (ksSketchDefinition*)entitySketch->GetDefinition(); //   
      if ( sketchDef ) {
        ksEntity * basePlane = (ksEntity*)part->GetDefaultEntity(o3d_planeXOY); //     XOY
	      if ( basePlane ) {
					sketchDef->SetPlane( basePlane ); //   XOY   
					entitySketch->Create();           //  

					//   
          ksDocument2D * sketchEdit = (ksDocument2D*)sketchDef->BeginEdit();
					if ( sketchEdit ) {
						sketchEdit->ksArcByAngle( 0, 0, 20, -90, 90, 1, 1 );
						sketchEdit->ksLineSeg( 0, -20, 0, 20, 3 );
					  sketchDef->EndEdit();                   //   
					}

          ksEntity * entityRotate = (ksEntity*)part->NewEntity(o3d_baseRotated);
					if ( entityRotate ) {
            ksBaseRotatedDefinition *rotateDef = (ksBaseRotatedDefinition*)entityRotate->GetDefinition(); //    
						if ( rotateDef ) {
              ksRotatedParam * rotproperty = (ksRotatedParam*)rotateDef->RotatedParam();
							if ( rotproperty ) {
								rotproperty->set_direction( dtBoth );
								rotproperty->set_toroidShape(false);
							}

							rotateDef->SetThinParam( true, dtBoth, 1, 1 ); //     
							rotateDef->SetSideParam( true, 180 );
							rotateDef->SetSideParam( false, 180 );
							rotateDef->SetSketch( entitySketch );          //   
							entityRotate->Create();                        //  
						}
					}
        }
      }
    }
		kompas->ksMessage( StringToOleStr("  " ) );

    ksEntity * entitySketch2 = (ksEntity*)part->NewEntity(o3d_sketch);
		if ( entitySketch2 ) {
			ksSketchDefinition * sketchDef2 = (ksSketchDefinition*)entitySketch2->GetDefinition();
			if ( sketchDef2 ) {
				ksEntity * basePlane = (ksEntity*)part->GetDefaultEntity(o3d_planeXOY);
				if ( basePlane ) {
					sketchDef2->SetPlane( basePlane ); //   XOY   
					entitySketch2->Create();           //  
					//   
					ksDocument2D * sketchEdit2 = (ksDocument2D*)sketchDef2->BeginEdit();
					if ( sketchEdit2 ) {
						sketchEdit2->ksArcByAngle( 15, 0, 10, -90, 90, 1, 1 );
						sketchEdit2->ksLineSeg( 15, -10, 15, 10, 3 );
						sketchDef2->EndEdit();                   //   
					}

					ksEntity * entityBossRotate = (ksEntity*)part->NewEntity(o3d_bossRotated);
					if ( entityBossRotate ) {
						ksBossRotatedDefinition * bossRotateDef = (ksBossRotatedDefinition*)entityBossRotate->GetDefinition();
						if ( bossRotateDef ) {
							bossRotateDef->set_directionType( dtNormal );
							bossRotateDef->SetSideParam( true, 360 );
							bossRotateDef->SetSketch( entitySketch2 );          //   
							entityBossRotate->Create();                        //  
						}
					}
				}
			}
		}
		kompas->ksMessage( StringToOleStr("  " ) );

    ksEntity * entitySketch3 = (ksEntity*)part->NewEntity(o3d_sketch);
		if ( entitySketch3 ) {
			ksSketchDefinition * sketchDef = (ksSketchDefinition*)entitySketch3->GetDefinition();
			if ( sketchDef ) {
				ksEntity * basePlane = (ksEntity*)part->GetDefaultEntity(o3d_planeXOY);
				if ( basePlane ) {
					sketchDef->SetPlane( basePlane ); //   XOY   
					entitySketch3->Create();           //  
					//   
					ksDocument2D * sketchEdit3 = (ksDocument2D*)sketchDef->BeginEdit();
					if ( sketchEdit3 ) {
						sketchEdit3->ksArcByAngle( 20, 0, 20, 90, 270, 1, 1 );
						sketchEdit3->ksLineSeg( 20, -20, 20, 20, 3 );
					  sketchDef->EndEdit();                   //   
					}

					ksEntity * entityCutRotate = (ksEntity*)part->NewEntity(o3d_cutRotated);
					if ( entityCutRotate ) {
						ksCutRotatedDefinition * cutRotateDef = (ksCutRotatedDefinition*)entityCutRotate->GetDefinition();
						if ( cutRotateDef ) {
							cutRotateDef->set_directionType( dtNormal );
							cutRotateDef->SetSideParam( true, 90 );
							cutRotateDef->SetThinParam( true, dtBoth, 5, 7 );   //     
							cutRotateDef->SetSketch( entitySketch3 );        //   
							entityCutRotate->Create();                       //  
						}
					}
				}
			}
		}
		kompas->ksMessage( StringToOleStr("  " ) );
	}
}

//------------------------------------------------------------------------------
//   
// ---
void OperationLoft( ksDocument3D * doc ) {
	ksPart * part = (ksPart*)doc->GetPart(pNew_Part); //  
	if ( part ) {
		//  
    ksEntity * entitySketch = (ksEntity*)part->NewEntity(o3d_sketch);
		if ( entitySketch ) {
			ksSketchDefinition * sketchDef = (ksSketchDefinition*)entitySketch->GetDefinition();
			if ( sketchDef ) {
				ksEntity * basePlane = (ksEntity*)part->GetDefaultEntity(o3d_planeXOY); //     XOY
				sketchDef->SetPlane( basePlane ); //   XOY   
				entitySketch->Create();           //  
				entitySketch->hidden = true;

				//   
				ksDocument2D * sketchEdit = (ksDocument2D*)sketchDef->BeginEdit();
				  sketchEdit->ksCircle( 0, 0, 4.5, 1 );
				sketchDef->EndEdit();                   //   
			}
		}

		//   ,    
		ksEntity * entityOffsetPlane = (ksEntity*)part->NewEntity(o3d_planeOffset);
		ksEntity * entitySketch2 = (ksEntity *)part->NewEntity(o3d_sketch);
		if ( entityOffsetPlane ) {
			//    
			ksPlaneOffsetDefinition * offsetDef = (ksPlaneOffsetDefinition*)entityOffsetPlane->GetDefinition();
			if ( offsetDef ) {
				offsetDef->set_offset( 30 ); //    
				ksEntity * basePlane = (ksEntity*)part->GetDefaultEntity(o3d_planeXOY);

				offsetDef->SetPlane( basePlane ); //  
				entityOffsetPlane->hidden = true;
				entityOffsetPlane->Create();                 //   

				if ( entitySketch2 ) {
					ksSketchDefinition * sketchDef2 = (ksSketchDefinition*)entitySketch2->GetDefinition();
					if ( sketchDef2 ) {
						sketchDef2->SetPlane( entityOffsetPlane ); //   XOY   
						entitySketch2->Create();           //  

						//   
						ksDocument2D * sketchEdit2 = (ksDocument2D*)sketchDef2->BeginEdit();
            if ( sketchEdit2 )
						  sketchEdit2->ksCircle( 0, 0, 8, 1 );
						sketchDef2->EndEdit();                   //   
					}
				}
			}
		}

		//   ,    
		ksEntity * entityOffsetPlane2 = (ksEntity*)part->NewEntity(o3d_planeOffset);
		ksEntity * entitySketch3 = (ksEntity*)part->NewEntity(o3d_sketch);
		if ( entityOffsetPlane2 ) {
			//    
			ksPlaneOffsetDefinition * offsetDef = (ksPlaneOffsetDefinition*)entityOffsetPlane2->GetDefinition();
			if ( offsetDef ) {
				offsetDef->set_offset( 60 ); //    
				ksEntity * basePlane = (ksEntity*)part->GetDefaultEntity(o3d_planeXOY);
				basePlane->set_name( StringToOleStr(" ") ); //   

				offsetDef->SetPlane( basePlane ); //  
				entityOffsetPlane2->set_name( StringToOleStr(" 2") ); //    
				entityOffsetPlane2->hidden = true;
				entityOffsetPlane2->Create();                 //   

				if ( entitySketch3 ) {
					ksSketchDefinition * sketchDef2 = (ksSketchDefinition*)entitySketch3->GetDefinition();
					if ( sketchDef2 ) {
						sketchDef2->SetPlane( entityOffsetPlane2 ); //   XOY   
						entitySketch3->Create();           //  

						//   
						ksDocument2D * sketchEdit2 = (ksDocument2D*)sketchDef2->BeginEdit();
            if ( sketchEdit2 )
						  sketchEdit2->ksCircle( 0, 0, 1.5, 1 );
						sketchDef2->EndEdit();                   //   
					}
				}
			}
		}

		//     
		ksEntity * entityBaseLoft = (ksEntity*)part->NewEntity(o3d_baseLoft);
		if ( entityBaseLoft ) {
			ksBaseLoftDefinition * baseLoft = (ksBaseLoftDefinition*)entityBaseLoft->GetDefinition();
			if ( baseLoft ) {
				ksEntityCollection * entCol = (ksEntityCollection*)baseLoft->Sketchs();
				if ( entCol ) {
          entCol->Add(entitySketch);
          entCol->Add(entitySketch2);
          entCol->Add(entitySketch3);
				}
				entityBaseLoft->set_name( StringToOleStr("") );
				entityBaseLoft->SetAdvancedColor( 12345678, .8, .8, .8, .8, 1, .8 );

				entityBaseLoft->Create();                        //  
			}
		}
		kompas->ksMessage( StringToOleStr("   " ) );

		//   ,    
		ksEntity * entitySketch7 = (ksEntity*)part->NewEntity(o3d_sketch);
		if ( entitySketch7 ) {
			//    
			ksSketchDefinition * sketchDef = (ksSketchDefinition*)entitySketch7->GetDefinition();
			if ( sketchDef ) {
				sketchDef->SetPlane( entityOffsetPlane2 ); //   XOY   
				entitySketch7->Create();           //  

				//   
				ksDocument2D * sketchEdit = (ksDocument2D*)sketchDef->BeginEdit();
					sketchEdit->ksCircle( 0, 0, 1.5, 1 );
				sketchDef->EndEdit();                   //   
			}
		}

		//   ,    
		ksEntity * entityOffsetPlane3 = (ksEntity*)part->NewEntity(o3d_planeOffset);
		ksEntity * entitySketch4 = (ksEntity*)part->NewEntity(o3d_sketch);
		if ( entityOffsetPlane3 ) {
			//    
			ksPlaneOffsetDefinition * offsetDef = (ksPlaneOffsetDefinition*)entityOffsetPlane3->GetDefinition();
			if ( offsetDef ) {
				offsetDef->set_offset( 120 ); //    
				ksEntity * basePlane = (ksEntity*)part->GetDefaultEntity(o3d_planeXOY);
				basePlane->set_name( StringToOleStr(" ") ); //   

				offsetDef->SetPlane( basePlane ); //  
				entityOffsetPlane3->set_name( StringToOleStr(" ") ); //    
				entityOffsetPlane3->hidden = true;
				entityOffsetPlane3->Create();                 //   

				if ( entitySketch4 ) {
					ksSketchDefinition * sketchDef = (ksSketchDefinition*)entitySketch4->GetDefinition();
					if ( sketchDef ) {
						sketchDef->SetPlane( entityOffsetPlane3 ); //   XOY   
						entitySketch4->Create();           //  

						//   
						ksDocument2D * sketchEdit3 = (ksDocument2D*)sketchDef->BeginEdit();
            if ( sketchEdit3 )
						  sketchEdit3->ksCircle( 0, 0, 1.8, 1 );
						sketchDef->EndEdit();                   //   
					}
				}
			}
		}


		//     
		ksEntity * entityBossLoft = (ksEntity*)part->NewEntity(o3d_bossLoft);
		if ( entityBossLoft ) {
			ksBossLoftDefinition * bossLoft = (ksBossLoftDefinition*)entityBossLoft->GetDefinition();
			if ( bossLoft ) {
				ksEntityCollection * entCol = (ksEntityCollection*)bossLoft->Sketchs();
				if ( entCol ) {
          entCol->Add(entitySketch7);
          entCol->Add(entitySketch4);
				}
				entityBossLoft->set_name( StringToOleStr("") );
				entityBossLoft->SetAdvancedColor( 1234567890, .8, .8, .8, .8, 1, .8 );

				entityBossLoft->Create();                        //  
			}
		}
		kompas->ksMessage( StringToOleStr("   " ) );

		//       
		ksEntity * entitySketch5 = (ksEntity *)part->NewEntity(o3d_sketch);
		if ( entitySketch5 ) {
			ksSketchDefinition * sketchDef = (ksSketchDefinition*)entitySketch5->GetDefinition();
			if ( sketchDef ) {
				sketchDef->SetPlane( entityOffsetPlane3 ); //   XOY   
				entitySketch5->Create();           //  

				//   
				ksDocument2D * sketchEdit3 = (ksDocument2D*)sketchDef->BeginEdit();
					ksRectangleParam * recPar = (ksRectangleParam *)kompas->GetParamStruct(ko_RectangleParam);
					recPar->Init();
					if ( recPar ) {
						recPar->set_x(-1.8);
						recPar->set_y(-.4);
						recPar->set_height(.8);
						recPar->set_width(3.6);
						recPar->set_style(1);
					}
          sketchEdit3->ksRectangle( recPar, 0 );
				sketchDef->EndEdit();                   //   
			}
		}

		//   ,    
		ksEntity * entityOffsetPlane4 = (ksEntity*)part->NewEntity(o3d_planeOffset);
		ksEntity * entitySketch6 = (ksEntity *)part->NewEntity(o3d_sketch);
		if ( entityOffsetPlane4 ) {
			//    
			ksPlaneOffsetDefinition * offsetDef = (ksPlaneOffsetDefinition*)entityOffsetPlane4->GetDefinition();
			if ( offsetDef ) {
				offsetDef->set_offset( 110 ); //    
				ksEntity * basePlane = (ksEntity*)part->GetDefaultEntity(o3d_planeXOY);
				basePlane->set_name( StringToOleStr(" ") ); //   

				offsetDef->SetPlane( basePlane ); //  
				entityOffsetPlane4->set_name( StringToOleStr(" ") ); //    
				entityOffsetPlane4->hidden = true;
				entityOffsetPlane4->Create();                 //   

				if ( entitySketch6 ) {
					ksSketchDefinition * sketchDef = (ksSketchDefinition*)entitySketch6->GetDefinition();
					if ( sketchDef ) {
						sketchDef->SetPlane( entityOffsetPlane4 ); //   XOY   
						entitySketch6->Create();           //  

						//   
						ksDocument2D * sketchEdit4 = (ksDocument2D*)sketchDef->BeginEdit();
							ksRectangleParam * recPar = (ksRectangleParam *)kompas->GetParamStruct(ko_RectangleParam);
							recPar->Init();
							if ( recPar ) {
								recPar->set_x(-1.8);
								recPar->set_y(-1.8);
								recPar->set_height(3.6);
								recPar->set_width(3.6);
								recPar->set_style(1);
							}
							sketchEdit4->ksRectangle( recPar, 0 );
						sketchDef->EndEdit();                   //   
					}
				}
			}
		}


		//     
		ksEntity * entityCutLoft = (ksEntity *)part->NewEntity(o3d_cutLoft);
		if ( entityCutLoft ) {
			ksCutLoftDefinition * cutLoft = (ksCutLoftDefinition*)entityCutLoft->GetDefinition();
			if ( cutLoft ) {
				ksEntityCollection * entCol = (ksEntityCollection*)cutLoft->Sketchs();
				if ( entCol ) {
          entCol->Add(entitySketch5);
          entCol->Add(entitySketch6);
				}
				cutLoft->SetThinParam( true, dtNormal, 3, 0 );
				entityCutLoft->set_name( StringToOleStr(" ") );
				entityCutLoft->SetAdvancedColor( 1234, .8, .8, .8, .8, 1, .8 );

				entityCutLoft->Create();                        //  
			}
		}
		kompas->ksMessage( StringToOleStr("   " ) );
	}
}

//------------------------------------------------------------------------------
//    
// ---
void CreateFilletAndChamfer( ksDocument3D * doc ) {
	ksPart * part = (ksPart*)doc->GetPart(pNew_Part); //  
	if ( part ) {
    ksEntity * entitySketch = (ksEntity*)part->NewEntity(o3d_sketch);
		if ( entitySketch ) {
			//   
			ksSketchDefinition * sketchDef = (ksSketchDefinition*)entitySketch->GetDefinition();
			if ( sketchDef ) {
				//     XOY
				ksEntity * basePlane = (ksEntity*)part->GetDefaultEntity(o3d_planeXOY);
				sketchDef->SetPlane( basePlane ); //   XOY   
  			sketchDef->angle = 45;        //   
				entitySketch->Create();           //  

				//   
				ksDocument2D * sketchEdit = (ksDocument2D*)sketchDef->BeginEdit();
          //    - 
					sketchEdit->ksLineSeg(  50,  50, -50,  50, 1 );
					sketchEdit->ksLineSeg(  50, -50, -50, -50, 1 );

					sketchEdit->ksLineSeg(  50, -50,  50,  50, 1 );
					sketchEdit->ksLineSeg( -50, -50, -50,  50, 1 );
				sketchDef->EndEdit();             //   

				ksEntity * entityExtr = (ksEntity*)part->NewEntity(o3d_baseExtrusion);
				if ( entityExtr ) {
					//     
					ksBaseExtrusionDefinition * extrusionDef = (ksBaseExtrusionDefinition*)entityExtr->GetDefinition(); //    
					if ( extrusionDef ) {
						extrusionDef->set_directionType( dtNormal );   //  
						extrusionDef->SetSideParam( true/* */, etBlind/*  */, 100, 0, false );
						extrusionDef->SetThinParam( false, 0, 0, 0 ); //   
						extrusionDef->SetSketch( entitySketch );      //   
						entityExtr->Create();                         //  

            ksEntityCollection * collect = (ksEntityCollection*)part->EntityCollection(o3d_face);
            if ( collect ) {
              bool res = collect->SelectByPoint(0, 0, 0);
              int count = collect->GetCount();
              if ( count && res  ) {
                kompas->ksMessage( StringToOleStr(" ") );
                ksEntity * entityFillet = (ksEntity*)part->NewEntity(o3d_fillet);
                if ( entityFillet ) {
                  ksFilletDefinition * filletDef = (ksFilletDefinition*)entityFillet->GetDefinition();
                  if ( filletDef ) {
                    filletDef->set_radius( 10 );      //  
                    filletDef->set_tangent( false );  //   
                    ksEntityCollection * arr = (ksEntityCollection*)filletDef->array(); //   
                    if ( arr ) {
                      for ( int i = 0; i < count; i++ )
                        arr->Add( collect->GetByIndex(i) );

                      entityFillet->Create();
                    }
                  }
                }
              }
            }  

            ksEntityCollection * collect2 = (ksEntityCollection*)part->EntityCollection(o3d_face);
            if ( collect2 ) {
              bool res = collect2->SelectByPoint(0, 0, 100);
              int count = collect2->GetCount();
              if ( count && res  ) {
                kompas->ksMessage( StringToOleStr(" ") );
                ksEntity * entityChamfer = (ksEntity*)part->NewEntity(o3d_chamfer);
                if ( entityChamfer ) {
                  ksChamferDefinition * ChamferDef = (ksChamferDefinition*)entityChamfer->GetDefinition();
                  if ( ChamferDef ) {
                    ChamferDef->set_tangent( false );
                    ChamferDef->SetChamferParam( true, 10, 10 );
                    ksEntityCollection * arr = (ksEntityCollection*)ChamferDef->array(); //   
                    if ( arr ) {
                      for ( int i = 0; i < count; i++ )
                        arr->Add( collect2->GetByIndex(i) );

                      entityChamfer->Create();
                    }
                  }
                }
              }
						}
					}
				}
			}
		}
	}
}

