rs_filterdxf.cpp

Linux下一个开源的CAD软件

/**
 * Implementation of the method which handles text 
 * chunks for MText entities.
 */
void RS_FilterDXF::addMTextChunk(const char* text) {
    RS_DEBUG->print("RS_FilterDXF::addMTextChunk: %s", text);
    //mtext += text;
    //mtext += RS_String::fromUtf8(text);

    /*
    QCString locallyEncoded = text;
    RS_String enc = RS_System::getEncoding(variables.getString("$DWGCODEPAGE", "ANSI_1252"));
    QTextCodec *codec = QTextCodec::codecForName(enc); // get the codec for Japanese
    if (codec!=NULL) {
        mtext += codec->toUnicode(toNativeString(locallyEncoded));
} else {
        mtext += toNativeString(text);
}
    */
    mtext+=text;

}



/**
 * Implementation of the method which handles 
 * multi texts (MTEXT).
 */
void RS_FilterDXF::addMText(const DL_MTextData& data) {
    RS_DEBUG->print("RS_FilterDXF::addMText: %s", data.text.c_str());

    RS_Vector ip(data.ipx, data.ipy);
    RS2::VAlign valign;
    RS2::HAlign halign;
    RS2::TextDrawingDirection dir;
    RS2::TextLineSpacingStyle lss;
    RS_String sty = data.style.c_str();

    if (data.attachmentPoint<=3) {
        valign=RS2::VAlignTop;
    } else if (data.attachmentPoint<=6) {
        valign=RS2::VAlignMiddle;
    } else {
        valign=RS2::VAlignBottom;
    }

    if (data.attachmentPoint%3==1) {
        halign=RS2::HAlignLeft;
    } else if (data.attachmentPoint%3==2) {
        halign=RS2::HAlignCenter;
    } else {
        halign=RS2::HAlignRight;
    }

    if (data.drawingDirection==1) {
        dir = RS2::LeftToRight;
    } else if (data.drawingDirection==3) {
        dir = RS2::TopToBottom;
    } else {
        dir = RS2::ByStyle;
    }

    if (data.lineSpacingStyle==1) {
        lss = RS2::AtLeast;
    } else {
        lss = RS2::Exact;
    }

    mtext+=QString(data.text.c_str());

    RS_String locallyEncoded = mtext;
    RS_String enc = RS_System::getEncoding(
                        variables.getString("$DWGCODEPAGE", "ANSI_1252"));
    // get the codec for Japanese
    QTextCodec *codec = QTextCodec::codecForName(enc);

    if (codec!=NULL) {
        mtext = codec->toUnicode(toNativeString(locallyEncoded));
    } else {
        mtext = toNativeString(mtext);
    }

    // use default style for the drawing:
    if (sty.isEmpty()) {
        // japanese, cyrillic:
        RS_String codepage = variables.getString("$DWGCODEPAGE", "ANSI_1252");
        if (codepage=="ANSI_932" || codepage=="ANSI_1251") {
            sty = "Unicode";
        } else {
            sty = variables.getString("$TEXTSTYLE", "Standard");
        }
    }

    RS_DEBUG->print("Text as unicode:");
    RS_DEBUG->printUnicode(mtext);

    RS_TextData d(ip, data.height, data.width,
                  valign, halign,
                  dir, lss,
                  data.lineSpacingFactor,
                  mtext, sty, data.angle,
                  RS2::NoUpdate);
    RS_Text* entity = new RS_Text(currentContainer, d);

    setEntityAttributes(entity, attributes);
    entity->update();
    currentContainer->addEntity(entity);

    mtext = "";
}



/**
 * Implementation of the method which handles 
 * texts (TEXT).
 */
