dl_writer.h

Go to the documentation of this file.

/****************************************************************************
** Copyright (C) 2001-2013 RibbonSoft, GmbH. All rights reserved.
** Copyright (C) 2001 Robert J. Campbell Jr.
**
** This file is part of the dxflib project.
**
** This file is free software; you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation; either version 2 of the License, or
** (at your option) any later version.
**
** Licensees holding valid dxflib Professional Edition licenses may use 
** this file in accordance with the dxflib Commercial License
** Agreement provided with the Software.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
** See http://www.ribbonsoft.com for further details.
**
** Contact [email protected] if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
 
#ifndef DL_WRITER_H
#define DL_WRITER_H
 
#include "dl_global.h"
 
#ifndef _WIN32
#include <strings.h>
#endif
 
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
 
#include <cstring>
#include <iostream>
#include <algorithm>
 
#include "dl_attributes.h"
#include "dl_codes.h"
 
 
 
class DXFLIB_EXPORT DL_Writer {
public:
    DL_Writer(DL_Codes::version version) : m_handle(0x30) {
        this->version = version;
        modelSpaceHandle = 0;
        paperSpaceHandle = 0;
        paperSpace0Handle = 0;
    }
 
    virtual ~DL_Writer() {}
    ;
 
    void section(const char* name) const {
        dxfString(0, "SECTION");
        dxfString(2, name);
    }
 
    void sectionHeader() const {
        section("HEADER");
    }
 
    void sectionTables() const {
        section("TABLES");
    }
 
    void sectionBlocks() const {
        section("BLOCKS");
    }
 
    void sectionEntities() const {
        section("ENTITIES");
    }
 
    void sectionClasses() const {
        section("CLASSES");
    }
 
    void sectionObjects() const {
        section("OBJECTS");
    }
 
    void sectionEnd() const {
        dxfString(0, "ENDSEC");
    }
 
    void table(const char* name, int num, int h=0) const {
        dxfString(0, "TABLE");
        dxfString(2, name);
        if (version>=DL_VERSION_2000) {
            if (h==0) {
                handle();
            }
            else {
                dxfHex(5, h);
            }
            dxfString(100, "AcDbSymbolTable");
        }
        dxfInt(70, num);
    }
 
    void tableLayers(int num) const {
        table("LAYER", num, 2);
    }
 
    void tableLinetypes(int num) const {
        //linetypeHandle = 5;
        table("LTYPE", num, 5);
    }
 
    void tableAppid(int num) const {
        table("APPID", num, 9);
    }
 
    void tableStyle(int num) const {
        table("STYLE", num, 3);
    }
 
    void tableEnd() const {
        dxfString(0, "ENDTAB");
    }
 
    void dxfEOF() const {
        dxfString(0, "EOF");
    }
 
    void comment(const char* text) const {
        dxfString(999, text);
    }
 
    void entity(const char* entTypeName) const {
        dxfString(0, entTypeName);
        if (version>=DL_VERSION_2000) {
            handle();
        }
    }
 
    void entityAttributes(const DL_Attributes& attrib) const {
    
        // layer name:
        dxfString(8, attrib.getLayer());
        
        // R12 doesn't accept BYLAYER values. The value has to be missing
        //   in that case.
        if (version>=DL_VERSION_2000 || attrib.getColor()!=256) {
            dxfInt(62, attrib.getColor());
        }
        if (version>=DL_VERSION_2000 && attrib.getColor24()!=-1) {
            dxfInt(420, attrib.getColor24());
        }
        if (version>=DL_VERSION_2000) {
            dxfInt(370, attrib.getWidth());
        }
        if (version>=DL_VERSION_2000) {
            dxfReal(48, attrib.getLinetypeScale());
        }
        std::string linetype = attrib.getLinetype();
        std::transform(linetype.begin(), linetype.end(), linetype.begin(), ::toupper);
        if (version>=DL_VERSION_2000 || linetype=="BYLAYER") {
            dxfString(6, attrib.getLinetype());
        }
    }
 
    void subClass(const char* sub) const {
        dxfString(100, sub);
    }
 
    void tableLayerEntry(unsigned long int h=0)  const {
        dxfString(0, "LAYER");
        if (version>=DL_VERSION_2000) {
            if (h==0) {
                handle();
            } else {
                dxfHex(5, h);
            }
            dxfString(100, "AcDbSymbolTableRecord");
            dxfString(100, "AcDbLayerTableRecord");
        }
    }
 
    void tableLinetypeEntry(unsigned long int h=0)  const {
        dxfString(0, "LTYPE");
        if (version>=DL_VERSION_2000) {
            if (h==0) {
                handle();
            } else {
                dxfHex(5, h);
            }
            //dxfHex(330, 0x5);
            dxfString(100, "AcDbSymbolTableRecord");
            dxfString(100, "AcDbLinetypeTableRecord");
        }
    }
 
    void tableAppidEntry(unsigned long int h=0)  const {
        dxfString(0, "APPID");
        if (version>=DL_VERSION_2000) {
            if (h==0) {
                handle();
            } else {
                dxfHex(5, h);
            }
            //dxfHex(330, 0x9);
            dxfString(100, "AcDbSymbolTableRecord");
            dxfString(100, "AcDbRegAppTableRecord");
        }
    }
 
    void sectionBlockEntry(unsigned long int h=0)  const {
        dxfString(0, "BLOCK");
        if (version>=DL_VERSION_2000) {
            if (h==0) {
                handle();
            } else {
                dxfHex(5, h);
            }
            //dxfHex(330, blockHandle);
            dxfString(100, "AcDbEntity");
            if (h==0x1C) {
                dxfInt(67, 1);
            }
            dxfString(8, "0");                 // TODO: Layer for block
            dxfString(100, "AcDbBlockBegin");
        }
    }
 
    void sectionBlockEntryEnd(unsigned long int h=0)  const {
        dxfString(0, "ENDBLK");
        if (version>=DL_VERSION_2000) {
            if (h==0) {
                handle();
            } else {
                dxfHex(5, h);
            }
            //dxfHex(330, blockHandle);
            dxfString(100, "AcDbEntity");
            if (h==0x1D) {
                dxfInt(67, 1);
            }
            dxfString(8, "0");                 // TODO: Layer for block
            dxfString(100, "AcDbBlockEnd");
        }
    }
 
    void color(int col=256) const {
        dxfInt(62, col);
    }
    void linetype(const char *lt) const {
        dxfString(6, lt);
    }
    void linetypeScale(double scale) const {
        dxfReal(48, scale);
    }
    void lineWeight(int lw) const {
        dxfInt(370, lw);
    }
 
    void coord(int gc, double x, double y, double z=0) const {
        dxfReal(gc, x);
        dxfReal(gc+10, y);
        dxfReal(gc+20, z);
    }
 
    void coordTriplet(int gc, const double* value) const {
        if (value) {
            dxfReal(gc, *value++);
            dxfReal(gc+10, *value++);
            dxfReal(gc+20, *value++);
        }
    }
 
    void resetHandle() const {
        m_handle = 1;
    }
 
    unsigned long handle(int gc=5) const {
        // handle has to be hex
        dxfHex(gc, m_handle);
        return m_handle++;
    }
 
    unsigned long getNextHandle() const {
        return m_handle;
    }
    
    virtual void dxfReal(int gc, double value) const = 0;
 
    virtual void dxfInt(int gc, int value) const = 0;
 
    virtual void dxfBool(int gc, bool value) const {
        dxfInt(gc, (int)value);
    }
 
    virtual void dxfHex(int gc, int value) const = 0;
 
    virtual void dxfString(int gc, const char* value) const = 0;
 
    virtual void dxfString(int gc, const std::string& value) const = 0;
 
protected:
    mutable unsigned long m_handle;
    mutable unsigned long modelSpaceHandle;
    mutable unsigned long paperSpaceHandle;
    mutable unsigned long paperSpace0Handle;
 
    DL_Codes::version version;
private:
};
 
#endif