//////////////////////////////////////////////////////////////////////////////// 
// 
// step9.cpp -     
// 
// 1.                - DrawLinDim
// 2.                 - DrawAngDim
// 3.                 - DrawRough
// 4.                  - DrawLeader
// 5.       - DrawPosLeader
// 6.                     - DrawBrandLeader
// 7.                  - DrawMarkerLeader
// 8.               - DrawBase
// 9.   /c       - DrawCutLine
// 10.          - DrawDiamDim
// 11.             - DrawRadDimt
// 12.   c  - DrawRadBreakDimt
// 13.                  - DrawViewPointer  
// 
//////////////////////////////////////////////////////////////////////////////// 
#include "stdafx.h"
#include <afxdllx.h> 
#include "resource.h"

#ifndef __LIBTOOL_H
#include <libtool.h>
#endif

#ifndef __LDEFIN2D_H
#include <ldefin2d.h>
#endif

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


//-------------------------------------------------------------------------------
//       DLL
// ---
static AFX_EXTENSION_MODULE StepDLL = { NULL, NULL };


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

  if ( dwReason == DLL_PROCESS_ATTACH )
  {
    TRACE0( "DLL Initializing!" );
 
    if ( !AfxInitExtensionModule( StepDLL, hInstance ) )
      return 0;

    new CDynLinkLibrary( StepDLL );
  }
  else if ( dwReason == DLL_PROCESS_DETACH )
  {
    TRACE0( "DLL Terminating!" );
    AfxTermExtensionModule( StepDLL );
  }
  return 1;
}


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


//-------------------------------------------------------------------------------
//   
// ---
void DrawLinDim();
void DrawAngDim();
void DrawRough();
void DrawLeader();
void DrawPosLeader();
void DrawBrandLeader();
void DrawMarkerLeader();
void DrawBase();
void DrawCutLine();
void DrawDiamDim();
void DrawRadDimt();
void DrawRadBreakDimt();
void DrawViewPointer();


//-------------------------------------------------------------------------------
//   
// ---
void WINAPI LIBRARYENTRY( unsigned int comm )
{
  if ( ksGetCurrentDocument( 1 ) ) //   2D 
  {
    switch ( comm )
    {
      case 1  : DrawLinDim();       break; //  
      case 2  : DrawAngDim();       break; //  
      case 3  : DrawRough();        break; // 
      case 4  : DrawLeader();       break; //  
      case 5  : DrawPosLeader();    break; //   
      case 6  : DrawBrandLeader();  break; // 
      case 7  : DrawMarkerLeader(); break; // 
      case 8  : DrawBase();         break; //  
      case 9  : DrawCutLine();      break; //  /c
      case 10 : DrawDiamDim();      break; //  
      case 11 : DrawRadDimt();      break; //  
      case 12 : DrawRadBreakDimt(); break; //   c 
      case 13 : DrawViewPointer();  break; //  
    }
  }
  else
    ErrorT( _T("   \n  /") );
}


//-------------------------------------------------------------------------------
//      ( 0 -  , 1 -  ,
// 2 -    , 3 -   c  )
// ---
static void ShowDimParam( LPCTSTR title, void *pParam, int typeParam, int typeDim )
{
  DimText * pParDimText             = NULL; //    
  DimDrawing * pParDimDrawing       = NULL; //       
  RDimDrawing  * pParRDimDrawing    = NULL; //       
  RBreakDrawing * pParRBreakDrawing = NULL; //       
  LDimSource * pParLDimSource       = NULL; //     
  ADimSource * pParADimSource       = NULL; //     
  RDimSource * pParRDimSource       = NULL; //       
  
  switch ( typeParam ) 
  {
    //   
    case ALLPARAM_W :  
    case ALLPARAM   :  
    {
      switch ( typeDim )
      {
        case 0 :
        {
          LDimParam * pParLDim = ( LDimParam * )pParam;
          pParDimText    = &pParLDim->tPar;
          pParLDimSource = &pParLDim->sPar;
          pParDimDrawing = &pParLDim->dPar;
          break;
        }
        case 1 :
        {
          ADimParam * pParADim = ( ADimParam * )pParam;
          pParDimText    = &pParADim->tPar;
          pParADimSource = &pParADim->sPar;
          pParDimDrawing = &pParADim->dPar;
          break;
        }
        case 2 :  
        {
          RDimParam * pParRDim = ( RDimParam * )pParam;
          pParDimText     = &pParRDim->tPar;
          pParRDimSource  = &pParRDim->sPar;
          pParRDimDrawing = &pParRDim->dPar;
          break;
        }
        case 3 :  
        {
          RBreakDimParam * pParRBreakDim = ( RBreakDimParam * )pParam;
          pParDimText       = &pParRBreakDim->tPar;
          pParRDimSource    = &pParRBreakDim->sPar;
          pParRBreakDrawing = &pParRBreakDim->dPar;
          break; 
        }
      }  
      break;
    }
    //    
    case DIM_TEXT_PARAM :
      pParDimText = ( DimText * )pParam;
      break;
    //   
    case DIM_SOURSE_PARAM :
    {
      switch ( typeDim )
      {
        case 0 :
          pParLDimSource = ( LDimSource * ) pParam;
          break;
        case 1 :
          pParADimSource = ( ADimSource * ) pParam;
          break;
        case 2 :
        case 3 :   
          pParRDimSource = ( RDimSource * ) pParam;
          break;
      }  
      break;
    }    
    //   
    case DIM_DRAW_PARAM : 
    {
      switch ( typeDim )
      {
        case 0 :
        case 1 :
          pParDimDrawing = ( DimDrawing * ) pParam;
          break;
        case 2 :
          pParRDimDrawing = ( RDimDrawing * ) pParam;
          break;
        case 3 :            
          pParRBreakDrawing = ( RBreakDrawing * ) pParam;
          break;
      }  
      break;
    }    
  }
  
  TCHAR buf[255];   
   
  //    
  if ( pParDimText ) 
  {
    TCHAR buf1[255], buf2[255];
    buf1[0] = _T('\0');
    
    //    
    int count = GetArrayCount( pParDimText->pText );
    
    //   
    for ( int i = 0; i < count; i++ ) 
    {
      //    
      GetArrayItem( pParDimText->pText, i, buf2, 255 ); 
      _tcscat( buf1, buf2 );
      _tcscat( buf1, _T(" ") );
    }

    _stprintf( buf, _T("%s\n%s\n \nsign = %d,\nbitFlag = %d"), 
             title, buf1, pParDimText->sign, pParDimText->bitFlag );
    MessageT( buf );
  }  
  
  //   
  if ( pParLDimSource ) 
  {
    _stprintf( buf, _T("%s\n \nx1 = %3.2f, y1 = %3.2f,\nx2 = %3.2f, y2 = %3.2f,\ndx = %3.2f, dy = %3.2f,\nbasePoint = %d, ps = %d"), 
             title, pParLDimSource->x1, pParLDimSource->y1, pParLDimSource->x2, pParLDimSource->y2, 
             pParLDimSource->dx, pParLDimSource->dy, pParLDimSource->basePoint, pParLDimSource->ps  );
    MessageT( buf );
  }
  if ( pParADimSource ) 
  {
    _stprintf( buf, _T("%s\n \nxc = %3.2f, yc = %3.2f,\nx1 = %3.2f, y1 = %3.2f,\nx2 = %3.2f, y2 = %3.2f,\nang1 = %3.2f, ang2 = %3.2f,\nrad = %3.2f, dir = %d"), 
             title, pParADimSource->xc, pParADimSource->yc, pParADimSource->x1, pParADimSource->y1, 
             pParADimSource->x2, pParADimSource->y2, pParADimSource->ang1, pParADimSource->ang2, 
             pParADimSource->rad, pParADimSource->dir );
    MessageT( buf );
  }  
  if ( pParRDimSource ) 
  {
    _stprintf( buf, _T("%s\n \nxc = %3.2f, yc = %3.2f,\nrad = %3.2f"), 
             title, pParRDimSource->xc, pParRDimSource->yc, pParRDimSource->rad );
    MessageT( buf );
  } 
  
  //    
  if ( pParDimDrawing ) 
  {
    _stprintf( buf, _T("%s\n \npl1 = %d, pl2 = %d,\npt1 = %d, pt2 = %d,\ntextPos = %d, textBase = %d,\nshelfDir = %d, ang = %3.2f, length = %3.2f"), 
             title, pParDimDrawing->pl1, pParDimDrawing->pl2, pParDimDrawing->pt1, pParDimDrawing->pt2, 
             pParDimDrawing->textPos, pParDimDrawing->textBase, pParDimDrawing->shelfDir,
             pParDimDrawing->ang, pParDimDrawing->length );
    MessageT( buf );
  }
  if ( pParRDimDrawing ) 
  {
    _stprintf( buf, _T("%s\n \npl1 = %d, pl2 = %d,\n\ntextPos = %d, shelfDir = %d,\n ang = %3.2f"), 
             title, pParRDimDrawing->pt1, pParRDimDrawing->pt2, 
             pParRDimDrawing->textPos, pParRDimDrawing->shelfDir, 
             pParRDimDrawing->ang );
    MessageT( buf );
  }
  if ( pParRBreakDrawing ) 
  {
    _stprintf( buf, _T("%s\n \npt = %d,\nang = %3.2f, pb = %3.2f"), 
             title, pParRBreakDrawing->pt, pParRBreakDrawing->ang, pParRBreakDrawing->pb );
    MessageT( buf );
  }    
}


