rs_python_wrappers.cpp

qcad2.05可用于windows和linux的源码

    class_<RS_Pen, bases<RS_Flags> >("Pen")
        .def(init<const RS_Color&, RS2::LineWidth, RS2::LineType>())
	.add_property("lineType", &RS_Pen::getLineType, &RS_Pen::setLineType)
	.add_property("width", &RS_Pen::getWidth, &RS_Pen::setWidth)
	.add_property("screenWidth", &RS_Pen::getScreenWidth, &RS_Pen::setScreenWidth)
	.add_property("color", make_function(&RS_Pen::getColor, return_value_policy<reference_existing_object>()), &RS_Pen::setColor)
	.add_property("valid", &RS_Pen::isValid)
    ;

    /* Common stuff */
    
    class_<RS_EntityContainer>("EntityContainer", init<RS_EntityContainer*, optional<bool> >())
        /* Wrapper functions for ownership transfer */
	.def("addEntity", RS_EntityContainer_addArc)
	.def("addEntity", RS_EntityContainer_addBlock)
	.def("addEntity", RS_EntityContainer_addCircle)
	.def("addEntity", RS_EntityContainer_addConstructionLine)
	.def("addEntity", RS_EntityContainer_addEllipse)
	.def("addEntity", RS_EntityContainer_addImage)
	.def("addEntity", RS_EntityContainer_addLine)
	.def("addEntity", RS_EntityContainer_addPoint)
	.def("addEntity", RS_EntityContainer_addPolyline)
	
	/** Owner-Containers will automatically delete entities upon removing,
	  * so no problem here. Other containers are not allowed in Python at the moment.
	  */
	.def("removeEntity", &RS_EntityContainer::removeEntity)

	/* Standard wrappers */
        .def("clear", &RS_EntityContainer::clear)
	.add_property("empty", &RS_EntityContainer::isEmpty)
	.def("entityAt", &RS_EntityContainer::entityAt, return_value_policy<reference_existing_object>())

        /* Iterators */
        .def("firstEntity", &RS_EntityContainer::firstEntity, return_value_policy<reference_existing_object>())
	.def("lastEntity", &RS_EntityContainer::lastEntity, return_value_policy<reference_existing_object>())
	.def("nextEntity", &RS_EntityContainer::nextEntity, return_value_policy<reference_existing_object>())
    ;

    class_<RS_LayerData>("LayerData")
        .def(init<const RS_String&, const RS_Pen&, bool>())
	.def_readwrite("name", &RS_LayerData::name)
	.def_readwrite("pen", &RS_LayerData::pen)
	.def_readwrite("frozen", &RS_LayerData::frozen)
    ;

    class_<RS_Layer, std::auto_ptr<RS_Layer> >("Layer", init<const RS_String&>())
        .add_property("name", &RS_Layer::getName, &RS_Layer::setName)
	.add_property("pen", &RS_Layer::getPen, &RS_Layer::setPen)
	.add_property("frozen", &RS_Layer::isFrozen, &RS_Layer::freeze)
	.add_property("toggle", &RS_Layer::toggle)
    ;

    class_<RS_LayerList>("LayerList")
        .def("clear", &RS_LayerList::clear)
	.def("count", &RS_LayerList::count)
	.def("at", &RS_LayerList::at, return_value_policy<reference_existing_object>())
	.add_property("active", make_function(&RS_LayerList::getActive, return_value_policy<reference_existing_object>()),
	                        RS_LayerList_activate_layer)
	.def("activate", RS_LayerList_activate_string)
	.def("activate", RS_LayerList_activate_layer)
        .def("add", RS_LayerList_add)
	.def("remove", &RS_LayerList::remove)
	.def("edit", &RS_LayerList::edit)
	.def("find", &RS_LayerList::find, return_value_policy<reference_existing_object>())
	.def("toggle", RS_LayerList_toggle_string)
	.def("toggle", RS_LayerList_toggle_layer)
	.def("freezeAll", &RS_LayerList::freezeAll)
    ;

    class_<RS_Document, bases<RS_EntityContainer>, boost::noncopyable >("Document", no_init)
        .add_property("layerList", make_function(&RS_Document::getLayerList, return_value_policy<reference_existing_object>()))
	.add_property("blockList", make_function(&RS_Document::getBlockList, return_value_policy<reference_existing_object>()))
	.def("newDoc", &RS_Document::newDoc)
	.def("save", &RS_Document::save)
	.def("saveAs", &RS_Document::saveAs)
	.def("open", &RS_Document::open)
	.add_property("modified", &RS_Document::isModified)
	.add_property("activePen", &RS_Document::getActivePen, &RS_Document::setActivePen)
	.add_property("filename", &RS_Document::getFilename)
    ;
    
    class_<RS_Graphic, bases<RS_Document> >("Graphic", init<RS_EntityContainer*>())
        .def("count", &RS_Graphic::count)
        .def("findLayer", &RS_Graphic::findLayer, return_value_policy<reference_existing_object>())
	.def("editLayer", &RS_Graphic::editLayer)
	.def("addLayer", RS_Graphic_addLayer)
	.def("removeLayer", &RS_Graphic::removeLayer)
	.def("toggleLayer", RS_Graphic_toggleLayer_string)
	.def("toggleLayer", RS_Graphic_toggleLayer_layer)
	.def("clearLayers", &RS_Graphic::clearLayers)
	.def("freezeAllLayers", &RS_Graphic::freezeAllLayers)
    ;

    /* Entity types */

    class_<RS_Entity, boost::noncopyable>("Entity", no_init)
        .def("init", &RS_Entity::init)
	.def("initId", &RS_Entity::initId)
	.def("clone", &RS_Entity::clone, return_value_policy<reference_existing_object>())
	.def("reparent", &RS_Entity::reparent)
	.def("resetBorders", &RS_Entity::resetBorders)
	.add_property("id", &RS_Entity::getId)
	.add_property("count", &RS_Entity::count)
	.add_property("parent", make_function(&RS_Entity::getParent, return_value_policy<reference_existing_object>()), &RS_Entity::setParent)
	.add_property("graphic", make_function(&RS_Entity::getGraphic, return_value_policy<reference_existing_object>()))
	.add_property("block", make_function(&RS_Entity::getBlock, return_value_policy<reference_existing_object>()))
	.add_property("insert", make_function(&RS_Entity::getInsert, return_value_policy<reference_existing_object>()))
	.add_property("blockOrInsert", make_function(&RS_Entity::getBlockOrInsert, return_value_policy<reference_existing_object>()))
	.add_property("document", make_function(&RS_Entity::getDocument, return_value_policy<reference_existing_object>()))
	.add_property("layer", make_function(&RS_Entity::getLayer, return_value_policy<reference_existing_object>()),
	              RS_Entity_setLayer_layer)
	.def("setLayer", RS_Entity_setLayer_string)
	.def("setLayer", RS_Entity_setLayer_layer)
	.def("setLayerToActive", &RS_Entity::setLayerToActive)
	.add_property("isContainer", &RS_Entity::isContainer)
	.add_property("isAtomic", &RS_Entity::isAtomic)
	.add_property("isEdge", &RS_Entity::isEdge)
	.add_property("isDocument", &RS_Entity::isDocument)
	.add_property("selected", &RS_Entity::isSelected, &RS_Entity::setSelected)
	.def("toggleSelected", &RS_Entity::toggleSelected)
	.add_property("processed", &RS_Entity::isProcessed, &RS_Entity::setProcessed)
	.add_property("visible", &RS_Entity::isVisible, &RS_Entity::setVisible)
	.add_property("min", &RS_Entity::getMin)
	.add_property("max", &RS_Entity::getMax)
	.add_property("size", &RS_Entity::getSize)
	.def("move", &RS_Entity::move)
	.def("rotate", &RS_Entity::rotate)
	.def("calculateBorders", &RS_Entity::calculateBorders)
    ;

    class_<RS_AtomicEntity, bases<RS_Entity>, boost::noncopyable>("AtomicEntity", no_init)
        .add_property("startpointSelected", &RS_AtomicEntity::isStartpointSelected)
	.add_property("endpointSelected", &RS_AtomicEntity::isEndpointSelected)
	.def("moveStartpoint", &RS_AtomicEntity::moveStartpoint)
	.def("moveEndpoint", &RS_AtomicEntity::moveEndpoint)
	.add_property("trimPoint", &RS_AtomicEntity::getTrimPoint)
	.def("reverse", &RS_AtomicEntity::reverse)
    ;

    /* Entities Data */

    class_<RS_ArcData>("ArcData")
        .def(init<RS_Vector&, double, double, double, bool>())
	.def("reset", &RS_ArcData::reset)
	.add_property("valid", &RS_ArcData::isValid)
	.def_readwrite("center", &RS_ArcData::center)
	.def_readwrite("radius", &RS_ArcData::radius)
	.def_readwrite("angle1", &RS_ArcData::angle1)
	.def_readwrite("angle2", &RS_ArcData::angle2)
	.def_readwrite("reversed", &RS_ArcData::reversed)
    ;

    class_<RS_BlockData>("BlockData")
        .def(init<RS_String&, const RS_Vector&, bool>())
	.add_property("valid", &RS_BlockData::isValid)
	.def_readwrite("name", &RS_BlockData::name)
	.def_readwrite("basePoint", &RS_BlockData::basePoint)
	.def_readwrite("frozen", &RS_BlockData::frozen)
    ;

    class_<RS_CircleData>("CircleData")
        .def(init<RS_Vector&, double>())
	.def("reset", &RS_CircleData::reset)
	.add_property("valid", &RS_CircleData::isValid)
	.def_readwrite("center", &RS_CircleData::center)
	.def_readwrite("radius", &RS_CircleData::radius)
    ;

    class_<RS_ConstructionLineData>("ConstructionLineData")
        .def(init<RS_Vector&, RS_Vector&>())
    ;

    class_<RS_EllipseData>("EllipseData", init<const RS_Vector&, const RS_Vector&, double, double, double, bool>())
    ;

    class_<RS_ImageData>("ImageData")
        .def(init<int, const RS_Vector&, const RS_Vector&, const RS_Vector&, const RS_Vector&, const RS_String&, int, int, int>())
	.def_readwrite("handle", &RS_ImageData::handle)
	.def_readwrite("insertionPoint", &RS_ImageData::insertionPoint)
	.def_readwrite("uVector", &RS_ImageData::uVector)
	.def_readwrite("vVector", &RS_ImageData::vVector)
	.def_readwrite("size", &RS_ImageData::size)
	.def_readwrite("file", &RS_ImageData::file)
	.def_readwrite("brightness", &RS_ImageData::brightness)
	.def_readwrite("contrast", &RS_ImageData::contrast)
	.def_readwrite("fade", &RS_ImageData::fade)
    ;

    class_<RS_LineData>("LineData")
        .def(init<RS_Vector&, RS_Vector&>())
	.def_readwrite("startpoint", &RS_LineData::startpoint)
	.def_readwrite("endpoint", &RS_LineData::endpoint)
    ;

    class_<RS_PointData>("PointData", init<const RS_Vector&>())
    ;

    class_<RS_PolylineData>("PolylineData")
        .def(init<const RS_Vector&, const RS_Vector&, bool>())
    ;

    /* Entities */

    class_<RS_Arc, bases<RS_AtomicEntity>, std::auto_ptr<RS_Arc> >("Arc", init<RS_EntityContainer*, RS_ArcData&>())
        .add_property("data", &RS_Arc::getData, &RS_Arc::setData)
	.add_property("center", &RS_Arc::getCenter, &RS_Arc::setCenter)
	.add_property("radius", &RS_Arc::getRadius, &RS_Arc::setRadius)
	.add_property("angle1", &RS_Arc::getAngle1, &RS_Arc::setAngle1)
	.add_property("angle2", &RS_Arc::getAngle2, &RS_Arc::setAngle2)
	.add_property("direction1", &RS_Arc::getDirection1)
	.add_property("direction2", &RS_Arc::getDirection2)
	.add_property("reversed", &RS_Arc::isReversed, &RS_Arc::setReversed)
	.add_property("middlepoint", &RS_Arc::getMiddlepoint)
	.add_property("angleLength", &RS_Arc::getAngleLength)
	.add_property("length", &RS_Arc::getLength)
	.add_property("bulge", &RS_Arc::getBulge)
	.def("createFrom3P", &RS_Arc::createFrom3P)
    ;

    class_<RS_Block, bases<RS_Document>, std::auto_ptr<RS_Block> >("Block", init<RS_EntityContainer*, const RS_BlockData&>())
        .add_property("name", &RS_Block::getName, &RS_Block::setName)
	.add_property("basePoint", &RS_Block::getBasePoint)
	.add_property("frozen", &RS_Block::isFrozen, &RS_Block::freeze)
	.def("toggle", &RS_Block::toggle)
    ;

    class_<RS_Circle, bases<RS_AtomicEntity>, std::auto_ptr<RS_Circle> >("Circle", init<RS_EntityContainer*, const RS_CircleData&>())
        .add_property("data", &RS_Circle::getData)
	.add_property("center", &RS_Circle::getCenter, &RS_Circle::setCenter)
	.add_property("radius", &RS_Circle::getRadius, &RS_Circle::setRadius)
	.add_property("angleLength", &RS_Circle::getAngleLength)
	.def("createFromCR", &RS_Circle::createFromCR)
	.def("createFrom2P", &RS_Circle::createFrom2P)
	.def("createFrom3P", &RS_Circle::createFrom3P)
    ;

    class_<RS_ConstructionLine, bases<RS_AtomicEntity>, std::auto_ptr<RS_ConstructionLine> >
            ("ConstructionLine", init<RS_EntityContainer*, const RS_ConstructionLineData&>())
        .add_property("data", &RS_ConstructionLine::getData)
	.add_property("point1", &RS_ConstructionLine::getPoint1)
	.add_property("point2", &RS_ConstructionLine::getPoint2)
    ;

    class_<RS_Ellipse, bases<RS_AtomicEntity>, std::auto_ptr<RS_Ellipse> >
            ("Ellipse", init<RS_EntityContainer*, const RS_EllipseData&>())
	.add_property("data", &RS_Ellipse::getData)
	.add_property("reversed", &RS_Ellipse::isReversed, &RS_Ellipse::setReversed)
	.add_property("angle", &RS_Ellipse::getAngle)
	.add_property("angle1", &RS_Ellipse::getAngle1, &RS_Ellipse::setAngle1)
	.add_property("angle2", &RS_Ellipse::getAngle2, &RS_Ellipse::setAngle2)
	.add_property("center", &RS_Ellipse::getCenter, &RS_Ellipse::setCenter)
	.add_property("majorP", &RS_Ellipse::getMajorP, &RS_Ellipse::setMajorP)
	.add_property("ratio", &RS_Ellipse::getRatio, &RS_Ellipse::setRatio)
	.add_property("majorRadius", &RS_Ellipse::getMajorRadius)
	.add_property("minorRadius", &RS_Ellipse::getMinorRadius)
    ;

    class_<RS_Image, bases<RS_AtomicEntity>, std::auto_ptr<RS_Image> >
            ("Image", init<RS_EntityContainer*, const RS_ImageData&>())
	.add_property("data", &RS_Image::getData)
	.add_property("insertionPoint", &RS_Image::getInsertionPoint, &RS_Image::setInsertionPoint)
	.add_property("file", &RS_Image::getFile, &RS_Image::setFile)
	.add_property("uVector", &RS_Image::getUVector)
	.add_property("vVector", &RS_Image::getVVector)
	.add_property("width", &RS_Image::getWidth)
	.add_property("height", &RS_Image::getHeight)
	.add_property("brightness", &RS_Image::getBrightness)
	.add_property("contrast", &RS_Image::getContrast)
	.add_property("fade", &RS_Image::getFade)
	.add_property("handle", &RS_Image::getHandle, &RS_Image::setHandle)
	.add_property("imageWidth", &RS_Image::getImageWidth)
	.add_property("imageHeight", &RS_Image::getImageHeight)
    ;

    class_<RS_Line, bases<RS_AtomicEntity>, std::auto_ptr<RS_Line> >
            ("Line", init<RS_EntityContainer*, const RS_LineData&>())
	.add_property("data", &RS_Line::getData)
	.add_property("startpoint", &RS_Line::getStartpoint, &RS_Line::setStartpoint)
	.add_property("endpoint", &RS_Line::getEndpoint, &RS_Line::setEndpoint)
    ;

    class_<RS_Point, bases<RS_AtomicEntity>, std::auto_ptr<RS_Point> >
            ("Point", init<RS_EntityContainer*, const RS_PointData&>())
	.add_property("pos", &RS_Point::getPos, &RS_Point::setPos)
    ;

    class_<RS_Polyline, bases<RS_EntityContainer>, std::auto_ptr<RS_Polyline> >
            ("Polyline", init<RS_EntityContainer*, const RS_PolylineData&>())
        .def(init<RS_EntityContainer*>())
	.add_property("startpoint", &RS_Polyline::getStartpoint, &RS_Polyline::setStartpoint)
	.add_property("endpoint", &RS_Polyline::getEndpoint)
	.add_property("closed", &RS_Polyline::isClosed)
	.def("addVertex", &RS_Polyline::addVertex, return_value_policy<reference_existing_object>())
	.def("createVertex", &RS_Polyline::createVertex, return_value_policy<reference_existing_object>())
	.def("endPolyline", &RS_Polyline::endPolyline)
    ;
}

#endif