Navigation

Main Page
Download
Support
Installation
Tutorial
Examples
Reference Manual
   Version 1.0.5new_solver
   Version 1.0.5dev
      Class Index
      File List
   Version 1.0.5b
   Version 1.0.4dev
   Version 1.0.4
Publications


Hosted by Get Ion Beam Simulator at SourceForge.net. Fast, secure and Free Open Source software downloads

mydxftables.hpp

Go to the documentation of this file.
00001 
00005 /* Copyright (c) 2010-2012 Taneli Kalvas. All rights reserved.
00006  *
00007  * You can redistribute this software and/or modify it under the terms
00008  * of the GNU General Public License as published by the Free Software
00009  * Foundation; either version 2 of the License, or (at your option)
00010  * any later version.
00011  * 
00012  * This library is distributed in the hope that it will be useful, but
00013  * WITHOUT ANY WARRANTY; without even the implied warranty of
00014  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
00015  * General Public License for more details.
00016  * 
00017  * You should have received a copy of the GNU General Public License
00018  * along with this library (file "COPYING" included in the package);
00019  * if not, write to the Free Software Foundation, Inc., 51 Franklin
00020  * Street, Fifth Floor, Boston, MA 02110-1301 USA
00021  * 
00022  * If you have questions about your rights to use or distribute this
00023  * software, please contact Berkeley Lab's Technology Transfer
00024  * Department at TTD@lbl.gov. Other questions, comments and bug
00025  * reports should be sent directly to the author via email at
00026  * taneli.kalvas@jyu.fi.
00027  * 
00028  * NOTICE. This software was developed under partial funding from the
00029  * U.S.  Department of Energy.  As such, the U.S. Government has been
00030  * granted for itself and others acting on its behalf a paid-up,
00031  * nonexclusive, irrevocable, worldwide license in the Software to
00032  * reproduce, prepare derivative works, and perform publicly and
00033  * display publicly.  Beginning five (5) years after the date
00034  * permission to assert copyright is obtained from the U.S. Department
00035  * of Energy, and subject to any subsequent five (5) year renewals,
00036  * the U.S. Government is granted for itself and others acting on its
00037  * behalf a paid-up, nonexclusive, irrevocable, worldwide license in
00038  * the Software to reproduce, prepare derivative works, distribute
00039  * copies to the public, perform publicly and display publicly, and to
00040  * permit others to do so.
00041  */
00042 
00043 #ifndef MY_DXF_TABLES_HPP
00044 #define MY_DXF_TABLES_HPP 1
00045 
00046 
00047 #include <vector>
00048 #include <string>
00049 #include <stdint.h>
00050 #include "mydxffile.hpp"
00051 
00052 
00055 class MyDXFTableEntry
00056 {
00057 
00058     std::string _handle;           // 5 (for others) or 105 (for DIMSTYLE)
00059     std::string _handle_to_owner;  // 330
00060 
00061 protected:
00062 
00065     MyDXFTableEntry();
00066 
00069     void process_group( class MyDXFFile *dxf );
00070         
00073     void write_common( class MyDXFFile *dxf, std::ofstream &ostr );
00074 
00077     void debug_print_common( std::ostream &os ) const;
00078     
00079 public:
00080 
00083     virtual ~MyDXFTableEntry() {};
00084 
00087     virtual void write( class MyDXFFile *dxf, std::ofstream &ostr ) = 0;
00088 
00091     virtual void debug_print( std::ostream &os ) const = 0;
00092     
00093     friend std::ostream &operator<<( std::ostream &os, const MyDXFTableEntry &e );
00094 };
00095 
00096 
00097 
00100 class MyDXFTableEntryBlockRecord : public MyDXFTableEntry
00101 {
00102 
00103     std::string _name;             // 2
00104     int16_t     _units;            // 70
00105     int8_t      _explodability;    // 280
00106     int8_t      _scalability;      // 281
00107     std::string _handle_to_layout; // 340
00108 
00109 public:
00110 
00113     MyDXFTableEntryBlockRecord( class MyDXFFile *dxf );
00114 
00117     virtual ~MyDXFTableEntryBlockRecord();
00118 
00121     virtual void write( class MyDXFFile *dxf, std::ofstream &ostr );
00122 
00125     virtual void debug_print( std::ostream &os ) const;
00126 };
00127 
00128 
00129 
00132 class MyDXFTableEntryLayer : public MyDXFTableEntry
00133 {
00134 
00135     std::string _name;             // 2
00136     std::string _linetype;         // 6
00137     int16_t     _flags;            // 70
00138     int16_t     _color;            // 62 (negative if layer off)
00139     bool        _plotting;         // 290
00140     int8_t      _lineweight;       // 370
00141 
00142     std::string _handle_to_plot_style_name; // 390
00143     std::string _handle_to_material; // 347
00144 
00145 public:
00146 
00149     MyDXFTableEntryLayer( class MyDXFFile *dxf );
00150 
00153     virtual ~MyDXFTableEntryLayer();
00154 
00157     const std::string &name( void ) const { return( _name ); }
00158 
00161     void set_name( const std::string &name ) { _name = name; }
00162 
00165     virtual void write( class MyDXFFile *dxf, std::ofstream &ostr );
00166 
00169     virtual void debug_print( std::ostream &os ) const;
00170 };
00171 
00172 
00173 
00176 class MyDXFTableEntryVport : public MyDXFTableEntry
00177 {
00178 
00179     std::string _name;             /* 2, Viewport name */
00180     int16_t     _flags;            /* 70, Standard flag values (bit-coded values):
00181                                     * 16 = If set, table entry is externally dependent on an xref
00182                                     * 32 = If both this bit and bit 16 are set, the externally dependent xref has been successfully resolved
00183                                     * 64 = If set, the table entry was referenced by at least one entity in the drawing the last time
00184                                     * the drawing was edited. (This flag is for the benefit of AutoCAD commands. It can be ignored
00185                                     * by most programs that read DXF files and does not need to be set by programs that write DXF
00186                                     * files) */
00187     Vec3D       _vmin;             /* 10, 20, Lower-left corner of viewport */
00188     Vec3D       _vmax;             /* 11, 21, Upper-right corner of viewport */
00189     Vec3D       _vcenter;          /* 12, 22, View center point (in DCS) */
00190     Vec3D       _snap_base;        /* 13, 23, Snap base point (in DCS) */
00191     Vec3D       _snap_spacing;     /* 14, 24, Snap spacing X and Y */
00192     Vec3D       _grid_spacing;     /* 15, 25, Grid spacing X and Y */
00193     Vec3D       _view_direction;   /* 16, 26, 36, View direction from target point (in WCS) */
00194     Vec3D       _view_target;      /* 17, 27, 37, View target point (in WCS) */
00195     
00196     Vec3D       _ucs_origin;       /* 110, 120, 130, UCS origin */
00197     Vec3D       _ucs_x;            /* 111, 121, 131, UCS x-axis */
00198     Vec3D       _ucs_y;            /* 112, 122, 132, UCS y-axis */
00199     int16_t     _ucs_type;         /* 79, Orthographic type of UCS
00200                                     * 0 = UCS is not orthographic
00201                                     * 1 = Top; 2 = Bottom
00202                                     * 3 = Front; 4 = Back
00203                                     * 5 = Left; 6 = Right */
00204     double      _elevation;        /* 146, Elevation */
00205 
00206 public:
00207 
00210     MyDXFTableEntryVport( class MyDXFFile *dxf );
00211 
00214     virtual ~MyDXFTableEntryVport();
00215 
00218     virtual void write( class MyDXFFile *dxf, std::ofstream &ostr );
00219 
00222     virtual void debug_print( std::ostream &os ) const;
00223 };
00224 
00225 
00226 
00229 class MyDXFTable
00230 {
00231     std::string               _name;            // 2
00232     std::string               _handle;          // 5
00233     std::string               _handle_to_owner; // 330
00234 
00235     std::vector<MyDXFTableEntry *> _entries;         // 70 (size)
00236 
00237 public:
00238 
00239     MyDXFTable( const std::string &name, class MyDXFFile *dxf );
00240     ~MyDXFTable();
00241 
00244     uint32_t size() const { return( _entries.size() ); }
00245 
00248     const MyDXFTableEntry *get_entry( uint32_t a ) const { return( _entries[a] ); }
00249 
00252     MyDXFTableEntry *get_entry( uint32_t a ) { return( _entries[a] ); }
00253 
00256     void write( class MyDXFFile *dxf, std::ofstream &ostr );
00257 
00260     void debug_print( std::ostream &os ) const;
00261 };
00262 
00263 
00264 
00269 class MyDXFTables
00270 {
00271 
00272     MyDXFTable  *_blockrecord;
00273     MyDXFTable  *_layer;
00274     MyDXFTable  *_vport;
00275 
00276 public:
00277 
00278     MyDXFTables( class MyDXFFile *dxf );
00279     ~MyDXFTables();
00280 
00283     const MyDXFTable *get_layers_table( void ) const { return( _layer ); }
00284 
00287     MyDXFTable *get_layers_table( void ) { return( _layer ); }
00288 
00291     void write( class MyDXFFile *dxf, std::ofstream &ostr );
00292 
00295     void debug_print( std::ostream &os ) const;
00296 };
00297 
00298 
00299 #endif


Reference manual for Ion Beam Simulator 1.0.5dev
Generated by Doxygen 1.7.1 on Mon Feb 6 2012 15:07:16.