//-------------------------------------------------------------------------------
//  
// ---
void DrawLinDim()
{
  LDimParam parLDim; //    
  memset( &parLDim, 0, sizeof( parLDim ) );
  
  //   
  parLDim.dPar.textPos  = 10;  //   ( 0 -   ,
		                           // > 0 -          ,
		                           // < 0 -           )
  parLDim.dPar.textBase = 2;   //    ( 0 -  , 1 - textPos  1 , 
		                           // 2 - textPos  2 , 3 -    )
  parLDim.dPar.pl1      = 0;   //      ( 0 - , 1 -  )
  parLDim.dPar.pl2      = 0;   //      ( 0 - , 1 -  )
  parLDim.dPar.pt1      = 2;   //       ( 0 -  , 1 - , 2 - , 3 - , 4 -  )
  parLDim.dPar.pt2      = 2;   //       ( 0 -  , 1 - , 2 - , 3 - , 4 -  )
  parLDim.dPar.shelfDir = 0;   //    ( 0 -   , -1 -   ,
                               // 1 -   , 2 -   , 3 -    )
  parLDim.dPar.ang      = -30; //     
  parLDim.dPar.length   = 20;  //    
  
  //   
  parLDim.tPar.style   = 0; // C  , ( 0 -    )
  parLDim.tPar.sign    = 0; //      ( 0 -  , 1 - , 2 - ,
                            // 3 - , > 3 -     Symbol type A )
  //    (   , 0 -   ) 
  //    PREFIX,   auto (    ), TOLERANCE, 
  //  auto (    ), UNIT, SUFFIX ( 4  )
  parLDim.tPar.bitFlag = _AUTONOMINAL|_PREFIX|_DEVIATION|_UNIT|_SUFFIX; 
  parLDim.tPar.pText   = CreateArray( CHAR_STR_ARR_T, 0 ); //   
  
  //    
  AddArrayItem( parLDim.tPar.pText, -1, _T("prefix"), 8 );
  AddArrayItem( parLDim.tPar.pText, -1, _T("+0.5"),  5 );
  AddArrayItem( parLDim.tPar.pText, -1, _T("-0.5"),  5 );
  AddArrayItem( parLDim.tPar.pText, -1, _T("mm"),     5 );
  AddArrayItem( parLDim.tPar.pText, -1, _T("suffics"), 13 );

  //   
  parLDim.sPar.ps        = 0;   //     ( 0 - , 1 - ,
                                // 2 -  ,   , 3 -  dx, dy,
                                // 4 -       dx, dy.
  parLDim.sPar.x1        = 50;  //    
  parLDim.sPar.y1        = 50; 
  parLDim.sPar.x2        = 70;  //    
  parLDim.sPar.y2        = 60; 
  parLDim.sPar.dy        = -20; // ,     
  parLDim.sPar.dx        = 0;
  parLDim.sPar.basePoint = 1;   // , ,     dx, dy
                                // ( 1 -   , 2 -    )
  //    
  reference rLinDimension = LinDimension( &parLDim );
  
  GetObjParam( rLinDimension,     //    
               &parLDim,          //    
               sizeof( parLDim ), //   
               ALLPARAM_T );        //     
  
  //      ( 0 -  , 1 -  ,
  // 2 -    , 3 -   c  )
  ShowDimParam( _T("C "), &parLDim, ALLPARAM_T, 0 );
  
  //    
  parLDim.dPar.textPos  = 1; //  
  parLDim.dPar.textBase = 2; //   
  parLDim.dPar.pl1      = 1; //     
  parLDim.dPar.pl2      = 1; //      
  parLDim.dPar.pt1      = 1; //      
  parLDim.dPar.pt2      = 1; //      
  parLDim.dPar.shelfDir = 0; //   
  
  SetObjParam( rLinDimension,          //    
               &parLDim.dPar,          //    
               sizeof( parLDim.dPar ), //   
               DIM_DRAW_PARAM );       //   

  GetObjParam( rLinDimension,          //    
               &parLDim.dPar,          //    
               sizeof( parLDim.dPar ), //   
               DIM_DRAW_PARAM );       //   

  //      ( 0 -  , 1 -  ,
  // 2 -    , 3 -   c  )
  ShowDimParam( _T(" "), &parLDim.dPar, DIM_DRAW_PARAM, 0 );

  //    
  DeleteArray( parLDim.tPar.pText );
}


