LibreCAD

cmake_minimum_required(VERSION 3.22)
project(LibreCAD VERSION 2.2.2)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)

#set(MIN_GW_PATH_PREFIX "c:\\DevTools\\QT\\6.7.2\\mingw_64")
set(MIN_GW_PATH_PREFIX "d:\\Qt\\QT6\\6.7.0\\mingw_64")
#set(MIN_GW_PATH_PREFIX "c:\\DevTools\\QT\\6.7.2\\mingw_64")
set(BOOST_DIR "c:\\Local\\boost_1_84_0")
set(Boost_INCLUDE_DIR "c:\\Local\\boost_1_84_0")

include_directories(librecad/src/ui/dock_widgets/entity_info)
include_directories(librecad/src/ui/dock_widgets/pen_palette)
include_directories(librecad/src/ui/dock_widgets/block_widget)
include_directories(librecad/src/ui/dock_widgets/library_widget)
include_directories(librecad/src/ui/dock_widgets/layer_widget)
include_directories(librecad/src/ui/dock_widgets/views_list)
#Temporary disabled for build
include_directories(plugins/iso_fittings)
include_directories(generated/plugin/iso_fittings/ui)
#include_directories(plugins/align)
#include_directories(plugins/asciifile)
#include_directories(plugins/divide)
#include_directories(plugins/gear)
#include_directories(plugins/list)
#include_directories(plugins/picfile)
#include_directories(plugins/plotequation)

#!/bin/sh

rsync unix/librecad /usr/local/bin/
rsync unix/ttf2lff /usr/local/bin/

strip -s /usr/local/bin/librecad
strip -s /usr/local/bin/ttf2lff

rm -rf /usr/local/lib/librecad/plugins/*
rsync --mkpath -r unix/resources/plugins/* /usr/local/lib/librecad/plugins/

strip -s /usr/share/librecad/plugins/*

rsync --mkpath -r unix/appdata/librecad.desktop /usr/local/share/applications/

rsync --mkpath -r unix/resources/fonts/* /usr/local/share/librecad/fonts/
rsync --mkpath -r unix/resources/library/* /usr/local/share/librecad/library/
rsync --mkpath -r unix/resources/patterns/* /usr/local/share/librecad/patterns/

rsync --mkpath CI/librecad.svg /usr/local/share/icons/hicolor/scalable/apps/

void LC_ActionDrawArc2PointsBase::trigger() {
    RS_PreviewActionInterface::trigger();
    RS_Entity* createdEntity = createArc(getStatus(), endPoint, alternated, true);
    if (createdEntity != nullptr){
        if (document) {
            document->startUndoCycle();
            createdEntity->setParent(container);
            createdEntity->setSelected(true);
            createdEntity->setLayerToActive();
            createdEntity->setPenToActive();
            createdEntity->setParent(container);
            container->addEntity(createdEntity);
            document->addUndoable(createdEntity);
            document->endUndoCycle();
        }
        setStatus(SetPoint1);
        alternated = false;
        deleteHighlights();

void LC_ActionCircleDimBase::trigger() {
    RS_ActionDimension::trigger();

    if (entity != nullptr) {
        preparePreview(entity, *pos, alternateAngle);
        auto *newEntity = createDim(container);
        newEntity->setLayerToActive();
        newEntity->setLayerToActive(true);
        newEntity->setPenToActive();
        newEntity->update();
        container->addEntity(newEntity);

        addToDocumentUndoable(newEntity);

        graphicView->redraw(RS2::RedrawDrawing);

    if (!dimArcData.centre.valid){
        RS_DEBUG->print(RS_Debug::D_ERROR, "LC_ActionDimArc::trigger: dimArcData.centre is not valid.\n");
        return;
    }

    auto newEntity= new LC_DimArc(container, *data, dimArcData);

    newEntity->setLayerToActive();
    newEntity->setLayerToActive(true);
    newEntity->setPenToActive();
    newEntity->update();
    container->addEntity(newEntity);

    addToDocumentUndoable(newEntity);

    setStatus(SetEntity);

}

void LC_ActionDimLinearBase::trigger(){
    RS_ActionDimension::trigger();

    preparePreview();
    auto *dim = createDim(container);
    dim->setLayerToActive();
    dim->setLayerToActive(true);
    dim->setPenToActive();
    dim->update();
    container->addEntity(dim);

    addToDocumentUndoable(dim);

    graphicView->redraw(RS2::RedrawDrawing);

}

void LC_ActionDrawDimBaseline::trigger() {
    RS_ActionDimension::trigger();

    preparePreview();
    auto *dim = createDim(container);
    dim->setLayerToActive();
    dim->setLayerToActive(true);
    dim->setPenToActive();
    dim->update();
    container->addEntity(dim);

    addToDocumentUndoable(dim);

    graphicView->redraw(RS2::RedrawDrawing);

void RS_ActionDimAngular::trigger(){
    RS_PreviewActionInterface::trigger();

    if (line1->getStartpoint().valid && line2->getStartpoint().valid) {
        auto* newEntity = new RS_DimAngular( container,*data,*edata);

        newEntity->setLayerToActive();
        newEntity->setLayerToActive(true);
        newEntity->setPenToActive();
        newEntity->update();
        container->addEntity(newEntity);

        addToDocumentUndoable(newEntity);

        RS_Vector rz {graphicView->getRelativeZero()};

void RS_ActionDimLeader::trigger(){
    RS_PreviewActionInterface::trigger();

    if (!pPoints->points.empty()){

        auto *leaderEntity = new RS_Leader(container, RS_LeaderData(true));
        leaderEntity->setLayerToActive();
        leaderEntity->setLayerToActive(true);
        leaderEntity->setPenToActive();

        for (const auto &vp: pPoints->points) {
            leaderEntity->addVertex(vp);
        }

        container->addEntity(leaderEntity);

                data.useCurrentAttributes = false;
                data.keepOriginals = isControl(e);
                data.offset = pPoints->v2 - pPoints->v1;
                m.move(data);
                goToNeutralStatus();
                updateSelectionWidget();
                deleteSnapper();
                clearSelection = true;
                break;
            }
            case MovingRef: {             
                RS_Vector mouse = snapPoint(e);

                deletePreview();

                    document->endUndoCycle();
                }
                graphicView->redraw();

                goToNeutralStatus();
                updateSelectionWidget();
                clearSelection = true;
                break;
            }
            default:
                break;
        }
    } else if (e->button() == Qt::RightButton){
        //cleanup

            // select single entity:
            RS_Entity *en = catchEntity(e);

            if (en != nullptr){
                deletePreview();

                RS_Selection s(*container, graphicView);
                if (clearSelection) s.selectAll(false);
                clearSelection = false;

                s.selectSingle(en);

                updateSelectionWidget();

                e->accept();

                goToNeutralStatus();
            } else {
                setStatus(SetCorner2);
                if (clearSelection) {
                    RS_Selection s(*container, graphicView);
                    s.selectAll(false);
                    clearSelection = false;
                }
            }
            break;
        }
        case SetCorner2: {
            //v2 = snapPoint(e);
            pPoints->v2 = toGraph(e);

            // select window:
            //if (graphicView->toGuiDX(v1.distanceTo(v2))>20) {
            deletePreview();

            bool cross = (pPoints->v1.x > pPoints->v2.x);
            RS_Selection s(*container, graphicView);
            if (clearSelection) s.selectAll(false);
            clearSelection = false;

            bool select = (e->modifiers() & Qt::ShiftModifier) == 0;
            s.selectWindow(typeToSelect, pPoints->v1, pPoints->v2, select, cross);

            updateSelectionWidget();

            goToNeutralStatus();
            e->accept();

    struct Points;
    std::unique_ptr<Points> pPoints;
    RS2::SnapRestriction snapRestriction;
    RS2::EntityType typeToSelect = RS2::EntityType::EntityUnknown;

    bool allowEntityQuickInfoForCTRL = false;
    bool allowEntityQuickInfoAuto = false;

    bool clearSelection = false;

    void checkSupportOfQuickEntityInfo();
    void clearQuickInfoWidget();
    void updateQuickInfoWidget(RS_Entity *pEntity);
    void goToNeutralStatus();
    RS2::CursorType doGetMouseCursor(int status) override;
    void onMouseLeftButtonRelease(int status, QMouseEvent *e) override;
    void onMouseRightButtonRelease(int status, QMouseEvent *e) override;

        double ds2=mouseCoord.squaredTo(t);
        if (ds2 < ds2Min){
            ds2Min=ds2;
            pImpData->snapSpot = t;
        }
    }

    if (snapMode.snapGrid) {
    if (snapMode.snapGrid && (graphicView == nullptr || graphicView->isGridOn())) {
        t = snapGrid(mouseCoord);
        double ds2=mouseCoord.squaredTo(t);
        if (ds2 < ds2Min){
//            ds2Min=ds2;
            pImpData->snapSpot = t;
        }
    }

    }
    return coord;
}

double RS_Snapper::getSnapRange() const{
    // issue #1631: redefine this method to the minimum graph distance to allow "Snap Free"
    // When the closest of any other snapping point is beyond this distance, free snapping is used.
    constexpr double Min_Snap_Factor = 0.25;
    constexpr double Min_Snap_Factor = 0.4; //0.25;
    std::vector<double> distances(3, RS_MAXDOUBLE);
    double& minGui=distances[0];
    double& minGrid=distances[1];
    double& minSize=distances[2];
    if (graphicView != nullptr) {
        minGui = graphicView->toGraphDX(32);
        // if grid is on, less than one quarter of the cell vector
        if (graphicView->isGridOn()) {
        if (graphicView->isGridOn() && snapMode.snapGrid) {
            RS_Grid *grid = graphicView->getGrid();
            const RS_Vector &cellVector = grid->getCellVector();
            minGrid = cellVector.magnitude() * Min_Snap_Factor;
        }
    }
    if (container != nullptr && isSizeValid(container->getSize())) {
        // The size bounding box

    bool snapEndpoint       {false}; //< Whether to snap to endpoints or not.
    bool snapGrid           {false}; //< Whether to snap to grid or not.
    bool snapFree           {false}; //< Whether to snap freely
    bool snapAngle          {false}; //< Whether to snap along line under certain angle

    RS2::SnapRestriction restriction {RS2::RestrictNothing}; /// The restriction on the free snap.

    double distance {5.0}; //< The distance to snap before defaulting to free snapping.
    double distance {32.0}; //< The distance to snap before defaulting to free snapping.

    /**
      * Disable all snapping.
      *
      * This effectively puts the object into free snap mode.
      *
      * @returns A reference to itself.

**
**********************************************************************/

#include <climits>
#include <cstdarg>
#include <cstdio>
#include <iostream>
#include <string_view>

#include <QDateTime>
#include <QString>
#include <QTextStream>

#include "rs_debug.h"

/**
 * Sets the debugging level.
 */
void RS_Debug::setLevel(RS_DebugLevel level) {
    if (debugLevel == level)
        return;
    debugLevel = level;
    print(D_NOTHING, "RS_DEBUG::setLevel(%d)", level);
    print(D_INFORMATIONAL, "RS_DEBUG::setLevel(%d)", level);
    print(D_CRITICAL, "RS_DEBUG: Critical");
    print(D_ERROR, "RS_DEBUG: Errors");
    print(D_WARNING, "RS_DEBUG: Warnings");
    print(D_NOTICE, "RS_DEBUG: Notice");
    print(D_INFORMATIONAL, "RS_DEBUG: Informational");
    print(D_DEBUGGING, "RS_DEBUG: Debugging");
}

    // point to new deep copies:
    for (auto e: tmp) {
        entities.append(e);
        e->reparent(this);
    }
}

void RS_EntityContainer::reparent(RS_EntityContainer *parent) {
    RS_Entity::reparent(parent);

    // All sub-entities:

    for (auto e: std::as_const(entities)) {
        e->reparent(parent);
    }
}

void RS_EntityContainer::setVisible(bool v) {
    //    RS_DEBUG->print("RS_EntityContainer::setVisible: %d", v);
    RS_Entity::setVisible(v);

    // All sub-entities:

                   return;
               }
           }
       }
    */

    if (!entity) return;
    RS_Layer* layer = entity->getLayer(true);


    if (entity->rtti() == RS2::EntityImage ||
        entity->rtti() == RS2::EntityHatch) {
        entity->rtti() == RS2::EntityHatch ||
        (layer != nullptr && layer->isConstruction())
    ) {
        entities.prepend(entity);
    } else {
        entities.append(entity);
    }
    if (autoUpdateBorders) {
        adjustBorders(entity);
    }

    virtual void detach();

    /** @return RS2::EntityContainer */
    RS2::EntityType rtti() const override{
        return RS2::EntityContainer;
    }

    void reparent(RS_EntityContainer* parent) override;

    /**
     * @return true: because entities made from this class
	 *         and subclasses are containers for other entities.
     */
    bool isContainer() const override{
        return true;
    }

** This copyright notice MUST APPEAR in all copies of the script!
**
**********************************************************************/


#include <cmath>
#include <iostream>
#include <libintl.h>

#include "lc_dimarc.h"
#include "rs_arc.h"
#include "rs_debug.h"
#include "rs_graphic.h"
#include "rs_line.h"
#include "rs_math.h"
#include "rs_mtext.h"
#include "rs_solid.h"
#include "rs_units.h"


