Пример #1
0
static void
gv_point_tool_button_press(GvTool *tool, GdkEventButton *event)
{
    if (event->button == 1)
    {
	GvVertex vertex;
	
	if (!gv_point_tool_configure(tool)) return;

	/* Get pointer location */
	gv_view_area_map_pointer(GV_TOOL(tool)->view, event->x, event->y,
				 &vertex.x, &vertex.y);

        if( !gv_tool_check_bounds( GV_TOOL(tool), vertex.x, vertex.y ) )
            return;

	/* Add a new point */
        if( GV_IS_POINT_LAYER(GV_POINT_TOOL(tool)->layer) )
        {
            gv_point_layer_select_new_point(
                GV_POINT_LAYER(GV_POINT_TOOL(tool)->layer), 
                &vertex);
        }
        else
        {
            GvShape   *new_point;

            new_point = gv_shape_new( GVSHAPE_POINT );
            gv_shape_set_xyz( new_point, 0, 0, vertex.x, vertex.y, 0.0 );
            gv_shapes_layer_select_new_shape( 
                GV_SHAPES_LAYER(GV_POINT_TOOL(tool)->layer), 
                new_point );
        }
    }
}
Пример #2
0
static gboolean
gv_rect_tool_button_press(GvTool *r_tool, GdkEventButton *event)
{
    GvRectTool *tool = GV_RECT_TOOL(r_tool);

    if (event->button == 1 && !tool->drawing )
    {
        GvNodeInfo edit_node;
        int        before, shape_id, is_rectangle = FALSE;

        if (!gv_rect_tool_configure(tool)) return FALSE;

        if (gv_shape_layer_pick_shape(GV_SHAPE_LAYER(tool->layer), 
                                      GV_TOOL(tool)->view,
                                      event->x, event->y, &shape_id))
        {
            GvShape *shape;

            /* Is the shape a rectangle? */
            shape = gv_shapes_get_shape( tool->layer->data, shape_id );
            if( shape != NULL 
                && gv_shape_type(shape) == GVSHAPE_AREA
                && gv_shape_get_rings( shape ) == 1 
                && gv_shape_get_nodes( shape, 0 ) == 5 )
            {
                gvgeocoord   x1, y1, x2, y2;

                x1 = gv_shape_get_x(shape,0,0);
                y1 = gv_shape_get_y(shape,0,0);
                x2 = gv_shape_get_x(shape,0,2);
                y2 = gv_shape_get_y(shape,0,2);

                tool->winding = 1;
                is_rectangle = gv_shape_get_x(shape,0,1) == x1
                    && gv_shape_get_y(shape,0,1) == y2
                    && gv_shape_get_x(shape,0,3) == x2
                    && gv_shape_get_y(shape,0,3) == y1
                    && gv_shape_get_x(shape,0,4) == x1
                    && gv_shape_get_y(shape,0,4) == y1;

                if( !is_rectangle )
                {
                    tool->winding = 0;
                    is_rectangle = gv_shape_get_x(shape,0,1) == x2
                        && gv_shape_get_y(shape,0,1) == y1
                        && gv_shape_get_x(shape,0,3) == x1
                        && gv_shape_get_y(shape,0,3) == y2
                        && gv_shape_get_x(shape,0,4) == x1
                        && gv_shape_get_y(shape,0,4) == y1;
                }

                if( is_rectangle )
                {
                    gv_shape_layer_clear_selection(
                        GV_SHAPE_LAYER(tool->layer));
                    gv_shape_layer_select_shape(
                        GV_SHAPE_LAYER(tool->layer), shape_id);
                }
            }
        }

        /* Is the user selecting an existing rectangles edge/corner? */
        if (is_rectangle 
            && gv_shape_layer_pick_node(GV_SHAPE_LAYER(tool->layer), 
                                        GV_TOOL(tool)->view,
                                        event->x, event->y, &before,
                                        &edit_node) )
        {
            if( tool->winding == 0 )
            {
                if( before )
                    edit_node.node_id = 5 - edit_node.node_id;
                else
                    edit_node.node_id = 4 - edit_node.node_id;
            }

            if( before && edit_node.node_id == 1 )
                tool->picked = PICK_SIDE_LEFT;
            else if( before && edit_node.node_id == 2 )
                tool->picked = PICK_SIDE_BOTTOM;
            else if( before && edit_node.node_id == 3 )
                tool->picked = PICK_SIDE_RIGHT;
            else if( before && edit_node.node_id == 4 )
                tool->picked = PICK_SIDE_TOP;
            else if( edit_node.node_id == 0 )
                tool->picked = PICK_CORNER_TOPLEFT;
            else if( edit_node.node_id == 1 )
                tool->picked = PICK_CORNER_BOTTOMLEFT;
            else if( edit_node.node_id == 2 )
                tool->picked = PICK_CORNER_BOTTOMRIGHT;
            else if( edit_node.node_id == 3 )
                tool->picked = PICK_CORNER_TOPRIGHT;
            else if( edit_node.node_id == 4 )
                tool->picked = PICK_CORNER_TOPLEFT;
            else
            {
                g_warning( "Yikes!  What node is this?" );
                return FALSE;
            }

            tool->reshaping = TRUE;
            tool->shape_id = edit_node.shape_id;

            /* Close down undo.  A single operation describing the new
               ring will be pushed to undo when drawing stops. */
            gv_undo_close();
            gv_undo_disable();

            return FALSE;
        }

        /* Map pointer position to tail vertex */
        gv_view_area_map_pointer(GV_TOOL(tool)->view, event->x, event->y,
                                 &tool->v_tail.x, &tool->v_tail.y);

        if( gv_tool_check_bounds( GV_TOOL(tool),
                                  tool->v_tail.x, tool->v_tail.y ) )
        {
            /* Start a new rect */
            tool->drawing = TRUE;
            tool->v_head = tool->v_tail;
        }
    }
    return FALSE;
}