예제 #1
0
bool ArrowModel::intersect(double p1, double q1, double p2, double q2)
{
    double x1, y1;
    double x2, y2;
    Goocanvas::Points points = this->property_points().get_value();
    for(int i=0; i<points.get_num_points()-1; i++)
    {
        points.get_coordinate(i, x1, y1);
        points.get_coordinate(i+1, x2, y2);

        // calculte intersection 
        double s1_x, s1_y, s2_x, s2_y;
        s1_x = x2 - x1;     
        s1_y = y2 - y1;
        s2_x = p2 - p1;     
        s2_y = q2 - q1;

        double s, t;
        s = (-s1_y * (x1 - p1) + s1_x * (y1 - q1)) / (-s2_x * s1_y + s1_x * s2_y);
        t = ( s2_x * (y1 - q1) - s2_y * (x1 - p1)) / (-s2_x * s1_y + s1_x * s2_y);

        if ((s >= 0) && (s <= 1) && (t >= 0) && (t <= 1))
            return true;
    }

    return false;
}
예제 #2
0
void ArrowModel::onPointUpdated(void)
{
    GraphicModel::points.clear();
    double x1, y1;
    GyPoint pt;

    if(!bNullArrow)
    {
        // Adding label position 
        Glib::RefPtr<Goocanvas::Item> item = parentWindow->m_Canvas->get_item(label); 
        if(item)
        {
            Goocanvas::Bounds bi = item->get_bounds();
            bi = item->get_bounds();
            pt.x = bi.get_x1();
            pt.y = bi.get_y1();
        }
        else
            pt.x = pt.y = -1;
    }

    GraphicModel::points.push_back(pt);

    Goocanvas::Points pts = this->property_points().get_value();
    for(int i=0; i<pts.get_num_points(); i++)
    {
        pts.get_coordinate(i, x1, y1);
        pt.x = x1;
        pt.y = y1;
        GraphicModel::points.push_back(pt);
    }
}
예제 #3
0
int ArrowModel::addPoint(double x, double y)
{
    int index = 0;
    double x1, y1;
    double x2, y2;

    Goocanvas::Points points = this->property_points().get_value();
    for(int i=0; i<points.get_num_points()-1; i++)
    {
        points.get_coordinate(i, x1, y1);
        points.get_coordinate(i+1, x2, y2);
        if((x > fmin(x1, x2)) && (x < fmax(x1, x2)) &&
           (y > fmin(y1, y2)) && (y < fmax(y1, y2)))
        {   
            double d = ((x-x1)*(x2-x1) + (y-y1)*(y2-y1)) / ((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1));
            if((d > 0.0) && (d < 1.0))
            {
                index = i;
                break;
            }
        }
    }

    addPoint(index, x, y);
    return index+1;
}
예제 #4
0
Gdk::Point ArrowModel::getPoint(int index)
{
    Goocanvas::Points points = this->property_points().get_value();
    if(index >= points.get_num_points())
        return Gdk::Point(-1,-1);
    double x, y;
    points.get_coordinate(index, x, y);
    return Gdk::Point((int)x,(int)y);
}
예제 #5
0
bool ArrowModel::setPoint(int index, double x, double y)
{
    Goocanvas::Points points = this->property_points().get_value();
    if(index >= points.get_num_points())
        return false;
    points.set_coordinate(index, x, y);
    this->property_points().set_value(points);
    onPointUpdated();
    return true;
}
예제 #6
0
void ArrowModel::updatCoordiantes(void)
{
    if(!bNested)
    {        
        Gdk::Point pt1 = source->getContactPoint(this);
        Gdk::Point pt2 = destination->getContactPoint(this);
        setPoint(0, pt1.get_x(), pt1.get_y()-ARROW_LINEWIDTH/2.0);
        Goocanvas::Points points = this->property_points().get_value();
        setPoint(points.get_num_points()-1, pt2.get_x(), pt2.get_y()-ARROW_LINEWIDTH/2.0);
        updatLabelCoordiante();
    }        
}
예제 #7
0
int ArrowModel::getIndex(double x, double y)
{
    double x1, y1;
    Goocanvas::Points points = this->property_points().get_value();
    for(int i=0; i<points.get_num_points(); i++)
    {
        points.get_coordinate(i, x1, y1);
        if((x1 == x) && (y1 == y))
            return i;
    }
    
    return -1;
}
예제 #8
0
bool ArrowModel::inside(double p1, double q1, double p2, double q2)
{
    double x1, y1;
    double x2, y2;
    Goocanvas::Points points = this->property_points().get_value();
    points.get_coordinate(0, x1, y1);
    points.get_coordinate(points.get_num_points()-1, x2, y2);
    x1 = fmin(x1, x2);
    x2 = fmax(x1, x2);
    y1 = fmin(y1, y2);
    y2 = fmax(y1, y2);

    if((x1>=p1) && (x1<=p2) && (y1>=q1) && (y2<=q2))
        return true;
 
    return false;
}
예제 #9
0
bool ArrowModel::setPoint(double x, double y,
                          double x_new, double y_new)
{
    double x1, y1;
    Goocanvas::Points points = this->property_points().get_value();
    for(int i=0; i<points.get_num_points(); i++)
    {
        points.get_coordinate(i, x1, y1);
        if((x1 == x) && (y1 == y))
        {
            points.set_coordinate(i, x_new, y_new);
            break;
        }
    }
    this->property_points().set_value(points);
    onPointUpdated();
    return true;
}
예제 #10
0
// add a new point after index
bool ArrowModel::addPoint(int index, double x, double y)
{
    Goocanvas::Points points = this->property_points().get_value();
    if(index >= points.get_num_points())
        return false;

    Goocanvas::Points new_points(points.get_num_points()+1);
    for(int i=0; i<=index; i++)
    {
        double _x, _y;
        points.get_coordinate(i, _x, _y);
        new_points.set_coordinate(i, _x, _y);
    }
    new_points.set_coordinate(index+1, x, y);
    for(int i=index+1; i<points.get_num_points(); i++)
    {
        double _x, _y;
        points.get_coordinate(i, _x, _y);
        new_points.set_coordinate(i+1, _x, _y);
    }
    this->property_points().set_value(new_points);
    onPointUpdated();
    return true;
}
예제 #11
0
void ArrowModel::updatLabelCoordiante(void)
{
    
    if(!bNullArrow)
    {
        Goocanvas::Points points = this->property_points().get_value();
        if(points.get_num_points() < 3)
        {
            double x1, y1, x2, y2;
            Goocanvas::Points points = this->property_points().get_value();
            int index = points.get_num_points() / 2;
            points.get_coordinate(index-1, x1, y1);
            points.get_coordinate(index, x2, y2);
            
            int text_w, text_h;
            PangoLayout *layout = gtk_widget_create_pango_layout((GtkWidget*)parentWindow->gobj(), strLabel.c_str());
            PangoFontDescription *fontdesc = pango_font_description_from_string("Monospace 9");
            pango_layout_set_font_description (layout, fontdesc);
            pango_layout_get_pixel_size (layout, &text_w, &text_h);

            setLabelPosition((x1+x2)/2.0 - text_w/2.0, (y1+y2)/2.0);
        }            
    }       
}
예제 #12
0
ArrowModel::ArrowModel(ApplicationWindow* parentWnd,
                       Glib::RefPtr<PortModel> src, Glib::RefPtr<PortModel> dest,
                       Connection* con, ApplicationModel* appModel, bool nullArw): PolylineModel(0,0,0,0), connection(NULL, NULL) 
{
    parentWindow = parentWnd;
    source = src;
    destination = dest;
    selected = false;
    bExist = false;
    bNullArrow = nullArw;
    applicationModel = appModel; 
    bNested = (applicationModel != NULL);
    if(appModel)
        application = appModel->getApplication();
    else        
        application = parentWindow->manager.getKnowledgeBase()->getApplication();

    if(con)
    {
        strLabel = con->carrier();
        connection = *con;
    }
        
    this->property_close_path().set_value(false);
    this->property_line_width().set_value(ARROW_LINEWIDTH);
    this->property_arrow_width().set_value(5.0);
    if(!bNullArrow)
        this->property_end_arrow().set_value(true);
    if(bNested)
    {
        defaultColor = "#555555";
        //GooCanvasLineDash *dash = goo_canvas_line_dash_new (ARROW_LINEWIDTH, 3.0, 3.0);
        //g_object_set(this->gobj(), "line-dash", dash, NULL);
    }
    else
        defaultColor = "black";

    source->addSourceArrow(this);
    destination->addDestinationArrow(this);
    if(!bNullArrow)
    {
        string strCarrier = strLabel;
        string dummyLabel;
        //Adding connection 
        if(application)
        {
            string strFrom, strTo;
            Glib::RefPtr<InternalPortModel> intPort;
            Glib::RefPtr<ExternalPortModel> extPort;
            Glib::RefPtr<PortArbitratorModel> arbPort;
            Module* module;
            InputData* input = NULL;
            OutputData* output = NULL;
            bool bExternFrom = false;
            bool bExternTo = false;

            // port arbitrator at the destination
            arbPort = Glib::RefPtr<PortArbitratorModel>::cast_dynamic(destination);

            // source 
            intPort = Glib::RefPtr<InternalPortModel>::cast_dynamic(source);
            if(intPort)
            {
                output = intPort->getOutput();
                module = (Module*) output->owner();
                strFrom = string(module->getPrefix()) + string(intPort->getOutput()->getPort()); 
                dummyLabel = string(intPort->getOutput()->getPort());
                if(!strCarrier.size())
                {
                    strCarrier = intPort->getOutput()->getCarrier();
                    if(arbPort)
                        strCarrier += "+recv.priority";
                }                    
            }
            else
            {
                extPort = Glib::RefPtr<ExternalPortModel>::cast_dynamic(source);
                strFrom = extPort->getPort();
                dummyLabel = string(extPort->getPort());
                if(!strCarrier.size() && arbPort)
                    strCarrier = "udp+recv.priority";
                bExternFrom = true;
            }
          
            // destination
            intPort = Glib::RefPtr<InternalPortModel>::cast_dynamic(destination);
            if(intPort)
            {
                input = intPort->getInput();
                module = (Module*) input->owner();
                strTo = string(module->getPrefix()) + string(intPort->getInput()->getPort()); 
                dummyLabel += string(" -> ") + string(intPort->getInput()->getPort()) + string(" "); 
                if(!strCarrier.size())   
                {
                    strCarrier = intPort->getInput()->getCarrier();
                    if(arbPort)
                        strCarrier += "+recv.priority";
                }                    
            }
            else if(arbPort)
            {
                intPort = Glib::RefPtr<InternalPortModel>::cast_dynamic(arbPort->getPortModel());
                extPort = Glib::RefPtr<ExternalPortModel>::cast_dynamic(arbPort->getPortModel());
                if(intPort)
                {
                    input = intPort->getInput();
                    module = (Module*) input->owner();
                    strTo = string(module->getPrefix()) + string(intPort->getInput()->getPort()); 
                    dummyLabel += string(" -> ") + string(intPort->getInput()->getPort()) + string(" "); 
                    if(!strCarrier.size())
                    {
                        strCarrier = intPort->getInput()->getCarrier();
                        strCarrier += "+recv.priority";
                    }                        
                }
                else
                {
                    strTo = extPort->getPort();
                    dummyLabel += string(" -> ") + string(extPort->getPort()) + string(" "); 
                    bExternTo = true;
                    if(!strCarrier.size())
                        strCarrier = "udp+recv.priority";
                }
            }
            else
            {
                extPort = Glib::RefPtr<ExternalPortModel>::cast_dynamic(destination);
                strTo = extPort->getPort();
                dummyLabel += string(" -> ") + string(extPort->getPort()) + string(" "); 
                bExternTo = true;
                if(!strCarrier.size())
                        strCarrier = "udp";
            }
            
            connection.setFrom(strFrom.c_str());
            connection.setTo(strTo.c_str());
            connection.setCarrier(strCarrier.c_str());
            connection.setFromExternal(bExternFrom);
            connection.setToExternal(bExternTo);
            connection.setCorOutputData(output);
            connection.setCorInputData(input);
            connection.setModel(this);
            connection = parentWindow->manager.getKnowledgeBase()->addConnectionToApplication(application, connection);
            tool = TooltipModel::create(parentWindow, dummyLabel.c_str());
        }

        strLabel = strCarrier;
        this->property_stroke_color().set_value(defaultColor.c_str());
        if(strLabel.size())
            label = LabelModel::create(parentWindow, this, strLabel.c_str());
        else
            label = LabelModel::create(parentWindow, this, strCarrier.c_str());

        // if it is an auxilary connections
        /*
        if((strLabel.find("virtual") != std::string::npos) || 
           (strLabel.find("auxiliary") != std::string::npos) )
        {
            GooCanvasLineDash *dash = goo_canvas_line_dash_new (ARROW_LINEWIDTH, 3.0, 3.0);
            g_object_set(this->gobj(), "line-dash", dash, NULL);      
        }
        */

        if(bNested)
        {
            applicationModel->add_child(label);
            label->property_visibility().set_value(Goocanvas::ITEM_HIDDEN);
        }
        else
            parentWindow->getRootModel()->add_child(label);
        label->raise();

        showLabel(parentWindow->m_showLabel);
    }

    
    Gdk::Point pt1 = source->getContactPoint(this);
    Gdk::Point pt2 = destination->getContactPoint(this);
    setPoint(0, pt1.get_x(), pt1.get_y()-ARROW_LINEWIDTH/2.0);
    Goocanvas::Points points = this->property_points().get_value();
    setPoint(points.get_num_points()-1, pt2.get_x(), pt2.get_y()-ARROW_LINEWIDTH/2.0);
    setLabel(strLabel.c_str());
    updatCoordiantes();
    //printf("%s : %d\n", __FILE__, __LINE__); 
}
예제 #13
0
ApplicationModel::ApplicationModel(ApplicationWindow* parentWnd, Application* app) : GroupModel()
{
    parentWindow = parentWnd;
    application = app;
    app->setModel(this);

    // adding application name
    text = Goocanvas::TextModel::create(app->getName());
#ifdef GLIBMM_PROPERTIES_ENABLED
    text->property_font() = FONT_DESC;
    text->property_alignment().set_value(Pango::ALIGN_CENTER);
#endif

    PangoLayout *layout = gtk_widget_create_pango_layout((GtkWidget*)parentWindow->gobj(),
                            app->getName());
    PangoFontDescription *fontdesc = pango_font_description_from_string(FONT_DESC);
    pango_layout_set_font_description (layout, fontdesc);
    pango_layout_get_pixel_size (layout, &text_w, &text_h);

    text->property_x().set_value(TEXT_MARGINE);
    text->property_y().set_value(text_h/2.0);

    poly = Goocanvas::PolylineModel::create(0,0,0,0);
    poly->property_close_path().set_value(true);
    poly->property_line_width().set_value(1.2);
    //poly->property_fill_color().set_value(APPLICATION_COLOR);
    poly->property_fill_color_rgba().set_value(APPLICATION_COLOR);
    poly->property_stroke_color().set_value("DodgerBlue3");
    //GooCanvasLineDash *dash = goo_canvas_line_dash_new (2, 3.0, 3.0);
    //g_object_set(poly->gobj(), "line-dash", dash, NULL);

    shadow = Goocanvas::PolylineModel::create(0,0,0,0);
    shadow->property_close_path().set_value(false);
    shadow->property_line_width().set_value(3.0);
    shadow->property_stroke_color().set_value("gray");

    getApplicationBounds(bounds);

    width = MAX(MIN_WIDTH + text_w, bounds.get_x2()-bounds.get_x1() + 2*ITEMS_MARGIE);
    height = MAX(MIN_HEIGHT, bounds.get_y2()-bounds.get_y1() + 2*ITEMS_MARGIE + text_h);
    Goocanvas::Points points(6);
    points.set_coordinate(0, 0, 0);
    points.set_coordinate(1, text_w+TEXT_MARGINE*2, 0);
    points.set_coordinate(2, text_w+TEXT_MARGINE*2, text_h+TEXT_MARGINE);
    points.set_coordinate(3, width, text_h+TEXT_MARGINE);
    points.set_coordinate(4, width, height);
    points.set_coordinate(5, 0, height);
    poly->property_points().set_value(points);

    Goocanvas::Points points3(3);
    points3.set_coordinate(0, width, text_h+TEXT_MARGINE);
    points3.set_coordinate(1, width, height);
    points3.set_coordinate(2, 0, height);
    shadow->property_points().set_value(points3);
    shadow->translate(1,1);

    this->add_child(shadow);
    this->add_child(poly);
    this->add_child(text);


    ModulePContainer modules = parentWindow->manager.getKnowledgeBase()->getModules(application);
    CnnContainer connections = parentWindow->manager.getKnowledgeBase()->getConnections(application);
    ApplicaitonPContainer applications = parentWindow->manager.getKnowledgeBase()->getApplications(application);

    int index = 0;
    ModulePIterator itr;
    for(itr=modules.begin(); itr!=modules.end(); itr++)
    {
        Module* module = (*itr);
        Glib::RefPtr<ModuleModel> mod = ModuleModel::create(parentWindow, module, true);
        this->add_child(mod);
        double x, y;
        x = (module->getModelBase().points.size()>0) ? module->getModelBase().points[0].x : index%900+10;
        y = (module->getModelBase().points.size()>0) ? module->getModelBase().points[0].y : ((index+=300)/900)*100+10;
        x -= bounds.get_x1();
        x += ITEMS_MARGIE;
        y -= bounds.get_y1();
        y += ITEMS_MARGIE + text_h + TEXT_MARGINE;
        mod->translate(x, y);

        double end_x, end_y;
        Goocanvas::Points points = poly->property_points().get_value();
        points.get_coordinate(4, end_x, end_y);
        if((x + mod->getWidth() + ITEMS_MARGIE) >= end_x)
            width = x + mod->getWidth() + ITEMS_MARGIE;
        if((y + mod->getHeight() + ITEMS_MARGIE) >= end_y)
            height = y + mod->getHeight() + ITEMS_MARGIE;

        //points.set_coordinate(0, 0, 0);
        //points.set_coordinate(1, text_w+TEXT_MARGINE*2, 0);
        //points.set_coordinate(2, text_w+TEXT_MARGINE*2, text_h+TEXT_MARGINE);
        points.set_coordinate(3, width, text_h+TEXT_MARGINE);
        points.set_coordinate(4, width, height);
        points.set_coordinate(5, 0, height);
        poly->property_points().set_value(points);
        Goocanvas::Points points3(3);
        points3.set_coordinate(0, width, text_h+TEXT_MARGINE);
        points3.set_coordinate(1, width, height);
        points3.set_coordinate(2, 0, height);
        shadow->property_points().set_value(points3);
    }

}
예제 #14
0
void ApplicationModel::updateChildItems(void)
{

    ModulePContainer modules = parentWindow->manager.getKnowledgeBase()->getModules(application);
    CnnContainer connections = parentWindow->manager.getKnowledgeBase()->getConnections(application);
    ApplicaitonPContainer applications = parentWindow->manager.getKnowledgeBase()->getApplications(application);

    int index = 0; //index = (index/900)*100+50;
    CnnIterator citr;
    for(citr=connections.begin(); citr<connections.end(); citr++)
    {
        Connection baseCon = *citr;
        GraphicModel model = baseCon.getModelBase();
        InputData* input = NULL;
        OutputData* output = NULL;
        Glib::RefPtr<PortModel> source(NULL);
        Glib::RefPtr<PortModel> dest(NULL);
        findInputOutputData((*citr), modules, input, output);
        if(output)
            source = findModelFromOutput(output);
        else
        {
            Glib::RefPtr<ExternalPortModel> extPort;
            bool bExist = false;
            for(int i=0; i<get_n_children(); i++)
            {
                extPort = Glib::RefPtr<ExternalPortModel>::cast_dynamic(get_child(i));
                if(extPort && compareString(extPort->getPort(), baseCon.from()))
                {
                    source = extPort;
                    bExist = true;
                    break;
                }
            }
            if(!bExist)
            {
                source = ExternalPortModel::create(parentWindow, OUTPUTD, (*citr).from(), true);
                add_child(source);
                 double x ,y;
                if(model.points.size() > 1)
                {
                    x = model.points[1].x - Glib::RefPtr<ExternalPortModel>::cast_dynamic(source)->getWidth()
                                              - bounds.get_x1()+ITEMS_MARGIE;
                    y = model.points[1].y - Glib::RefPtr<ExternalPortModel>::cast_dynamic(source)->getHeight()/2.0
                                              - bounds.get_y1()+ITEMS_MARGIE+text_h+TEXT_MARGINE;
                    source->set_property("x", x);
                    source->set_property("y", y);
                }
                else
                {
                    x = 10;
                    y = index;
                    source->set_property("x", 10);
                    source->set_property("y", index);
                }

                double end_x, end_y;
                double start_x;
                Goocanvas::Points points = poly->property_points().get_value();
                points.get_coordinate(4, end_x, end_y);
                points.get_coordinate(5, start_x, end_y);
                double port_w = Glib::RefPtr<ExternalPortModel>::cast_dynamic(source)->getWidth();
                double port_h = Glib::RefPtr<ExternalPortModel>::cast_dynamic(source)->getHeight();
                if((x + port_w + ITEMS_MARGIE) >= end_x)
                    width = x + port_w + ITEMS_MARGIE;
                if((y + port_h + ITEMS_MARGIE) >= end_y)
                    height = y + port_h + ITEMS_MARGIE;

                double minx = start_x;
                if(x < start_x)
                {
                    minx = x - ITEMS_MARGIE;
                    text->translate(-abs(start_x-x)-ITEMS_MARGIE, 0);
                }
                points.set_coordinate(0, minx, 0);
                points.set_coordinate(1, text_w+TEXT_MARGINE*2+minx, 0);
                points.set_coordinate(2, text_w+TEXT_MARGINE*2+minx, text_h+TEXT_MARGINE);
                points.set_coordinate(3, width, text_h+TEXT_MARGINE);
                points.set_coordinate(4, width, height);
                points.set_coordinate(5, minx, height);
                poly->property_points().set_value(points);
                Goocanvas::Points points3(3);
                points3.set_coordinate(0, width, text_h+TEXT_MARGINE);
                points3.set_coordinate(1, width, height);
                points3.set_coordinate(2, minx, height);
                shadow->property_points().set_value(points3);
            }
            index+=40;
        }

        if(input)
           dest = findModelFromInput(input);
        else
        {
            Glib::RefPtr<ExternalPortModel> extPort;
            bool bExist = false;
            for(int i=0; i<get_n_children(); i++)
            {
                extPort = Glib::RefPtr<ExternalPortModel>::cast_dynamic(get_child(i));
                if(extPort && compareString(extPort->getPort(), baseCon.to()))
                {
                    dest = extPort;
                    bExist = true;
                    break;
                }
            }
            if(!bExist)
            {
                double x,y;
                dest = ExternalPortModel::create(parentWindow, INPUTD, (*citr).to(), true);
                add_child(dest);
                size_t size = model.points.size();
                if(size > 2)
                {
                    x = model.points[size-1].x-bounds.get_x1()+ITEMS_MARGIE;
                    y = model.points[size-1].y - Glib::RefPtr<ExternalPortModel>::cast_dynamic(dest)->getHeight()/2.0
                                            - bounds.get_y1()+ITEMS_MARGIE+text_h+TEXT_MARGINE;
                    dest->set_property("x", x);
                    dest->set_property("y", y);
                }
                else
                {
                    x = 400;
                    y = index;
                    dest->set_property("x", x);
                    dest->set_property("y", y);
                }
                double end_x, end_y;
                Goocanvas::Points points = poly->property_points().get_value();
                points.get_coordinate(4, end_x, end_y);
                double port_w = Glib::RefPtr<ExternalPortModel>::cast_dynamic(dest)->getWidth();
                double port_h = Glib::RefPtr<ExternalPortModel>::cast_dynamic(dest)->getHeight();
                if((x + port_w + ITEMS_MARGIE) >= end_x)
                    width = x + port_w + ITEMS_MARGIE;
                if((y + port_h + ITEMS_MARGIE) >= end_y)
                    height = y + port_h + ITEMS_MARGIE;

                points.set_coordinate(3, width, text_h+TEXT_MARGINE);
                points.set_coordinate(4, width, height);
                points.get_coordinate(5, end_x, end_y);
                points.set_coordinate(5, end_x, height);
                poly->property_points().set_value(points);
                Goocanvas::Points points3(3);
                points3.set_coordinate(0, width, text_h+TEXT_MARGINE);
                points3.set_coordinate(1, width, height);
                points3.set_coordinate(2, end_x, height);
                shadow->property_points().set_value(points3);
            }
        }

        if(source && dest)
        {
            Glib::RefPtr<ArrowModel> arrow = ArrowModel::create(parentWindow, source, dest, &baseCon, this);
            add_child(arrow);
            int size = model.points.size();
            for(int i=2; i<size-1; i++)
                arrow->addMidPoint(model.points[i].x-bounds.get_x1()+ITEMS_MARGIE,
                                   model.points[i].y-bounds.get_y1()+ITEMS_MARGIE+text_h+TEXT_MARGINE, i-2);
            arrow->setSelected(false);
            if(size)
                arrow->setLabelPosition(model.points[0].x-bounds.get_x1()+ITEMS_MARGIE,
                                        model.points[0].y-bounds.get_y1()+ITEMS_MARGIE+text_h+TEXT_MARGINE);
        }
    }
}