DXFReader.h

/*--------------------------------------------------------------------------------------------
Copyright (c) 2019, NDEVR LLC
tyler.parke@ndevr.org
  __    __   ____     _____ __     __  _______
 |  \  |  | |  __ \  |  ___|\ \   / / |   __  \
 |   \ |  | | |  \ \ | |___  \ \ / /  |  |__)  |
 |  . \|  | | |__/ / | |___   \ V /   |   _   /
 |  |\    |_|_____/__|_____|___\_/____|  | \  \
 |__| \__________________________________|  \__\
 
Subject to the terms of the Enterprise+ Agreement, NDEVR hereby grants 
Licensee a limited, non-exclusive, non-transferable, royalty-free license 
(without the right to sublicense) to use the API solely for the purpose of 
Licensee's internal development efforts to develop applications for which 
the API was provided.
 
The above copyright notice and this permission notice shall be included in all 
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
 
Library: CAD
File: DXFReader
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include "DLLInfo.h"
#include "EntityCodes.h"
#include "CADEntityStreamer.h"
#include <NDEVR/String.h>
#include <functional>
namespace NDEVR
{
    class TranslatedString;
    class File;
    class Scanner;
    class DXFValueManager;
    class BinaryFile;
    class NDEVR_CAD_API DXFReader
    {
    public:
        explicit DXFReader(CADEntityStreamer& entity_streamer, ProgressInfo& progress, CancelInfo& cancel);
        ~DXFReader();
        void readFile(File file);
        bool isBinaryFile(File& file) const;
        void setWarningCallback(const std::function<void(const TranslatedString&)>& callback) { m_warning_callback = callback; }
    protected:
        void readBinaryFile(File& file);
        void readAsciiFile(File& file);
        bool readNextLinePair(Scanner& scan);
        bool readNextPair(BinaryFile& scan);
 
        bool processDXFGroup(uint04 group_code);
        void addSetting();
        void addLayer();
        void addLinetype();
        void addBlock();
        void addMaterial();
        void addBlockRecord();
        void addTextStyle();
        void endBlock();
        void addPoint();
        void addLine();
        void addXLine();
        void addRay();
        void addSection();
        void addLWPolyline();
        void addPolyline();
        void addVertex();
 
        void addSpline();
        void addMesh();
        void addArc();
        void addCircle();
        void addEllipse();
        void addInsert();
 
        void addTrace();
        void add3dFace(bool is_solid);
        void addLeader();
        void addMText();
        void addText();
        void addTableEntry();
        void addViewport();
        void addVPort();
        void addGroup();
        void addAttribute();
        void addAttributeDefinition();
        
        void addDimLinear();
        void addDimAligned();
        void addDimRadial();
        void addDimDiametric();
        void addDimAngular();
        void addDimAngular3P();
        void addDimOrdinate();
        const PaperSpace& paperspace() const { return m_paper_space; }
        /*void addLeader();
 
        void addHatch();
        void addHatchLoop();
        void addHatchEdge();
        bool handleHatchData();
 
        void addImage();*/
        void addImageDef();
 
        void addDictionary();
 
        bool handleXRecordData();
        bool handleDictionaryData();
        bool handleGroupData();
 
        bool handleXData();
        bool handleMTextData();
        bool handleLWPolylineData();
        bool handleMeshData();
        bool handleSplineData();
        bool handleLeaderData();
        bool handleLinetypeData();
        bool handleMatrixData();
        void endEntity();
        void endSequence();
        void addHandleInfo(HandleData& data);
        void addEntityInfo(EntityData& data);
        void addDimensionInfo(DimensionData& data);
    private:
        Vector<3, fltp08> getExtrusion() const;
        DXFValueManager* m_value_manager;       
        uint04 m_current_line;                  
        String m_polyline_layer;                
        Buffer<Vector<4, fltp08>> m_vertices;   
        enum class MeshProperty
        {
              e_none                
            , e_face                
            , e_edge                
            , e_sub_entity_count    
            , e_property_type       
        };
        CADMeshData m_mesh_data;
        CADDictionaryObject m_dictionary;
        MeshProperty m_current_mesh_property;
        
        Buffer<fltp08> m_knots;
        Buffer<fltp08> m_weights;
 
        Buffer<Vector<3, fltp08>> m_control_points;
        Buffer<Vector<3, fltp08>> m_fit_points;
 
        bool m_first_hatch_loop;
        HatchEdgeData m_hatch_edge;
        DXFGroup m_group_data;
        Buffer<Buffer<HatchEdgeData>> m_hatch_edges;
        PaperSpace m_paper_space;
        String m_x_record_handle;
        bool m_x_recordValues;
        bool m_complex_object;
        uint04 m_group_code;
        uint04 m_matrix_count = 0;
        Matrix<fltp08> m_matrix = Matrix<fltp08>(1.0);
        // Current entity type
        DXFEntityCodes m_current_object_type;
        // Value of the current setting
        String m_setting_value;
        // Key of the current setting (e.g. "$ACADVER")
        String m_setting_key;
        CADEntityStreamer& m_entity_streamer;
        ProgressInfo& m_progress;
        CancelInfo& m_cancel;
        std::function<void(const TranslatedString&)> m_warning_callback;
    };
}