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 info@ribbonsoft.com 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 <algorithm>
#include <iostream>
 
#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; }
 
    unsigned long incHandle() const { return m_handle++; }
 
    void setModelSpaceHandle(unsigned long h) { modelSpaceHandle = h; }
 
    unsigned long getModelSpaceHandle() { return modelSpaceHandle; }
 
    void setPaperSpaceHandle(unsigned long h) { paperSpaceHandle = h; }
 
    unsigned long getPaperSpaceHandle() { return paperSpaceHandle; }
 
    void setPaperSpace0Handle(unsigned long h) { paperSpace0Handle = h; }
 
    unsigned long getPaperSpace0Handle() { return paperSpace0Handle; }
 
    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