void RS_FilterDXF::addText(const DL_TextData& data) {
    RS_DEBUG->print("RS_FilterDXF::addText");
    int attachmentPoint;
    RS_Vector refPoint;
    double angle = data.angle;

    // TODO: check, maybe implement a separate TEXT instead of using MTEXT

    // baseline has 5 vertical alignment modes:
    if (data.vJustification!=0 || data.hJustification!=0) {
        switch (data.hJustification) {
        default:
        case 0: // left aligned
            attachmentPoint = 1;
            refPoint = RS_Vector(data.apx, data.apy);
            break;
        case 1: // centered
            attachmentPoint = 2;
            refPoint = RS_Vector(data.apx, data.apy);
            break;
        case 2: // right aligned
            attachmentPoint = 3;
            refPoint = RS_Vector(data.apx, data.apy);
            break;
        case 3: // aligned (TODO)
            attachmentPoint = 2;
            refPoint = RS_Vector((data.ipx+data.apx)/2.0,
                                 (data.ipy+data.apy)/2.0);
            angle =
                RS_Vector(data.ipx, data.ipy).angleTo(
                    RS_Vector(data.apx, data.apy));
            break;
        case 4: // Middle (TODO)
            attachmentPoint = 2;
            refPoint = RS_Vector(data.apx, data.apy);
            break;
        case 5: // fit (TODO)
            attachmentPoint = 2;
            refPoint = RS_Vector((data.ipx+data.apx)/2.0,
                                 (data.ipy+data.apy)/2.0);
            angle =
                RS_Vector(data.ipx, data.ipy).angleTo(
                    RS_Vector(data.apx, data.apy));
            break;
        }

        switch (data.vJustification) {
        default:
        case 0: // baseline
        case 1: // bottom
            attachmentPoint += 6;
            break;

        case 2: // middle
            attachmentPoint += 3;
            break;

        case 3: // top
            break;
        }
    } else {
        //attachmentPoint = (data.hJustification+1)+(3-data.vJustification)*3;
        attachmentPoint = 7;
        refPoint = RS_Vector(data.ipx, data.ipy);
    }

    int drawingDirection = 5;
    double width = 100.0;

    mtext = "";
    addMText(DL_MTextData(
                 refPoint.x,
                 refPoint.y,
                 refPoint.z,
                 data.height, width,
                 attachmentPoint,
                 drawingDirection,
                 RS2::Exact,
                 1.0,
                 data.text.c_str(), data.style,
                 angle));
}



/**
 * Implementation of the method which handles 
 * dimensions (DIMENSION).
 */
RS_DimensionData RS_FilterDXF::convDimensionData(
    const DL_DimensionData& data) {

    RS_Vector defP(data.dpx, data.dpy);
    RS_Vector midP(data.mpx, data.mpy);
    RS2::VAlign valign;
    RS2::HAlign halign;
    RS2::TextLineSpacingStyle lss;
    RS_String sty = data.style.c_str();
    RS_String t; //= data.text;

    // middlepoint of text can be 0/0 which is considered to be invalid (!):
    //  0/0 because older QCad versions save the middle of the text as 0/0
    //  althought they didn't suport saving of the middle of the text.
    if (fabs(data.mpx)<1.0e-6 && fabs(data.mpy)<1.0e-6) {
        midP = RS_Vector(false);
    }

    if (data.attachmentPoint<=3) {
        valign=RS2::VAlignTop;
    } else if (data.attachmentPoint<=6) {
        valign=RS2::VAlignMiddle;
    } else {
        valign=RS2::VAlignBottom;
    }

    if (data.attachmentPoint%3==1) {
        halign=RS2::HAlignLeft;
    } else if (data.attachmentPoint%3==2) {
        halign=RS2::HAlignCenter;
    } else {
        halign=RS2::HAlignRight;
    }

    if (data.lineSpacingStyle==1) {
        lss = RS2::AtLeast;
    } else {
        lss = RS2::Exact;
    }

    t = toNativeString(data.text.c_str());

    if (sty.isEmpty()) {
        sty = variables.getString("$DIMSTYLE", "Standard");
    }

    RS_DEBUG->print("Text as unicode:");
    RS_DEBUG->printUnicode(t);

    // data needed to add the actual dimension entity
    return RS_DimensionData(defP, midP,
                            valign, halign,
                            lss,
                            data.lineSpacingFactor,
                            t, sty, data.angle);
}



/**
 * Implementation of the method which handles 
 * aligned dimensions (DIMENSION).
 */
void RS_FilterDXF::addDimAlign(const DL_DimensionData& data,
                               const DL_DimAlignedData& edata) {
    RS_DEBUG->print("RS_FilterDXF::addDimAligned");

    RS_DimensionData dimensionData = convDimensionData(data);

    RS_Vector ext1(edata.epx1, edata.epy1);
    RS_Vector ext2(edata.epx2, edata.epy2);

    RS_DimAlignedData d(ext1, ext2);

    RS_DimAligned* entity = new RS_DimAligned(currentContainer,
                            dimensionData, d);
    setEntityAttributes(entity, attributes);
    entity->update();
    currentContainer->addEntity(entity);
}



/**
 * Implementation of the method which handles 
 * linear dimensions (DIMENSION).
 */
