CADTextWriteModifier.h

Go to the documentation of this file.

#pragma once
#include "CAD/Headers/DXFBlockWriter.h"
#if NDEVR_TEXT_MODEL
#include "CAD/Headers/CADWriteModifier.h"
#include "Design/Headers/Text.h"
namespace NDEVR
{
    class Model;
    struct CADGeometryWriter;
    class DXFTableWriteIterator;
    class DXFBlockWriter;
    class CADTextWriteModifier : public CADWriteModifier
    {
    public:
        static void WriteText(DXFWriter& writer, const Matrix<fltp08>& tr, const Text& text, uint04 handle, uint04 parent_handle)
        {
            
            TextData text_data;
            text_data.handle = handle;
            text_data.parent_handle = parent_handle;
            text_data.text = text.plainText();
            text_data.text.replace("\n", "\\P");
            if (text_data.text.size() == 0)
                return;
            FillOutData(text, text_data);
            text_data.color_info = GenerateDXFColorInfo(text, false, false);
            writer.cleanupCADName(text_data.layer);
 
            Model text_object = text.textObject();
            Bounds<3, fltp08> bounds = text_object.getBounds();
            if (isNaN(bounds))
                bounds = text_object.getSelectionBounds();
            Matrix<fltp08> text_sub_matrix = tr * text_object.getTransform();
            text_data.align_a = text_sub_matrix * bounds[MIN];
            text_data.align_b = text_sub_matrix * bounds.center();
 
            text_data.alignment = cast<uint01>(TextAlignment::e_center);
            Vector<3, fltp08> scale = text_sub_matrix.decomposeScale();
            text_data.height = scale[Y] * bounds.span()[Y];
            text_data.reference_width = scale[X] * bounds.span()[X];
 
            text_data.line_spacing_factor = text.lineSpaceFactor();
 
            Ray<3, fltp08> up(0.0, 0.0, 1.0);
            text_data.extrusion = (text_sub_matrix * up).normalized<fltp08>();
            auto rotation = (EntityConverter::GetOrientation(text_data.extrusion) * text_sub_matrix).decomposeRotation<fltp08>();
            text_data.rotatation = rotation[YAW];
            //text_data.extrusion = orientation.first;
            writer.addText(text_data);
        }
        bool canHandleBlock(const Model& model) final override
        {
            return model.isOfType(Text::TypeName());
        }
        ModelIterator::ParseResult handleBlock(const Model& model, DXFTableWriteIterator& options) final override
        {
            BlockData data = options.convertToBlock(model);
 
            data.handle = options.handle_manager->getHandleIndex(data.name);
            options.handle_manager->setHandleToUUID(model.uuid(), data.handle);
            options.writer.handleManager()->setTransfromCoords(data.handle
                , options.params.options.units.coordinate_space_unit.get()->matrix() * model.getCompleteTransform());
            //options.block_data.insert({ model.uuid(), data });
            return ModelIterator::ParseResult::e_do_not_parse_children;
        }
        ModelIterator::ParseResult handleBlock(const Model&, DXFBlockWriter&) final override
        {
            return ModelIterator::ParseResult::e_do_not_parse_children;
        }
 
        bool canHandleInsert(const Model& model) final override
        {
            return model.isOfType(Text::TypeName());
        }
        void handleInsert(const Matrix<fltp08>& parent_transform, const Model& model, uint04 parent_handle, DXFBlockWriter& options)  final override
        {
            Text text(model);
            WriteText(options.writer, parent_transform, text, options.writer.handleManager()->getHandleIndex(model.uuid()), parent_handle);
        }
        void handleInsert(const Matrix<fltp08>&, const Model&, uint04, CADGeometryWriter&) final override
        {
 
        }
    };
}
    #endif