LC_DimArcData::LC_DimArcData(const LC_DimArcData &input_dimArcData)
    :

    extLine1->setLayer (nullptr);
    extLine2->setLayer (nullptr);

    addEntity (extLine1);
    addEntity (extLine2);

    RS_Arc* refArc
    {
        new RS_Arc( this, 
                    RS_ArcData( dimArcData.centre, 
                                dimArcData.radius, 
                                dimArcData.startAngle.angle(), 
                                dimArcData.endAngle.angle(), 
                                false) 
                  ) 
    };

    arrow (arrowStartPoint, dimArcData.startAngle.angle(), +1.0, pen);
    arrow (arrowEndPoint,   dimArcData.endAngle.angle(),   -1.0, pen);

    double textAngle  { 0.0 };

    RS_Vector textPos { refArc->getMiddlePoint() };
    RS_Vector textPos { dimArc->getMiddlePoint() };

    const double textAngle_preliminary { std::trunc((textPos.angleTo(dimArcData.centre) - M_PI) * 1.0E+10) * 1.0E-10 };

    if ( ! this->getInsideHorizontalText())
    {
        RS_Vector textPosOffset;

        textAngle = RS_Math::correctAngle(textPos.angleTo(dimArcData.centre) - M_PI_2);
        const double deg360 { M_PI * 2.0 };

        const double degTolerance { 1.0E-3 };

        /* With regards to Quadrants #1 and #2 */
        if (((textAngle_preliminary >= -degTolerance) && (textAngle_preliminary <= (M_PI + degTolerance))) 
        if ( (textAngle > M_PI_2) && (textAngle < M_PI+M_PI_2) ) textAngle = RS_Math::correctAngle(textAngle+M_PI);
        ||  ((textAngle_preliminary <= -(M_PI - degTolerance)) && (textAngle_preliminary >= -(deg360 + degTolerance))))
        {
            textPosOffset.setPolar (getDimensionLineGap() * getGeneralScale(), textAngle_preliminary);
            textAngle = textAngle_preliminary + M_PI + M_PI_2;
        }
        /* With regards to Quadrants #3 and #4 */
        else
        {
            textPosOffset.setPolar (getDimensionLineGap() * getGeneralScale(), textAngle_preliminary + M_PI);
            textAngle = textAngle_preliminary + M_PI_2;
        }
    }

    QString dimLabel { getLabel() };

    bool ok = false;

    const double dummyVar = dimLabel.toDouble(&ok);

    if (dummyVar) { /* This is a dummy code, to suppress the unused variable compiler warning. */ }

    if (ok)
        dimLabel.prepend("∩ ");

    RS_MTextData textData
    {
        RS_MTextData( textPos, 
                      getTextHeight() * getGeneralScale(),
                      30.0, 
                      RS_MTextData::VABottom, 
                      RS_MTextData::HACenter, 

    auto* text { new RS_MText (this, textData) };

    text->setPen (RS_Pen (getTextColor(), RS2::WidthByBlock, RS2::SolidLine));
    text->setLayer (nullptr);
    addEntity (text);

    double halfWidth_plusGap  = (text->getUsedTextWidth() / 2.0) + getDimensionLineGap() * getGeneralScale();
    text->move(RS_Vector::polar(getDimensionLineGap() * getGeneralScale(), textAngle + M_PI_2));
    double halfHeight_plusGap = (getTextHeight()          / 2.0) + getDimensionLineGap() * getGeneralScale();

    text->move(-RS_Vector::polar(getTextHeight() / 2.0, textAngle + M_PI_2));

    /* Text rectangle's corners : top left, top right, bottom right, bottom left. */
    RS_Vector textRectCorners [4] = 
    {
        RS_Vector(false), 
        RS_Vector(textPos + RS_Vector(+halfWidth_plusGap, +halfHeight_plusGap)), 
        RS_Vector(false), 
        RS_Vector(textPos + RS_Vector(-halfWidth_plusGap, -halfHeight_plusGap))
    };

    RS_Vector cornerTopRight   { textRectCorners [1] };
    RS_Vector cornerBottomLeft { textRectCorners [3] };

    textRectCorners [0] = RS_Vector(cornerBottomLeft.x, cornerTopRight.y);
    textRectCorners [2] = RS_Vector(cornerTopRight.x,   cornerBottomLeft.y);

    for (int i = 0; i < 4; i++)
    {
        textRectCorners[i].rotate(textPos, text->getAngle());
        textRectCorners[i].x = std::trunc(textRectCorners[i].x * 1.0E+4) * 1.0E-4;
        textRectCorners[i].y = std::trunc(textRectCorners[i].y * 1.0E+4) * 1.0E-4;
    }

    if (RS_DEBUG->getLevel() == RS_Debug::D_INFORMATIONAL)
    {
        std::cout << std::endl 
                  << " LC_DimArc::updateDim: Text position / angle : " << textPos << " / " << text->getAngle() 
                  << std::endl;

        std::cout << std::endl 
                  << " LC_DimArc::updateDim: Reference arc middle point : " << refArc->getMiddlePoint() 
                  << std::endl;

        std::cout << std::endl 
                  << " LC_DimArc::updateDim: DimArc-1 start point : " << dimArc1->getStartpoint() 
                  << std::endl;

        std::cout << std::endl 
                  << " LC_DimArc::updateDim: DimArc-2 start point : " << dimArc2->getStartpoint() 
                  << std::endl;

        std::cout << std::endl 
                  << " LC_DimArc::updateDim: Text rectangle corners : " << textRectCorners [0] << ", " 
                                                                        << textRectCorners [1] << ", " 
                                                                        << textRectCorners [2] << ", " 
                                                                        << textRectCorners [3] 
                  << std::endl;
    }

    const auto [cornerLeftX, cornerRightX] = std::minmax(
        { textRectCorners[0].x, textRectCorners[1].x, textRectCorners[2].x, textRectCorners[3].x});

    const auto [cornerBottomY, cornerTopY] = std::minmax(
        { textRectCorners[0].y, textRectCorners[1].y, textRectCorners[2].y, textRectCorners[3].y});

    constexpr double deltaOffset { 1.0E-2 };

    while (((dimArc1->getEndpoint().x < cornerLeftX)   || (dimArc1->getEndpoint().x > cornerRightX) 
    ||      (dimArc1->getEndpoint().y < cornerBottomY) || (dimArc1->getEndpoint().y > cornerTopY))

    &&     (dimArc1->getAngle2() < RS_MAXDOUBLE) 
    &&     (dimArc1->getAngle2() > RS_MINDOUBLE))
    {
        dimArc1->setAngle2(dimArc1->getAngle2() + deltaOffset);
    }

    while (((dimArc2->getStartpoint().x < cornerLeftX)   || (dimArc2->getStartpoint().x > cornerRightX) 
    ||      (dimArc2->getStartpoint().y < cornerBottomY) || (dimArc2->getStartpoint().y > cornerTopY)) 

    &&     (dimArc2->getAngle1() < RS_MAXDOUBLE) 
    &&     (dimArc2->getAngle1() > RS_MINDOUBLE))
    {
        dimArc2->setAngle1(dimArc2->getAngle1() - deltaOffset);
    }

    dimArc1->setPen (pen);
    dimArc->setPen (pen);
    dimArc2->setPen (pen);

    dimArc1->setLayer (nullptr);
    dimArc->setLayer (nullptr);
    dimArc2->setLayer (nullptr);

    addEntity (dimArc1);
    addEntity (dimArc);
    addEntity (dimArc2);

    calculateBorders();
}


void LC_DimArc::update()
{

void LC_DimArc::calcDimension()
{
    const double endAngle   = dimArcData.endAngle.angle();
    const double startAngle = dimArcData.startAngle.angle();

    dimArc1 = new RS_Arc (this, RS_ArcData(dimArcData.centre, dimArcData.radius, startAngle, startAngle, false));
    dimArc = new RS_Arc (this, RS_ArcData(dimArcData.centre, dimArcData.radius, startAngle, endAngle, false));
    dimArc2 = new RS_Arc (this, RS_ArcData(dimArcData.centre, dimArcData.radius, endAngle,   endAngle, false));

    RS_Vector entityStartPoint = truncateVector(data.definitionPoint);

    const double entityRadius  = dimArcData.centre.distanceTo(entityStartPoint);

    RS_Vector entityEndPoint   = truncateVector(dimArcData.centre 
                               + RS_Vector(dimArcData.endAngle).scale(entityRadius));

        RS_Vector arrowEndPoint;

        RS_Vector dimStartPoint;
        RS_Vector dimEndPoint;

        RS_Line* extLine1 = nullptr;
        RS_Line* extLine2 = nullptr;
        RS_Arc*  dimArc1 = nullptr;
        RS_Arc*  dimArc = nullptr;
        RS_Arc*  dimArc2 = nullptr;

        void calcDimension();

        RS_Vector truncateVector(const RS_Vector input_vector);

        void arrow( const RS_Vector& point, 
                    const double angle, 

RS_Vector RS_Arc::getStartpoint() const{
    return startPoint;    
}

/** @return End point of the entity. */
RS_Vector RS_Arc::getEndpoint() const{
    return endPoint;
    return data.center + RS_Vector::polar(data.radius, data.angle2);
    return data.center + RS_Vector::polar(data.radius, data.angle2);         // ??????????????
}

RS_VectorSolutions RS_Arc::getRefPoints() const{
	//order: start, end, center
    //order: start, center, middle, end
    return {{getStartpoint(),  data.center, middlePoint, getEndpoint()}};
}

#include<cmath>
#include<iostream>

#include "rs_arc.h"
#include "rs_constructionline.h"
#include "rs_debug.h"
#include "rs_dimangular.h"
#include "rs_dimension.h"
#include "rs_information.h"
#include "rs_line.h"
#include "rs_math.h"
#include "rs_mtext.h"
#include "rs_solid.h"
#include "rs_units.h"

                             textAngle);

    RS_MText* text {new RS_MText( this, textData)};

    // move text to the side:
    text->setPen( RS_Pen( getTextColor(), RS2::WidthByBlock, RS2::SolidLine));
    text->setLayer( nullptr);

    auto* bg = createBackground(text);

    addEntity(bg);
    addEntity( text);

    calculateBorders();
}

void RS_DimAngular::update()
{

** Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
**
** This copyright notice MUST APPEAR in all copies of the script!
**
**********************************************************************/
#include<iostream>

#include "rs_block.h"
#include "rs_color.h"
#include "rs_debug.h"
#include "rs_dimension.h"
#include "rs_filterdxfrw.h" //for int <-> rs_color conversion
#include "rs_information.h"
#include "rs_line.h"
#include "rs_math.h"
#include "rs_modification.h"
#include "rs_mtext.h"
#include "rs_polyline.h"
#include "rs_solid.h"
#include "rs_units.h"
#include "rs_vector.h"
#include "rs_graphicview.h"

RS_DimensionData::RS_DimensionData():
    definitionPoint(false),
    middleOfText(false),
    valign(RS_MTextData::VABottom),
    halign(RS_MTextData::HALeft),
    lineSpacingStyle(RS_MTextData::Exact),

/**
 * Sets a new text for the label.
 */
void RS_Dimension::setLabel(const QString& l) {
        data.text = l;
}


RS_Hatch* RS_Dimension::createBackground(RS_MText* text) {

    text->update();
    double w = text->getUsedTextWidth()/2;
    double h = text->getUsedTextHeight()/2;

    auto* rect = new RS_Polyline();
    double b = -0.414213562373; // tan(90°/4)

    rect->addVertex(RS_Vector(-w, -2*h),   b);
    rect->addVertex(RS_Vector(-w-h, -h), 0.0);
    rect->addVertex(RS_Vector(-w-h, h),    b);
    rect->addVertex(RS_Vector(-w, 2*h),  0.0);
    rect->addVertex(RS_Vector(w, 2*h),     b);
    rect->addVertex(RS_Vector(w+h, h),   0.0);
    rect->addVertex(RS_Vector(w+h, -h),    b);
    rect->addVertex(RS_Vector(w, -2*h),  0.0);
    rect->setClosed(true, b);

    double ofsx = 0.0;
    double ofsy = 0.0;

    switch (text->getHAlign()) {
        case RS_MTextData::HALeft : ofsx = w; break;
        case RS_MTextData::HARight : ofsx = -w; break;
        default:;
    }

    switch (text->getVAlign()) {
        case RS_MTextData::VABottom : ofsy = h; break;
        case RS_MTextData::VATop : ofsy = -h; break;
        default:;
    }

    rect->move(RS_Vector(ofsx, ofsy, 0.0));
    rect->rotate(RS_Vector(0,0,0), text->getAngle());
    rect->move(text->getInsertionPoint());

    auto* bg = new RS_Hatch(this, RS_HatchData(true, 1.0, 0.0, nullptr));
    bg->addEntity(rect);
    bg->update();

    RS_Document* doc = getDocument();
    RS_Block* block = getBlock();
    RS_GraphicView* view = (doc) ? doc->getGraphicView() : (block) ? block->getGraphicView() : nullptr;
    RS_Color clr = (view) ? view->getBackground() : RS_Color(255, 255, 255, 254);

    bg->setPen(RS_Pen(clr, RS2::WidthByBlock, RS2::SolidLine));
    bg->setLayer(nullptr);

    return bg;
}


/**
 * Find intersections between a line and an EntityContainer.  Solutions are
 * sorted along the line before returning.
 *
 * @param infiniteLine Treat the line as infinitely long in both directions.
 */

                            getLabel(),
                            getTextStyle(),
                            textAngle);

    auto* text = new RS_MText(this, textData);
    text->setPen(RS_Pen(getTextColor(), RS2::WidthByBlock, RS2::SolidLine));
    text->setLayer(nullptr);

    RS_Hatch* bg = createBackground(text);

    // evaluate intersection between dim line and text
    double textIntersectionLength = 0.0;
    double w = text->getUsedTextWidth()/2+dimgap;
    double h = text->getUsedTextHeight()/2+dimgap;
    // textCorner variables correspond to the corners of the text bounding box
    // if the text were to be positioned in the center of the dimensionLine.

        dimensionLineOutside2 = new RS_Line{this, p2 + dir, p2};

        // move text to the side if it won't fit either
        RS_Vector distH;
        if (textIntersectionLength>distance && autoText) {
            distH.setPolar(textIntersectionLength/2.0+arrowSize*2+distance/2.0,
                           arrowAngle1);
            bg->move(distH);
            text->move(distH);
            textPos = text->getInsertionPoint();
            data.middleOfText = textPos;
        }
    }
    double dimtsz=getTickSize()*dimscale;
    bool displayArrows = dimtsz < 0.01;

    } else if (splitDimensionLine && dimensionLineInside1) {
        addEntity(dimensionLineInside1);
        addEntity(dimensionLineInside2);
    } else {
        addEntity(dimensionLine);
    }

    addEntity(bg);
    addEntity(text);
}

/**
 * Creates an aligned-text dimensioning line (line with one, two or no arrows
 * and aligned text).
 *
 * @param forceAutoText Automatically reposition the text label.
 */
void RS_Dimension::updateCreateAlignedTextDimensionLine(const RS_Vector& p1,
        const RS_Vector& p2, bool arrow1, bool arrow2, bool forceAutoText) {
    // general scale (DIMSCALE)
    double dimscale = getGeneralScale();
    // text height (DIMTXT)
    double dimtxt = getTextHeight()*dimscale;
    // text distance to line (DIMGAP)
    double dimgap = getDimensionLineGap()*dimscale;

    // length of dimension line:
    double distance = p1.distanceTo(p2);
    double direction = (cos(p1.angleTo(p2)) >= 0.0) ? 1.0 : -1.0;

    // arrow size:
    double arrowSize = getArrowSize()*dimscale;

    // do we have to put the arrows outside of the line?
    bool outsideArrows = (distance<arrowSize*2.5);

    // arrow angles:

        RS_Vector distV = RS_Vector::polar(dimgap + dimtxt/2.0, dimAngle1+a);

        // move text away from dimension line:
        textPos+=distV;

        //// the next update should still be able to adjust this
        ////   auto text position. leave it invalid
        data.middleOfText = textPos;
 //       data.middleOfText = textPos;
 //       std::cout<<"Middle of text 1: "<<data.middleOfText<<std::endl;
    }

    textData = RS_MTextData(textPos,
                            dimtxt, 30.0,
                            RS_MTextData::VAMiddle,
                            RS_MTextData::HACenter,
                            RS_MTextData::LeftToRight,
                            RS_MTextData::Exact,
                            1.0,
                            getLabel(),
                            getTextStyle(),
                            textAngle);

    auto text = new RS_MText(this, textData);
    text->setPen(RS_Pen(getTextColor(), RS2::WidthByBlock, RS2::SolidLine));
    text->setLayer(nullptr);

    RS_Hatch* bg = createBackground(text);

    // move text to the side:
    bool outsideText = (text->getUsedTextWidth() > distance);

    if (outsideText) {
    RS_Vector distH;
        RS_Vector distH;
    if (text->getUsedTextWidth()>distance) {
        distH.setPolar(text->getUsedTextWidth()/2.0
                       +distance/2.0+dimgap, textAngle);
        text->move(distH);
    }

        distH.setPolar(text->getUsedTextWidth()/2.0 + distance/2.0 + dimgap, textAngle);
        distH *= direction;

        if (!data.middleOfText.valid || forceAutoText) {
          text->move(distH);
          bg->move(distH);
        }
        outsideArrows = true;
    }

    data.middleOfText = text->getInsertionPoint();
    addEntity(bg);
    addEntity(text);

    // add arrows
    if (outsideArrows==false) {
    if (outsideArrows) {
        arrowAngle1 = dimensionLine->getAngle2();
        arrowAngle2 = dimensionLine->getAngle1();
    } else {
        arrowAngle1 = dimensionLine->getAngle1();
        arrowAngle2 = dimensionLine->getAngle2();

        // extend dimension line outside arrows
        RS_Vector dir1 = RS_Vector::polar(arrowSize*2, arrowAngle1);
        RS_Vector dir = RS_Vector::polar(arrowSize*2, arrowAngle2);
        dimensionLine->setStartpoint(p1 + dir);
        dimensionLine->setEndpoint(p2 - dir);
        RS_Vector dir2 = RS_Vector::polar(arrowSize*2, arrowAngle2);
        if (outsideText) {
          dir1 = RS_Vector::polar(std::min(arrowSize*2, text->getUsedTextWidth() + 2.0*dimgap), arrowAngle1);
          dir2 = RS_Vector::polar(text->getUsedTextWidth() + 2.0*dimgap, arrowAngle2);
        }
        dimensionLine->setStartpoint(p1 - dir1);
        dimensionLine->setEndpoint(p2 - dir2);
    } else {
        arrowAngle1 = dimensionLine->getAngle2();
        arrowAngle2 = dimensionLine->getAngle1();
    }
    double dimtsz=getTickSize()*dimscale;
    if(dimtsz < 0.01) {
        //display arrow
        // Arrows:
        RS_SolidData sd;
        RS_Solid* arrow;

**********************************************************************/


#ifndef RS_DIMENSION_H
#define RS_DIMENSION_H

#include "rs_entitycontainer.h"
#include "rs_hatch.h"
#include "rs_mtext.h"

/**
 * Holds the data that is common to all dimension entities.
 */
struct RS_DimensionData : public RS_Flags {
    /**

        bool arrow1=true, bool arrow2=true, bool autoText=false);
    void updateCreateAlignedTextDimensionLine(
        const RS_Vector& p1, const RS_Vector& p2,
        bool arrow1=true, bool arrow2=true, bool autoText=false);
protected:
    /** Data common to all dimension entities. */
    RS_DimensionData data;
    RS_Hatch* createBackground(RS_MText* text);
};

#endif

#include <iostream>
#include <utility>
#include <QPolygon>
#include <QString>

#include "lc_layertreeitem.h"
#include "lc_layertreemodel.h"
#include "lc_layertreemodel_options.h"
#include "rs_arc.h"
#include "rs_block.h"
#include "rs_circle.h"
#include "rs_ellipse.h"
#include "rs_entity.h"
#include "rs_graphic.h"
#include "rs_graphicview.h"
#include "rs_information.h"
#include "rs_insert.h"
#include "rs_layer.h"
#include "rs_layerlist.h"
#include "rs_line.h"
#include "rs_mtext.h"
#include "rs_point.h"
#include "rs_polyline.h"
#include "rs_text.h"
#include "rs_units.h"
#include "rs_vector.h"

}


/**
 * @return true if this entity or any parent entities are undone.
 */
bool RS_Entity::isUndone() const {
		if (!parent) {
                return RS_Undoable::isUndone();
    if (!parent) {
        return RS_Undoable::isUndone();
        }
        else {
                return RS_Undoable::isUndone() || parent->isUndone();
        }
    } else {
        return RS_Undoable::isUndone() || parent->isUndone();
    }
}


/**
 * @return True if the entity is in the given range.
 */
bool RS_Entity::isInWindow(RS_Vector v1, RS_Vector v2) const

}

/**
 * Sets the layer of this entity to the current layer of
 * the graphic this entity is in. If this entity (and none
 * of its parents) are in a graphic the layer is set to nullptr.
 */
void RS_Entity::setLayerToActive() {
void RS_Entity::setLayerToActive(bool dim) {
    RS_Graphic* graphic = getGraphic();
    RS_Layer* active = nullptr;

    if (graphic) {
        layer = graphic->getActiveLayer();
    } else {
        layer = nullptr;
    }
}
      active = graphic->getActiveLayer();

      if (dim) {
        RS_LayerList* list = graphic->getLayerList();
        auto* op = new LC_LayerTreeModelOptions();
        auto* lt = new LC_LayerTreeModel(nullptr, op);
        lt->setLayerList(list);

        LC_LayerTreeItem* item = (active) ? lt->getItemForLayer(active) : lt->getRoot();

        if (item && item->getLayerType() != LC_LayerTreeItem::DIMENSIONAL) item = item->firstChildOfType(LC_LayerTreeItem::DIMENSIONAL);
        if (!item) {
          item = lt->getRoot();
          item = item->firstChildOfType(LC_LayerTreeItem::DIMENSIONAL);
        }

        if (item) active = item->getLayer();
      }
    }

    layer = active;
}


RS_Pen RS_Entity::getPenResolved() const {
    RS_Pen p = pen;
    // use parental attributes (e.g. vertex of a polyline, block
    // entities when they are drawn in block documents):
    if (parent != nullptr && parent->rtti() != RS2::EntityGraphic) {
        //if pen is invalid gets all from parent

    virtual RS_Graphic* getGraphic() const;
    RS_Block *getBlock() const;
    RS_Insert *getInsert() const;
    RS_Entity *getBlockOrInsert() const;
    RS_Document *getDocument() const;
    void setLayer(const QString &name);
    void setLayer(RS_Layer *l);
    void setLayerToActive();
    void setLayerToActive(bool dim=false);
    RS_Layer *getLayer(bool resolve = true) const;
    RS_Layer *getLayerResolved() const;

    /**
     * Sets the explicit pen for this entity or a pen with special
     * attributes such as BY_LAYER, ..
     */

**
** This copyright notice MUST APPEAR in all copies of the script!
**
**********************************************************************/
#include <cmath>
#include <iostream>
#include <memory>
#include <qnamespace.h>
#include <set>

#include <QPainterPath>
#include <QBrush>
#include <QString>

#include "lc_looputils.h"

                    auto* loop = (RS_EntityContainer*)l;
                    loop->optimizeContours();
                }
            }
        needOptimization = false;
    }
    QPainterPath path;
    QList<QPolygon> paClosed;
    QPolygon pa;


    const QBrush brush(painter->brush());
    const RS_Pen pen=painter->getPen();
    const QBrush oldbrush(painter->brush());
    const RS_Pen oldpen=painter->getPen();
    painter->setBrush(pen.getColor());
//    painter->disablePen();

    createSolidFillPath(painter, view, path);
    /*  if(pa.size()>2){
            pa<<pa.first();
            paClosed<<pa;
        }


        for(auto& p:paClosed){
            path.addPolygon(p);
        }*/

    //bug#474, restore brush after solid fill
/*    const QBrush brush(painter->brush());
    const RS_Pen pen=painter->getPen();
    painter->setBrush(pen.getColor());
    painter->disablePen();*/
    painter->drawPath(path);
    QBrush fillBrush = brush;
    QBrush fillBrush = oldbrush;
    fillBrush.setColor(pen.getColor());
    fillBrush.setStyle(Qt::SolidPattern);
//    path.closeSubpath();
//    painter->fillPath(path, fillBrush);

//    debugOutPath(path);

    if (isSelected() || isHighlighted()) {
      fillBrush.setColor(oldpen.getColor());
      fillBrush.setStyle(Qt::Dense6Pattern);
      painter->fillPath(path, fillBrush);
    } else {
      painter->fillPath(path, fillBrush);
    }

//    painter->drawPath(path);
    painter->setBrush(brush);
    painter->setPen(pen);
    painter->setBrush(oldbrush);
    painter->setPen(oldpen);
}

void RS_Hatch::createSolidFillPath(RS_Painter *painter, const RS_GraphicView *view, QPainterPath &path) {
    painter->createSolidFillPath(path, view, entities);
}