void RS_FilterDXF::addDimLinear(const DL_DimensionData& data,
                                const DL_DimLinearData& edata) {
    RS_DEBUG->print("RS_FilterDXF::addDimLinear");

    RS_DimensionData dimensionData = convDimensionData(data);

    RS_Vector dxt1(edata.dpx1, edata.dpy1);
    RS_Vector dxt2(edata.dpx2, edata.dpy2);

    RS_DimLinearData d(dxt1, dxt2, RS_Math::deg2rad(edata.angle),
                       RS_Math::deg2rad(edata.oblique));

    RS_DimLinear* entity = new RS_DimLinear(currentContainer,
                                            dimensionData, d);
    setEntityAttributes(entity, attributes);
    entity->update();
    currentContainer->addEntity(entity);
}



/**
 * Implementation of the method which handles
 * radial dimensions (DIMENSION).
 */
void RS_FilterDXF::addDimRadial(const DL_DimensionData& data,
                                const DL_DimRadialData& edata) {
    RS_DEBUG->print("RS_FilterDXF::addDimRadial");

    RS_DimensionData dimensionData = convDimensionData(data);
    RS_Vector dp(edata.dpx, edata.dpy);

    RS_DimRadialData d(dp, edata.leader);

    RS_DimRadial* entity = new RS_DimRadial(currentContainer,
                                            dimensionData, d);

    setEntityAttributes(entity, attributes);
    entity->update();
    currentContainer->addEntity(entity);
}



/**
 * Implementation of the method which handles
 * diametric dimensions (DIMENSION).
 */
void RS_FilterDXF::addDimDiametric(const DL_DimensionData& data,
                                   const DL_DimDiametricData& edata) {
    RS_DEBUG->print("RS_FilterDXF::addDimDiametric");

    RS_DimensionData dimensionData = convDimensionData(data);
    RS_Vector dp(edata.dpx, edata.dpy);

    RS_DimDiametricData d(dp, edata.leader);

    RS_DimDiametric* entity = new RS_DimDiametric(currentContainer,
                              dimensionData, d);

    setEntityAttributes(entity, attributes);
    entity->update();
    currentContainer->addEntity(entity);
}



/**
 * Implementation of the method which handles
 * angular dimensions (DIMENSION).
 */
void RS_FilterDXF::addDimAngular(const DL_DimensionData& data,
                                 const DL_DimAngularData& edata) {
    RS_DEBUG->print("RS_FilterDXF::addDimAngular");

    RS_DimensionData dimensionData = convDimensionData(data);
    RS_Vector dp1(edata.dpx1, edata.dpy1);
    RS_Vector dp2(edata.dpx2, edata.dpy2);
    RS_Vector dp3(edata.dpx3, edata.dpy3);
    RS_Vector dp4(edata.dpx4, edata.dpy4);

    RS_DimAngularData d(dp1, dp2, dp3, dp4);

    RS_DimAngular* entity = new RS_DimAngular(currentContainer,
                            dimensionData, d);

    setEntityAttributes(entity, attributes);
    entity->update();
    currentContainer->addEntity(entity);
}



/**
 * Implementation of the method which handles
 * angular dimensions (DIMENSION).
 */
void RS_FilterDXF::addDimAngular3P(const DL_DimensionData& data,
                                   const DL_DimAngular3PData& edata) {
    RS_DEBUG->print("RS_FilterDXF::addDimAngular3P");

    RS_DimensionData dimensionData = convDimensionData(data);
    RS_Vector dp1(edata.dpx3, edata.dpy3);
    RS_Vector dp2(edata.dpx1, edata.dpy1);
    RS_Vector dp3(edata.dpx3, edata.dpy3);
    RS_Vector dp4 = dimensionData.definitionPoint;
    dimensionData.definitionPoint = RS_Vector(edata.dpx2, edata.dpy2);

    RS_DimAngularData d(dp1, dp2, dp3, dp4);

    RS_DimAngular* entity = new RS_DimAngular(currentContainer,
                            dimensionData, d);

    setEntityAttributes(entity, attributes);
    entity->update();
    currentContainer->addEntity(entity);
}



/**
 * Implementation of the method which handles leader entities.
 */
void RS_FilterDXF::addLeader(const DL_LeaderData& data) {
    RS_DEBUG->print("RS_FilterDXF::addDimLeader");
    //RS_DEBUG->print("RS_FilterDXF::addPolyline()");
    RS_LeaderData d(data.arrowHeadFlag==1);
    leader = new RS_Leader(currentContainer, d);
    setEntityAttributes(leader, attributes);

    currentContainer->addEntity(leader);
}



/**
 * Implementation of the method which handles leader vertices.
 */
void RS_FilterDXF::addLeaderVertex(const DL_LeaderVertexData& data) {
    RS_DEBUG->print("RS_FilterDXF::addLeaderVertex");
    //RS_DEBUG->print("RS_FilterDXF::addVertex() bulge: %f", bulge);

    RS_Vector v(data.x, data.y);