home *** CD-ROM | disk | FTP | other *** search
/ Windows 95 v2.4 Fix / W95-v2.4fix.iso / ACADWIN / ADS / CPP / GENERAL / ADSDXF.CPP < prev    next >
Encoding:
C/C++ Source or Header  |  1995-02-08  |  12.1 KB  |  346 lines
  1. /* 
  2.     ADSDXF.CPP
  3.     
  4.     This file:
  5.  
  6.     Defines DXF group conversion functions and enums in converting
  7.     DXF group code.
  8.  
  9.     (C) Copyright 1988-1994 by Autodesk, Inc.
  10.  
  11.     This program is copyrighted by Autodesk, Inc. and is  licensed
  12.     to you under the following conditions.  You may not distribute
  13.     or  publish the source code of this program in any form.   You
  14.     may  incorporate this code in object form in derivative  works
  15.     provided  such  derivative  works  are  (i.) are  designed and
  16.     intended  to  work  solely  with  Autodesk, Inc. products, and
  17.     (ii.)  contain  Autodesk's  copyright  notice  "(C)  Copyright
  18.     1988-1994 by Autodesk, Inc."
  19.  
  20.     AUTODESK  PROVIDES THIS PROGRAM "AS IS" AND WITH  ALL  FAULTS.
  21.     AUTODESK  SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTY OF  MER-
  22.     CHANTABILITY OR FITNESS FOR A PARTICULAR USE.  AUTODESK,  INC.
  23.     DOES  NOT  WARRANT THAT THE OPERATION OF THE PROGRAM  WILL  BE
  24.     UNINTERRUPTED OR ERROR FREE.
  25. */
  26. #include "adsinc.h"
  27.  
  28. //-----------------------------------------------------------------------------
  29. static      int     real_precision      =  6;
  30. static      int     int_radix           = 10;
  31. static      int     long_radix          = 10;
  32. static      char    *adsname_seperator  = ":";
  33.  
  34. //-----------------------------------------------------------------------------
  35. // Use these buffers carefully, make sure no recursive usages of these
  36. // buffers in this file. Like :
  37. //
  38. // void foo()
  39. // {
  40. //      bar( temp_buffer );
  41. // }
  42. //
  43. // void bar( char* buf )
  44. // {
  45. //      strcpy( temp_buffer, "hello" );     // oops
  46. //      strcat( temp_buffer, buf );
  47. //
  48. // }
  49. //
  50. static char temp_buffer[ 256 ];
  51. static char temp_buffer1[ 256 ];
  52.  
  53. //-----------------------------------------------------------------------------
  54. DXF_GROUP_INFO dxf_group_info[] =
  55. {
  56.     { DXF_PRIM_ENT_TEXT,    DXF_PRIM_ENT_TEXT_LOWER_1,  DXF_PRIM_ENT_TEXT_UPPER_1
  57.         , Str2Str,      Str2Str,    "Primary Entity Text" }
  58.     , { DXF_STRING1,        DXF_STRING_LOWER_1,         DXF_STRING_UPPER_1
  59.         , Str2Str,      Str2Str,    "String" }
  60.     , { DXF_PRIM_X,         DXF_PRIM_X_LOWER,           DXF_PRIM_X_UPPER
  61. //        , ThreeD2Str,   Str2ThreeD,     "Primary X Coordinates" }
  62.         , ThreeD2Str,   Str2ThreeD,     "Primary Coordinate" }
  63.     , { DXF_OTHER_X,        DXF_OTHER_X_LOWER,          DXF_OTHER_X_UPPER
  64. //        , ThreeD2Str,   Str2ThreeD,     "Coordinates" }
  65.         , ThreeD2Str,   Str2ThreeD,     "Secondary Coordinate" }
  66.     , { DXF_PRIM_Y,         DXF_PRIM_Y_LOWER,           DXF_PRIM_Y_UPPER
  67.         , ThreeD2Str,   Str2ThreeD,     "Primary Y Coordinates" }
  68.     , { DXF_OTHER_Y,        DXF_OTHER_Y_LOWER,          DXF_OTHER_Y_UPPER
  69.         , ThreeD2Str,   Str2ThreeD,     "Y Coordinates" }
  70.     , { DXF_PRIM_Z,         DXF_PRIM_Z_LOWER,           DXF_PRIM_Z_UPPER
  71.         , ThreeD2Str,   Str2ThreeD,     "Primary Z Coordinates" }
  72.     , { DXF_OTHER_Z,        DXF_OTHER_Z_LOWER,          DXF_OTHER_Z_UPPER
  73.         , ThreeD2Str,   Str2ThreeD,     "Z Coordinates" }
  74.     , { DXF_FLOAT_FACT,     DXF_FLOAT_FACT_LOWER_1,     DXF_FLOAT_FACT_UPPER_1
  75.         , Double2Str,   Str2Double, "Scale Factor" }
  76.     , { DXF_ANGLE,          DXF_ANGLE_LOWER,            DXF_ANGLE_UPPER
  77.         , Double2Str,   Str2Double, "Angle" }
  78.     , { DXF_FLOAT1,         DXF_FLOAT_LOWER_1,          DXF_FLOAT_UPPER_1
  79.         , Double2Str,   Str2Double, "Floating Point" }
  80.     , { DXF_COLOR_NUMBER,   DXF_COLOR_NUMBER_LOWER,     DXF_COLOR_NUMBER_UPPER
  81.         , Int2Str,      Str2Int,    "Color Number" }
  82.     , { DXF_INTEGER1,       DXF_INTEGER_LOWER_1,        DXF_INTEGER_UPPER_1
  83.         , Int2Str,      Str2Int,    "Integer" }
  84.     , { DXF_LONG,           DXF_LONG_LOWER,             DXF_LONG_UPPER
  85.         , Long2Str,      Str2Long,    "Long Integer" }
  86.     , { DXF_STRING2,       DXF_STRING_LOWER_2,        DXF_STRING_UPPER_2
  87.         , Str2Str,      Str2Str,    "String" }
  88.     , { DXF_FLOAT2,         DXF_FLOAT_LOWER_2,          DXF_FLOAT_UPPER_2
  89.         , Double2Str,   Str2Double, "Floating Point" }
  90.     , { DXF_INTEGER2,       DXF_INTEGER_LOWER_2,        DXF_INTEGER_UPPER_2
  91.         , Int2Str,      Str2Int,    "Integer" }
  92.     , { DXF_EXTRUSION_X,    DXF_EXTRUSION_X_LOWER,      DXF_EXTRUSION_X_UPPER
  93. //        , ThreeD2Str,   Str2ThreeD,     "X Extrusion" }
  94.         , ThreeD2Str,   Str2ThreeD,     "Extrusions" }
  95.     , { DXF_EXTRUSION_Y,    DXF_EXTRUSION_Y_LOWER,      DXF_EXTRUSION_Y_UPPER
  96.         , ThreeD2Str,   Str2ThreeD,     "Y Extrusion" }
  97.     , { DXF_EXTRUSION_Z,    DXF_EXTRUSION_Z_LOWER,      DXF_EXTRUSION_Z_UPPER
  98.         , ThreeD2Str,   Str2ThreeD,     "Z Extrusion" }
  99.     , { DXF_FLOAT3,         DXF_FLOAT_LOWER_3,          DXF_FLOAT_UPPER_3
  100.         , Double2Str,   Str2Double, "Floating Point" }
  101.     , { DXF_INTEGER3,       DXF_INTEGER_LOWER_3,        DXF_INTEGER_UPPER_3
  102.         , Int2Str,      Str2Int,    "Integer" }
  103.     , { DXF_STRING3,        DXF_STRING_LOWER_3,         DXF_STRING_UPPER_3
  104.         , Str2Str,      Str2Str,    "String" }
  105.     , { DXF_COMMENT_STRING, DXF_COMMENT_LOWER,          DXF_COMMENT_UPPER
  106.         , Str2Str,      Str2Str,    "Comment" }
  107.     , { DXF_STRING4,        DXF_STRING_LOWER_4,         DXF_STRING_UPPER_4
  108.         , Str2Str,      Str2Str,    "String" }
  109.     , { DXF_FLOAT4,         DXF_FLOAT_LOWER_4,          DXF_FLOAT_UPPER_4
  110.         , Double2Str,   Str2Double, "Floating Point" }
  111.     , { DXF_INTEGER4,       DXF_INTEGER_LOWER_4,        DXF_INTEGER_UPPER_4
  112.         , Int2Str,      Str2Int,    "Integer" }
  113.     , { DXF_UNKNOWN_GROUP,  DXF_UNKNOWN_LOWER,          DXF_UNKNOWN_UPPER
  114.         , NULL,         NULL,       "Unknow" }
  115. };
  116.  
  117. //-----------------------------------------------------------------------------
  118. DXFGROUPCODE DXFGroupCode(int dxfcode)
  119. {
  120.     int group_index;
  121.  
  122.     for ( group_index = 0
  123.         ; group_index < ARRAY_SIZE( dxf_group_info )
  124.         ; group_index++ )
  125.     {
  126.         if ( dxfcode >= dxf_group_info[ group_index ].lower
  127.             && dxfcode <= dxf_group_info[ group_index ].upper )
  128.         {
  129.             return dxf_group_info[ group_index ].dxfgroup;
  130.         }
  131.     }
  132.     return DXF_UNKNOWN_GROUP;
  133. }
  134.  
  135. //-----------------------------------------------------------------------------
  136. char *DXFGroupCode2Str( struct resbuf* src, char *buffer )
  137. {
  138.     ASSERT( src != NULL && buffer != NULL );
  139.     int dxfcode = src->restype;
  140.  
  141.     int group_index;
  142.  
  143.     for ( group_index = 0
  144.         ; group_index < ARRAY_SIZE( dxf_group_info )
  145.         ; group_index++ )
  146.     {
  147.         if ( dxfcode >= ( dxf_group_info[ group_index ] ).lower
  148.             && dxfcode <= ( dxf_group_info[ group_index ] ).upper )
  149.         {
  150.             if ( ( *dxf_group_info[ group_index ].dxf2strfunc )( temp_buffer1, src ) )
  151.             {
  152.                 wsprintf( buffer
  153.                         , "%d( %s )\t%s"
  154.                         , dxfcode
  155.                         , dxf_group_info[ group_index ].string
  156.                         , temp_buffer1 );
  157.                 return buffer;
  158.             }
  159.         }
  160.     }
  161.     return NULL;
  162. }
  163.  
  164. //-----------------------------------------------------------------------------
  165. char *ThreeD2Str( char* dst, struct resbuf* src )
  166. {
  167.     ASSERT( dst != NULL && src != NULL );
  168.  
  169.     dst[ 0 ] = '\0';
  170.     for ( int i = 0; i < 3; i++ )
  171.     {
  172.         if ( _gcvt( src->resval.rpoint[ i ], real_precision, temp_buffer ) )
  173.         {
  174.             strcat( dst, temp_buffer );
  175.             strcat( dst, "\t" );
  176.         }
  177.         else
  178.         {
  179.             ASSERT( 0 );
  180.         }
  181.     }
  182.     return dst;
  183. }
  184.  
  185. //-----------------------------------------------------------------------------
  186. struct resbuf       *Str2ThreeD( struct resbuf* dst, char* src )
  187. {
  188.     ASSERT( 0 );    //shit...
  189.     return NULL;
  190. }
  191.  
  192. //-----------------------------------------------------------------------------
  193. char*   Double2Str( char* dst, struct resbuf* src )
  194. {
  195.     ASSERT( dst != NULL && src != NULL );
  196.     return _gcvt( src->resval.rreal, real_precision, dst );
  197. }
  198.  
  199. //-----------------------------------------------------------------------------
  200. struct resbuf*   Str2Double( struct resbuf* dst, char* src )
  201. {
  202.     ASSERT( dst != NULL && src != NULL );
  203.     dst->resval.rreal = atof( src );
  204.  
  205.     return dst;
  206. }
  207.  
  208. //-----------------------------------------------------------------------------
  209. char*   Double2Str( char* dst, double src )
  210. {
  211.     ASSERT( dst != NULL );
  212.     return _gcvt( src, real_precision, dst );
  213. }
  214.  
  215. //-----------------------------------------------------------------------------
  216. double*   Str2Double( double* dst, char* src )
  217. {
  218.     ASSERT( dst != NULL && src != NULL );
  219.     *dst = atof( src );
  220.  
  221.     return dst;
  222. }
  223.  
  224. //-----------------------------------------------------------------------------
  225. char*   Int2Str( char* dst, struct resbuf* src )
  226. {
  227.     ASSERT( dst != NULL && src != NULL );
  228.  
  229.     _itoa( src->resval.rint, dst, int_radix );
  230.     return dst;
  231. }
  232.  
  233. //-----------------------------------------------------------------------------
  234. struct resbuf*   Str2Int( struct resbuf* dst, char* src )
  235. {
  236.     ASSERT( dst != NULL && src != NULL );
  237.  
  238.     dst->resval.rint = atoi( src );
  239.     return dst;
  240. }
  241.  
  242. //-----------------------------------------------------------------------------
  243. char*   Long2Str( char* dst, struct resbuf* src )
  244. {
  245.     ASSERT( dst != NULL && src != NULL );
  246.  
  247.     _ltoa( src->resval.rlong, dst, long_radix );
  248.     return dst;
  249. }
  250.  
  251. //-----------------------------------------------------------------------------
  252. struct resbuf*   Str2Long( struct resbuf* dst, char* src )
  253. {
  254.     ASSERT( dst != NULL && src != NULL );
  255.  
  256.     dst->resval.rlong = atol( src );
  257.     return dst;
  258. }
  259.  
  260. //-----------------------------------------------------------------------------
  261. char*   Str2Str( char* dst, struct resbuf* src )
  262. {
  263.     ASSERT( dst != NULL && src != NULL && src->resval.rstring != NULL );
  264.  
  265.     strcpy( dst, src->resval.rstring );
  266.     return dst;
  267. }
  268.  
  269. //-----------------------------------------------------------------------------
  270. struct resbuf*   Str2Str( struct resbuf* dst, char* src )
  271. {
  272.     ASSERT( dst != NULL && src != NULL && dst->resval.rstring != NULL );
  273.  
  274.     strcpy( dst->resval.rstring, src );
  275.     return dst;
  276. }
  277.  
  278. //-----------------------------------------------------------------------------
  279. char* AdsName2Str( char* dst, struct resbuf *src )
  280. {
  281.     ASSERT( dst != NULL 
  282.             && src != NULL 
  283.             && src->resval.rstring != NULL );
  284.  
  285.     _ltoa( src->resval.rlname[ 0 ], dst, long_radix );
  286.     _ltoa( src->resval.rlname[ 1 ], temp_buffer, long_radix );
  287.     strcat( dst, adsname_seperator );
  288.     strcat ( dst, temp_buffer );
  289.     return dst;
  290. }
  291.  
  292. //-----------------------------------------------------------------------------
  293. struct resbuf* Str2AdsName( struct resbuf* dst, char *src)
  294. {
  295.     char first_long[ 256 ];
  296.  
  297.     ASSERT( dst != NULL 
  298.             && src != NULL 
  299.             && dst->resval.rstring != NULL );
  300.  
  301.     char *second_long = strstr( src, adsname_seperator );
  302.     strncpy( first_long, src, second_long - src );
  303.     ASSERT ( second_long != NULL );
  304.     second_long++;
  305.     ASSERT ( second_long != NULL );
  306.  
  307.     dst->resval.rlname[ 0 ] = atol( first_long );
  308.     dst->resval.rlname[ 1 ] = atol( second_long );
  309.     return dst;
  310. }
  311.  
  312. //-----------------------------------------------------------------------------
  313. char* AdsName2Str( char* dst, ads_name& src )
  314. {
  315.     ASSERT( dst != NULL 
  316.             && src != NULL
  317.             && src[ 0 ] != NULL 
  318.             && src[ 1 ] != NULL );
  319.  
  320.     _ltoa( src[ 0 ], dst, long_radix );
  321.     _ltoa( src[ 1 ], temp_buffer, long_radix );
  322.     strcat( dst, adsname_seperator );
  323.     strcat ( dst, temp_buffer );
  324.     return dst;
  325. }
  326.  
  327. //-----------------------------------------------------------------------------
  328. ads_name& Str2AdsName( ads_name& dst, char *src)
  329. {
  330.     char first_long[ 256 ];
  331.  
  332.     ASSERT( dst != NULL 
  333.             && src != NULL );
  334.  
  335.     char *second_long = strstr( src, adsname_seperator );
  336.     ASSERT ( second_long != NULL );
  337.     strncpy( first_long, src, second_long - src );
  338.     second_long++;
  339.     ASSERT ( second_long != NULL );
  340.  
  341.     dst[ 0 ] = atol( first_long );
  342.     dst[ 1 ] = atol( second_long );
  343.     return dst;
  344. }
  345.  
  346.