//-------------------------------------------------------------------------------
//   
// --- 
void DrawAngDim()
{
  ADimParam parADim; //     
  memset( &parADim, 0, sizeof( parADim ) );
  
  //   
  parADim.dPar.textPos  = -10; //   ( 0 -   ,
		                           // > 0 -          ,
		                           // < 0 -           )
  parADim.dPar.textBase = 0;   //    ( 0 -  , 1 - textPos  1 , 
		                           // 2 - textPos  2 , 3 -    )
  parADim.dPar.pl1      = 0;   //      ( 0 - , 1 -  )
  parADim.dPar.pl2      = 0;   //      ( 0 - , 1 -  )
  parADim.dPar.pt1      = 1;   //       ( 0 -  , 1 - , 2 - , 3 - , 4 -  )
  parADim.dPar.pt2      = 1;   //       ( 0 -  , 1 - , 2 - , 3 - , 4 -  )
  parADim.dPar.shelfDir = 0;   //    ( 0 -   , -1 -   ,
                               // 1 -   , 2 -   , 3 -    )
  parADim.dPar.ang      = 30;  //     
  parADim.dPar.length   = 20;  //    
  
  //   
  parADim.tPar.style   = 0; // C  , ( 0 -    )
  parADim.tPar.sign    = 0; //      ( 0 -  , 1 - , 2 - ,
                            // 3 - , > 3 -     Symbol type A )
  //    (   , 0 -   ) 
  //    PREFIX,   auto (    ), TOLERANCE, 
  //  auto (    ), UNIT, SUFFIX ( 4  )
  parADim.tPar.bitFlag = _AUTONOMINAL|_PREFIX|_DEVIATION|_UNIT|_SUFFIX; 
  parADim.tPar.pText   = CreateArray( CHAR_STR_ARR_T, 0 ); //   
  
  //    
  AddArrayItem( parADim.tPar.pText, -1, _T("prefix"), 8 );
  AddArrayItem( parADim.tPar.pText, -1, _T("+0.3"),  5 );
  AddArrayItem( parADim.tPar.pText, -1, _T("-0.3"),  5 );
  AddArrayItem( parADim.tPar.pText, -1, _T(""),    5 );
  AddArrayItem( parADim.tPar.pText, -1, _T("suffics"), 8 );

  //   
  parADim.sPar.xc   = 40; //    
  parADim.sPar.yc   = 0;   
  parADim.sPar.x1   = 40; //      
  parADim.sPar.y1   = 40;     
  parADim.sPar.x2   = 60; //      
  parADim.sPar.y2   = 20;   
  parADim.sPar.ang1 = 0;  //     (      )
  parADim.sPar.ang2 = 0;  //     (      )
  parADim.sPar.rad  = 50; //   
  parADim.sPar.dir  = 1;  //  ( 1 -     , -1 -    )

  //   
  reference rAngDimension = AngDimension( &parADim );

  GetObjParam( rAngDimension,     //    
               &parADim,          //    
               sizeof( parADim ), //   
               ALLPARAM_T );        //   
 
  //      ( 0 -  , 1 -  ,
  // 2 -    , 3 -   c  )
  ShowDimParam( _T(" "), &parADim, ALLPARAM_T, 1 );

  //   
  parADim.sPar.xc   = 40; //    
  parADim.sPar.yc   = 60;   
  parADim.sPar.x1   = 10; //      
  parADim.sPar.y1   = 60;     
  parADim.sPar.x2   = 20; //      
  parADim.sPar.y2   = 80;   
  parADim.sPar.ang1 = 0;  //     (      )
  parADim.sPar.ang2 = 0;  //     (      )
  parADim.sPar.rad  = 50; //   
  parADim.sPar.dir  = -1; //  ( 1 -     , -1 -    )

  SetObjParam( rAngDimension,          //    
               &parADim.sPar,          //    
               sizeof( parADim.sPar ), //   
               DIM_SOURSE_PARAM	);     //   

  GetObjParam( rAngDimension,          //    
               &parADim.sPar,          //    
               sizeof( parADim.sPar ), //   
               DIM_SOURSE_PARAM );     //   
               
  //      ( 0 -  , 1 -  ,
  // 2 -    , 3 -   c  )
  ShowDimParam( _T(" "), &parADim.sPar, DIM_SOURSE_PARAM, 1 );

  //    
  DeleteArray( parADim.tPar.pText );
}


//-------------------------------------------------------------------------------
// 
// ---
void DrawRough()
{
  RoughParam parRougham; //       
  memset( &parRougham, 0, sizeof( parRougham ) );

  //   
  parRougham.shPar.psh    = 0;   //     X ( 0 -   ,
                                 // -1 -   , 1 -   ,	
                                 // 2 -   , 3 -    )
  parRougham.shPar.ang    = 130; //    
  parRougham.shPar.length = 20;  //  

  //   
  parRougham.rPar.type  = 0;   //   ( 0 -    , 1 -    ,
                               // 2 -      )
  parRougham.rPar.around = 0;  // 1 -   
  parRougham.rPar.x      = 50; //     
  parRougham.rPar.y      = 50;       
  parRougham.rPar.ang    = 90; //        X
  parRougham.rPar.cText0 = 2;  //       (  -   2789-73 )
  parRougham.rPar.cText1 = 2;  //       (      )
  parRougham.rPar.cText2 = 2;  //       (     2789-73 ) (     )
  parRougham.rPar.cText3 = 1;  //       (     ) (     )  
 
  // ,       
  parRougham.rPar.style = INDICATIN_TEXT_LINE_ARR; //   ( 0 -   , INDICATIN_TEXT_LINE_ARR -  TEXT_LINE_ARR )
    
  TextLineParam parTextLine; //      
  
  parTextLine.style     = 0;                               //    
  parTextLine.pTextItem = CreateArray( TEXT_ITEM_ARR, 0 ); //      

  TextItemFontT parItemFont; //      
  memset( &parItemFont, 0, sizeof( parItemFont ) );

  TextItemParamT parTextItem; //       
  
  parTextItem.tip    = 0;           // SPECIAL_SYMBOL, FONT_SYMBOL, FRACTION_TYPE, SUM_TYPE  0
  parTextItem.font   = parItemFont; //     
  parTextItem.iSNumb = 0;           //  ,              0

  parRougham.rPar.pText = CreateArray( TEXT_LINE_ARR, 0 ); //      
  //  4     (      ) 
  // 1.    (  -   2789-73 )
  // 2.    (  -  ,  )   
  // 3.    (     2789-73 ) 
  // 4.    ( ..  )
  //  cText0 = 0  cText1 = 0  cText2 = 0  cText3 = 0,       

  //     
  _tcscpy( parTextItem.s, _T("00_1") );   
  AddArrayItem( parTextLine.pTextItem, -1, &parTextItem, sizeof( parTextItem ) );
  AddArrayItem( parRougham.rPar.pText, -1, &parTextLine, sizeof( parTextLine ) );
  ClearArray( parTextLine.pTextItem ); //  
  _tcscpy( parTextItem.s, _T("00_2") );   
  AddArrayItem( parTextLine.pTextItem, -1, &parTextItem, sizeof( parTextItem ) );
  AddArrayItem( parRougham.rPar.pText, -1, &parTextLine, sizeof( parTextLine ) );
  ClearArray( parTextLine.pTextItem ); //  
  _tcscpy( parTextItem.s, _T("11_1") );   
  AddArrayItem( parTextLine.pTextItem, -1, &parTextItem, sizeof( parTextItem ) );
  AddArrayItem( parRougham.rPar.pText, -1, &parTextLine, sizeof( parTextLine ) );
  ClearArray( parTextLine.pTextItem ); //  
  _tcscpy( parTextItem.s, _T("11_2") );   
  AddArrayItem( parTextLine.pTextItem, -1, &parTextItem, sizeof( parTextItem ) );
  AddArrayItem( parRougham.rPar.pText, -1, &parTextLine, sizeof( parTextLine ) );
  ClearArray( parTextLine.pTextItem ); //  
  _tcscpy( parTextItem.s, _T("22_1") ); 
  AddArrayItem( parTextLine.pTextItem, -1, &parTextItem, sizeof( parTextItem ) );
  AddArrayItem( parRougham.rPar.pText, -1, &parTextLine, sizeof( parTextLine ) );
  ClearArray( parTextLine.pTextItem ); //  
  _tcscpy( parTextItem.s, _T("22_2") );   
  AddArrayItem( parTextLine.pTextItem, -1, &parTextItem, sizeof( parTextItem ) );
  AddArrayItem( parRougham.rPar.pText, -1, &parTextLine, sizeof( parTextLine ) );
  ClearArray( parTextLine.pTextItem ); //  
  _tcscpy( parTextItem.s, _T("33_1") );
  AddArrayItem( parTextLine.pTextItem, -1, &parTextItem, sizeof( parTextItem ) );
  AddArrayItem( parRougham.rPar.pText, -1, &parTextLine, sizeof( parTextLine ) );  
   
  /*
  // ,      
  parRougham.rPar.style = 0; //   ( 0 -   , INDICATIN_TEXT_LINE_ARR -  TEXT_LINE_ARR )    
  parRougham.rPar.pText = CreateArray( CHAR_STR_ARR_T, 0 ); //      
  //  4     (      ) 
  // 1.    (  -   2789-73 )
  // 2.    (  -  ,  )   
  // 3.    (     2789-73 ) 
  // 4.    ( ..  )
  //  cText0 = 0  cText1 = 0  cText2 = 0  cText3 = 0,       
  
  //     
  AddArrayItem( parRougham.rPar.pText, -1, _T("00_1"), 5 );
  AddArrayItem( parRougham.rPar.pText, -1, _T("00_2"), 5 );
  AddArrayItem( parRougham.rPar.pText, -1, _T("11_1"), 5 );
  AddArrayItem( parRougham.rPar.pText, -1, _T("11_2"), 5 );
  AddArrayItem( parRougham.rPar.pText, -1, _T("22_1"), 5 );
  AddArrayItem( parRougham.rPar.pText, -1, _T("22_2"), 5 );
  AddArrayItem( parRougham.rPar.pText, -1, _T("33_1"), 5 );
  */

  //  
  reference rRough = Rough( &parRougham );
 
  //   
  LightObj( rRough, 1 );
  MessageT( _T("  ") );
  LightObj( rRough, 0 );

  // ,       
  //   
  DeleteArray( parRougham.rPar.pText ); //    
  DeleteArray( parTextLine.pTextItem ); //    
  
  /* 
  // ,       
  //      
  DeleteArray( parRougham.rPar.pText ); 
  */
}