void RS_Hatch::debugOutPath(const QPainterPath &tmpPath) const {

 * text or it's data, position, alignment, .. changes.
 * This method also updates the usedTextWidth / usedTextHeight property.
 */
void RS_MText::update() {
  RS_DEBUG->print("RS_MText::update");

  clear();

  if (isUndone()) {
    return;
  }

  usedTextWidth = 0.0;
  usedTextHeight = 0.0;

          ++i;
        }

        // add texts:
        double upperWidth{0.0};
        if (!upperText.isEmpty()) {
          RS_MText *upper =
              createUpperLower(upperText, data, letterPos + RS_Vector{0., 9.});
              createUpperLower(upperText, data, letterPos + RS_Vector{0.0, 12.0});
          oneLine->addEntity(upper);
          upper->reparent(oneLine);
          upperWidth = upper->getSize().x;
        }

        double lowerWidth{0.0};
        if (!lowerText.isEmpty()) {

    // next letter position:
    letterPosition += letterSpace;
}

RS_MText *RS_MText::createUpperLower(QString text, const RS_MTextData &data,
                                     const RS_Vector &position) {
    auto *line = new RS_MText(
        nullptr, {position, 4.0, 100.0, RS_MTextData::VATop, RS_MTextData::HALeft,
        nullptr, {position, 6.0, 100.0, RS_MTextData::VATop, RS_MTextData::HALeft,
                  data.drawingDirection, RS_MTextData::Exact, 1.0,
                  std::move(text), data.style, 0.0, RS2::Update});
    line->setLayer(nullptr);
    line->setPen({RS2::FlagInvalid});
    line->calculateBorders();
    line->update();
    return line;
}

/**
 * Used internally by update() to add a text line created with
 * default values and alignment to this text container.
 *

            textLine->move(RS_Vector{- textLine->getMax().x, 0.});
            break;

        default:
            textLine->move(RS_Vector{- textLine->getMin().x, 0.});
            break;
    }

    textLine->setPen(RS_Pen(RS2::FlagInvalid));
    textLine->setLayer(nullptr);
    textLine->forcedCalculateBorders();

    // Update actual text size (before rotating, after scaling!):
    if (textLine->getSize().x > usedTextWidth) {
        usedTextWidth = textLine->getSize().x;
    }

    usedTextHeight += data.height * data.lineSpacingFactor * ls;

    // Gets the distance over text base-line (before rotating, after scaling!):
    double textTail = textLine->getMin().y;

    // Move:
    textLine->move(data.insertionPoint + RS_Vector{0., -data.height * lineCounter * data.lineSpacingFactor * ls});
    // Rotate:
    // textLine->rotate(data.insertionPoint, data.angle);

    textLine->setPen(RS_Pen(RS2::FlagInvalid));
    textLine->setLayer(nullptr);
    textLine->forcedCalculateBorders();

    addEntity(textLine);
    return textTail;
}

RS_Vector RS_MText::getNearestEndpoint(const RS_Vector &coord,
                                       double *dist) const {
    if (dist) {

void RS_MText::draw(RS_Painter *painter, RS_GraphicView *view,
                    double & patternOffset) {
    /*if (!(painter && view))
        return;*/
#ifdef DEBUG_LINE_POINTS
    painter->drawRect(view->toGui(getMin()), view->toGui(getMax()));
#endif

    if (!view->isPrintPreview() && !view->isPrinting()) {
        if ((view->getSimplifyPanning() && view->isPanning()) ||
        if (view->isPanning() || view->toGuiDY(getHeight()) < view->getMinRenderableTextHeightInPx()) {
           (view->getSimplifySmall() && (view->toGuiDY(getHeight()) < view->getMinRenderableTextHeightInPx()))) {
            drawDraft(painter, view, patternOffset);
            return;
        }
    }

    for (RS_Entity *entity: std::as_const(entities)) {
        entity->drawAsChild(painter, view, patternOffset);

    painter->drawLine(view->toGui(baselineStartPoint), view->toGui(baselineEndPoint));
}

void RS_Text::draw(RS_Painter* painter, RS_GraphicView* view, double& patternOffset){
//    if (!(painter && view)) {
//        return;
//    }

    if (!view->isPrintPreview() && !view->isPrinting()){
        if (
           (view->getSimplifyPanning() && view->isPanning()) ||
        if (view->isPanning() || view->toGuiDY(getHeight()) < view->getMinRenderableTextHeightInPx()){
           (view->getSimplifySmall() && (view->toGuiDY(getHeight()) < view->getMinRenderableTextHeightInPx()))
           )
        {
            drawDraft(painter, view, patternOffset);
            return;
        }
    }

    foreach (auto e, entities){
       view->drawAsChild(painter, e, patternOffset);

     */
    RS_Pen(const RS_Color& c,
           RS2::LineWidth w,
           RS2::LineType t) : RS_Flags() {
        setColor(c);
        setWidth(w);
        setLineType(t);
		      setScreenWidth(0);
        setScreenWidth(1.0);
        setAlpha(1.0);
    }
    /**
     * Creates a default pen with the given flags. This is 
     * usually used to create invalid pens.
     *
     * e.g.:
     * <pre>
     *   RS_Pen p(RS2::FlagInvalid);
     * </pre>
     */
    RS_Pen(unsigned int f) : RS_Flags(f) {
        setColor(RS_Color(0,0,0));
        setWidth(RS2::Width00);
        setLineType(RS2::SolidLine);
		      setScreenWidth(0);
        setScreenWidth(1.0);
        setAlpha(1.0);
    }
    //RS_Pen(const RS_Pen& pen) : RS_Flags(pen.getFlags()) {
    //    lineType = pen.lineType;
    //    width = pen.width;
    //    color = pen.color;
    //}

    float getAlpha() const {
        return alpha;
    }
    void setAlpha(float a) {
        alpha = a;
    }

    void setScale(double s) {
        Scale = s;
    }

    double getScale() const {
        return Scale;
    }

    //RS_Pen& operator = (const RS_Pen& p) {
    //    lineType = p.lineType;
    //    width = p.width;
    //    color = p.color;
    //    setFlags(p.getFlags());

    friend std::ostream& operator << (std::ostream& os, const RS_Pen& p);


protected:
    RS2::LineType lineType = RS2::SolidLine;
    RS2::LineWidth width = RS2::Width00;
    double screenWidth = 0.;
    double Scale = 1.0;

    double screenWidth = 1.0;               // This field MUST contain the exact width of the pen in pixels, in order to provide correct scaling of the line patterns.
                                            // The widths < 1.0 will be converted to plain 0 in RS_Painter, before actual draw.
                                            // Because of some reason, we still have values of 0.0 or ever wrong huge values in this field and this looks like a bug somewhere.
    RS_Color color{};
    float alpha = 1.;
    double m_dashOffset = 0.;
};

#endif

            for(QString& file: files)
            {
                fileList += path + "/" + file;
            }
        }
    }

    LC_LOG<<__func__<<"():: fileList:";
    foreach(const auto& file, fileList)
        LC_LOG<<file;

    return fileList;
}


/**
 * @return List of all directories in subdirectory 'subDirectory' in
 * all possible LibreCAD directories.

    QStringList ret;

    RS_DEBUG->print("RS_System::getDirectoryList: Paths:");
    for (QStringList::Iterator it = dirList.begin(); it != dirList.end(); ++it ) {
        if (QFileInfo( *it).isDir()) {
            ret += (*it);
            RS_DEBUG->print(*it);
        }
    }

    for (auto& dir: ret) {
        RS_DEBUG->print("%s\n", QString("%1(): line %2: dir=%3").arg(__func__).arg(__LINE__).arg(dir).toUtf8().constData());
    }

    return ret;
}

/**
 * Converts a language string to a symbol (e.g. Deutsch or German to 'de').
 * Languages taken from RFC3066
 */

    QString ret;
#if QT_VERSION >= QT_VERSION_CHECK(6, 2, 0)
    QString territory = RS_Locale::territoryToString(loc.territory());
#else
    QString territory = RS_Locale::countryToString(loc.country());
#endif

if (symb.contains( QRegularExpression( "^en"))) {
    if (symb.contains( QRegularExpression( "^en"))) {
        ret = RS_Locale::languageToString( loc.language());
        if( symb.contains('_') ) {
            ret += " (" + territory + ')';
        }
    }
    else {
        ret = RS_Locale::languageToString( loc.language()) + ' ' + loc.nativeLanguageName();

 */
RS_Vector::RS_Vector(double vx, double vy, double vz):
    x(vx)
    ,y(vy)
    ,z(vz)
    ,valid(true)
{
    FixZeroes();
}

/**
 * Constructor for a unit vector with given angle
 */
RS_Vector::RS_Vector(double angle):
    x(std::cos(angle))
    ,y(std::sin(angle))
    ,valid(true)
{
    FixZeroes();
}

RS_Vector::RS_Vector(const QPointF &point):
    RS_Vector{point.x(), point.y()}
{}

/**

 * Sets to a unit vector by the direction angle
 */
void RS_Vector::set(double angle) {
    x = std::cos(angle);
    y = std::sin(angle);
    z = 0.;
    valid = true;
    FixZeroes();
}

/**
 * Sets a new position for the vector.
 */
void RS_Vector::set(double vx, double vy, double vz) {
    x = vx;
    y = vy;
    z = vz;
    valid = true;
    FixZeroes();
}

void RS_Vector::plus(const RS_Vector &other) {
   x+= other.x;
   y+= other.y;
   z+= other.z;
   FixZeroes();
}

void RS_Vector::minus(const RS_Vector &other) {
    x-= other.x;
    y-= other.y;
    z-= other.z;
    FixZeroes();
}

/**
 * Sets a new position for the vector in polar coordinates.
 */
void RS_Vector::setPolar(double radius, double angle) {
    x = radius * std::cos(angle);
    y = radius * std::sin(angle);
    z = 0.0;
    valid = true;
    FixZeroes();
}

RS_Vector RS_Vector::polar(double rho, double theta){
    return {rho * std::cos(theta), rho * std::sin(theta), 0.};
}
/**
 * Returns vector that defines point located in specified distance and angle from current

 * 0/0 by the angle of the vector
 */
RS_Vector& RS_Vector::rotate(const RS_Vector& angleVector) {
    double x0 = x * angleVector.x - y * angleVector.y;
    y = x * angleVector.y + y * angleVector.x;
    x = x0;

    FixZeroes();
    return *this;
}

/**
 * Rotates this vector around the given center by the given angle.
 */
RS_Vector& RS_Vector::rotate(const RS_Vector& center, double ang) {

/**
 * Scales this vector by the given factors with 0/0 as center.
 */
RS_Vector& RS_Vector::scale(double factor) {
    x *= factor;
    y *= factor;
    FixZeroes();
    return *this;
}

/**
 * Scales this vector by the given factors with 0/0 as center.
 */
RS_Vector& RS_Vector::scale(const RS_Vector& factor) {
    x *= factor.x;
    y *= factor.y;
    FixZeroes();
    return *this;
}

RS_Vector RS_Vector::scale(const RS_Vector& factor) const{
    return {x*factor.x, y*factor.y};
}

    return *this;
}

RS_Vector& RS_Vector::shear(double k)
{
    x += k * y;
    FixZeroes();
    return *this;
}

/**
 * Streams the vector components to stdout. e.g.: "1/4/0"
 */
std::ostream& operator << (std::ostream& os, const RS_Vector& v) {

/**
 * += operator. Assert: both vectors must be valid.
 */
RS_Vector RS_Vector::operator += (const RS_Vector& v) {
    x += v.x;
    y += v.y;
    z += v.z;
    FixZeroes();
    return *this;
}

/**
 * -= operator
 */
RS_Vector RS_Vector::operator -= (const RS_Vector& v) {
    x -= v.x;
    y -= v.y;
    z -= v.z;
    FixZeroes();
    return *this;
}

RS_Vector RS_Vector::operator *= (const RS_Vector& v) {
    x *= v.x;
    y *= v.y;
    z *= v.z;
    FixZeroes();
    return *this;
}

RS_Vector RS_Vector::operator /= (const RS_Vector& v) {
    if (fabs(v.x)> RS_TOLERANCE && fabs(v.y)>RS_TOLERANCE){
        x /= v.x;
        y /= v.y;
        if (std::isnormal(v.z))
            z /= v.z;
    }
    FixZeroes();
    return *this;
}

/**
 * *= operator
 */
RS_Vector RS_Vector::operator *= (double s) {
    x *= s;
    y *= s;
    z *= s;
    FixZeroes();
    return *this;
}
/**
 * /= operator
 */
RS_Vector RS_Vector::operator /= (double s) {
    if(std::abs(s)>RS_TOLERANCE) {
        x /= s;
        y /= s;
        z /= s;
    }
    FixZeroes();
    return *this;
}

/**
 * == operator
 */
bool RS_Vector::operator == (const RS_Vector& v) const {

}

bool RS_Vector::operator != (bool valid) const
{
    return this->valid != valid;
}


void RS_Vector::FixZeroes() {
  if (fabs(x)<RS_TOLERANCE) x = 0.0;
  if (fabs(y)<RS_TOLERANCE) y = 0.0;
  if (fabs(z)<RS_TOLERANCE) z = 0.0;
}

/**
 * @return A vector with the minimum components from the vectors v1 and v2.
 * These might be mixed components from both vectors.
 */
RS_Vector RS_Vector::minimum (const RS_Vector& v1, const RS_Vector& v2) {
    if (!v2) return v1;
    if (!v1) return v2;

**
**********************************************************************/


#ifndef RS_VECTOR_H
#define RS_VECTOR_H

#include "rs.h"
#include <vector>
#include <iosfwd>

class QPointF;

/**
 * Represents a 3d vector (x/y/z)
 *
 * @author Andrew Mustun
 */
class RS_Vector {

public:
    RS_Vector()=default;
    RS_Vector(double vx, double vy, double vz=0.0);
    explicit RS_Vector(double angle);
    //RS_Vector(double v[]);
    explicit RS_Vector(bool valid);
    explicit RS_Vector(const QPointF& point);

#endif

public:
    double x=0.;
    double y=0.;
    double z=0.;
    bool valid=false;

private:
    void FixZeroes();

};


/**
 * Represents one to 4 vectors. Typically used to return multiple
 * solutions from a function.
 */

#include "rs_math.h"
#include "rs_painter.h"
#include "rs_snapper.h"
#include "rs_settings.h"
#include "rs_units.h"
#include "lc_linemath.h"
#include "dxf_format.h"
#include "lc_defaults.h"

#ifdef EMU_C99
#include "emu_c99.h"
#endif

#ifdef DEBUG_RENDERING
#define DEBUG_RENDERING_DETAILS

    :QWidget(parent, f), eventHandler{new RS_EventHandler{this}},
    m_colorData{std::make_unique<ColorData>()},
    grid{std::make_unique<RS_Grid>(this)},
    defaultSnapMode{std::make_unique<RS_SnapMode>()},
    drawingMode(RS2::ModeFull),
    savedViews(16),
    previousViewTime{std::make_unique<QDateTime>(QDateTime::currentDateTime())} {
//    loadSettings();
}

void RS_GraphicView::loadSettings() {

    LC_GROUP("Appearance");
    {
        this->m_colorData->hideRelativeZero = LC_GET_BOOL("hideRelativeZero");
        extendAxisLines = LC_GET_BOOL("ExtendAxisLines", false);
        entityHandleHalfSize = LC_GET_INT("EntityHandleSize", 4) / 2;
        relativeZeroRadius = LC_GET_INT("RelZeroMarkerRadius", 5);
        zeroShortAxisMarkSize = LC_GET_INT("ZeroShortAxisMarkSize", 20);
        extendAxisModeX = LC_GET_INT("ExtendModeXAxis",0);
        extendAxisModeY = LC_GET_INT("ExtendModeYAxis",0);
        ignoreDraftForHighlight = LC_GET_BOOL("IgnoreDraftForHighlight", false);
        draftLinesMode = LC_GET_BOOL("DraftLinesMode", false);

        m_panOnZoom = LC_GET_BOOL("PanOnZoom", false);
        m_skipFirstZoom = LC_GET_BOOL("FirstTimeNoZoom", false);
        m_modifyOnZoom = LC_GET_BOOL("ModifyOnViewChange", true);
    } // Appearance group
    LC_GROUP_END();

    RS_Graphic* graphic = getGraphic();
    if (graphic != nullptr) {
        unitFactor = RS_Units::convert(1.0, RS2::Millimeter, graphic->getUnit());
        unitFactor100 =  unitFactor / 100.0;
        defaultWidthFactor = graphic->getVariableDouble("$DIMSCALE", 1.0);

        pdmode = graphic->getGraphicVariableInt("$PDMODE", LC_DEFAULTS_PDMode);
        pdsize = graphic->getGraphicVariableDouble("$PDSIZE", LC_DEFAULTS_PDSize);

        //        Lineweight endcaps setting for new objects:
        //        0 = none; 1 = round; 2 = angle; 3 = square
        int endCaps = graphic->getGraphicVariableInt("$ENDCAPS", 1);
        switch (endCaps){
            case 0:
                penCapStyle = Qt::FlatCap;
                break;
            case 1:
                penCapStyle = Qt::RoundCap;
                break;
            case 2:
                penCapStyle = Qt::MPenCapStyle;
                break;
            case 3:
                penCapStyle = Qt::SquareCap;
                break;
            default:
                penCapStyle = Qt::FlatCap; // fixme - or round?
        }
        //0=none; 1= round; 2 = angle; 3 = flat
        int joinStyle = graphic->getGraphicVariableInt("$JOINSTYLE", 1);

        switch (joinStyle){
            case 0:
                penJoinStyle = Qt::BevelJoin;
                break;
            case 1:
                penJoinStyle = Qt::RoundJoin;
                break;
            case 2:
                penJoinStyle = Qt::MiterJoin;
                break;
            case 3:
                penJoinStyle = Qt::BevelJoin;
                break;
            default:
                penJoinStyle = Qt::RoundJoin;
        }
    }

    LC_GROUP("Render");
    {
        simplifySmall = LC_GET_BOOL("SimplifySmall", true);
        simplifyPanning = LC_GET_BOOL("SimplifyPanning", true);

        minRenderableTextHeightInPx = LC_GET_INT("MinRenderableTextHeightPx", 4);
        int minArcRadius100 = LC_GET_INT("MinArcRadius", 80);
        minArcDrawingRadius = minArcRadius100 / 100.0;

        int minCircleRadius100 = LC_GET_INT("MinCircleRadius", 200);
        minCircleDrawingRadius = minCircleRadius100 / 100.0;

}

/**
 * zooms in by factor f in x
 */
void RS_GraphicView::zoomInX(double f) {
    factor.x *= f;
    offsetX = (int) ((offsetX - getWidth() / 2) * f) + getWidth() / 2;
    offsetX = offsetX + RS_Math::round((getWidth() / 2.0) * (1 - f));
    adjustOffsetControls();
    adjustZoomControls();
    invalidate();
    redraw();
}

/**
 * zooms in by factor f in y
 */
void RS_GraphicView::zoomInY(double f) {
    factor.y *= f;
    offsetY = (int) ((offsetY - getHeight() / 2) * f) + getHeight() / 2;
    offsetY = offsetY + RS_Math::round((getHeight() / 2.0) * (1-f));
    adjustOffsetControls();
    adjustZoomControls();
    invalidate();
    redraw();
}

/**

            auto const dV = container->getMax() - container->getMin();
            sx = std::max(dV.x, 0.);
            sy = std::max(dV.y, 0.);
        } else {
            sx = container->getSize().x;
            sy = container->getSize().y;
        }
//		    std::cout<<" RS_GraphicView::zoomAuto("<<sx<<","<<sy<<")"<<std::endl;
//			std::cout<<" RS_GraphicView::zoomAuto("<<axis<<","<<keepAspectRatio<<")"<<std::endl;
//                  std::cout<<" RS_GraphicView::zoomAuto("<<sx<<","<<sy<<")"<<std::endl;
//                      std::cout<<" RS_GraphicView::zoomAuto("<<axis<<","<<keepAspectRatio<<")"<<std::endl;

        double fx = 1., fy = 1.;
        unsigned short fFlags = 0;

        if (sx > RS_TOLERANCE) {
            fx = (getWidth() - borderLeft - borderRight) / sx;
        } else {

}

/**
 * Saves the current view as previous view to which we can
 * switch back later with @see restoreView().
 */
void RS_GraphicView::saveView() {
    if (getGraphic()) getGraphic()->setModified(true);
    if (m_modifyOnZoom && getGraphic()) getGraphic()->setModified(true);
    QDateTime noUpdateWindow = QDateTime::currentDateTime().addMSecs(-500);
//do not update view within 500 milliseconds
    if (*previousViewTime > noUpdateWindow) return;
    *previousViewTime = QDateTime::currentDateTime();
    savedViews[savedViewIndex] = std::make_tuple(offsetX, offsetY, factor);
    savedViewIndex = (savedViewIndex + 1) % savedViews.size();
    if (savedViewCount < savedViews.size()) savedViewCount++;

    adjustOffsetControls();
    adjustZoomControls();
    invalidate();
    redraw();
}


/*	*
 *	Function name:
 *	Description:		Performs autozoom in Y axis only.
 *	Author(s):			..., Claude Sylvain
 *	Created:				?
 *	Last modified:		23 July 2011
/*      *
 *      Function name:
 *      Description:            Performs autozoom in Y axis only.
 *      Author(s):                      ..., Claude Sylvain
 *      Created:                                ?
 *      Last modified:          23 July 2011
 *
 *	Parameters:			bool axis:
 *								Axis in zoom.
 *      Parameters:                     bool axis:
 *                                                              Axis in zoom.
 *
 *	Returns:				void
 *	*/
 *      Returns:                                void
 *      */

void RS_GraphicView::zoomAutoY(bool axis) {
    if (container) {
        double visibleHeight = 0.0;
        double minY = RS_MAXDOUBLE;
        double maxY = RS_MINDOUBLE;
        bool noChange = false;

            painter->setPen(penSaved);
    }
#ifdef DEBUG_RENDERING_DETAILS
    layer1Time += drawLayer1Timer.elapsed();
#endif
}

/*	*
 *	Function name:
 *	Description: 		Do the drawing, step 2/3.
 *	Author(s):			..., Claude Sylvain
 *	Created:				?
 *	Last modified:		23 July 2011
/*      *
 *      Function name:
 *      Description:            Do the drawing, step 2/3.
 *      Author(s):                      ..., Claude Sylvain
 *      Created:                                ?
 *      Last modified:          23 July 2011
 *
 *	Parameters:			RS_Painter *painter:
 *								...
 *      Parameters:                     RS_Painter *painter:
 *                                                              ...
 *
 *	Returns:				void
 *	*/
 *      Returns:                                void
 *      */

void RS_GraphicView::drawLayer2(RS_Painter *painter) {
#ifdef DEBUG_RENDERING_DETAILS
    drawLayer2Timer.start();
#endif
    screenPDSize = determinePointScreenSize(painter, pdsize);
    double patternOffset = 0.;

                pen.setColor(m_colorData->previewReferenceHighlightedEntitiesColor);
            } else {
                pen.setColor(m_colorData->previewReferenceEntitiesColor);
            }
            pen.setLineType(RS2::SolidLine);
            pen.setWidth(RS2::LineWidth::Width00);
            e->setPen(pen);

//            pen.setScreenWidth(0.0);
            pen.setScreenWidth(1.0);
            painter->setPen(pen);
            break;
        }
        default: {
            if (draftMode){
                if (ignoreDraftForHighlight) {
                    setPenForEntity(painter, e, patternOffset, true);

                }
            }
        }
    }
}


/*	*
 *	Function name:
/*      *
 *      Function name:
 *
 *	Description:	- Sets the pen of the painter object to the suitable pen
 *						  for the given entity.
 *      Description:    - Sets the pen of the painter object to the suitable pen
 *                                                for the given entity.
 *
 *	Author(s):		..., Claude Sylvain
 *	Created:			?
 *	Last modified:	17 November 2011
 *      Author(s):              ..., Claude Sylvain
 *      Created:                        ?
 *      Last modified:  17 November 2011
 *
 *	Parameters:		RS_Painter *painter:
 *							...
 *      Parameters:             RS_Painter *painter:
 *                                                      ...
 *
 *						RS_Entity *e:
 *							...
 *                                              RS_Entity *e:
 *                                                      ...
 *
 *	Returns:			void
 *      Returns:                        void
 */
void RS_GraphicView::setPenForPrintingEntity(RS_Painter *painter, RS_Entity *e, double &patternOffset) {
#ifdef DEBUG_RENDERING
    setPenTimer.start();
#endif
// Getting pen from entity (or layer)

//   This is the standard (AutoCAD like) behaviour.
// bug# 3437941
// ------------------------------------------------------------

    if (pen.getAlpha() == 1.0) {
        if (width >0) {
            double wf = 1.0; // Width factor.

            if (paperScale > RS_TOLERANCE) {
            if (paperScale > RS_TOLERANCE && !scaleLineWidth) wf = 1.0 / paperScale;
                if (scaleLineWidth) {
                    wf = defaultWidthFactor;
                } else {
                    wf = 1.0 / paperScale;
                }

            }
            double screenWidth = toGuiDX(width * unitFactor100 * wf);

            /*// prevent drawing with 1-width which is slow:
            if (RS_Math::round(pen.getScreenWidth()) == 1) {
                pen.setScreenWidth(0.0);
            pen.setScreenWidth(screenWidth);
            }*/
            if (screenWidth < 1){ // fixme - not sure about this check. However, without it, lines will stay transparent and then disappear on zooming out. Probably some other threshold value (instead 1) should be used?
                screenWidth = 0.0;
            }
            pen.setScreenWidth(screenWidth);

            pen.setScale(1.0/wf);
        }
        else{
            pen.setScreenWidth(0.0);
            pen.setScreenWidth(1.0);
            pen.setScale(1.0);
        }
    }
    else{
        // fixme - if we'll support transparency, add necessary processing there
        if (RS_Math::round(pen.getScreenWidth()) == 1) {
            pen.setScreenWidth(0.0);
            pen.setScreenWidth(1.0);
        }
    }

    RS_Color backgroundColor;
    if (printPreview /*|| inPrintingMode*/){ //  todo - should we change color for printer mode too?
        backgroundColor = printPreviewPrintAreaColor; // same color as used for drawing print area in drawPaper
        // fixme - sand - nicer handling colors is needed. That should work fine if entity is over paper entity.

        }
    }
    else{
        lastPaintedHighlighted = highlighted;
        lastPaintedSelected = selected;
        lastPaintOverlay = overlayPaint;
    }
    pen.setScreenWidth(0.0);
    pen.setScreenWidth(1.0);

    if (overlayPaint) {
        if (highlighted) {    // Glowing effects on mouse hovering: use the "selected" color
            // for glowing effects on mouse hovering, draw solid lines
            pen.setColor(m_colorData->selectedColor);
            pen.setLineType(RS2::SolidLine);
        }
        else{
            if (pen.getColor().isEqualIgnoringFlags(m_colorData->background) || (pen.getColor().toIntColor() == RS_Color::Black
                                                                                 && pen.getColor().colorDistance(m_colorData->background) < RS_Color::MinColorDistance)) {
                pen.setColor(this->m_colorData->foreground);
            }
        }
    } else {
        // this entity is selected:
        if (selected) {
            pen.setLineType(RS2::DashLineTiny);
            pen.setWidth(RS2::Width00);
            pen.setColor(m_colorData->selectedColor);
            pen.setAlpha(0.7);
        }
        else if (highlighted) {
            pen.setColor(m_colorData->highlightedColor);
        }
        else if (deleteMode || e->getFlag(RS2::FlagTransparent)) {
            pen.setColor(m_colorData->background);
        }

        lastPaintOverlay = overlayPaint;
    }


#ifdef DEBUG_RENDERING
    setPenTimer.start();
#endif
    // Avoid negative widths

//    int w = std::max(static_cast<int>(pen.getWidth()), 0);
    double width = pen.getWidth();
    if (pen.getAlpha() == 1.0) {
        if (width>0) {
            double screenWidth = toGuiDX(width * unitFactor100);
    if (width>0) {
        double screenWidth = toGuiDX(width * unitFactor100);
            // prevent drawing with 1-width which is slow:
           /* if (RS_Math::round(screenWidth) == 1) {
                screenWidth = 0.0;
            }
            else*/ if (screenWidth < 1){ // fixme - not sure about this check. However, without it, lines will stay transparent and then disappear on zooming out. Probably some other threshold value (instead 1) should be used?
                screenWidth = 0.0;
            }
            pen.setScreenWidth(screenWidth);
        pen.setScreenWidth(screenWidth);
        }
        else{
            pen.setScreenWidth(0.0);
    } else {
        pen.setScreenWidth(1.0);
        }
    }
    else{
            // fixme - if we'll support transparency, add necessary processing there
        if (RS_Math::round(pen.getScreenWidth()) == 1) {
            pen.setScreenWidth(0.0);
        }
    }


    if (overlayPaint) {
        if (highlighted) {    // Glowing effects on mouse hovering: use the "selected" color
            // for glowing effects on mouse hovering, draw solid lines
            pen.setColor(m_colorData->selectedColor);
            pen.setLineType(RS2::SolidLine);
        }
        else{
            if (pen.getColor().isEqualIgnoringFlags(m_colorData->background) || (pen.getColor().toIntColor() == RS_Color::Black
                                                                                 && pen.getColor().colorDistance(m_colorData->background) < RS_Color::MinColorDistance)) {
                pen.setColor(this->m_colorData->foreground);
            }
        }
    } else {
        // this entity is selected:
        if (selected) {
            pen.setLineType(RS2::DashLineTiny);
            pen.setWidth(RS2::Width00); // fixme - move to settings?
            pen.setColor(m_colorData->selectedColor);
            pen.setAlpha(0.7);
        }
        // this entity is highlighted:
        else if (highlighted) {
            pen.setColor(m_colorData->highlightedColor);
        }
        else  if (deleteMode || e->getFlag(RS2::FlagTransparent)) {
            pen.setColor(m_colorData->background);

    // update is disabled:
    // given entity is nullptr:
    if (!e) {
        return;
    }

    // check for selected entity drawing
    if (/*!e->isContainer() && */(e->getFlag(RS2::FlagSelected) != painter->shouldDrawSelected())) {
    if ((e->getFlag(RS2::FlagSelected) != painter->shouldDrawSelected())) {
        return;
    }
#ifdef DEBUG_RENDERING
    isVisibleTimer.start();
#endif
    // entity is not visible:
    bool visible = e->isVisible();

 *
 * @see drawIt()
 */
void RS_GraphicView::drawAbsoluteZero(RS_Painter *painter){
    int const zr = zeroShortAxisMarkSize;

    RS_Pen pen_xAxis (m_colorData->xAxisExtensionColor, RS2::Width00, RS2::SolidLine);
    pen_xAxis.setScreenWidth(0);
    pen_xAxis.setScreenWidth(1.0);

    RS_Pen pen_yAxis (m_colorData->yAxisExtensionColor, RS2::Width00, RS2::SolidLine);
    pen_yAxis.setScreenWidth(0);
    pen_yAxis.setScreenWidth(1.0);

    auto originPoint = toGui(RS_Vector(0,0));


    int width = getWidth();
    int height = getHeight();
    if (extendAxisLines){

    }

    RS2::LineType relativeZeroPenType = RS2::SolidLine;

    if (m_colorData->hideRelativeZero) relativeZeroPenType = RS2::NoPen;

    RS_Pen p(m_colorData->relativeZeroColor, RS2::Width00, relativeZeroPenType);
    p.setScreenWidth(0);
    p.setScreenWidth(1.0);
    painter->setPen(p);

    int const zr = relativeZeroRadius*2;
    auto vp = toGui(relativeZero);
    if (vp.x + zr < 0 || vp.x - zr > getWidth()) return;
    if (vp.y + zr < 0 || vp.y - zr > getHeight()) return;

    int numX = graphic->getPagesNumHoriz();
    int numY = graphic->getPagesNumVert();

// gray background:
    painter->fillRect(0, 0, getWidth(), getHeight(),
                      printPreviewBackgroundColor);

// shadow:    
// shadow:
    painter->fillRect(paperX1 + 6, paperY1 + 6, paperW, paperH,
                      printPreviewBorderAndShadowColor);

// border:
    painter->fillRect(paperX1, paperY1, paperW, paperH,
                      printPreviewBorderAndShadowColor);

// paper:    
// paper:
    painter->fillRect(paperX1 + 1, paperY1 - 1, paperW - 2, paperH + 2,
                      printPreviewPaperColor);

// print area:
    painter->fillRect(paperX1 + 1 + marginLeft, paperY1 - 1 - marginBottom,
                      printAreaW - 2, printAreaH + 2,
                      printPreviewPrintAreaColor);

RS2::EntityType RS_GraphicView::getTypeToSelect() const {
    return typeToSelect;
}

void RS_GraphicView::setTypeToSelect(RS2::EntityType mType) {
    typeToSelect = mType;
}

bool RS_GraphicView::getSimplifySmall() const {
  return simplifySmall;
}

bool RS_GraphicView::getSimplifyPanning() const {
  return simplifyPanning;
}


int RS_GraphicView::getMinRenderableTextHeightInPx() const {
    return minRenderableTextHeightInPx;
}

void RS_GraphicView::loadGridSettings() {
    if (grid != nullptr){

    int getPointMode() const;
    int getPointSize() const;
    double getMinCircleDrawingRadius() const;
    double getMinArcDrawingRadius() const;
    double getMinEllipseMajorRadius() const;
    double getMinEllipseMinorRadius() const;
    double getMinLineDrawingLen() const;
    int getMinRenderableTextHeightInPx() const;
    int  getMinRenderableTextHeightInPx() const;
    bool getSimplifySmall() const;
    bool getSimplifyPanning() const;
    void setHasNoGrid(bool hasNoGrid);
    bool isDraftLinesMode() const;
    void setDraftLinesMode(bool draftLinesMode);
    void setForcedActionKillAllowed(bool forcedActionKillAllowed);

    bool getPanOnZoom() const;
    bool getSkipFirstZoom() const;

    bool extendAxisLines = false;
    int extendAxisModeX = 0;
    int extendAxisModeY = 0;
    int entityHandleHalfSize = 2;
    int relativeZeroRadius = 5;
    int zeroShortAxisMarkSize = 20;
    bool simplifySmall = true;
    bool simplifyPanning = true;
    int minRenderableTextHeightInPx = 4;
    bool ignoreDraftForHighlight = false;

/**
  * Delete mode. If true, all drawing actions will delete in background color
  * instead.
  */
    bool deleteMode = false;
    LC_Rect view_rect;
    void drawEntityReferencePoints(RS_Painter *painter, const RS_Entity *e) const;
    void invalidate();

    // painting cached values

    double unitFactor;
    double unitFactor100;
    double unitFactor = 1.0;
    double unitFactor100 = 0.01;
    double defaultWidthFactor;
    double paperScale;
    // points rendering settings
    int pdmode;
    double pdsize;
    int screenPDSize;
#ifdef DEBUG_RENDERING

signals:
    void relative_zero_changed(const RS_Vector &);
    void previous_zoom_state(bool);
private:

    bool m_panOnZoom = false;
    bool m_skipFirstZoom = false;
    bool m_modifyOnZoom = true;
};

#endif

#include <map>

#include "rs_linetypepattern.h"

#include "rs.h"

namespace {
// after the line pattern fixed, these patteds are defined in millimeters.
// It is another question how correct are these numbers bellow.
// For example - in my drawings, patternCenterSmall is too big and patternCenterTiny a
// little bit smaller than I need.
//define all line patterns in pixels

const RS_LineTypePattern patternSolidLine={10.0};

const RS_LineTypePattern patternDotLineTiny{{0.15, -1.}};
const RS_LineTypePattern patternDotLine{{0.2, -6.2}};
const RS_LineTypePattern patternDotLine2{{0.2, -3.1}};
const RS_LineTypePattern patternDotLineX2{{0.2, -12.4}};

** This copyright notice MUST APPEAR in all copies of the script!
**
**********************************************************************/
#include<cmath>

#include<QPainterPath>
#include<QPolygon>
#include <cstdio>

#include "dxf_format.h"
#include "rs_color.h"
#include "rs_spline.h"
#include "rs_polyline.h"
#include "rs_debug.h"
#include "rs_math.h"
#include "rs_painter.h"
#include "rs_graphicview.h"
#include "rs_linetypepattern.h"
#include "rs_arc.h"
#include "rs_ellipse.h"
#include "rs_circle.h"


namespace {
// Convert from LibreCAD line style pattern to QPen Dash Pattern.
// QPen dash pattern by default is in the unit of pixel
    QVector<qreal> rsToQDashPattern(const RS2::LineType &t, double screenWidth, double dpmm, double &newDashOffset) {
    QVector<qreal> rsToQDashPattern(const RS2::LineType &t, double k, double &newDashOffset) {
        // dash pattern is in mm
        // d*dpmm/screenWidth, so, the scaling factor k = dpmm/screenWidth
        // Qt dash pattern is in line width units.
        dpmm = std::max(dpmm, 1e-6);
        double k = dpmm / std::max(screenWidth, 1.);
        // k == 1/linewidth[mm]

        const std::vector<double> &pattern = RS_LineTypePattern::getPattern(t)->pattern;
        QVector<qreal> dashPattern;
        std::transform(pattern.cbegin(), pattern.cend(), std::back_inserter(dashPattern), [k](double d) {
            return std::max(k * std::abs(d), 1.);
        });

        dashPattern.resize(dashPattern.size() - dashPattern.size() % 2);
        dashPattern.resize(dashPattern.size() - dashPattern.size() % 2); // do we really need this?

        newDashOffset = newDashOffset * k;
        return dashPattern;
    }

/**
 * Wrapper for Qt

        restore();
    }
}


void RS_Painter::createSolidFillPath(QPainterPath &path, const RS_GraphicView *view,   QList<RS_Entity *> entities)  {
        foreach (auto l, entities) {
            if (l->rtti()==RS2::EntityContainer) {
            if (l->isContainer()) {
                auto* loop = (RS_EntityContainer*)l;
                QPainterPath loopPath;
                // edges:
//                LC_ERR << "loop------------------------------- " << loop->count();
                for(auto e: *loop){
                    switch (e->rtti()) {
                        case RS2::EntityLine: {

    }

    pColor.setAlphaF(pen.getAlpha());
    RS2::LineType lineType = pen.getLineType();
    Qt::PenStyle style = rsToQtLineType(lineType);

    double screenWidth = pen.getScreenWidth();
    double swpx;

    if (screenWidth < 1.0) {
        swpx = 0.0;
    } else {
        swpx = screenWidth;
    }

    if (style == Qt::CustomDashLine){
        double newDashOffset = pen.dashOffset();
        auto dashPattern = rsToQDashPattern(lineType,
                                            screenWidth/*p.widthF()*/,
                                            getDpmmCached(),
                                            newDashOffset);

        double k = pen.getWidth();

        if (k <= 0.0) {
            k = 1.0;
        } else {
            k = 100.0/k;
        }

        k = k * pen.getScale();

        if ((screenWidth < 1.0) && (screenWidth > RS_TOLERANCE) )
          k = k*screenWidth;

        auto dashPattern = rsToQDashPattern(lineType, k, newDashOffset);

        if (dashPattern.isEmpty()) {
            style = Qt::SolidLine;
        } else {
            QPen p(pColor, screenWidth, style);
            QPen p(pColor, swpx, style);
            p.setDashPattern(std::move(dashPattern));
            // fixme - how this is related to RS_AtomicEntity::updateDashOffset??? Will we set dash offset twice?
            p.setDashOffset(newDashOffset);
            p.setJoinStyle(penJoinStyle);
            p.setCapStyle(penCapStyle);
            lastUsedPen = p;
            QPainter::setPen(p);
            return;
        }
    }
    // processing solid line

    bool changed = false;
    if (lastUsedPen.color() != pColor){
        lastUsedPen.setColor(pColor);
        changed = true;
    }
    if (lastUsedPen.widthF() != screenWidth){
        lastUsedPen.setWidthF(screenWidth);
    if (lastUsedPen.widthF() != swpx){
        lastUsedPen.setWidthF(swpx);
        changed = true;
    }
    if (lastUsedPen.style() != style){
        lastUsedPen.setStyle(style);
        changed = true;
    }
    lastUsedPen.setJoinStyle(penJoinStyle);

#include <QEventLoop>
#include <QList>
#include <QInputDialog>
#include <QFileInfo>

#include "doc_plugin_interface.h"
#include "document_interface.h"
#include "intern/qc_actiongetent.h"
#include "intern/qc_actiongetpoint.h"
#include "intern/qc_actiongetselect.h"
#include "lc_splinepoints.h"
#include "lc_undosection.h"
#include "rs_actioninterface.h"
#include "rs_arc.h"
#include "rs_block.h"
#include "rs_circle.h"
#include "rs_debug.h"
#include "rs_dimension.h"
#include "rs_ellipse.h"
#include "rs_eventhandler.h"
#include "rs_graphicview.h"
#include "rs_image.h"
#include "rs_insert.h"
#include "rs_layer.h"
#include "rs_line.h"

        data->insert(DPI::CLOSEPOLY, static_cast<RS_Polyline*>(entity)->isClosed() );
        break;
    case RS2::EntityVertex:
        data->insert(DPI::ETYPE, DPI::UNKNOWN);
        break;
    case RS2::EntityDimAligned:
        data->insert(DPI::ETYPE, DPI::DIMALIGNED);
        data->insert(DPI::TEXTCONTENT, static_cast<RS_Dimension*>(entity)->getLabel(false));
        data->insert(DPI::SIZEU, static_cast<RS_Dimension*>(entity)->getMeasuredLabel().toDouble());
        break;
    case RS2::EntityDimLinear:
        data->insert(DPI::ETYPE, DPI::DIMLINEAR);
        data->insert(DPI::TEXTCONTENT, static_cast<RS_Dimension*>(entity)->getLabel(false));
        data->insert(DPI::SIZEU, static_cast<RS_Dimension*>(entity)->getMeasuredLabel().toDouble());
        break;
    case RS2::EntityDimRadial:
        data->insert(DPI::ETYPE, DPI::DIMRADIAL);
        data->insert(DPI::TEXTCONTENT, static_cast<RS_Dimension*>(entity)->getLabel(false));
        data->insert(DPI::SIZEU, static_cast<RS_Dimension*>(entity)->getMeasuredLabel().toDouble());
        break;
    case RS2::EntityDimDiametric:
        data->insert(DPI::ETYPE, DPI::DIMDIAMETRIC);
        data->insert(DPI::TEXTCONTENT, static_cast<RS_Dimension*>(entity)->getLabel(false));
        data->insert(DPI::SIZEU, static_cast<RS_Dimension*>(entity)->getMeasuredLabel().toDouble());
        break;
    case RS2::EntityDimAngular:
        data->insert(DPI::ETYPE, DPI::DIMANGULAR);
        data->insert(DPI::TEXTCONTENT, static_cast<RS_Dimension*>(entity)->getLabel(false));
        data->insert(DPI::SIZEU, static_cast<RS_Dimension*>(entity)->getMeasuredLabel().toDouble());
        break;
    case RS2::EntityDimLeader:
        data->insert(DPI::ETYPE, DPI::DIMLEADER);
        break;
    case RS2::EntityUnknown:
    default:
        data->insert(DPI::ETYPE, DPI::UNKNOWN);

        }else{
            pl->setClosed(false);
        }
        break;}
    case RS2::EntityVertex:
        break;
    case RS2::EntityDimAligned:
        if (hash.contains(DPI::TEXTCONTENT)) {
           static_cast<RS_Dimension*>(ec)->setLabel(hash.take(DPI::TEXTCONTENT).toString());
        }
        break;
    case RS2::EntityDimLinear:
        if (hash.contains(DPI::TEXTCONTENT)) {
            static_cast<RS_Dimension*>(ec)->setLabel(hash.take(DPI::TEXTCONTENT).toString());
        }
        break;
    case RS2::EntityDimRadial:
        if (hash.contains(DPI::TEXTCONTENT)) {
            static_cast<RS_Dimension*>(ec)->setLabel(hash.take(DPI::TEXTCONTENT).toString());
        }
        break;
    case RS2::EntityDimDiametric:
        if (hash.contains(DPI::TEXTCONTENT)) {
            static_cast<RS_Dimension*>(ec)->setLabel(hash.take(DPI::TEXTCONTENT).toString());
        }
        break;
    case RS2::EntityDimAngular:
        if (hash.contains(DPI::TEXTCONTENT)) {
            static_cast<RS_Dimension*>(ec)->setLabel(hash.take(DPI::TEXTCONTENT).toString());
        }
        break;
    case RS2::EntityDimLeader:
        break;
    case RS2::EntityUnknown:
    default:
        break;
    }

 * Main. Creates Application window.
 */
 // fixme - sand - refactor and split to several specialized functions
int main(int argc, char** argv)
{
    QT_REQUIRE_VERSION(argc, argv, "5.2.1");

    // Check first two arguments in order to decide if we want to run librecad
    // as console dxf2pdf or dxf2png tools. On Linux we can create a link to
    // librecad executable and  name it dxf2pdf. So, we can run either:
    //
    //     librecad dxf2pdf [options] ...
    //
    // or just:
    //
    //     dxf2pdf [options] ...
    //
    for (int i = 0; i < qMin(argc, 2); i++) {
        QString arg(argv[i]);
        if (i == 0) {
            arg = QFileInfo(QFile::decodeName(argv[i])).baseName();
        }
        if (arg.compare("dxf2pdf") == 0) {
            return console_dxf2pdf(argc, argv);
        }
        if (arg.compare("dxf2png") == 0 || arg == "dxf2svg") {
            return console_dxf2png(argc, argv);
        }
    }

    RS_DEBUG->setLevel(RS_Debug::D_WARNING);
    RS_DEBUG->setLevel(RS_Debug::D_NOTHING);

    LC_Application app(argc, argv);
    QCoreApplication::setOrganizationName("LibreCAD");
    QCoreApplication::setApplicationName("LibreCAD");
    QCoreApplication::setApplicationVersion(XSTR(LC_VERSION));

    RS_Settings::init(app.organizationName(), app.applicationName());

#if (QT_VERSION >= QT_VERSION_CHECK(5, 7, 0))
    QGuiApplication::setDesktopFileName("librecad.desktop");
#endif

    QSettings settings; // fixme - direct invocation of settings

    bool first_load = settings.value("Startup/FirstLoad", 1).toBool();

    const QString lpDebugSwitch0("-d"),lpDebugSwitch1("--debug") ;
    const QString help0("-h"), help1("--help");
    bool allowOptions=true;
    QList<int> argClean;
    for (int i=0; i<argc; i++)
    {
        QString argstr(argv[i]);
        if(allowOptions&&QString::compare("--", argstr)==0)
        {
            allowOptions=false;
            continue;
        }
        if (allowOptions && (help0.compare(argstr, Qt::CaseInsensitive)==0 ||
                             help1.compare(argstr, Qt::CaseInsensitive)==0 ))
            help1.compare(argstr, Qt::CaseInsensitive)==0 ))
        {
            qDebug()<<"Usage: librecad [command] <options> <dxf file>";
            qDebug()<<"";
            qDebug()<<"Commands:";
            qDebug()<<"";
            qDebug()<<"  dxf2pdf\tRun librecad as console dxf2pdf tool. Use -h for help.";
            qDebug()<<"  dxf2png\tRun librecad as console dxf2png tool. Use -h for help.";

            RS_DEBUG->print( RS_Debug::D_NOTHING, "    %d Warning", RS_Debug::D_WARNING);
            RS_DEBUG->print( RS_Debug::D_NOTHING, "    %d Notice", RS_Debug::D_NOTICE);
            RS_DEBUG->print( RS_Debug::D_NOTHING, "    %d Informational", RS_Debug::D_INFORMATIONAL);
            RS_DEBUG->print( RS_Debug::D_NOTHING, "    %d Debugging", RS_Debug::D_DEBUGGING);
            exit(0);
        }
        if (allowOptions&& (argstr.startsWith(lpDebugSwitch0, Qt::CaseInsensitive) ||
                             argstr.startsWith(lpDebugSwitch1, Qt::CaseInsensitive) )){
            argstr.startsWith(lpDebugSwitch1, Qt::CaseInsensitive) )){
            argClean<<i;

            // to control the level of debugging output use --debug with level 0-6, e.g. --debug3
            // for a list of debug levels use --debug?
            // if no level follows, the debugging level is set
            argstr.remove(QRegularExpression("^"+lpDebugSwitch0));
            argstr.remove(QRegularExpression("^"+lpDebugSwitch1));
            char level;
            if(argstr.size()==0){
                if(i+1<argc){
                    if(QRegularExpression(R"(\d*)").match(argv[i+1]).hasMatch()){
        // to control the level of debugging output use --debug with level 0-6, e.g. --debug3
        // for a list of debug levels use --debug?
        // if no level follows, the debugging level is set

        argstr.remove(QRegularExpression("^"+lpDebugSwitch0));
        argstr.remove(QRegularExpression("^"+lpDebugSwitch1));
        char level;
        if(argstr.size()==0){
            if(i+1<argc){
                if(QRegularExpression(R"(\d*)").match(argv[i+1]).hasMatch()){
                        ++i;
                        qDebug()<<"reading "<<argv[i]<<" as debugging level";
                        level=argv[i][0];
                        argClean<<i;
                    }
                }
                    else {
                        level = '3';
                    }
                }
            }
                else {
                    level = '3'; //default to D_WARNING
                }
            }
        }
            else {
                level = argstr.toStdString()[0];
            }

            switch(level){
                case '?' : {
                    RS_DEBUG->print(RS_Debug::D_NOTHING, "possible debug levels:");
                    RS_DEBUG->print(RS_Debug::D_NOTHING, "    %d Nothing", RS_Debug::D_NOTHING);
                    RS_DEBUG->print(RS_Debug::D_NOTHING, "    %d Critical", RS_Debug::D_CRITICAL);
                    RS_DEBUG->print(RS_Debug::D_NOTHING, "    %d Error", RS_Debug::D_ERROR);
                    RS_DEBUG->print(RS_Debug::D_NOTHING, "    %d Warning", RS_Debug::D_WARNING);
                    RS_DEBUG->print(RS_Debug::D_NOTHING, "    %d Notice", RS_Debug::D_NOTICE);
                    RS_DEBUG->print(RS_Debug::D_NOTHING, "    %d Informational", RS_Debug::D_INFORMATIONAL);
                    RS_DEBUG->print(RS_Debug::D_NOTHING, "    %d Debugging", RS_Debug::D_DEBUGGING);
                    return false;
                    return 0;
                }
                case '0' + RS_Debug::D_NOTHING : {
                    RS_DEBUG->setLevel(RS_Debug::D_NOTHING);
                    break;
                }
                case '0' + RS_Debug::D_CRITICAL : {
                    RS_DEBUG->setLevel(RS_Debug::D_CRITICAL);

                }
                default : {
                    RS_DEBUG->setLevel(RS_Debug::D_DEBUGGING);
                    break;
                }
            }

        }
            }
    }


    // Check first two arguments in order to decide if we want to run librecad
    // as console dxf2pdf or dxf2png tools. On Linux we can create a link to
    // librecad executable and  name it dxf2pdf. So, we can run either:
    //
    //     librecad dxf2pdf [options] ...
    //
    // or just:
    //
    //     dxf2pdf [options] ...
    //
    for (int i = 0; i < qMin(argc, 2); i++) {
        QString arg(argv[i]);
        if (i == 0) {
            arg = QFileInfo(QFile::decodeName(argv[i])).baseName();
        }
        if (arg.compare("dxf2pdf") == 0) {
            return console_dxf2pdf(argc, argv);
        }
        if (arg.compare("dxf2png") == 0 || arg == "dxf2svg") {
            return console_dxf2png(argc, argv);
        }
    }


    LC_Application app(argc, argv);
    QCoreApplication::setOrganizationName("LibreCAD");
    QCoreApplication::setApplicationName("LibreCAD");
    QCoreApplication::setApplicationVersion(XSTR(LC_VERSION));

    RS_Settings::init(app.organizationName(), app.applicationName());

#if (QT_VERSION >= QT_VERSION_CHECK(5, 7, 0))
    QGuiApplication::setDesktopFileName("librecad");
#endif

    QSettings settings; // fixme - direct invocation of settings

    bool first_load = settings.value("Startup/FirstLoad", 1).toBool();

    RS_DEBUG->print("param 0: %s", argv[0]);

    QFileInfo prgInfo( QFile::decodeName(argv[0]) );
    QString prgDir(prgInfo.absolutePath());

    RS_SYSTEM->init(app.applicationName(), app.applicationVersion(), XSTR(QC_APPDIR), prgDir);

**
**********************************************************************/

#ifndef QC_PLUGININTERFACE_H
#define QC_PLUGININTERFACE_H

#include <QtPlugin>
#include <qcontainerfwd.h>

class Document_Interface;

/**
  * Menu locations for Plugins
  */
class PluginMenuLocation
{
    public:
        PluginMenuLocation(QString menuEntryPoint, QString menuEntryActionName) {
        PluginMenuLocation(QString menuEntryPoint, QString menuEntryActionName, QString menuEntryCmd="", QString menuEntryKey="") {
            this->menuEntryActionName=menuEntryActionName;
            this->menuEntryPoint=menuEntryPoint;
            this->menuEntryCmd=menuEntryCmd;
            this->menuEntryKey=menuEntryKey;

        }

    QString menuEntryPoint;
    QString menuEntryActionName;
    QString menuEntryCmd;
    QString menuEntryKey;
};

class PluginCapabilities {
    public:
        QList<PluginMenuLocation> menuEntryPoints;
        QList<int> paintEventPriorities;    // if set, this plugin will get it's paintEvent function called
                                        // lower numbers are drawn first

}

void QG_InsertOptions::onAngleEditingFinished(){
    setAngleToActionAndView(ui->leAngle->text());
}

void QG_InsertOptions::onFactorEditingFinished(){
    setAngleToActionAndView(ui->leFactor->text());
    setFactorToActionAndView(ui->leFactor->text());
}

void QG_InsertOptions::onColumnSpacingEditingFinished() {
    setColumnSpacingActionAndView(ui->leColumnSpacing->text());
}

void QG_InsertOptions::onRowSpacingEditingFinished() {

        checked = LC_GET_BOOL("PanOnZoom", false);
        cbPanOnWheelZoom->setChecked(checked);

        checked = LC_GET_BOOL("FirstTimeNoZoom", false);
        cbFirstTimeNoZoom->setChecked(checked);

        checked = LC_GET_BOOL("ModifyOnViewChange", true);
        cbModifyOnView->setChecked(checked);
    }
    LC_GROUP_END();

    LC_GROUP("Render");
    {
        bool checked = LC_GET_BOOL("SimplifyPanning", true);
        cbSimplifyPanning->setChecked(checked);

        checked = LC_GET_BOOL("SimplifySmall", true);
        cbSimplifySmall->setChecked(checked);

        int minTextHeight = LC_GET_INT("MinRenderableTextHeightPx", 4);
        sbTextMinHeight->setValue(minTextHeight);

        int minArcRadius100 = LC_GET_INT("MinArcRadius", 80);
        double minArcRadius = minArcRadius100 / 100.0;
        sbRenderMinArcRadius->setValue(minArcRadius);

            LC_SET("ShowCloseButtonActiveOnly", cbTabCloseButtonMode->currentIndex() == 1);

            LC_SET("ShowActionIconInOptions", cbShowCurrentActionIconInOptions->isChecked());
            LC_SET("ShowEntityIDs", cbShowEntityIDs->isChecked());

            LC_SET("PanOnZoom", cbPanOnWheelZoom->isChecked());
            LC_SET("FirstTimeNoZoom", cbFirstTimeNoZoom->isChecked());
            LC_SET("ModifyOnViewChange", cbModifyOnView->isChecked());
        }
        LC_GROUP_END();

        LC_GROUP("Render");
        {
            LC_SET("SimplifySmall", cbSimplifySmall->isChecked());
            LC_SET("SimplifyPanning", cbSimplifyPanning->isChecked());
            LC_SET("MinRenderableTextHeightPx", sbTextMinHeight->value());
            LC_SET("MinArcRadius", (int)(sbRenderMinArcRadius->value()*100));
            LC_SET("MinCircleRadius", (int)(sbRenderMinCircleRadius->value()*100));
            LC_SET("MinLineLen", (int)(sbRenderMinLineLen->value()*100));
            LC_SET("MinEllipseMajor", (int)(sbRenderMinEllipseMajor->value()*100));
            LC_SET("MinEllipseMinor", (int)(sbRenderMinEllipseMinor->value()*100));
        }

<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
 <class>QG_DlgOptionsGeneral</class>
 <widget class="QDialog" name="QG_DlgOptionsGeneral">
  <property name="geometry">
   <rect>
    <x>0</x>
    <y>0</y>
    <width>730</width>
    <height>636</height>
    <width>797</width>
    <height>677</height>
   </rect>
  </property>
  <property name="windowTitle">
   <string>Application Preferences</string>
  </property>
  <property name="sizeGripEnabled">
   <bool>true</bool>

      <set>QDialogButtonBox::Cancel|QDialogButtonBox::Ok</set>
     </property>
    </widget>
   </item>
   <item row="0" column="0">
    <widget class="QTabWidget" name="tabWidget">
     <property name="currentIndex">
      <number>3</number>
      <number>0</number>
     </property>
     <widget class="QWidget" name="tabAppearance">
      <attribute name="title">
       <string>&amp;Graphic View</string>
      </attribute>
      <layout class="QGridLayout" name="gridLayout_6">
       <item row="0" column="2">

              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="text">
             <string>First time only pan</string>
            </property>
           </widget>
          </item>
          <item row="10" column="0">
           <widget class="QCheckBox" name="cbModifyOnView">
            <property name="text">
             <string>View change modifies the document</string>
            </property>
           </widget>
          </item>
         </layout>
        </widget>
       </item>
       <item row="2" column="0">
        <spacer name="verticalSpacer_7">
         <property name="orientation">

       </item>
       <item row="2" column="0">
        <widget class="QGroupBox" name="groupBox_14">
         <property name="title">
          <string>Rendering Minimums</string>
         </property>
         <layout class="QGridLayout" name="gridLayout_27">
          <item row="0" column="2">
          <item row="3" column="0">
           <widget class="QLabel" name="label_13">
            <property name="text">
             <string>Line length:</string>
            </property>
           </widget>
          </item>
          <item row="4" column="3">
           <widget class="QLabel" name="label_17">
            <property name="text">
             <string>Ellipse Major Axis:</string>
            </property>
           </widget>
          </item>
          <item row="2" column="0">
           <widget class="QLabel" name="label_2">
            <property name="text">
             <string>Height of text line:</string>
            </property>
           </widget>
          </item>
          <item row="4" column="0">
           <widget class="QLabel" name="label_16">
            <property name="text">
             <string>Ellipse Minor Axis:</string>
            </property>
           </widget>
          </item>
          <item row="2" column="3">
           <widget class="QLabel" name="label_14">
            <property name="text">
             <string>Arc Radius:</string>
            </property>
           </widget>
          </item>
          <item row="2" column="4">
           <widget class="QDoubleSpinBox" name="sbRenderMinArcRadius">
            <property name="toolTip">
             <string>If screen radius of arc is less than value, arc is drawn as point</string>
            </property>
            <property name="suffix">
             <string> px</string>
            </property>
            <property name="maximum">
             <double>5.000000000000000</double>
            </property>
            <property name="singleStep">
             <double>0.010000000000000</double>
            </property>
           </widget>
          </item>
          <item row="2" column="2">
           <widget class="QSpinBox" name="sbTextMinHeight">
            <property name="toolTip">
             <string>If height of text line on the screen is less than specified pixels, placholder will be drawn instead of text</string>
            </property>
            <property name="suffix">
             <string> px</string>
            </property>

             <number>15</number>
            </property>
            <property name="singleStep">
             <number>1</number>
            </property>
           </widget>
          </item>
          <item row="1" column="0">
          <item row="3" column="4">
           <widget class="QLabel" name="label_13">
            <property name="text">
             <string>Line length:</string>
            </property>
           </widget>
          </item>
          <item row="0" column="0">
           <widget class="QLabel" name="label_2">
            <property name="text">
             <string>Height of text line:</string>
            </property>
           </widget>
          </item>
          <item row="2" column="3">
           <widget class="QLabel" name="label_17">
            <property name="text">
             <string>Ellipse Major Axis:</string>
            </property>
           </widget>
          </item>
          <item row="2" column="4">
           <widget class="QDoubleSpinBox" name="sbRenderMinEllipseMinor">
           <widget class="QDoubleSpinBox" name="sbRenderMinCircleRadius">
            <property name="toolTip">
             <string>If screen size of minor ellipse axis is less than value, ellipse is drawn as line</string>
             <string>If screen radius of circle is less than value, circle is drawn as point</string>
            </property>
            <property name="suffix">
             <string> px</string>
            </property>
            <property name="maximum">
             <double>5.000000000000000</double>
            </property>
            <property name="singleStep">
             <double>0.010000000000000</double>
            </property>
           </widget>
          </item>
          <item row="1" column="2">
          <item row="3" column="2">
           <widget class="QDoubleSpinBox" name="sbRenderMinLineLen">
            <property name="toolTip">
             <string>If screen length of line is less than value, the line is drawn as point</string>
            </property>
            <property name="suffix">
             <string> px</string>
            </property>
            <property name="maximum">
             <double>5.000000000000000</double>
            </property>
            <property name="singleStep">
             <double>0.010000000000000</double>
            </property>
           </widget>
          </item>
          <item row="1" column="4">
           <widget class="QDoubleSpinBox" name="sbRenderMinCircleRadius">
          <item row="4" column="4">
           <widget class="QDoubleSpinBox" name="sbRenderMinEllipseMinor">
            <property name="toolTip">
             <string>If screen radius of circle is less than value, circle is drawn as point</string>
             <string>If screen size of minor ellipse axis is less than value, ellipse is drawn as line</string>
            </property>
            <property name="suffix">
             <string> px</string>
            </property>
            <property name="maximum">
             <double>5.000000000000000</double>
            </property>
            <property name="singleStep">
             <double>0.010000000000000</double>
            </property>
           </widget>
          </item>
          <item row="1" column="3">
          <item row="4" column="2">
           <widget class="QLabel" name="label_15">
            <property name="text">
             <string>Circle Radius:</string>
            </property>
           </widget>
          </item>
          <item row="0" column="3">
           <widget class="QLabel" name="label_14">
            <property name="text">
             <string>Arc Radius:</string>
            </property>
           </widget>
          </item>
          <item row="0" column="4">
           <widget class="QDoubleSpinBox" name="sbRenderMinArcRadius">
           <widget class="QDoubleSpinBox" name="sbRenderMinEllipseMajor">
            <property name="toolTip">
             <string>If screen radius of arc is less than value, arc is drawn as point</string>
             <string>If screen size for major ellipse axis is less than value, ellipse is drawn as point</string>
            </property>
            <property name="suffix">
             <string> px</string>
            </property>
            <property name="maximum">
             <double>5.000000000000000</double>
            </property>
            <property name="singleStep">
             <double>0.010000000000000</double>
            </property>
           </widget>
          </item>
          <item row="2" column="0">
           <widget class="QLabel" name="label_16">
          <item row="3" column="3">
           <widget class="QLabel" name="label_15">
            <property name="text">
             <string>Ellipse Minor Axis:</string>
             <string>Circle Radius:</string>
            </property>
           </widget>
          </item>
          <item row="1" column="0" colspan="4">
           <widget class="QCheckBox" name="cbSimplifySmall">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Maximum" vsizetype="Fixed">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="toolTip">
             <string>Render the small entities in draft mode</string>
            </property>
            <property name="text">
             <string>Simplify the small entities</string>
            </property>
           </widget>
          </item>
          <item row="2" column="2">
           <widget class="QDoubleSpinBox" name="sbRenderMinEllipseMajor">
            <property name="toolTip">
             <string>If screen size for major ellipse axis is less than value, ellipse is drawn as point</string>
            </property>
            <property name="suffix">
             <string> px</string>
          <item row="0" column="0" colspan="5">
           <widget class="QCheckBox" name="cbSimplifyPanning">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Maximum" vsizetype="Fixed">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="maximum">
             <double>5.000000000000000</double>
            <property name="toolTip">
             <string>Simplify the rendering during the mouse drag panning.</string>
            </property>
            <property name="singleStep">
             <double>0.010000000000000</double>
            <property name="text">
             <string>Simplify rendering on panning</string>
            </property>
           </widget>
          </item>
         </layout>
        </widget>
       </item>
      </layout>

#include <QAction>
#include <QDockWidget>
#include <QKeyEvent>
#include <QFileDialog>
#include <QSettings>

#include "lc_application.h"
#include "qc_applicationwindow.h"
#include "qg_actionhandler.h"
#include "rs_commandevent.h"
#include "rs_commands.h"
#include "rs_debug.h"
#include "rs_settings.h"
#include "rs_system.h"
#include "rs_utility.h"

/*
 *  Constructs a QG_CommandWidget as a child of 'parent', with the
 *  name 'name' and widget flags set to 'f'.
 */
QG_CommandWidget::QG_CommandWidget(QWidget* parent, const char* name, Qt::WindowFlags fl)

    bool isDisplayPointsPathOnPreview(){return options->displayPointsPath;};
    bool isSelectEntitiesInDefaultActionWithCTRL(){return options->selectEntitiesInDefaultActionByCTRL;};
    bool isAutoSelectEntitiesInDefaultAction(){return options->autoSelectEntitiesInDefaultAction;};

    void onEntityPropertiesEdited(unsigned long originalId, unsigned long editedCloneId);

signals:
    virtual void escape();

protected slots:
    void onSettings();
    void onClearAll();
    void onCopyAll();
    void onTextChanged();
    void onPickEntity();
    void onPickCoordinates();

        if (child->getLayerType() == type){
            result = true;
            break;
        }
    }
    return result;
}


/**
 * Searches recursively and returns the first child of the given type.
 * Or nullptr if there is none.
 * @param type layer type
 * @return LC_LayerTreeItem* or nullptr
 */
LC_LayerTreeItem* LC_LayerTreeItem::firstChildOfType(int type){
    LC_LayerTreeItem* result = nullptr;
    int count = childItems.length();

    for (int i = 0; i < count; i++) {
        LC_LayerTreeItem *child = childItems.at(i);

        if (child->getLayerType() == type){
            result = child;
            break;
        } else {
          result = child->firstChildOfType(type);
          if (result) break;
        }
    }

    return result;
}



void LC_LayerTreeItem::setLayerType(int value){
    layerType = value;
}
/**
 * If layer is secondary, this is the reference to the normal layer (if any) that corresponds to this item
 * @return primary layer item

    void setMatched(bool enabled) {matched = enabled;};
    bool isMatched() const {return matched;};
    bool isActiveLayer() const {return activeLayer;};
    void setActiveLayer(bool value){activeLayer = value;};
    void invalidate();
    bool isInValid() const;
    bool hasChildOfType(int type);
    LC_LayerTreeItem* firstChildOfType(int type);
    bool hasChildWithName(QString& nameToFind, int layerTypeToFind);
    void collectPathToParent(QList<LC_LayerTreeItem*> &result, bool includeSelf);
    bool isDescendantOf(LC_LayerTreeItem* item);
    bool isZero() const {return zero_layer;}
    void markAsZero(){zero_layer = true;}
    QString getFullName(){return fullName;};
    void setFullName(QString &name){fullName = name;};

    vboxLayout->addWidget(dirView);
    ivPreview = new QListView(this);
    ivPreview->setViewMode(QListView::IconMode);
    vboxLayout->addWidget(ivPreview);
    bInsert = new QPushButton(tr("Insert"), this);
    vboxLayout->addWidget(bInsert);

    QHBoxLayout *refreshButtonsLayout = new QHBoxLayout(this);
    QHBoxLayout *refreshButtonsLayout = new QHBoxLayout();
    bRefresh = new QPushButton(tr("Refresh"), this);
    refreshButtonsLayout->addWidget(bRefresh);
    bRebuild = new QPushButton(tr("Rebuild"), this);
    refreshButtonsLayout->addWidget(bRebuild);
    vboxLayout->addLayout(refreshButtonsLayout);

    buildTree();

        // handle error later
    }
    return result;
}

bool LC_PenPaletteData::loadItems(){
    QString fileName = options->pensFileName;

    if (fileName.length() == 0) {
        createDefaultPens();
    bool result = false;
        return false;
    }

    QFile file(fileName);
    file.open(QIODevice::ReadOnly | QIODevice::Text);
    if (file.isOpen()){
        QTextStream in(&file);
#if QT_VERSION >= QT_VERSION_CHECK(6, 2, 0)
        in.setEncoding(QStringConverter::Utf8);
#else

        }
        file.close();
        return true;
    }
    else {
        createDefaultPens();
    }
    return result;
    return false;
}

/**
 * Quite naive implementation that stores all attributes of pen in string using common separator.
 * @param item
 * @return
 */

}

void LC_NamedViewsListWidget::setGraphicView(RS_GraphicView *gv,
                                             QMdiSubWindow *w) {
    LC_ViewList *viewsList = nullptr;
    if (gv != nullptr && gv->getGraphic() != nullptr) {
        RS_Graphic *graphic = gv->getGraphic();
        if (graphic != nullptr) {
        linearFormat = graphic->getLinearFormat();
        precision = graphic->getLinearPrecision();
        drawingUnit = graphic->getUnit();
        viewsList = graphic->getViewList();
            linearFormat = graphic->getLinearFormat();
            precision = graphic->getLinearPrecision();
            drawingUnit = graphic->getUnit();
            viewsList = graphic->getViewList();
        }
    }
    graphicView = gv;
    window = w;
    setViewsList(viewsList);
}

void LC_NamedViewsListWidget::setViewsList(LC_ViewList *viewsList) {

                QC_PluginInterface *pluginInterface = qobject_cast<QC_PluginInterface *>(plugin);
                if (pluginInterface) {
                    loadedPlugins.push_back(pluginInterface);
                    loadedPluginFileNames.push_back(fileName);
                    PluginCapabilities pluginCapabilities=pluginInterface->getCapabilities();
                    for(const PluginMenuLocation& loc: pluginCapabilities.menuEntryPoints) {
                        QAction *actpl = new QAction(loc.menuEntryActionName, plugin);
                        actpl->setText(loc.menuEntryActionName);
                        if (loc.menuEntryCmd == "") {
                        actpl->setData(loc.menuEntryActionName);
                          actpl->setData(loc.menuEntryActionName);
                        } else {
                          actpl->setData(loc.menuEntryCmd);
                        }
                        if (loc.menuEntryKey != "") actpl->setShortcut(QKeySequence::fromString(loc.menuEntryKey));
                        connect(actpl, SIGNAL(triggered()), this, SLOT(execPlug()));
                        connect(this, SIGNAL(windowsChanged(bool)), actpl, SLOT(setEnabled(bool)));
                        QMenu *atMenu = findMenu("/"+loc.menuEntryPoint, menuBar()->children(), "");
                        if (atMenu) {
                            atMenu->addAction(actpl);
                        } else {
#if QT_VERSION >= QT_VERSION_CHECK(5, 15, 0)

#include <QMap>
#include <QSettings>

#include "rs.h"
#include "rs_pen.h"
#include "rs_snapper.h"
#include "mainwindowx.h"
#include "lc_penpalettewidget.h"
#include "lc_quickinfowidget.h"
#include "lc_mdiapplicationwindow.h"
#include "lc_releasechecker.h"
#include "lc_qtstatusbarmanager.h"
#include "lc_namedviewslistwidget.h"

        break;
    }
    RS_DEBUG->print("QG_GraphicView::mouseReleaseEvent: OK");
}

void QG_GraphicView::addEditEntityEntry(QMouseEvent* event, QMenu& contextMenu){
    RS_Entity* entity = snapEntity(*this, event);
    if (entity == nullptr)
    if (entity == nullptr)  return;
    return;
    if (container==nullptr)
    if (container==nullptr)  return;
        return;
    RS_Insert* insert = getAncestorInsert(entity);
    // MText/Text should not be edited as blocks
    RS_Entity* toEdit = getParentText(insert) != nullptr ? getParentText(insert) : nullptr;
    if (toEdit != nullptr) {
        insert = nullptr;
        entity = toEdit;
    }

        antialiasing  = LC_GET_BOOL("Antialiasing");
        classicRenderer =  LC_GET_BOOL("ClassicRenderer", true);
        int zoomFactor1000 = LC_GET_INT("ScrollZoomFactor", 1137);
        scrollZoomFactor = zoomFactor1000 / 1000.0;
    }
    LC_GROUP_END();

    RS_Graphic* graphic = getGraphic();
    if (graphic != nullptr) {
        unitFactor = RS_Units::convert(1.0, RS2::Millimeter, graphic->getUnit());
        unitFactor100 =  unitFactor / 100.0;
        defaultWidthFactor = graphic->getVariableDouble("$DIMSCALE", 1.0);

        pdmode = graphic->getGraphicVariableInt("$PDMODE", LC_DEFAULTS_PDMode);
        pdsize = graphic->getGraphicVariableDouble("$PDSIZE", LC_DEFAULTS_PDSize);

//        Lineweight endcaps setting for new objects:
//        0 = none; 1 = round; 2 = angle; 3 = square
        int endCaps = graphic->getGraphicVariableInt("$ENDCAPS", 1);
        switch (endCaps){
            case 0:
                penCapStyle = Qt::FlatCap;
                break;
            case 1:
                penCapStyle = Qt::RoundCap;
                break;
            case 2:
                penCapStyle = Qt::MPenCapStyle;
                break;
            case 3:
                penCapStyle = Qt::SquareCap;
                break;
            default:
                penCapStyle = Qt::FlatCap; // fixme - or round?
        }
        //0=none; 1= round; 2 = angle; 3 = flat
        int joinStyle = graphic->getGraphicVariableInt("$JOINSTYLE", 1);

        switch (joinStyle){
            case 0:
                penJoinStyle = Qt::BevelJoin;
                break;
            case 1:
                penJoinStyle = Qt::RoundJoin;
                break;
            case 2:
                penJoinStyle = Qt::MiterJoin;
                break;
            case 3:
                penJoinStyle = Qt::BevelJoin;
                break;
            default:
                penJoinStyle = Qt::RoundJoin;
        }
    }

    if (HIDE_SELECT_CURSOR) {
        // potentially, select cursor may be also hidden and so snapper will be used instead of cursor.
        // however, this will require review and modifications of significant amount of actions, so
        // probably I'll return to this later. In such case, the code within this "if" will be handy for such support
        LC_GROUP("Appearance");
        {
            cursor_hiding = LC_GET_BOOL("cursor_hiding", false);

# Format:            LibreCAD Font 1
# Creator:           LibreCAD
# Version:           1.1
# Version:           2.2.2.6-alpha
# Name:              lc_opengost-ar
# Encoding:          UTF-8
# LetterSpacing:     1.92857
# WordSpacing:       3.85715
# LineSpacingFactor: 0.94286
# Created:           2014-10-02
# Last modified:     2014-12-03
# Last modified:     2025-09-13
# Author:            stranger573 <stranger573@mail.ru>
# License:           SIL OPEN FONT LICENSE Version 1.1

[fffd] �
1,0;0,2;1,4;2,2;1,0

[0021] !
0,8.67857;0,2.25
0,0.27143;0,0.37143

[0022] "
0.32143,8.67857;0,7.39286
1.60714,8.67857;1.28571,7.39285

[0035] 5
3.21428,8.67857;0,8.67857;0,4.82143;1.28571,4.82143;3.21429,2.89286,A-0.41333;3.21428,2.25;1.28571,0.32143,A-0.415;0,0.32143

[0036] 6
2.57142,8.67857;-0,4.5,A0.25451;0,2.05714;3.85714,2.05714,A1;3.85714,2.89286;1.92857,4.82143,A0.41333;0.02727,4.82143

[0037] 7
0,7.71429;0,8.67857;3.85815,8.67857;1.92857,0.32143
0,7.71429;0,8.67857;3.8,8.67857;1.92857,0.32143

[0038] 8
3.92143,6.62143;0.32143,6.62143,A-1;0.32143,7.07143;3.92143,7.07143,A-1;3.92143,6.62143
4.24286,2.25;0,2.25,A-1;0,2.7;4.24286,2.7,A-1;4.24286,2.25

[0039] 9
3.82884,4.17857;1.92857,4.17857;0,6.10714,A-0.41667;0,6.94286;3.85714,6.94286,A-1;3.85714,4.5;1.28571,0.32143,A-0.25272

[0071] q
3.21429,-2.25;3.21429,6.10714;1.28571,6.10714;0,4.82143,A0.415;0,1.60714;1.28571,0.32143,A0.415;3.21429,0.32143

[0072] r
2.57143,5.14286;1.60714,6.10714,A0.40667;0,6.10714;0,0.32143

[0073] s
3.08605,5.78571;0.74175,6.11515,A0.22001;0.40309,4.29213,A0.60873;2.72857,2.48419;2.2205,0.25996,A-0.63711;-0,0.64307,A-0.1935
3.08605,5.78571;0.74175,6.11515,A0.22001;0.40309,4.29213,A0.60873;2.72857,2.48419;2.2205,0.25996,A-0.63711;0,0.64307,A-0.1935

[0074] t
0,6.10714;1.92857,6.10714
0.64285,8.67857;0.64285,0.32143

[0075] u
0,6.10714;0,1.60714;1.28571,0.32143,A0.415;3.21428,0.32143;3.21428,6.10714

0.64286,8.67857;1.28572,8.03961;1.92857,8.67857

[015a] Ś
3.66448,8.35714;0.91938,8.73186,A0.21596;0.28961,6.68501,A0.53506;3.50134,2.74655;2.56751,0.19158,A-0.56893;-0,0.64298,A-0.18192
2.25011,10.60714;1.92869,9.96429

[015b] ś
3.08605,5.78571;0.74175,6.11515,A0.22001;0.40309,4.29213,A0.60873;2.72857,2.48419;2.2205,0.25996,A-0.63711;-0,0.64307,A-0.1935
3.08605,5.78571;0.74175,6.11515,A0.22001;0.40309,4.29213,A0.60873;2.72857,2.48419;2.2205,0.25996,A-0.63711;0,0.64307,A-0.1935
1.92876,8.67857;1.60734,8.03571

[0160] Š
3.66448,8.35714;0.91938,8.73186,A0.21596;0.28961,6.68501,A0.53506;3.50134,2.74655;2.56751,0.19158,A-0.56893;-0,0.64298,A-0.18192
1.28583,10.60714;1.92869,9.96818;2.57154,10.60714

[0161] š
3.08605,5.78571;0.74175,6.11515,A0.22001;0.40309,4.29213,A0.60873;2.72857,2.48419;2.2205,0.25996,A-0.63711;-0,0.64307,A-0.1935
3.08605,5.78571;0.74175,6.11515,A0.22001;0.40309,4.29213,A0.60873;2.72857,2.48419;2.2205,0.25996,A-0.63711;0,0.64307,A-0.1935
0.96449,8.67857;1.60735,8.03961;2.2502,8.67857

[0164] Ť
0,8.67857;3.85714,8.67857
1.92857,8.67857;1.92857,0.32143
1.28571,10.60714;1.92857,9.96818;2.57143,10.60714

0.96467,8.67857;1.60753,8.03961;2.25039,8.67857

[0218] Ș
3.66448,8.35714;0.91938,8.73186,A0.21596;0.28961,6.68501,A0.53506;3.50134,2.74655;2.56751,0.19158,A-0.56893;-0,0.64298,A-0.18192
1.92869,-0.96428;1.92869,-1.60714

[0219] ș
3.08605,5.78571;0.74175,6.11515,A0.22001;0.40309,4.29213,A0.60873;2.72857,2.48419;2.2205,0.25996,A-0.63711;-0,0.64307,A-0.1935
3.08605,5.78571;0.74175,6.11515,A0.22001;0.40309,4.29213,A0.60873;2.72857,2.48419;2.2205,0.25996,A-0.63711;0,0.64307,A-0.1935
1.60734,-0.96428;1.60734,-1.60714

[021a] Ț
0,8.67857;3.85714,8.67857
1.92857,8.67857;1.92857,0.32143
1.92857,-0.96428;1.92857,-1.60714

2.25,8.67857;2.25,0.32143
0,8.67857;0,5.14286;4.5,5.14286,A1;4.5,8.67857

[03a9] Ω
0.64286,0.32143;1.60714,0.32143;1.60714,1.93398;-0,3.53571,A-0.41555;0,6.62143;4.5,6.62143,A-1;4.5,3.53571;2.89286,1.93364,A-0.41432;2.89286,0.32143;3.85714,0.32143

[03b1] α
3.85714,6.10714;2.52965,1.14429;-0,1.47857,A-0.8756;0,4.95;2.52964,5.28429,A-0.8756;3.77035,0.64929;4.17857,0.32143,A0.38774
3.85714,6.10714;2.52965,1.14429;0,1.47857,A-0.8756;0,4.95;2.52964,5.28429,A-0.8756;3.77035,0.64929;4.17857,0.32143,A0.38774

[03b2] β
1.28571,0.32143;1.60714,0.32143;3.21429,1.92857,A0.412;3.21428,3.85714;1.52679,5.46429,A0.42546;2.89286,6.91071,A0.39856;2.89286,7.36071;0,7.36071,A1;0,-2.25
1.28571,5.46429;1.52679,5.46429

[03b3] γ
0,6.10714;1.03231,5.49095,A-0.27576;2.25,0.32143,A-0.1157;2.25681,-0.3383;2.1501,-2.05288,A-0.03109;1.70312,-2.04951,A-0.88954;1.60955,-0.3383,A-0.02732;1.60714,0.32143;3.21107,6.10071,A-0.15441

0,6.10714;2.57143,6.10714;3.53571,6.42857,A0.169
1.60714,6.10714;1.60714,0.96429;2.25,0.32143,A0.42;2.57143,0.32143

[03c5] υ
0,6.12;0.3825,5.72142,A-0.38513;0.3825,1.15714;1.56374,0.21918,A0.48257;2.55214,0.95464,A0.20391;2.95393,6.10393,A0.19823

[03c6] φ
0.64285,6.10714;-0,2.44286,A0.08705;4.5,2.44286,A1;4.02783,5.59603,A0.07446;2.25,5.32981,A0.86141;2.25,-2.25
0.64285,6.10714;0,2.44286,A0.08705;4.5,2.44286,A1;4.02783,5.59603,A0.07446;2.25,5.32981,A0.86141;2.25,-2.25

[03c7] χ
3.53572,6.10715;0.32143,-2.25
0,6.10714;0.6075,5.67964,A-0.32241;3.24964,-1.8225;3.85714,-2.25,A0.32241

[03c8] ψ
2.25,7.39286;2.25,-2.25

[0416] Ж
2.57143,8.67857;2.57143,0.32143
0,8.67857;2.22857,4.77857;0,0.32143
5.14285,8.67857;2.91429,4.77857;5.14286,0.32143
2.22857,4.77857;2.91429,4.77857

[0417] З
0.33672,8.33049;1.59578,8.87143,A-0.20573;1.91721,8.87143;3.65292,7.13571,A-0.41421;3.65292,6.55714;1.91721,4.82143,A-0.41421;3.84578,2.89286,A-0.41421;3.84578,2.05714;1.91721,0.12857,A-0.41421;1.59578,0.12857;-0,0.97415,A-0.24857
0.33672,8.33049;1.59578,8.87143,A-0.20573;1.91721,8.87143;3.65292,7.13571,A-0.41421;3.65292,6.55714;1.91721,4.82143,A-0.41421;3.84578,2.89286,A-0.41421;3.84578,2.05714;1.91721,0.12857,A-0.41421;1.59578,0.12857;0,0.97415,A-0.24857
1.27435,4.82143;1.91721,4.82143

[0418] И
0,8.67857;0,0.32589;3.85714,8.67411;3.85714,0.32143

[0419] Й
1.28571,9.96429;2.57143,9.96429

2.25096,7.71429;2.25096,5.14286
1.28667,10.92857;0,6.42857;3.21524,6.42857

[2075] ⁵
2.57143,10.92857;0,10.92857;0,8.35714;1.28571,8.35714;2.57143,7.07143,A-0.415;2.57143,6.42857;1.28571,5.14286,A-0.415;0,5.14286

[2076] ⁶
1.92214,10.92857;0,8.03571,A0.32203;0,6.42857;2.57143,6.42857,A1;2.57143,7.07143;1.28571,8.35714,A0.415;0.0056,8.35714
1.92214,10.92857;-0,8.03571,A0.32203;0,6.42857;2.57143,6.42857,A1;2.57143,7.07143;1.28571,8.35714,A0.415;0.0056,8.35714

[2077] ⁷
0,10.28571;0,10.92857;2.56976,10.92857;0.96429,5.14286

[2078] ⁸
2.57143,9.64286;0,9.64286,A-1;2.57143,9.64286,A-1
2.57143,7.07143;2.57143,6.42857;0,6.42857,A-1;0,7.07143;2.57143,7.07143,A-1

[2081] ₁
0,2.57143;1.28571,3.85306;1.28571,-1.92857

[2082] ₂
0.00702,3.22393;2.19274,3.48108,A-0.45417;2.37273,1.89321,A-0.35006;0,-1.92857;2.56881,-1.92857

[2083] ₃
0,3.85714;1.28571,3.85714;1.28573,1.28571,A-1.00001;2.57143,0,A-0.41409;2.57143,-0.64286;1.28571,-1.92857,A-0.415;0,-1.92857
0,3.85714;1.28571,3.85714;1.28573,1.28571,A-1.00001;2.57143,-0,A-0.41409;2.57143,-0.64286;1.28571,-1.92857,A-0.415;0,-1.92857
0.64286,1.28571;1.28573,1.28571

[2084] ₄
2.25096,0.64286;2.25096,-1.92857
1.28667,3.85714;0,-0.64286;3.21524,-0.64286

[2085] ₅

13.49585,11.24916;0,-2.25;13.49346,-2.25;26.99585,11.24916

[e05e] 
0,0.32143;17.35714,0.32143,A-0.96296

[e05f] 
0,0.32143;17.36598,0.32143,A-0.96247;0,0.32143

[fffd] �
1,0;0,2;1,4;2,2;1,0

999
dxflib 2.0.1.3
dxfrw 0.6.3
  0
SECTION
  2
HEADER
  9
$ACADVER
  1
AC1015
AC1021
  9
$DWGCODEPAGE
  3
ANSI_1252
  9
$INSBASE
 10
0
 20
0
 30
0
  9
$EXTMIN
 10
0
 20
0
 30
0
  9
$EXTMAX
 10
100
 20
100
 30
0
  9
$LIMMIN
 10
0
 20
0
  9
$LIMMAX
 10
420
 20
297
  9
$ORTHOMODE
 70
    0
  9
$REGENMODE
 70
    1
  9
$FILLMODE
 70
    1
  9
$QTEXTMODE
 70
    0
  9
$MIRRTEXT
 70
    0
  9
$LTSCALE
 40
1
  9
$ATTMODE
 70
    0
  9
$TEXTSIZE
 40
2.5
  9
$TRACEWID
 40
15.68
  9
$TEXTSTYLE
  7
$HANDSEED
  5
STANDARD
  9
$CLAYER
  8
0
  9
$CELTYPE
  6
BYLAYER
  9
$CECOLOR
 62
  256
FFFF
  9
$CELTSCALE
 40
1
  9
$DISPSILH
 70
    0
  9
$DIMSCALE
 40
2.5
  9
$DIMASZ
 40
2.5
  9
$DIMGAP
 40
0.625
  9
$DIMEXO
 40
0.625
  9
$INSUNITS
 70
4
$DIMDLI
 40
3.75
  9
$DIMRND
 40
0
  9
$DIMDLE
 40
0
  9
$DIMEXE
 40
1.25
  9
$DIMTP
 40
0
  9
$DIMTM
 40
0
  9
$DIMTXT
 40
2.5
  9
$DIMCEN
 40
2.5
  9
$DIMTSZ
 40
0
  9
$DIMTOL
 70
    0
  9
$DIMLIM
 70
    0
  9
$DIMTIH
 70
    0
  9
$DIMTOH
 70
    0
  9
$DIMSE1
 70
    0
  9
$DIMSE2
 70
    0
  9
$DIMTAD
 70
    1
  9
$DIMZIN
 70
    8
  9
$DIMBLK
  1

  9
$DIMASO
 70
    1
  9
$DIMSHO
 70
    1
  9
$DIMPOST
  1

  9
$DIMAPOST
  1

  9
$DIMALT
 70
    0
  9
$DIMALTD
 70
    3
  9
$DIMALTF
 40
0.03937
  9
$DIMLFAC
 40
1
  9
$DIMTOFL
 70
    1
  9
$DIMTVP
 40
0
  9
$DIMTIX
 70
    0
  9
$DIMSOXD
 70
    0
  9
$DIMSAH
 70
    0
  9
$DIMBLK1
  1

  9
$DIMBLK2
  1

  9
$DIMSTYLE
  2
Standard
  9
$DIMCLRD
 70
    0
  9
$DIMCLRE
 70
    0
  9
$DIMCLRT
 70
    0
  9
$DIMTFAC
 40
1
  9
$DIMGAP
 40
0.625
  9
$DIMJUST
 70
    0
  9
$DIMSD1
 70
    0
  9
$DIMSD2
 70
    0
  9
$DIMTOLJ
 70
    0
  9
$DIMTZIN
 70
    8
  9
$DIMALTZ
 70
    0
  9
$DIMALTTZ
 70
    0
  9
$DIMUPT
 70
    0
  9
$DIMDEC
 70
    4
  9
$DIMTDEC
 70
    2
  9
$DIMALTU
 70
    2
  9
$DIMALTTD
 70
    3
  9
$DIMTXSTY
  7
STANDARD
  9
$DIMAUNIT
 70
    0
  9
$DIMADEC
 70
    0
  9
$DIMALTRND
 40
0
  9
$DIMAZIN
 70
    0
  9
$DIMDSEP
 70
   44
  9
$DIMATFIT
 70
    3
  9
$DIMFRAC
 70
    0
  9
$DIMLDRBLK
  1
STANDARD
  9
$DIMLUNIT
 70
    2
  9
$DIMLWD
 70
   -2
  9
$DIMLWE
 70
   -2
  9
$DIMTMOVE
 70
    0
  9
$DIMFXL
 40
1
  9
$DIMFXLON
 70
    0
  9
$DIMJOGANG
 40
0.7854
  9
$DIMTFILL
 70
    0
  9
$DIMTFILLCLR
 70
    0
  9
$DIMARCSYM
 70
    0
  9
$DIMLTYPE
  6

  9
$DIMLTEX1
  6

  9
$DIMLTEX2
  6

  9
$LUNITS
 70
    2
  9
$LUPREC
 70
    4
  9
$SKETCHINC
 40
1
  9
$FILLETRAD
 40
0
  9
$AUNITS
 70
    0
  9
$AUPREC
 70
    2
  9
$MENU
  1
.
  9
$ELEVATION
 40
0
  9
$PELEVATION
 40
0
  9
$THICKNESS
 40
0
  9
$LIMCHECK
 70
    0
  9
$CHAMFERA
 40
0
  9
$CHAMFERB
 40
0
  9
$CHAMFERC
 40
0
  9
$CHAMFERD
 40
0
  9
$SKPOLY
 70
    0
  9
$USRTIMER
 70
    1
  9
$ANGBASE
 50
0
  9
$ANGDIR
 70
    0
  9
$PDMODE
 70
   96
  9
$PDSIZE
 40
-2
  9
$PLINEWID
 40
0
  9
$SPLFRAME
 70
    0
  9
$SPLINETYPE
 70
    2
  9
$SPLINESEGS
 70
    8
  9
$HANDSEED
  5
20000
  9
$SURFTAB1
 70
    6
  9
$SURFTAB2
 70
    6
  9
$SURFTYPE
 70
    6
  9
$SURFU
 70
    6
  9
$SURFV
 70
    6
  9
$UCSBASE
  2

  9
$UCSNAME
  2

  9
$UCSORG
 10
0
 20
0
 30
0
  9
$UCSXDIR
 10
1
 20
0
 30
0
  9
$UCSYDIR
 10
0
 20
1
 30
0
  9
$UCSORTHOREF
  2

  9
$UCSORTHOVIEW
 70
    0
  9
$UCSORGTOP
 10
0
 20
0
 30
0
  9
$UCSORGBOTTOM
 10
0
 20
0
 30
0
  9
$UCSORGLEFT
 10
0
 20
0
 30
0
  9
$UCSORGRIGHT
 10
0
 20
0
 30
0
  9
$UCSORGFRONT
 10
0
 20
0
 30
0
  9
$UCSORGBACK
 10
0
 20
0
 30
0
  9
$PUCSBASE
  2

  9
$PUCSNAME
  2

  9
$PUCSORG
 10
0
 20
0
 30
0
  9
$PUCSXDIR
 10
1
 20
0
 30
0
  9
$PUCSYDIR
 10
0
 20
1
 30
0
  9
$PUCSORTHOREF
  2

  9
$PUCSORTHOVIEW
 70
    0
  9
$PUCSORGTOP
 10
0
 20
0
 30
0
  9
$PUCSORGBOTTOM
 10
0
 20
0
 30
0
  9
$PUCSORGLEFT
 10
0
 20
0
 30
0
  9
$PUCSORGRIGHT
 10
0
 20
0
 30
0
  9
$PUCSORGFRONT
 10
0
 20
0
 30
0
  9
$PUCSORGBACK
 10
0
 20
0
 30
0
  9
$USERI1
 70
    0
  9
$USERI2
 70
    0
  9
$USERI3
 70
    0
  9
$USERI4
 70
    0
  9
$USERI5
 70
    0
  9
$USERR1
 40
0
  9
$USERR2
 40
0
  9
$USERR3
 40
0
  9
$USERR4
 40
0
  9
$USERR5
 40
0
  9
$WORLDVIEW
 70
    1
  9
$SHADEDGE
 70
    3
  9
$SHADEDIF
 70
   70
  9
$TILEMODE
 70
    1
  9
$MAXACTVP
 70
   64
  9
$PINSBASE
 10
0
 20
0
 30
0
  9
$PLIMMAX
$PLIMCHECK
 70
    0
  9
$PEXTMIN
 10
0
 20
0
 30
0
  9
$PEXTMAX
 10
210.0
0
 20
297.0
0
 30
0.0
0
  9
$GRIDMODE
 70
    1
  9
$SNAPSTYLE
 70
    0
  9
$PLIMMIN
 10
0
 20
0
  9
$PLIMMAX
 10
210
 20
297
  9
$UNITMODE
 70
    0
  9
$VISRETAIN
 70
    1
  9
$PLINEGEN
 70
    0
  9
$PSLTSCALE
 70
    1
  9
$TREEDEPTH
 70
0.0
 20
0.0
 30
0.0
 3020
  9
$CMLSTYLE
  2
Standard
  9
$CMLJUST
 70
    0
  9
$CMLSCALE
 40
20
  9
$PROXYGRAPHICS
 70
    1
  9
$MEASUREMENT
 70
    1
  9
$CELWEIGHT
370
   -1
  9
$ENDCAPS
280
    1
  9
$JOINSTYLE
280
    1
  9
$LWDISPLAY
290
    0
  9
$INSUNITS
 70
    4
  9
$HYPERLINKBASE
  1

  9
$STYLESHEET
  1

  9
$XEDIT
290
    1
  9
$CEPSNTYPE
380
    0
  9
$PSTYLEMODE
290
    1
  9
$EXTNAMES
290
    1
  9
$PSVPSCALE
 40
1
  9
$OLESTARTUP
290
    0
  9
$SORTENTS
280
  127
  9
$INDEXCTL
280
    0
  9
$HIDETEXT
280
    1
  9
$XCLIPFRAME
290
    0
  9
$HALOGAP
280
    0
  9
$OBSCOLOR
 70
  257
  9
$OBSLTYPE
280
    0
  9
$INTERSECTIONDISPLAY
280
    0
  9
$INTERSECTIONCOLOR
 70
  257
  9
$DIMASSOC
280
    1
  9
$PROJECTNAME
  1

  9
$CAMERADISPLAY
290
    0
  9
$LENSLENGTH
 40
50
  9
$CAMERAHEIGHT
 40
0
  9
$STEPSPERSEC
 40
2
  9
$STEPSIZE
 40
50
  9
$3DDWFPREC
 40
2
  9
$PSOLWIDTH
 40
5
  9
$PSOLHEIGHT
 40
80
  9
$LOFTANG1
 40
1.570796326794897
  9
$LOFTANG2
 40
1.570796326794897
  9
$LOFTMAG1
 40
0
  9
$LOFTMAG2
 40
0
  9
$LOFTPARAM
 70
    7
  9
$LOFTNORMALS
280
    1
  9
$LATITUDE
 40
1
  9
$LONGITUDE
 40
1
  9
$DIMEXE
$NORTHDIRECTION
 40
0
  9
$TIMEZONE
 70
-8000
  9
$LIGHTGLYPHDISPLAY
1.25
280
    1
  9
$TILEMODELIGHTSYNCH
280
    1
  9
$SOLIDHIST
280
    1
  9
$SHOWHIST
280
    1
  9
$DWFFRAME
280
    2
  9
$DGNFRAME
280
    0
  9
$REALWORLDSCALE
290
    1
  9
$INTERFERECOLOR
 62
    1
  9
$CSHADOW
280
    0
  9
$SHADOWPLANELOCATION
 40
0
  0
ENDSEC
  0
SECTION
  2
CLASSES
  0
ENDSEC
  0
SECTION
  2
TABLES
  0
TABLE
  2
VPORT
  5
8
330
0
100
AcDbSymbolTable
 70
1
    1
  0
VPORT
  5
30
31
330
2
100
AcDbSymbolTableRecord
100
AcDbViewportTableRecord
  2
*Active
*ACTIVE
 70
0
    0
 10
0.0
0
 20
0.0
0
 11
1.0
1
 21
1.0
1
 12
286.3055555555554861
140.688488958444
 22
148.5
93.0455717846185
 13
0.0
0
 23
0.0
0
 14
10.0
10
 24
10.0
10
 15
10.0
10
 25
10.0
10
 16
0.0
0
 26
0.0
0
 36
1.0
1
 17
0.0
0
 27
0.0
0
 37
0.0
0
 40
297.0
276.0003477656099
 41
1.92798353909465
1.54978354978355
 42
50.0
50
 43
0.0
0
 44
0.0
0
 50
0.0
0
 51
0.0
0
 71
0
    0
 72
100
  100
 73
1
    1
 74
3
    3
 75
1
    0
 76
1
    1
 77
0
    0
 78
0
    0
281
0
    0
 65
1
    1
110
0.0
0
120
0.0
0
130
0.0
0
111
1.0
1
121
0.0
0
131
0.0
0
112
0.0
0
122
1.0
1
132
0.0
0
 79
0
    0
146
0
348
0.0
10020
 60
    7
 61
    5
292
1
282
    1
141
0
142
0
 63
  250
421
3358443
  0
ENDTAB
  0
TABLE
  2
LTYPE
  5
5
330
0
100
AcDbSymbolTable
 70
3
    4
  0
LTYPE
  5
14
330
5
100
AcDbSymbolTableRecord
100
AcDbLinetypeTableRecord
  2
ByBlock
 70
0
    0
  3

 72
65
   65
 73
0
    0
 40
0.0
0
  0
LTYPE
  5
15
330
5
100
AcDbSymbolTableRecord
100
AcDbLinetypeTableRecord
  2
ByLayer
 70
0
    0
  3

 72
65
   65
 73
0
    0
 40
0.0
0
  0
LTYPE
  5
16
330
5
100
AcDbSymbolTableRecord
100
AcDbLinetypeTableRecord
  2
CONTINUOUS
Continuous
 70
0
    0
  3
Solid line
 72
65
   65
 73
0
    0
 40
0.0
0
  0
LTYPE
  5
31
32
330
5
100
AcDbSymbolTableRecord
100
AcDbLinetypeTableRecord
  2
DOT
 70
0
  0
    0
  3
Dot . . . . . . . . . . . . . . . . . . . . . .
 72
   65
 73
    2
 40
6.35
 49
0
 74
    0
 49
-6.35
 74
    0
  0
LTYPE
  5
32
33
330
5
100
AcDbSymbolTableRecord
100
AcDbLinetypeTableRecord
  2
DOTTINY
 70
    0
  3
Dot (.15x) .....................................
 72
   65
 73
    2
 40
0.9525
 49
0
 74
    0
 49
-0.9525
 74
    0
  0
LTYPE
  5
34
330
5
100
AcDbSymbolTableRecord
100
AcDbLinetypeTableRecord
  2
DOT2
 70
0
    0
  3
Dot (.5x) .....................................
 72
   65
 73
    2
 40
3.175
 49
0
 74
    0
 49
-3.175
 74
    0
  0
LTYPE
  5
35
33
330
5
100
AcDbSymbolTableRecord
100
AcDbLinetypeTableRecord
  2
DOTX2
 70
0
    0
  3
Dot (2x) .  .  .  .  .  .  .  .  .  .  .  .  .
 72
   65
 73
    2
 40
12.7
 49
0
 74
    0
 49
-12.7
 74
    0
  0
LTYPE
  5
34
36
330
5
100
AcDbSymbolTableRecord
100
AcDbLinetypeTableRecord
  2
DASHED
 70
0
  0
    0
  3
Dashed _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
 72
   65
 73
    2
 40
19.05
 49
12.7
 74
    0
 49
-6.35
 74
    0
  0
LTYPE
  5
35
37
330
5
100
AcDbSymbolTableRecord
100
AcDbLinetypeTableRecord
  2
DASHEDTINY
 70
    0
  3
Dashed (.15x) _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
 72
   65
 73
    2
 40
2.8575
 49
1.905
 74
    0
 49
-0.9525
 74
    0
  0
LTYPE
  5
38
330
5
100
AcDbSymbolTableRecord
100
AcDbLinetypeTableRecord
  2
DASHED2
 70
0
    0
  3
Dashed (.5x) _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
 72
   65
 73
    2
 40
9.524999999999999
 49
6.35
 74
    0
 49
-3.175
 74
    0
  0
LTYPE
  5
36
39
330
5
100
AcDbSymbolTableRecord
100
AcDbLinetypeTableRecord
  2
DASHEDX2
 70
0
    0
  3
Dashed (2x) ____  ____  ____  ____  ____  ___
 72
   65
 73
    2
 40
38.09999999999999
 49
25.4
 74
    0
 49
-12.7
 74
    0
  0
LTYPE
  5
37
3A
330
5
100
AcDbSymbolTableRecord
100
AcDbLinetypeTableRecord
  2
DASHDOT
 70
0
    0
  3
Dash dot __ . __ . __ . __ . __ . __ . __ . __
 72
   65
 73
    4
 40
25.4
 49
12.7
 74
    0
 49
-6.35
 74
    0
 49
0
 74
    0
 49
-6.35
 74
    0
  0
LTYPE
  5
3B
330
5
100
AcDbSymbolTableRecord
100
AcDbLinetypeTableRecord
  2
DASHDOTTINY
 70
    0
  3
Dash dot (.15x) _._._._._._._._._._._._._._._.
 72
   65
 73
    4
 40
3.81
 49
1.905
 74
    0
 49
-0.9525
 74
    0
 49
0
 74
    0
 49
-0.9525
 74
    0
  0
LTYPE
  5
38
3C
330
5
100
AcDbSymbolTableRecord
100
AcDbLinetypeTableRecord
  2
DASHDOT2
 70
0
    0
  3
Dash dot (.5x) _._._._._._._._._._._._._._._.
 72
   65
 73
    4
 40
12.7
 49
6.35
 74
    0
 49
-3.175
 74
    0
 49
0
 74
    0
 49
-3.175
 74
    0
  0
LTYPE
  5
39
3D
330
5
100
AcDbSymbolTableRecord
100
AcDbLinetypeTableRecord
  2
DASHDOTX2
 70
0
    0
  3
Dash dot (2x) ____  .  ____  .  ____  .  ___
 72
   65
 73
    4
 40
50.8
 49
25.4
 74
    0
 49
-12.7
 74
    0
 49
0
 74
    0
 49
-12.7
 74
    0
  0
LTYPE
  5
3A
3E
330
5
100
AcDbSymbolTableRecord
100
AcDbLinetypeTableRecord
  2
DIVIDE
 70
0
    0
  3
Divide ____ . . ____ . . ____ . . ____ . . ____
 72
   65
 73
    6
 40
31.75
 49
12.7
 74
    0
 49
-6.35
 74
    0
 49
0
 74
    0
 49
-6.35
 74
    0
 49
0
 74
    0
 49
-6.35
 74
    0
  0
LTYPE
  5
3F
330
5
100
AcDbSymbolTableRecord
100
AcDbLinetypeTableRecord
  2
DIVIDETINY
 70
    0
  3
Divide (.15x) __..__..__..__..__..__..__..__.._
 72
   65
 73
    6
 40
4.7625
 49
1.905
 74
    0
 49
-0.9525
 74
    0
 49
0
 74
    0
 49
-0.9525
 74
    0
 49
0
 74
    0
 49
-0.9525
 74
    0
  0
LTYPE
  5
40
3B
330
5
100
AcDbSymbolTableRecord
100
AcDbLinetypeTableRecord
  2
DIVIDE2
 70
0
    0
  3
Divide (.5x) __..__..__..__..__..__..__..__.._
 72
   65
 73
    6
 40
15.875
 49
6.35
 74
    0
 49
-3.175
 74
    0
 49
0
 74
    0
 49
-3.175
 74
    0
 49
0
 74
    0
 49
-3.175
 74
    0
  0
LTYPE
  5
41
3C
330
5
100
AcDbSymbolTableRecord
100
AcDbLinetypeTableRecord
  2
DIVIDEX2
 70
0
  0
    0
  3
Divide (2x) ________  .  .  ________  .  .  _
 72
   65
 73
    6
 40
63.5
 49
25.4
 74
    0
LTYPE
  5
3D
100
AcDbSymbolTableRecord
100
AcDbLinetypeTableRecord
  2
 49
-12.7
CENTER
 70
0
  0
 74
    0
 49
0
LTYPE
  5
3E
100
AcDbSymbolTableRecord
100
AcDbLinetypeTableRecord
  2
 74
    0
 49
-12.7
CENTER2
 70
0
  0
 74
    0
 49
0
LTYPE
  5
3F
100
AcDbSymbolTableRecord
100
AcDbLinetypeTableRecord
  2
 74
    0
 49
-12.7
CENTERX2
 70
0
 74
    0
  0
LTYPE
  5
40
42
330
5
100
AcDbSymbolTableRecord
100
AcDbLinetypeTableRecord
  2
BORDER
 70
0
    0
  3
Border __ __ . __ __ . __ __ . __ __ . __ __ .
 72
   65
 73
    6
 40
44.45
 49
12.7
 74
    0
 49
-6.35
 74
    0
 49
12.7
 74
    0
 49
-6.35
 74
    0
 49
0
 74
    0
 49
-6.35
 74
    0
  0
LTYPE
  5
43
330
5
100
AcDbSymbolTableRecord
100
AcDbLinetypeTableRecord
  2
BORDERTINY
 70
    0
  3
Border (.15x) __.__.__.__.__.__.__.__.__.__.__.
 72
   65
 73
    6
 40
6.6675
 49
1.905
 74
    0
 49
-0.9525
 74
    0
 49
1.905
 74
    0
 49
-0.9525
 74
    0
 49
0
 74
    0
 49
-0.9525
 74
    0
  0
LTYPE
  5
41
44
330
5
100
AcDbSymbolTableRecord
100
AcDbLinetypeTableRecord
  2
BORDER2
 70
0
    0
  3
Border (.5x) __.__.__.__.__.__.__.__.__.__.__.
 72
   65
 73
    6
 40
22.225
 49
6.35
 74
    0
 49
-3.175
 74
    0
 49
6.35
 74
    0
 49
-3.175
 74
    0
 49
0
 74
    0
 49
-3.175
 74
    0
  0
LTYPE
  5
42
45
330
5
100
AcDbSymbolTableRecord
100
AcDbLinetypeTableRecord
  2
BORDERX2
 70
0
    0
  3
Border (2x) ____  ____  .  ____  ____  .  ___
 72
   65
 73
    6
 40
88.89999999999999
 49
25.4
 74
    0
 49
-12.7
 74
    0
 49
25.4
 74
    0
 49
-12.7
 74
    0
 49
0
 74
    0
 49
-12.7
 74
    0
  0
LTYPE
  5
46
330
5
100
AcDbSymbolTableRecord
100
AcDbLinetypeTableRecord
  2
CENTER
 70
    0
  3
Center ____ _ ____ _ ____ _ ____ _ ____ _ ____
 72
   65
 73
    4
 40
50.8
 49
31.75
 74
    0
 49
-6.35
 74
    0
 49
6.35
 74
    0
 49
-6.35
 74
    0
  0
LTYPE
  5
47
330
5
100
AcDbSymbolTableRecord
100
AcDbLinetypeTableRecord
  2
CENTERTINY
 70
    0
  3
Center (.15x) ___ _ ___ _ ___ _ ___ _ ___ _ ___
 72
   65
 73
    4
 40
7.619999999999999
 49
4.7625
 74
    0
 49
-0.9525
 74
    0
 49
0.9525
 74
    0
 49
-0.9525
 74
    0
  0
LTYPE
  5
48
330
5
100
AcDbSymbolTableRecord
100
AcDbLinetypeTableRecord
  2
CENTER2
 70
    0
  3
Center (.5x) ___ _ ___ _ ___ _ ___ _ ___ _ ___
 72
   65
 73
    4
 40
28.575
 49
19.05
 74
    0
 49
-3.175
 74
    0
 49
3.175
 74
    0
 49
-3.175
 74
    0
  0
LTYPE
  5
49
330
5
100
AcDbSymbolTableRecord
100
AcDbLinetypeTableRecord
  2
CENTERX2
 70
    0
  3
Center (2x) ________  __  ________  __  _____
 72
   65
 73
    4
 40
101.6
 49
63.5
 74
    0
 49
-12.7
 74
    0
 49
12.7
 74
    0
 49
-12.7
 74
    0
  0
ENDTAB
  0
TABLE
  2
LAYER
  5
2
330
0
100
AcDbSymbolTable
 70
1
    1
  0
LAYER
  5
10
330
2
100
AcDbSymbolTableRecord
100
AcDbLayerTableRecord
  2
0
 70
0
    0
 62
7
    7
  6
CONTINUOUS
370
0
    0
390
F
  0
ENDTAB
  0
TABLE
  2
STYLE
  5
3
330
0
100
AcDbSymbolTable
 70
1
    3
  0
STYLE
  5
11
4A
330
2
100
AcDbSymbolTableRecord
100
AcDbTextStyleTableRecord
  2
Standard
 70
0
    0
 40
0.0
0
 41
1.0
1
 50
0.0
0
 71
0
    0
 42
2.5
1
  3
txt
  4

  0
ENDTAB
  0
TABLE
  2
VIEW
  5
6
330
0
100
AcDbSymbolTable
 70
0
    0
  0
ENDTAB
  0
TABLE
  2
UCS
  5
7
330
0
100
AcDbSymbolTable
 70
0
    0
  0
ENDTAB
  0
TABLE
  2
APPID
  5
9
330
0
100
AcDbSymbolTable
 70
1
    1
  0
APPID
  5
12
330
9
100
AcDbSymbolTableRecord
100
AcDbRegAppTableRecord
  2
ACAD
 70
0
    0
  0
APPID
  5
4B
330
9
100
AcDbSymbolTableRecord
100
AcDbRegAppTableRecord
  2
LibreCad
 70
    0
  0
ENDTAB
  0
TABLE
  2
DIMSTYLE
  5
A
330
0
100
AcDbSymbolTable
 70
1
    1
100
AcDbDimStyleTable
 71
0
    1
  0
DIMSTYLE
105
27
4C
330
A
100
AcDbSymbolTableRecord
100
AcDbDimStyleTableRecord
  2
Standard
 70
0
  0
    0
 40
1
 41
2.5
 42
0.625
 43
0.38
 44
1.25
 45
0
 46
0
 47
0
 48
0
 49
1
140
2.5
141
0.09
142
2.5
143
25.4
144
1
145
0
146
1
147
0.625
148
0
 71
    0
 72
    0
 73
    0
 74
    1
 75
    0
 76
    0
 77
    0
 78
    1
 79
    0
170
    0
171
    2
172
    0
173
    0
174
    0
175
    0
176
    0
177
    0
178
    0
179
    0
271
    4
272
    4
273
    2
274
    2
275
    0
276
    0
277
    2
278
    0
279
    0
280
    0
281
    0
282
    0
283
    1
284
    0
285
    0
286
    0
288
    0
289
    3
340
4A
  0
ENDTAB
  0
TABLE
  2
BLOCK_RECORD
  5
1
330
0
100
AcDbSymbolTable
 70
1
    2
  0
BLOCK_RECORD
  5
1F
330
1
100
AcDbSymbolTableRecord
100
AcDbBlockTableRecord
  2
*Model_Space
340
22
 70
    0
280
    1
281
    0
  0
BLOCK_RECORD
  5
1B
1E
330
1
100
AcDbSymbolTableRecord
100
AcDbBlockTableRecord
  2
*Paper_Space
340
1E
  0
 70
    0
BLOCK_RECORD
  5
23
280
100
AcDbSymbolTableRecord
100
AcDbBlockTableRecord
  2
    1
281
*Paper_Space0
340
26
    0
  0
ENDTAB
  0
ENDSEC
  0
SECTION
  2
BLOCKS
  0
BLOCK
  5
20
330
1F
100
AcDbEntity
  8
0
100
AcDbBlockBegin
  2
*Model_Space
 70
0
    0
 10
0.0
0
 20
0.0
0
 30
0.0
0
  3
*Model_Space
  1

  0
ENDBLK
  5
21
330
1F
100
AcDbEntity
  8
0
100
AcDbBlockEnd
  0
BLOCK
  5
1C
330
1B
100
AcDbEntity
 67
1
  8
0
100
AcDbBlockBegin
  2
*Paper_Space
 70
0
    0
 10
0.0
0
 20
0.0
0
 30
0.0
0
  3
*Paper_Space
  1

  0
ENDBLK
  5
1D
100
AcDbEntity
 67
1
  8
0
100
AcDbBlockEnd
  0
BLOCK
  5
24
100
AcDbEntity
  8
0
100
AcDbBlockBegin
  2
*Paper_Space0
 70
0
 10
0.0
 20
0.0
 30
330
0.0
  3
*Paper_Space0
  1
1F

  0
ENDBLK
  5
25
100
AcDbEntity
  8
0
100
AcDbBlockEnd
  0
ENDSEC
  0
SECTION
  2
ENTITIES
  0
LINE
  5
43
4D
100
AcDbEntity
100
AcDbLine
  8
0
  6
ByLayer
 62
256
  256
370
-1
   -3
  6
ByLayer
100
AcDbLine
 10
0.0
0
 20
0.0
 30
0.0
0
 11
100.0
100
 21
100.0
100
 31
0.0
  0
LINE
  5
44
4E
100
AcDbEntity
100
AcDbLine
AcDbEntity
  8
0
  6
ByLayer
 62
256
  256
370
-1
   -3
  6
ByLayer
100
AcDbLine
 10
20.0
20
 20
0.0
 30
0.0
0
 11
100.0
100
 21
80.0
80
 31
0.0
  0
LINE
  5
45
4F
100
AcDbEntity
100
AcDbLine
  8
0
  6
ByLayer
 62
256
  256
370
-1
   -3
  6
ByLayer
100
AcDbLine
 10
40.0
40
 20
0.0
 30
0.0
0
 11
100.0
100
 21
60.0
60
 31
0.0
  0
LINE
  5
46
50
100
AcDbEntity
100
AcDbLine
  8
0
  6
ByLayer
 62
256
  256
370
-1
   -3
  6
ByLayer
100
AcDbLine
 10
60.0
60
 20
0.0
 30
0.0
0
 11
100.0
100
 21
40.0
40
 31
0.0
  0
LINE
  5
47
51
100
AcDbEntity
100
AcDbLine
  8
0
 62
256
370
-1
  6
ByLayer
 62
  256
370
   -3
100
AcDbLine
 10
80.0
80
 20
0.0
 30
0.0
0
 11
100.0
100
 21
20.0
20
 31
0.0
  0
LINE
  5
48
52
100
AcDbEntity
100
AcDbLine
  8
0
  6
ByLayer
 62
256
  256
370
-1
   -3
  6
ByLayer
100
AcDbLine
 10
0.0
0
 20
20.0
20
 30
0.0
 11
80.0
80
 21
100.0
100
 31
0.0
  0
LINE
  5
49
53
100
AcDbEntity
100
AcDbLine
  8
0
  6
ByLayer
 62
256
  256
370
-1
   -3
  6
ByLayer
 10
0.0
 20
40.0
 30
0.0
100
AcDbLine
 10
0
 20
40
 11
60.0
60
 21
100.0
100
 31
0.0
  0
LINE
  5
4A
54
100
AcDbEntity
100
AcDbLine
  8
0
  6
ByLayer
 62
256
  256
370
-1
   -3
  6
ByLayer
100
AcDbLine
 10
0.0
0
 20
60.0
60
 30
0.0
 11
40.0
40
 21
100.0
100
 31
0.0
  0
LINE
  5
4B
55
100
AcDbEntity
100
AcDbLine
  8
0
  6
ByLayer
 62
256
  256
370
-1
   -3
  6
ByLayer
100
AcDbLine
 10
0.0
0
 20
80.0
80
 30
0.0
 11
20.0
20
 21
100.0
100
 31
0.0
  0
ENDSEC
  0
SECTION
  2
OBJECTS
  0
DICTIONARY
  5
C
330
0
100
AcDbDictionary
280
0
281
1
    1
  3
ACAD_GROUP
350
D
  3
ACAD_LAYOUT
350
1A
  3
ACAD_MLINESTYLE
350
17
  3
ACAD_PLOTSETTINGS
350
19
  3
ACAD_PLOTSTYLENAME
350
E
  3
AcDbVariableDictionary
350
4C
  0
DICTIONARY
  5
D
100
AcDbDictionary
280
0
281
1
  0
ACDBDICTIONARYWDFLT
  5
E
100
AcDbDictionary
281
1
  3
330
Normal
350
F
100
AcDbDictionaryWithDefault
340
F
  0
ACDBPLACEHOLDER
  5
F
  0
DICTIONARY
  5
17
100
AcDbDictionary
280
0
281
1
  3
Standard
350
18
  0
MLINESTYLE
  5
18
100
AcDbMlineStyle
  2
STANDARD
 70
0
  3

C
 62
256
 51
90.0
 52
90.0
 71
2
 49
0.5
 62
256
  6
BYLAYER
 49
-0.5
 62
256
  6
BYLAYER
  0
DICTIONARY
  5
19
100
AcDbDictionary
280
0
281
1
  0
DICTIONARY
  5
1A
100
AcDbDictionary
281
1
  3
Layout1
350
1E
  3
Layout2
350
26
  3
Model
350
22
  0
LAYOUT
  5
1E
100
AcDbPlotSettings
  1

  2
AcDbDictionary
281
C:\Program Files\AutoCAD 2002\plotters\DWF ePlot (optimized for plotting).pc3
  4

  6

 40
0.0
 41
0.0
 42
0.0
 43
0.0
 44
0.0
 45
0.0
 46
0.0
 47
0.0
 48
0.0
 49
0.0
140
0.0
141
0.0
142
1.0
143
1.0
 70
688
 72
0
 73
0
 74
5
  7

 75
16
147
1.0
148
0.0
149
0.0
100
AcDbLayout
  1
Layout1
 70
1
 71
1
    1
 10
0.0
 20
0.0
 11
420.0
 21
297.0
 12
0.0
 22
0.0
 32
0.0
 14
100000000000000000000.0
 24
100000000000000000000.0
 34
100000000000000000000.0
 15
-100000000000000000000.0
 25
-100000000000000000000.0
 35
-100000000000000000000.0
146
0.0
 13
0.0
 23
0.0
 33
0.0
 16
1.0
 26
0.0
 36
0.0
 17
0.0
 27
1.0
 37
0.0
 76
0
  0
330
1B
  0
LAYOUT
PLOTSETTINGS
  5
22
56
100
AcDbPlotSettings
  1

  6
  2
C:\Program Files\AutoCAD 2002\plotters\DWF ePlot (optimized for plotting).pc3
  4

1x1
  6

 40
0.0
 41
0.0
 42
0.0
 43
0.0
 44
0.0
 45
0.0
 46
0.0
 47
0.0
 48
0.0
 49
0.0
140
0.0
141
0.0
142
1.0
143
1.0
 70
1712
 72
0
 73
0
 74
0
  7

 75
0
147
1.0
148
0.0
149
0.0
100
AcDbLayout
  1
Model
 70
1
 71
0
 10
0.0
 20
0.0
 11
12.0
 21
9.0
 12
0.0
 22
0.0
 32
0.0
 14
0.0
 24
0.0
 34
0.0
 15
0.0
 25
0.0
 35
0.0
146
0.0
 13
0.0
 23
0.0
 33
0.0
 16
1.0
 26
0.0
 36
0.0
 17
0.0
 27
1.0
 37
0.0
 76
0
330
1F
  0
LAYOUT
  5
26
100
AcDbPlotSettings
  1

  2
C:\Program Files\AutoCAD 2002\plotters\DWF ePlot (optimized for plotting).pc3
  4

 41
0
  6

 40
0.0
 41
0.0
 42
0.0
 43
0.0
 44
0.0
 45
0.0
 46
0.0
 47
0.0
 48
0.0
 49
0.0
140
0.0
141
0.0
142
 42
1.0
143
1.0
 70
688
 72
0
 73
0
 74
 43
5
  7

0
 75
16
147
1.0
148
0.0
149
0.0
100
AcDbLayout
  1
Layout2
 70
1
 71
2
 10
0.0
 20
0.0
 11
12.0
 21
9.0
 12
0.0
 22
0.0
 32
0.0
 14
0.0
 24
0.0
 34
0.0
 15
0.0
 25
0.0
 35
0.0
146
0.0
 13
0.0
 23
0.0
 33
0.0
 16
1.0
 26
0.0
 36
0.0
 17
0.0
 27
1.0
 37
0.0
 76
0
330
23
  0
DICTIONARY
  5
4C
100
AcDbDictionary
281
1
  3
DIMASSOC
350
4E
  3
HIDETEXT
350
4D
  0
DICTIONARYVAR
  5
4D
100
DictionaryVariables
280
0
  1
2
  0
DICTIONARYVAR
  5
4E
100
DictionaryVariables
280
0
  1
1
  0
ENDSEC
  0
EOF