//-------------------------------------------------------------------------------
//  
// ---
void DrawLeader()
{
  TextLineParam parTextLine; //    

  parTextLine.style = 0; //    
  parTextLine.pTextItem = CreateArray( TEXT_ITEM_ARR, 0 ); //      

  TextItemFontT parItemFont; //      
  memset( &parItemFont, 0, sizeof( parItemFont ) );

  TextItemParamT parTextItem; //       
  
  parTextItem.tip    = 0;           // SPECIAL_SYMBOL, FONT_SYMBOL, FRACTION_TYPE, SUM_TYPE  0
  parTextItem.font   = parItemFont; //     
  parTextItem.iSNumb = 0;           //  ,              0

  LeaderParam parLeader; //   - 
  memset( &parLeader, 0, sizeof( parLeader ) );
  
  parLeader.x         = 50; //    (   )
  parLeader.y         = 50;             
  parLeader.arrowType = 1;  //   ( 0 -  , 1 - , 2 - ,
                            // 3 -   , 4 -    )
  parLeader.dirX      = 1;  //    X ( 0 -  , -1 -  ,
                            // 1 -  , 2 -  , 3 -   )
  parLeader.signType  = 0;  //   ( 0 -  , 1 -  , 2 -  , 3 -  ,
                            // 4 -     ,
                            // 5 -     , 6 -    )
  parLeader.around    = 0;  //     ( 0 - , 1 -  )
  parLeader.cText0    = 1;  //      ( 0 -   )
  parLeader.cText1    = 1;  //      ( 0 -   )
  parLeader.cText2    = 1;  //      (   1  ) ( 0 -   )
  parLeader.cText3    = 1;  //      (   1  ) ( 0 -   )

  parLeader.pTextline = CreateArray( TEXT_LINE_ARR, 0 ); //     

  //      
  _tcscpy( parTextItem.s, _T("00_1") );   
  AddArrayItem( parTextLine.pTextItem, -1, &parTextItem, sizeof( parTextItem ) );
  AddArrayItem( parLeader.pTextline, -1, &parTextLine, sizeof( parTextLine ) );
  ClearArray( parTextLine.pTextItem ); //  
  _tcscpy( parTextItem.s, _T("11_1") ); 
  AddArrayItem( parTextLine.pTextItem, -1, &parTextItem, sizeof( parTextItem ) );
  AddArrayItem( parLeader.pTextline, -1, &parTextLine, sizeof( parTextLine ) );
  ClearArray( parTextLine.pTextItem ); //  
  _tcscpy( parTextItem.s, _T("22_1") );   
  AddArrayItem( parTextLine.pTextItem, -1, &parTextItem, sizeof( parTextItem ) );
  AddArrayItem( parLeader.pTextline, -1, &parTextLine, sizeof( parTextLine ) );
  ClearArray( parTextLine.pTextItem ); //  
  _tcscpy( parTextItem.s, _T("33_1") );
  AddArrayItem( parTextLine.pTextItem, -1, &parTextItem, sizeof( parTextItem ) );
  AddArrayItem( parLeader.pTextline, -1, &parTextLine, sizeof( parTextLine ) );

  parLeader.pPolyline  = CreateArray( POLYLINE_ARR, 0 ); //      
  reference rArPoint = CreateArray( POINT_ARR, 0 ); //     

  MathPointParam parMathPoint; //    
  
  //     
  parMathPoint.x = 10; //  
  parMathPoint.y = 10; 
  AddArrayItem( rArPoint, -1, &parMathPoint, sizeof( parMathPoint ) );
  AddArrayItem( parLeader.pPolyline, -1, &rArPoint, sizeof( rArPoint ) );
  parMathPoint.x = 30; //  
  parMathPoint.y = 10;
  ClearArray( rArPoint ); //   
  AddArrayItem( rArPoint, -1, &parMathPoint, sizeof( parMathPoint ) );
  AddArrayItem( parLeader.pPolyline, -1, &rArPoint, sizeof( rArPoint ) );

  //   
  reference rLeader = Leader( &parLeader );
  
  //   
  LightObj( rLeader, 1 );
  MessageT( _T("  ") );
  LightObj( rLeader, 0 );
 
  //   
  DeleteArray( parLeader.pTextline ); //    
  DeleteArray( parLeader.pPolyline ); //    
  DeleteArray( rArPoint );            //   
}


//-------------------------------------------------------------------------------
//   
// --- 
void DrawPosLeader()
{  
  PosLeaderParam parPosLeader; //    -
  memset( &parPosLeader, 0, sizeof( parPosLeader ) );

  parPosLeader.x         = 50; //    (   )
  parPosLeader.y         = 50;             
  parPosLeader.arrowType = 1;  //   ( 0 -  , 1 - , 2 - ,
                               // 3 -   , 4 -    )
  parPosLeader.dirX      = -1; //    X ( 0 -  , -1 -  ,
                               // 1 -  , 2 -  , 3 -   )

  // ,       
  parPosLeader.style = INDICATIN_TEXT_LINE_ARR; //   ( 0 -   , INDICATIN_TEXT_LINE_ARR -  TEXT_LINE_ARR )
  
  TextLineParam parTextLine; //    
  
  parTextLine.style     = 0;                               //    
  parTextLine.pTextItem = CreateArray( TEXT_ITEM_ARR, 0 ); //      

  TextItemFontT  parItemFont; //      
  memset( &parItemFont, 0, sizeof( parItemFont ) );

  TextItemParamT parTextItem; //     
  
  parTextItem.tip    = 0;           // SPECIAL_SYMBOL, FONT_SYMBOL, FRACTION_TYPE, SUM_TYPE  0
  parTextItem.font   = parItemFont; //     
  parTextItem.iSNumb = 0;           //  ,              0

  parPosLeader.pText = CreateArray( TEXT_LINE_ARR, 0 ); //     
 
  //     
  _tcscpy( parTextItem.s, _T("1") );   
  AddArrayItem( parTextLine.pTextItem, -1, &parTextItem, sizeof( parTextItem ) );
  AddArrayItem( parPosLeader.pText, -1, &parTextLine, sizeof( parTextLine ) );
  ClearArray( parTextLine.pTextItem ); //  
  _tcscpy( parTextItem.s, _T("2") );  
  AddArrayItem( parTextLine.pTextItem, -1, &parTextItem, sizeof( parTextItem ) );
  AddArrayItem( parPosLeader.pText, -1, &parTextLine, sizeof( parTextLine ) );

  /*
  // ,       
  parPosLeader.style = 0; //   ( 0 -   , INDICATIN_TEXT_LINE_ARR -  TEXT_LINE_ARR )                   
  
  parPosLeader.pText = CreateArray( CHAR_STR_ARR, 0 ); //     
  
  //     
  AddArrayItem( parPosLeader.pText, -1, _T("1"), 3 );
  AddArrayItem( parPosLeader.pText, -1, _T("2"), 3 );
  */

  parPosLeader.pPolyline  = CreateArray( POLYLINE_ARR, 0 ); //      
  reference rArPoint = CreateArray( POINT_ARR, 0 ); //     

  MathPointParam parMathPoint; //    
  
  //     
  parMathPoint.x = 10; //  
  parMathPoint.y = 10; 
  AddArrayItem( rArPoint, -1, &parMathPoint, sizeof( parMathPoint ) );
  AddArrayItem( parPosLeader.pPolyline, -1, &rArPoint, sizeof( rArPoint ) );
  parMathPoint.x = 30; //  
  parMathPoint.y = 10;
  ClearArray( rArPoint ); //   
  AddArrayItem( rArPoint, -1, &parMathPoint, sizeof( parMathPoint ) );
  AddArrayItem( parPosLeader.pPolyline, -1, &rArPoint, sizeof( rArPoint ) );

  //   
  reference rPositionLeader = PositionLeader( &parPosLeader );
 
  //   
  LightObj( rPositionLeader, 1 );
  MessageT( _T("  ") );
  LightObj( rPositionLeader, 0 );
  
  //   
  DeleteArray( parPosLeader.pPolyline ); //    
  DeleteArray( rArPoint );               //       
  
  // ,       
  DeleteArray( parPosLeader.pText ); //    
  DeleteArray( parTextLine.pTextItem );   //     
   
  /* 
  // ,       
  //      
  DeleteArray( parPosLeader.rPar.pText ); 
  */
}


//-------------------------------------------------------------------------------
//  
// --- 
void DrawBrandLeader()
{  
  BrandLeaderParam  parBrandLeader; //      
  memset( &parBrandLeader, 0, sizeof( parBrandLeader ) );
  
  parBrandLeader.cText0    = 1;  //      (   1  ) ( 0 -   )
  parBrandLeader.cText1    = 1;  //      (   1  ) ( 0 -   )
  parBrandLeader.cText2    = 1;  //      (   1  ) ( 0 -   )
  parBrandLeader.x         = 50; //    (   )
  parBrandLeader.y         = 50;   
  parBrandLeader.arrowType = 1;  //   ( 0 -  , 1 - , 2 - ,
                                 // 3 -   , 4 -    )
  parBrandLeader.dirX      = -1; //    X ( 0 -  , -1 -  ,
                                 // 1 -  , 2 -  , 3 -   )
  
  // ,       
  parBrandLeader.style1 = INDICATIN_TEXT_LINE_ARR; //   ( 0 -   , INDICATIN_TEXT_LINE_ARR -  TEXT_LINE_ARR )    

  TextLineParam parTextLine; //    
  
  parTextLine.style     = 0;                               //    
  parTextLine.pTextItem = CreateArray( TEXT_ITEM_ARR, 0 ); //      

  TextItemFontT  parItemFont; //      
  memset( &parItemFont, 0, sizeof( parItemFont ) );

  TextItemParamT parTextItem; //     
  
  parTextItem.tip    = 0;           // SPECIAL_SYMBOL, FONT_SYMBOL, FRACTION_TYPE, SUM_TYPE  0
  parTextItem.font   = parItemFont; //     
  parTextItem.iSNumb = 0;           //  ,              0
  
  parBrandLeader.pText = CreateArray( TEXT_LINE_ARR, 0 ); //     

  //    
  _tcscpy( parTextItem.s, _T(".11") );   
  AddArrayItem( parTextLine.pTextItem, -1, &parTextItem, sizeof( parTextItem ) );
  AddArrayItem( parBrandLeader.pText, -1, &parTextLine, sizeof( parTextLine ) );
  ClearArray( parTextLine.pTextItem ); //  
  _tcscpy( parTextItem.s, _T("") );   
  AddArrayItem( parTextLine.pTextItem, -1, &parTextItem, sizeof( parTextItem ) );
  AddArrayItem( parBrandLeader.pText, -1, &parTextLine, sizeof( parTextLine ) );
  ClearArray( parTextLine.pTextItem ); //  
  _tcscpy( parTextItem.s, _T("T") );   
  AddArrayItem( parTextLine.pTextItem, -1, &parTextItem, sizeof( parTextItem ) );
  AddArrayItem( parBrandLeader.pText, -1, &parTextLine, sizeof( parTextLine ) );

  /*
  // ,       
  parBrandLeader.style1 = 0; //   ( 0 -   , INDICATIN_TEXT_LINE_ARR -  TEXT_LINE_ARR )    
  
  parBrandLeader.pText = CreateArray( CHAR_STR_ARR_T, 0 ); //     

  //     
  AddArrayItem( parBrandLeader.pText, -1, _T(".11"), 5 );
  AddArrayItem( parBrandLeader.pText, -1, _T(""), 3 );
  AddArrayItem( parBrandLeader.pText, -1, _T(""), 3 );
  */

  parBrandLeader.pPolyline  = CreateArray( POLYLINE_ARR, 0 ); //      
  reference rArPoint = CreateArray( POINT_ARR, 0 ); //     

  MathPointParam parMathPoint; //    

  //     
  parMathPoint.x = 10; //  
  parMathPoint.y = 10; 
  AddArrayItem( rArPoint, -1, &parMathPoint, sizeof( parMathPoint ) );
  AddArrayItem( parBrandLeader.pPolyline, -1, &rArPoint, sizeof( rArPoint ) );
  parMathPoint.x = 30; //  
  parMathPoint.y = 10;
  ClearArray( rArPoint ); //   
  AddArrayItem( rArPoint, -1, &parMathPoint, sizeof( parMathPoint ) );
  AddArrayItem( parBrandLeader.pPolyline, -1, &rArPoint, sizeof( rArPoint ) );

  //  
  reference rBrandLeader = BrandLeader( &parBrandLeader );
 
  //   
  LightObj( rBrandLeader, 1 );
  MessageT( _T("  ") );
  LightObj( rBrandLeader, 0 );
  
  //   
  DeleteArray( parBrandLeader.pPolyline ); //    
  DeleteArray( rArPoint );                 //       
  
  // ,       
  DeleteArray( parBrandLeader.pText );  //    
  DeleteArray( parTextLine.pTextItem ); //     
   
  /* 
  // ,       
  //      
  DeleteArray( parBrandLeader.pText ); 
  */
}


//-------------------------------------------------------------------------------
// 
// --- 
void DrawMarkerLeader()
{  
  MarkerLeaderParam  parMarkerLeader; //   -   
  memset( &parMarkerLeader, 0, sizeof( parMarkerLeader ) );
  
  parMarkerLeader.cText0    = 1;  //      (   1  ) ( 0 -   )
  parMarkerLeader.cText1    = 1;  //      (   1  ) ( 0 -   )
  parMarkerLeader.cText2    = 1;  //      (   1  ) ( 0 -   )
  parMarkerLeader.x         = 50; //    (   )
  parMarkerLeader.y         = 50;
  parMarkerLeader.arrowType = 2;  //   ( 0 -  , 1 - , 2 - ,
                                  // 3 -   , 4 -    )
 
  // ,       
  parMarkerLeader.style1 = INDICATIN_TEXT_LINE_ARR; //   ( 0 -   , INDICATIN_TEXT_LINE_ARR -  TEXT_LINE_ARR )     

  TextLineParam parTextLine; //    
  
  parTextLine.style     = 0;                               //    
  parTextLine.pTextItem = CreateArray( TEXT_ITEM_ARR, 0 ); //      

  TextItemFontT  parItemFont; //      
  memset( &parItemFont, 0, sizeof( parItemFont ) );

  TextItemParamT parTextItem; //     
  parTextItem.tip    = 0;           // SPECIAL_SYMBOL, FONT_SYMBOL, FRACTION_TYPE, SUM_TYPE  0
  parTextItem.font   = parItemFont; //     
  parTextItem.iSNumb = 0;           //  ,              0

  parMarkerLeader.pText = CreateArray( TEXT_LINE_ARR, 0 ); //     

  _tcscpy( parTextItem.s, _T(".11") );  
  AddArrayItem( parTextLine.pTextItem, -1, &parTextItem, sizeof( parTextItem ) );
  AddArrayItem( parMarkerLeader.pText, -1, &parTextLine, sizeof( parTextLine ) );
  ClearArray( parTextLine.pTextItem ); //  
  _tcscpy( parTextItem.s, _T("") );  
  AddArrayItem( parTextLine.pTextItem, -1, &parTextItem, sizeof( parTextItem ) );
  AddArrayItem( parMarkerLeader.pText, -1, &parTextLine, sizeof( parTextLine ) );
  ClearArray( parTextLine.pTextItem ); //  
  _tcscpy( parTextItem.s, _T("T") ); 
  AddArrayItem( parTextLine.pTextItem, -1, &parTextItem, sizeof( parTextItem ) );
  AddArrayItem( parMarkerLeader.pText, -1, &parTextLine, sizeof( parTextLine ) );

  /* 
  // ,       
  parMarkerLeader.style1 = 0; //   ( 0 -   , INDICATIN_TEXT_LINE_ARR -  TEXT_LINE_ARR )    
  
  parMarkerLeader.pText = CreateArray( CHAR_STR_ARR_T, 0 ); //     

  //     
  AddArrayItem( parMarkerLeader.pText, -1, _T(".11"), 5 );
  AddArrayItem( parMarkerLeader.pText, -1, _T(""), 3 );
  AddArrayItem( parMarkerLeader.pText, -1, _T(""), 3 );
  */
  
  parMarkerLeader.pPolyline  = CreateArray( POLYLINE_ARR, 0 ); //      
  reference rArPoint = CreateArray( POINT_ARR, 0 ); //     

  MathPointParam parMathPoint; //    

  //     
  parMathPoint.x = 10; //  
  parMathPoint.y = 10; 
  AddArrayItem( rArPoint, -1, &parMathPoint, sizeof( parMathPoint ) );
  AddArrayItem( parMarkerLeader.pPolyline, -1, &rArPoint, sizeof( rArPoint ) );
  parMathPoint.x = 30; //  
  parMathPoint.y = 10;
  ClearArray( rArPoint ); //   
  AddArrayItem( rArPoint, -1, &parMathPoint, sizeof( parMathPoint ) );
  AddArrayItem( parMarkerLeader.pPolyline, -1, &rArPoint, sizeof( rArPoint ) );

  //  
  reference rMarkerLeader = MarkerLeader( &parMarkerLeader );
  
  //   
  LightObj( rMarkerLeader, 1 );
  MessageT( _T("  ") );
  LightObj( rMarkerLeader, 0 );
  
  //   
  DeleteArray( parMarkerLeader.pPolyline ); //    
  DeleteArray( rArPoint );                  //       
  
  // ,       
  DeleteArray( parMarkerLeader.pText ); //    
  DeleteArray( parTextLine.pTextItem ); //     
   
  /* 
  // ,       
  //      
  DeleteArray( parMarkerLeader.pText ); 
  */
}


//-------------------------------------------------------------------------------
//  
// ---
void DrawBase()
{
  BaseParamT basePar; //    
  memset( &basePar, 0, sizeof( basePar ) );
  
  basePar.x1 = 50; //    (   )
  basePar.y1 = 50;             
  basePar.x2 = 50; //    
  basePar.y2 = 30;             
  _tcscpy( basePar.str, _T("ABC") ); // 

  //   
  reference rBase = BaseT( &basePar );
  
  //   
  LightObj( rBase, 1 );
  MessageT( _T("  ") );
  LightObj( rBase, 0 );
}


//-------------------------------------------------------------------------------
//  /c
// --- 
void DrawCutLine()
{
  CutLineParamT parCutLine; //    /
  memset( &parCutLine, 0, sizeof( parCutLine ) );
  
  parCutLine.right = 1; //    ( 0 - , 1 -     ) 
  _tcscpy ( parCutLine.str, _T("A$;1$") ); // 
  parCutLine.x1 = 30; //     
  parCutLine.y1 = 65;
  parCutLine.x2 = 95; //     
  parCutLine.y2 = 15;
  parCutLine.pMathPoint = CreateArray( POINT_ARR, 0 ); //     
 
  MathPointParam parMathPoint; //    
  
  //  
  parMathPoint.x = 50; 
  parMathPoint.y = 50;
  AddArrayItem( parCutLine.pMathPoint, -1, &parMathPoint, sizeof( parMathPoint ) );
  //   
  parMathPoint.x = 50;
  parMathPoint.y = 30;
  AddArrayItem( parCutLine.pMathPoint, -1, &parMathPoint, sizeof( parMathPoint ) );
  //  
  parMathPoint.x = 80; 
  parMathPoint.y = 30;
  AddArrayItem( parCutLine.pMathPoint, -1, &parMathPoint, sizeof( parMathPoint ) );

  //   /c
  reference rCutLine = CutLineT( &parCutLine );
  
  //   
  LightObj( rCutLine, 1 );
  MessageT( _T("  ") );
  LightObj( rCutLine, 0 );
  
  //     
  DeleteArray( parCutLine.pMathPoint );   
}


//-------------------------------------------------------------------------------
//  
// ---
void DrawViewPointer()
{
  ViewPointerParamT parViewPointer; //     
  memset( &parViewPointer, 0, sizeof( parViewPointer ) );
  
  parViewPointer.x1 = 50; //   
  parViewPointer.y1 = 50;             
  parViewPointer.x2 = 20, //    
  parViewPointer.y2 = 50;             
  parViewPointer.xt = 25; //  
  parViewPointer.yt = 55;             
  
  // ,         
  parViewPointer.type = 1; //      ( 0 -    , 1 -     )
  parViewPointer.pTextItem = CreateArray( TEXT_ITEM_ARR, 0 );
 
  TextItemParamT parTextItem; //    
  memset( &parTextItem, 0, sizeof( parTextItem ) );
   
  //    
  _tcscpy( parTextItem.s, _T("AAA") ); 
  AddArrayItem( parViewPointer.pTextItem, -1, &parTextItem, sizeof( parTextItem ) );
  
  /*
  // ,      
  parViewPointer->type = 0; //      ( 0 -    , 1 -     )
  _tcscpy( parViewPointer->str, _T("AAA") ); // 
  */

  reference rViewPointer = ViewPointerT( &parViewPointer );//   
  
  //   
  LightObj( rViewPointer, 1 );
  MessageT( _T("  ") );
  LightObj( rViewPointer, 0 );
  
  // ,         
  //     
  DeleteArray( parViewPointer.pTextItem );   
}


//-------------------------------------------------------------------------------
//   
// --- 
void DrawDiamDim()
{
  RDimParam parRDim; //       
  memset( &parRDim, 0, sizeof( parRDim ) );
  
  //   
  parRDim.dPar.textPos  = 75;  //       -  (     )
  parRDim.dPar.pt1      = 2;   //       ( 0 -  , 1 - , 2 - , 3 - , 4 -  )
  parRDim.dPar.pt2      = 2;   //       ( 0 -  , 1 - , 2 - , 3 - , 4 -  )
  parRDim.dPar.shelfDir = 1;   //    ( 0 -   , -1 -   ,
                               // 1 -   , 2 -   , 3 -    )
  parRDim.dPar.ang      = -30; //     
  
  //   
  parRDim.tPar.style   = 0; // C  , ( 0 -    )
  parRDim.tPar.sign    = 0; //      ( 0 -  , 1 - , 2 - ,
                            // 3 - , > 3 -     Symbol type A )
  //    (   , 0 -   ) 
  //    PREFIX,   auto (    ), TOLERANCE, 
  //  auto (    ), UNIT, SUFFIX ( 4  )
  parRDim.tPar.bitFlag = _AUTONOMINAL|_PREFIX|_DEVIATION|_UNIT|_SUFFIX; 
  parRDim.tPar.pText   = CreateArray( CHAR_STR_ARR_T, 0 ); //   
  
  //    
  AddArrayItem( parRDim.tPar.pText, -1, _T("prefix"), 8 );
  AddArrayItem( parRDim.tPar.pText, -1, _T("+0.5"),  5 );
  AddArrayItem( parRDim.tPar.pText, -1, _T("-0.5"),  5 );
  AddArrayItem( parRDim.tPar.pText, -1, _T("mm"),     5 );
  AddArrayItem( parRDim.tPar.pText, -1, _T("suffics"), 13 );

  //   
  parRDim.sPar.xc  = 50; //  
  parRDim.sPar.yc  = 50; 
  parRDim.sPar.rad = 70; // 
  
  //   
  reference rDiamDimension = DiamDimension( &parRDim );
 
  GetObjParam( rDiamDimension,    //    
               &parRDim,          //    
               sizeof( parRDim ), //   
               ALLPARAM_T );        //   
               
  //      ( 0 -  , 1 -  ,
  // 2 -    , 3 -   c  ) 
  ShowDimParam( _T("C "), &parRDim, ALLPARAM_T, 2 );

  //   
  parRDim.dPar.textPos  = 0; //       -  (     )
  parRDim.dPar.pt1      = 1; //       ( 0 -  , 1 - , 2 - , 3 - , 4 -  )
  parRDim.dPar.pt2      = 1; //       ( 0 -  , 1 - , 2 - , 3 - , 4 -  )
  parRDim.dPar.shelfDir = 0; //    ( 0 -   , -1 -   ,
                             // 1 -   , 2 -   , 3 -    )
  parRDim.dPar.ang      = 0; //     
  
  //   
  parRDim.tPar.sign    = 1; //      ( 0 -  , 1 - , 2 - ,
                            // 3 - , > 3 -     Symbol type A )
 
  //   
  parRDim.sPar.xc  = 30; //  
  parRDim.sPar.yc  = 30; 
  parRDim.sPar.rad = 20; // 

  SetObjParam( rDiamDimension,    //    
               &parRDim,          //    
               sizeof( parRDim ), //   
               ALLPARAM_T );        //     
  
  GetObjParam( rDiamDimension,    //    
               &parRDim,          //    
               sizeof( parRDim ), //   
               ALLPARAM_T );        //   
               
  //      ( 0 -  , 1 -  ,
  // 2 -    , 3 -   c  )
  ShowDimParam( _T(" "), &parRDim, ALLPARAM_T, 2 );
  
  //    
  DeleteArray( parRDim.tPar.pText );  
}


//-------------------------------------------------------------------------------
//  
// --- 
void DrawRadDimt()
{
  RDimParam parRDim; //       
  memset( &parRDim, 0, sizeof( parRDim ) );
  
  //   
  parRDim.dPar.textPos  = 75; //       -  (     )
  parRDim.dPar.pt1      = 2;  //       ( 0 -  , 1 - , 2 - , 3 - , 4 -  )
  parRDim.dPar.pt2      = 1;  //    ( 0 -   , 1 -    )
  parRDim.dPar.shelfDir = 1;  //    ( 0 -   , -1 -   ,
                              // 1 -   , 2 -   , 3 -    )
  parRDim.dPar.ang      = 30; //     
  
  //   
  parRDim.tPar.style   = 0; // C  , ( 0 -    )
  parRDim.tPar.sign    = 0; //      ( 0 -  , 1 - , 2 - ,
                            // 3 - , > 3 -     Symbol type A )
  //    (   , 0 -   ) 
  //    PREFIX,   auto (    ), TOLERANCE, 
  //  auto (    ), UNIT, SUFFIX ( 4  )
  parRDim.tPar.bitFlag = _AUTONOMINAL|_PREFIX|_DEVIATION|_UNIT|_SUFFIX; 
  parRDim.tPar.pText   = CreateArray( CHAR_STR_ARR_T, 0 ); //   
  
  //    
  AddArrayItem( parRDim.tPar.pText, -1, _T("prefix"), 8 );
  AddArrayItem( parRDim.tPar.pText, -1, _T("+0.5"),  5 );
  AddArrayItem( parRDim.tPar.pText, -1, _T("-0.5"),  5 );
  AddArrayItem( parRDim.tPar.pText, -1, _T("mm"),     5 );
  AddArrayItem( parRDim.tPar.pText, -1, _T("suffics"), 13 );

  //   
  parRDim.sPar.xc  = 50; //  
  parRDim.sPar.yc  = 50; 
  parRDim.sPar.rad = 70; // 
  
  //   
  reference rDiamDimension = RadDimension( &parRDim );
 
  GetObjParam( rDiamDimension,    //    
               &parRDim,          //    
               sizeof( parRDim ), //   
               ALLPARAM_T );        //   
               
  //      ( 0 -  , 1 -  ,
  // 2 -    , 3 -   c  ) 
  ShowDimParam( _T("C "), &parRDim, ALLPARAM_T, 2 );

  //   
  parRDim.dPar.textPos  = 0; //       -  (     )
  parRDim.dPar.pt1      = 1; //       ( 0 -  , 1 - , 2 - , 3 - , 4 -  )
  parRDim.dPar.pt2      = 1; //    ( 0 -   , 1 -    )
  parRDim.dPar.shelfDir = 0; //    ( 0 -   , -1 -   ,
                             // 1 -   , 2 -   , 3 -    )
  parRDim.dPar.ang      = 0; //     
  
  //    
  parRDim.tPar.sign = 3; //      ( 0 -  , 1 - , 2 - ,
                         // 3 - , > 3 -     Symbol type A )
 
  //   
  parRDim.sPar.xc  = 30; //  
  parRDim.sPar.yc  = 30; 
  parRDim.sPar.rad = 30; // 

  SetObjParam( rDiamDimension,    //    
               &parRDim,          //    
               sizeof( parRDim ), //   
               ALLPARAM_T );        //     
  
  GetObjParam( rDiamDimension,    //    
               &parRDim,          //    
               sizeof( parRDim ), //   
               ALLPARAM_T );        //   
               
  //      ( 0 -  , 1 -  ,
  // 2 -    , 3 -   c  )
  ShowDimParam( _T(" "), &parRDim, ALLPARAM_T, 2 );
  
  //    
  DeleteArray( parRDim.tPar.pText );  

}


//-------------------------------------------------------------------------------
//   c 
// --- 
void DrawRadBreakDimt()
{
  RBreakDimParam parRBreakDim; //      
  memset( &parRBreakDim, 0, sizeof( parRBreakDim ) );
  
  //   
  parRBreakDim.dPar.pt  = 2;  //   ( 0 -  , 1 - , 2 - , 3 - , 4 -  )
  parRBreakDim.dPar.ang = 30; // 
  parRBreakDim.dPar.pb  = 20; //  
  
  //   
  parRBreakDim.tPar.style   = 0; // C  , ( 0 -    )
  parRBreakDim.tPar.sign    = 0; //      ( 0 -  , 1 - , 2 - ,
                                 // 3 - , > 3 -     Symbol type A )
  //    (   , 0 -   ) 
  //    PREFIX,   auto (    ), TOLERANCE, 
  //  auto (    ), UNIT, SUFFIX ( 4  )
  parRBreakDim.tPar.bitFlag = _AUTONOMINAL|_PREFIX|_DEVIATION|_UNIT|_SUFFIX; 
  parRBreakDim.tPar.pText   = CreateArray( CHAR_STR_ARR_T, 0 ); //   
  
  //    
  AddArrayItem( parRBreakDim.tPar.pText, -1, _T("prefix"), 8 );
  AddArrayItem( parRBreakDim.tPar.pText, -1, _T("+0.5"),  5 );
  AddArrayItem( parRBreakDim.tPar.pText, -1, _T("-0.5"),  5 );
  AddArrayItem( parRBreakDim.tPar.pText, -1, _T("mm"),     5 );
  AddArrayItem( parRBreakDim.tPar.pText, -1, _T("suffics"), 13 );

  //   
  parRBreakDim.sPar.xc  = 50; //  
  parRBreakDim.sPar.yc  = 50; 
  parRBreakDim.sPar.rad = 70; // 
  
  //   
  reference rRadBreakDimension = RadBreakDimension( &parRBreakDim );
 
  GetObjParam( rRadBreakDimension,     //    
               &parRBreakDim,          //    
               sizeof( parRBreakDim ), //   
               ALLPARAM_T );             //   
               
  //      ( 0 -  , 1 -  ,
  // 2 -    , 3 -   c  ) 
  ShowDimParam( _T("C "), &parRBreakDim, ALLPARAM_T, 3 );

  //   
  parRBreakDim.dPar.pt  = 1;  //   ( 0 -  , 1 - , 2 - , 3 - , 4 -  )
  parRBreakDim.dPar.pb  = 10; //  
  
  //   
  parRBreakDim.tPar.sign = 3; //      ( 0 -  , 1 - , 2 - ,
                              // 3 - , > 3 -     Symbol type A )
 
  //   
  parRBreakDim.sPar.xc  = 30; //  
  parRBreakDim.sPar.yc  = 30; 
  parRBreakDim.sPar.rad = 40; //  
 
  SetObjParam( rRadBreakDimension,     //    
               &parRBreakDim,          //    
               sizeof( parRBreakDim ), //   
               ALLPARAM_T );             //    
 
  GetObjParam( rRadBreakDimension,      //    
               &parRBreakDim,           //    
               sizeof( parRBreakDim ),  //   
               ALLPARAM_T );              //   
               
  //      ( 0 -  , 1 -  ,
  // 2 -    , 3 -   c  )
  ShowDimParam( _T(" "), &parRBreakDim, ALLPARAM_T, 3 );
  
  //    
  DeleteArray( parRBreakDim.tPar.pText ); 
}
