static gint
properties_apply(GtkWidget *canvas, gpointer data)
{
ObjectChange *obj_change = NULL;
if ( (current_obj == NULL) || (current_dia == NULL) )
return 0;
object_add_updates(current_obj, current_dia);
obj_change = current_obj->ops->apply_properties(current_obj);
object_add_updates(current_obj, current_dia);
diagram_update_connections_object(current_dia, current_obj, TRUE);
if (obj_change != NULL) {
undo_object_change(current_dia, current_obj, obj_change);
}
diagram_modified(current_dia);
diagram_update_extents(current_dia);
if (obj_change != NULL) {
undo_set_transactionpoint(current_dia->undo);
} else {
message_warning(_("This object doesn't support Undo/Redo.\n"
"Undo information erased."));
undo_clear(current_dia->undo);
}
diagram_flush(current_dia);
return 0;
}
static void
group_objects_apply(struct GroupObjectsChange *change, Diagram *dia)
{
GList *list;
DEBUG_PRINTF(("group_objects_apply()\n"));
change->applied = 1;
diagram_unselect_objects(dia, change->obj_list);
layer_remove_objects(change->layer, change->obj_list);
layer_add_object(change->layer, change->group);
object_add_updates(change->group, dia);
list = change->obj_list;
while (list != NULL) {
DiaObject *obj = (DiaObject *)list->data;
/* Have to hide any open properties dialog
if it contains some object in cut_list */
properties_hide_if_shown(dia, obj);
object_add_updates(obj, dia);
list = g_list_next(list);
}
diagram_tree_add_object(diagram_tree(), dia, change->group);
diagram_tree_remove_objects(diagram_tree(), change->obj_list);
}
static void
move_handle_revert(struct MoveHandleChange *change, Diagram *dia)
{
object_add_updates(change->obj, dia);
change->obj->ops->move_handle(change->obj, change->handle,
&change->orig_pos, NULL,
HANDLE_MOVE_USER_FINAL, 0);
object_add_updates(change->obj, dia);
diagram_update_connections_object(dia, change->obj, TRUE);
}
static void
connect_revert(struct ConnectChange *change, Diagram *dia)
{
object_unconnect(change->obj, change->handle);
object_add_updates(change->obj, dia);
change->obj->ops->move_handle(change->obj, change->handle ,
&change->handle_pos, NULL,
HANDLE_MOVE_CONNECTED, 0);
object_add_updates(change->obj, dia);
}
static void
connect_apply(struct ConnectChange *change, Diagram *dia)
{
object_connect(change->obj, change->handle, change->connectionpoint);
object_add_updates(change->obj, dia);
change->obj->ops->move_handle(change->obj, change->handle ,
&change->connectionpoint->pos,
change->connectionpoint,
HANDLE_MOVE_CONNECTED, 0);
object_add_updates(change->obj, dia);
}
/* Match and replace property values. */
static gboolean
_replace (DiaObject *obj, const SearchData *sd, const char *replacement)
{
ObjectChange *obj_change;
GPtrArray *plist = NULL;
plist = _match_props (obj, sd, replacement);
if (!plist)
return FALSE;
/* Refresh screen and free the list of modified properties. */
obj_change = object_apply_props (obj, plist);
prop_list_free (plist);
if (obj_change)
undo_object_change(sd->diagram, obj, obj_change);
object_add_updates(obj, sd->diagram);
diagram_update_connections_object(sd->diagram, obj, TRUE);
diagram_modified(sd->diagram);
diagram_object_modified(sd->diagram, obj);
diagram_update_extents(sd->diagram);
diagram_flush(sd->diagram);
return TRUE;
}
void
highlight_object(DiaObject *obj, DiaHighlightType type, Diagram *dia)
{
data_highlight_add(dia->data, obj, type);
object_add_updates(obj, dia);
}
static void
object_change_revert(struct ObjectChangeChange *change,
Diagram *dia)
{
object_add_updates(change->obj, dia);
change->obj_change->revert(change->obj_change, change->obj);
{ /* Make sure object updates its data: */
Point p = change->obj->position;
(change->obj->ops->move)(change->obj,&p);
}
object_add_updates(change->obj, dia);
diagram_update_connections_object(dia, change->obj, TRUE);
properties_update_if_shown(dia, change->obj);
}
static void
unconnect_revert(struct UnconnectChange *change, Diagram *dia)
{
object_connect(change->obj, change->handle, change->connectionpoint);
object_add_updates(change->obj, dia);
}
static void
unconnect_apply(struct UnconnectChange *change, Diagram *dia)
{
object_unconnect(change->obj, change->handle);
object_add_updates(change->obj, dia);
}
void
diagram_unselect_object(Diagram *diagram, DiaObject *obj)
{
object_add_updates(obj, diagram);
textedit_remove_focus(obj, diagram);
data_unselect(DIA_DIAGRAM_DATA(diagram), obj);
}
/* Updates all objects connected to the 'obj' object.
Calls this function recursively for objects modified.
If update_nonmoved is TRUE, also objects that have not
moved since last time is updated. This is not propagated
in the recursion.
*/
void
diagram_update_connections_object(Diagram *dia, DiaObject *obj,
int update_nonmoved)
{
int i,j;
ConnectionPoint *cp;
GList *list;
DiaObject *connected_obj;
Handle *handle;
for (i=0;i<dia_object_get_num_connections(obj);i++) {
cp = obj->connections[i];
if ((update_nonmoved) ||
(distance_point_point_manhattan(&cp->pos, &cp->last_pos) > CHANGED_TRESHOLD)) {
cp->last_pos = cp->pos;
list = cp->connected;
while (list!=NULL) {
connected_obj = (DiaObject *) list->data;
object_add_updates(connected_obj, dia);
handle = NULL;
for (j=0;j<connected_obj->num_handles;j++) {
if (connected_obj->handles[j]->connected_to == cp) {
handle = connected_obj->handles[j];
connected_obj->ops->move_handle(connected_obj, handle, &cp->pos,
cp, HANDLE_MOVE_CONNECTED,0);
}
}
object_add_updates(connected_obj, dia);
diagram_update_connections_object(dia, connected_obj, FALSE);
list = g_list_next(list);
}
}
}
if (obj->children) {
GList *child;
for (child = obj->children; child != NULL; child = child->next) {
DiaObject *child_obj = (DiaObject *)child->data;
diagram_update_connections_object(dia, child_obj, update_nonmoved);
}
}
}
static void
_object_remove(Diagram *dia,
Layer *layer,
DiaObject *obj,
gpointer user_data)
{
if (obj)
object_add_updates(obj, dia);
}
/** Make a single object selected.
* Note that an object inside a closed group cannot be made selected, nor
* can an object in a non-active layer.
* @param diagram The diagram that the object belongs to (sorta redundant now)
* @param obj The object that should be made selected.
*/
void
diagram_select(Diagram *diagram, DiaObject *obj)
{
if (dia_object_is_selectable(obj)) {
data_select(diagram->data, obj);
obj->ops->selectf(obj, NULL, NULL);
object_add_updates(obj, diagram);
}
}
static gint
properties_respond(GtkWidget *widget,
gint response_id,
gpointer data)
{
ObjectChange *obj_change = NULL;
gboolean set_tp = TRUE;
GList *tmp;
if ( response_id == GTK_RESPONSE_APPLY
|| response_id == GTK_RESPONSE_OK) {
if ((current_objects != NULL) && (current_dia != NULL)) {
object_add_updates_list(current_objects, current_dia);
for (tmp = current_objects; tmp != NULL; tmp = tmp->next) {
DiaObject *current_obj = (DiaObject*)tmp->data;
obj_change = current_obj->ops->apply_properties_from_dialog(current_obj, object_part);
object_add_updates(current_obj, current_dia);
diagram_update_connections_object(current_dia, current_obj, TRUE);
if (obj_change != NULL) {
undo_object_change(current_dia, current_obj, obj_change);
set_tp = set_tp && TRUE;
} else
set_tp = FALSE;
diagram_object_modified(current_dia, current_obj);
}
diagram_modified(current_dia);
diagram_update_extents(current_dia);
if (set_tp) {
undo_set_transactionpoint(current_dia->undo);
} else {
message_warning(_("This object doesn't support Undo/Redo.\n"
"Undo information erased."));
undo_clear(current_dia->undo);
}
diagram_flush(current_dia);
}
}
if (response_id != GTK_RESPONSE_APPLY) {
#ifdef G_OS_WIN32
/* on windows we are not hiding the dialog, because shrinking when hidden does
* not work (the dialog shows up with the same size as before, bug #333751) */
gtk_widget_destroy (dialog);
#else
properties_dialog_hide();
#endif
}
return 0;
}
void
object_add_updates_list(GList *list, Diagram *dia)
{
DiaObject *obj;
while (list != NULL) {
obj = (DiaObject *)list->data;
object_add_updates(obj, dia);
list = g_list_next(list);
}
}
static void
group_objects_revert(struct GroupObjectsChange *change, Diagram *dia)
{
DEBUG_PRINTF(("group_objects_revert()\n"));
change->applied = 0;
diagram_unselect_object(dia, change->group);
object_add_updates(change->group, dia);
layer_set_object_list(change->layer, g_list_copy(change->orig_list));
object_add_updates_list(change->obj_list, dia);
properties_hide_if_shown(dia, change->group);
diagram_tree_add_objects(diagram_tree(), dia, change->obj_list);
diagram_tree_remove_object(diagram_tree(), change->group);
}
static void
ungroup_objects_apply(struct UngroupObjectsChange *change, Diagram *dia)
{
DEBUG_PRINTF(("ungroup_objects_apply()\n"));
change->applied = 1;
diagram_unselect_object(dia, change->group);
object_add_updates(change->group, dia);
layer_replace_object_with_list(change->layer, change->group,
g_list_copy(change->obj_list));
object_add_updates_list(change->obj_list, dia);
properties_hide_if_shown(dia, change->group);
diagram_tree_add_objects(diagram_tree(), dia, change->obj_list);
diagram_tree_remove_object(diagram_tree(), change->group);
}
static void
modify_motion (ModifyTool *tool,
GdkEventMotion *event,
DDisplay *ddisp)
{
Point to;
Point now, delta, full_delta;
gboolean auto_scroll, vertical = FALSE;
ConnectionPoint *connectionpoint = NULL;
ObjectChange *objchange = NULL;
ddisplay_untransform_coords(ddisp, event->x, event->y, &to.x, &to.y);
if (tool->state==STATE_NONE) {
DiaObject *obj = NULL;
Handle *handle = NULL;
diagram_find_closest_handle (ddisp->diagram, &handle, &obj, &to);
if (handle && handle->type != HANDLE_NON_MOVABLE
&& handle->id >= HANDLE_RESIZE_NW && handle->id <= HANDLE_RESIZE_SE
&& handle_is_clicked(ddisp, handle, &to)
&& g_list_length (ddisp->diagram->data->selected) == 1)
ddisplay_set_all_cursor (get_direction_cursor (CURSOR_DIRECTION_0 + handle->id));
else
ddisplay_set_all_cursor_name (NULL, "default");
return; /* Fast path... */
}
auto_scroll = ddisplay_autoscroll(ddisp, event->x, event->y);
if (!modify_move_already(tool, ddisp, &to)) return;
switch (tool->state) {
case STATE_MOVE_OBJECT:
if (tool->orig_pos == NULL) {
GList *list, *pla;
int i;
DiaObject *obj;
/* consider non-selected children affected */
pla = list = parent_list_affected(ddisp->diagram->data->selected);
tool->orig_pos = g_new(Point, g_list_length(list));
i=0;
while (list != NULL) {
obj = (DiaObject *) list->data;
tool->orig_pos[i] = obj->position;
list = g_list_next(list); i++;
}
g_list_free (pla);
}
if (tool->break_connections)
diagram_unconnect_selected(ddisp->diagram); /* Pushes UNDO info */
if (gdk_event_to_dia_ModifierKeys (event->state) & MODIFIER_CONTROL) {
full_delta = to;
point_sub(&full_delta, &tool->start_at);
vertical = (fabs(full_delta.x) < fabs(full_delta.y));
}
point_add(&to, &tool->move_compensate);
snap_to_grid(ddisp, &to.x, &to.y);
now = tool->object->position;
delta = to;
point_sub(&delta, &now);
if (gdk_event_to_dia_ModifierKeys (event->state) & MODIFIER_CONTROL) {
/* Up-down or left-right */
if (vertical) {
delta.x = tool->start_at.x + tool->move_compensate.x - now.x;
} else {
delta.y = tool->start_at.y + tool->move_compensate.y - now.y;
}
}
object_add_updates_list(ddisp->diagram->data->selected, ddisp->diagram);
objchange = object_list_move_delta(ddisp->diagram->data->selected, &delta);
if (objchange != NULL) {
undo_object_change(ddisp->diagram, tool->object, objchange);
}
object_add_updates_list(ddisp->diagram->data->selected, ddisp->diagram);
object_add_updates(tool->object, ddisp->diagram);
/* Put current mouse position in status bar */
{
gchar *postext;
GtkStatusbar *statusbar = GTK_STATUSBAR (ddisp->modified_status);
guint context_id = gtk_statusbar_get_context_id (statusbar, "ObjectPos");
gtk_statusbar_pop (statusbar, context_id);
postext = g_strdup_printf("%.3f, %.3f - %.3f, %.3f",
tool->object->bounding_box.left,
tool->object->bounding_box.top,
tool->object->bounding_box.right,
tool->object->bounding_box.bottom);
gtk_statusbar_pop (statusbar, context_id);
gtk_statusbar_push (statusbar, context_id, postext);
g_free(postext);
}
diagram_update_connections_selection(ddisp->diagram);
diagram_flush(ddisp->diagram);
break;
case STATE_MOVE_HANDLE:
full_delta = to;
point_sub(&full_delta, &tool->start_at);
/* make sure resizing is restricted to its parent */
/* if resize was blocked by parent, that means the resizing was
outward, thus it won't bother the children so we don't have to
check the children */
if (!parent_handle_move_out_check(tool->object, &to))
parent_handle_move_in_check(tool->object, &to, &tool->start_at);
if (gdk_event_to_dia_ModifierKeys (event->state) & MODIFIER_CONTROL)
vertical = (fabs(full_delta.x) < fabs(full_delta.y));
highlight_reset_all(ddisp->diagram);
if ((tool->handle->connect_type != HANDLE_NONCONNECTABLE)) {
/* Move to ConnectionPoint if near: */
connectionpoint = object_find_connectpoint_display (ddisp,
&to,
tool->object, TRUE);
if (connectionpoint != NULL) {
DiaHighlightType type;
to = connectionpoint->pos;
if (connectionpoint->flags & CP_FLAGS_MAIN) {
type = DIA_HIGHLIGHT_CONNECTIONPOINT_MAIN;
} else {
type = DIA_HIGHLIGHT_CONNECTIONPOINT;
}
highlight_object(connectionpoint->object, type, ddisp->diagram);
ddisplay_set_all_cursor_name (NULL, "crosshair");
}
}
if (connectionpoint == NULL) {
/* No connectionopoint near, then snap to grid (if enabled) */
snap_to_grid(ddisp, &to.x, &to.y);
ddisplay_set_all_cursor_name (NULL, "move");
}
if (tool->break_connections) {
/* break connections to the handle currently selected. */
if (tool->handle->connected_to!=NULL) {
Change *change = undo_unconnect (ddisp->diagram,
tool->object,
tool->handle);
(change->apply)(change, ddisp->diagram);
}
}
if (gdk_event_to_dia_ModifierKeys (event->state) & MODIFIER_CONTROL) {
/* Up-down or left-right */
if (vertical) {
to.x = tool->start_at.x;
} else {
to.y = tool->start_at.y;
}
}
if (tool->orig_pos == NULL) {
tool->orig_pos = g_new(Point, 1);
*tool->orig_pos = tool->handle->pos;
}
/* Put current mouse position in status bar */
{
gchar *postext;
GtkStatusbar *statusbar = GTK_STATUSBAR (ddisp->modified_status);
guint context_id = gtk_statusbar_get_context_id (statusbar, "ObjectPos");
if (tool->object) { /* play safe */
real w = tool->object->bounding_box.right - tool->object->bounding_box.left;
real h = tool->object->bounding_box.bottom - tool->object->bounding_box.top;
postext = g_strdup_printf("%.3f, %.3f (%.3fx%.3f)", to.x, to.y, w, h);
} else {
postext = g_strdup_printf("%.3f, %.3f", to.x, to.y);
}
gtk_statusbar_pop (statusbar, context_id);
gtk_statusbar_push (statusbar, context_id, postext);
g_free(postext);
}
object_add_updates(tool->object, ddisp->diagram);
/* Handle undo */
if (tool->object)
objchange = tool->object->ops->move_handle(tool->object, tool->handle,
&to, connectionpoint,
HANDLE_MOVE_USER, gdk_event_to_dia_ModifierKeys(event->state));
if (objchange != NULL) {
undo_object_change(ddisp->diagram, tool->object, objchange);
}
object_add_updates(tool->object, ddisp->diagram);
diagram_update_connections_selection(ddisp->diagram);
diagram_flush(ddisp->diagram);
break;
case STATE_BOX_SELECT:
tool->end_box = to;
ddisplay_transform_coords (ddisp,
MIN (tool->start_box.x, tool->end_box.x),
MIN (tool->start_box.y, tool->end_box.y),
&tool->x1, &tool->y1);
ddisplay_transform_coords (ddisp,
MAX (tool->start_box.x, tool->end_box.x),
MAX (tool->start_box.y, tool->end_box.y),
&tool->x2, &tool->y2);
dia_interactive_renderer_set_selection (ddisp->renderer,
TRUE,
tool->x1,
tool->y1,
tool->x2 - tool->x1,
tool->y2 - tool->y1);
ddisplay_flush (ddisp);
break;
case STATE_NONE:
break;
default:
message_error("Internal error: Strange state in modify_tool\n");
}
tool->last_to = to;
tool->auto_scrolled = auto_scroll;
}
static void
modify_button_release(ModifyTool *tool, GdkEventButton *event,
DDisplay *ddisp)
{
Point *dest_pos, to;
GList *list;
int i;
ObjectChange *objchange;
tool->break_connections = FALSE;
ddisplay_set_all_cursor(default_cursor);
/* remove position from status bar */
{
GtkStatusbar *statusbar = GTK_STATUSBAR (ddisp->modified_status);
guint context_id = gtk_statusbar_get_context_id (statusbar, "ObjectPos");
gtk_statusbar_pop (statusbar, context_id);
}
switch (tool->state) {
case STATE_MOVE_OBJECT:
/* Return to normal state */
gdk_pointer_ungrab (event->time);
ddisplay_untransform_coords(ddisp, event->x, event->y, &to.x, &to.y);
if (!modify_move_already(tool, ddisp, &to)) {
tool->orig_pos = NULL;
tool->state = STATE_NONE;
return;
}
diagram_update_connections_selection(ddisp->diagram);
if (tool->orig_pos != NULL) {
/* consider the non-selected children affected */
list = parent_list_affected(ddisp->diagram->data->selected);
dest_pos = g_new(Point, g_list_length(list));
i=0;
while (list != NULL) {
DiaObject *obj = (DiaObject *) list->data;
dest_pos[i] = obj->position;
list = g_list_next(list); i++;
}
undo_move_objects(ddisp->diagram, tool->orig_pos, dest_pos,
parent_list_affected(ddisp->diagram->data->selected));
}
ddisplay_connect_selected(ddisp); /* pushes UNDO info */
diagram_update_extents(ddisp->diagram);
diagram_modified(ddisp->diagram);
diagram_flush(ddisp->diagram);
undo_set_transactionpoint(ddisp->diagram->undo);
tool->orig_pos = NULL;
tool->state = STATE_NONE;
break;
case STATE_MOVE_HANDLE:
gdk_pointer_ungrab (event->time);
tool->state = STATE_NONE;
if (tool->orig_pos != NULL) {
undo_move_handle(ddisp->diagram, tool->handle, tool->object,
*tool->orig_pos, tool->last_to, gdk_event_to_dia_ModifierKeys(event->state));
}
/* Final move: */
object_add_updates(tool->object, ddisp->diagram);
objchange = tool->object->ops->move_handle(tool->object, tool->handle,
&tool->last_to, NULL,
HANDLE_MOVE_USER_FINAL,gdk_event_to_dia_ModifierKeys(event->state));
if (objchange != NULL) {
undo_object_change(ddisp->diagram, tool->object, objchange);
}
object_add_updates(tool->object, ddisp->diagram);
/* Connect if possible: */
if (tool->handle->connect_type != HANDLE_NONCONNECTABLE) {
object_connect_display(ddisp, tool->object, tool->handle, TRUE); /* pushes UNDO info */
diagram_update_connections_selection(ddisp->diagram);
}
highlight_reset_all(ddisp->diagram);
diagram_flush(ddisp->diagram);
diagram_modified(ddisp->diagram);
diagram_update_extents(ddisp->diagram);
undo_set_transactionpoint(ddisp->diagram->undo);
if (tool->orig_pos != NULL) {
g_free(tool->orig_pos);
tool->orig_pos = NULL;
}
break;
case STATE_BOX_SELECT:
gdk_pointer_ungrab (event->time);
/* Remove last box: */
dia_interactive_renderer_set_selection (ddisp->renderer,
FALSE, 0, 0, 0, 0);
{
GList *list, *list_to_free;
list = list_to_free = find_selected_objects(ddisp, tool);
if (selection_style == SELECT_REPLACE &&
!(event->state & GDK_SHIFT_MASK)) {
/* Not Multi-select => Remove all selected */
diagram_remove_all_selected(ddisp->diagram, TRUE);
}
if (selection_style == SELECT_INTERSECTION) {
GList *intersection = NULL;
while (list != NULL) {
DiaObject *obj = (DiaObject *)list->data;
if (diagram_is_selected(ddisp->diagram, obj)) {
intersection = g_list_append(intersection, obj);
}
list = g_list_next(list);
}
list = intersection;
diagram_remove_all_selected(ddisp->diagram, TRUE);
while (list != NULL) {
DiaObject *obj = (DiaObject *)list->data;
diagram_select(ddisp->diagram, obj);
list = g_list_next(list);
}
g_list_free(intersection);
} else {
while (list != NULL) {
DiaObject *obj = (DiaObject *)list->data;
if (selection_style == SELECT_REMOVE) {
if (diagram_is_selected(ddisp->diagram, obj))
diagram_unselect_object(ddisp->diagram, obj);
} else if (selection_style == SELECT_INVERT) {
if (diagram_is_selected(ddisp->diagram, obj))
diagram_unselect_object(ddisp->diagram, obj);
else
diagram_select(ddisp->diagram, obj);
} else {
if (!diagram_is_selected(ddisp->diagram, obj))
diagram_select(ddisp->diagram, obj);
}
list = g_list_next(list);
}
}
g_list_free(list_to_free);
}
ddisplay_do_update_menu_sensitivity(ddisp);
ddisplay_flush(ddisp);
tool->state = STATE_NONE;
break;
case STATE_NONE:
break;
default:
message_error("Internal error: Strange state in modify_tool\n");
}
}
void
highlight_object_off(DiaObject *obj, Diagram *dia)
{
object_add_updates(obj, dia);
data_highlight_remove(dia->data, obj);
}
static void
create_object_button_press(CreateObjectTool *tool, GdkEventButton *event,
DDisplay *ddisp)
{
Point clickedpoint, origpoint;
Handle *handle1;
Handle *handle2;
DiaObject *obj;
real click_distance;
ddisplay_untransform_coords(ddisp,
(int)event->x, (int)event->y,
&clickedpoint.x, &clickedpoint.y);
origpoint = clickedpoint;
snap_to_grid(ddisp, &clickedpoint.x, &clickedpoint.y);
click_distance = ddisplay_untransform_length(ddisp, 3.0);
obj = dia_object_default_create (tool->objtype, &clickedpoint,
tool->user_data,
&handle1, &handle2);
tool->obj = obj; /* ensure that tool->obj is initialised in case we
return early. */
if (!obj) {
tool->moving = FALSE;
tool->handle = NULL;
message_error(_("'%s' creation failed"), tool->objtype ? tool->objtype->name : "NULL");
return;
}
diagram_add_object(ddisp->diagram, obj);
/* Try a connect */
if (handle1 != NULL &&
handle1->connect_type != HANDLE_NONCONNECTABLE) {
ConnectionPoint *connectionpoint;
connectionpoint =
object_find_connectpoint_display(ddisp, &origpoint, obj, TRUE);
if (connectionpoint != NULL) {
(obj->ops->move)(obj, &origpoint);
}
}
if (!(event->state & GDK_SHIFT_MASK)) {
/* Not Multi-select => remove current selection */
diagram_remove_all_selected(ddisp->diagram, TRUE);
}
diagram_select(ddisp->diagram, obj);
/* Connect first handle if possible: */
if ((handle1!= NULL) &&
(handle1->connect_type != HANDLE_NONCONNECTABLE)) {
object_connect_display(ddisp, obj, handle1, TRUE);
}
object_add_updates(obj, ddisp->diagram);
ddisplay_do_update_menu_sensitivity(ddisp);
diagram_flush(ddisp->diagram);
if (handle2 != NULL) {
tool->handle = handle2;
tool->moving = TRUE;
tool->last_to = handle2->pos;
gdk_pointer_grab (gtk_widget_get_window(ddisp->canvas), FALSE,
GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON1_MOTION_MASK | GDK_BUTTON_RELEASE_MASK,
NULL, NULL, event->time);
ddisplay_set_all_cursor(get_cursor(CURSOR_SCROLL));
} else {
diagram_update_extents(ddisp->diagram);
tool->moving = FALSE;
}
}
static void
create_object_motion(CreateObjectTool *tool, GdkEventMotion *event,
DDisplay *ddisp)
{
Point to;
ConnectionPoint *connectionpoint = NULL;
gchar *postext;
GtkStatusbar *statusbar;
guint context_id;
if (!tool->moving)
return;
ddisplay_untransform_coords(ddisp, event->x, event->y, &to.x, &to.y);
/* make sure the new object is restricted to its parent */
parent_handle_move_out_check(tool->obj, &to);
/* Move to ConnectionPoint if near: */
if (tool->handle != NULL &&
tool->handle->connect_type != HANDLE_NONCONNECTABLE) {
connectionpoint =
object_find_connectpoint_display(ddisp, &to, tool->obj, TRUE);
if (connectionpoint != NULL) {
to = connectionpoint->pos;
highlight_object(connectionpoint->object, DIA_HIGHLIGHT_CONNECTIONPOINT, ddisp->diagram);
ddisplay_set_all_cursor(get_cursor(CURSOR_CONNECT));
}
}
if (connectionpoint == NULL) {
/* No connectionopoint near, then snap to grid (if enabled) */
snap_to_grid(ddisp, &to.x, &to.y);
highlight_reset_all(ddisp->diagram);
ddisplay_set_all_cursor(get_cursor(CURSOR_SCROLL));
}
object_add_updates(tool->obj, ddisp->diagram);
tool->obj->ops->move_handle(tool->obj, tool->handle, &to, connectionpoint,
HANDLE_MOVE_CREATE, 0);
object_add_updates(tool->obj, ddisp->diagram);
/* Put current mouse position in status bar */
statusbar = GTK_STATUSBAR (ddisp->modified_status);
context_id = gtk_statusbar_get_context_id (statusbar, "ObjectPos");
postext = g_strdup_printf("%.3f, %.3f - %.3f, %.3f",
tool->obj->bounding_box.left,
tool->obj->bounding_box.top,
tool->obj->bounding_box.right,
tool->obj->bounding_box.bottom);
gtk_statusbar_pop (statusbar, context_id);
gtk_statusbar_push (statusbar, context_id, postext);
g_free(postext);
diagram_flush(ddisp->diagram);
tool->last_to = to;
return;
}
static void
create_object_button_release(CreateObjectTool *tool, GdkEventButton *event,
DDisplay *ddisp)
{
GList *list = NULL;
DiaObject *obj = tool->obj;
gboolean reset;
GList *parent_candidates;
g_return_if_fail (obj != NULL);
if (!obj) /* not sure if this isn't enough */
return; /* could be a legal invariant */
if (tool->moving) {
gdk_pointer_ungrab (event->time);
object_add_updates(tool->obj, ddisp->diagram);
tool->obj->ops->move_handle(tool->obj, tool->handle, &tool->last_to,
NULL, HANDLE_MOVE_CREATE_FINAL, 0);
object_add_updates(tool->obj, ddisp->diagram);
}
parent_candidates =
layer_find_objects_containing_rectangle(obj->parent_layer,
&obj->bounding_box);
/* whole object must be within another object to parent it */
for (; parent_candidates != NULL; parent_candidates = g_list_next(parent_candidates)) {
DiaObject *parent_obj = (DiaObject *) parent_candidates->data;
if (obj != parent_obj
&& object_within_parent(obj, parent_obj)) {
Change *change = undo_parenting(ddisp->diagram, parent_obj, obj, TRUE);
(change->apply)(change, ddisp->diagram);
break;
/*
obj->parent = parent_obj;
parent_obj->children = g_list_append(parent_obj->children, obj);
*/
}
}
g_list_free(parent_candidates);
list = g_list_prepend(list, tool->obj);
undo_insert_objects(ddisp->diagram, list, 1);
if (tool->moving) {
if (tool->handle->connect_type != HANDLE_NONCONNECTABLE) {
object_connect_display(ddisp, tool->obj, tool->handle, TRUE);
diagram_update_connections_selection(ddisp->diagram);
diagram_flush(ddisp->diagram);
}
tool->moving = FALSE;
tool->handle = NULL;
tool->obj = NULL;
}
{
/* remove position from status bar */
GtkStatusbar *statusbar = GTK_STATUSBAR (ddisp->modified_status);
guint context_id = gtk_statusbar_get_context_id (statusbar, "ObjectPos");
gtk_statusbar_pop (statusbar, context_id);
}
highlight_reset_all(ddisp->diagram);
reset = prefs.reset_tools_after_create != tool->invert_persistence;
/* kind of backward: first starting editing to see if it is possible at all, than GUI reflection */
if (textedit_activate_object(ddisp, obj, NULL) && reset) {
gtk_action_activate (menus_get_action ("ToolsTextedit"));
reset = FALSE; /* don't switch off textedit below */
}
diagram_update_extents(ddisp->diagram);
diagram_modified(ddisp->diagram);
undo_set_transactionpoint(ddisp->diagram->undo);
if (reset)
tool_reset();
ddisplay_set_all_cursor(default_cursor);
ddisplay_do_update_menu_sensitivity(ddisp);
}
void
diagram_selected_break_external(Diagram *dia)
{
GList *list;
GList *connected_list;
DiaObject *obj;
DiaObject *other_obj;
int i,j;
list = dia->data->selected;
while (list != NULL) {
obj = (DiaObject *)list->data;
/* Break connections between this object and objects not selected: */
for (i=0;i<obj->num_handles;i++) {
ConnectionPoint *con_point;
con_point = obj->handles[i]->connected_to;
if ( con_point == NULL )
break; /* Not connected */
other_obj = con_point->object;
if (g_list_find(dia->data->selected, other_obj) == NULL) {
/* other_obj is not selected, break connection */
Change *change = undo_unconnect(dia, obj, obj->handles[i]);
(change->apply)(change, dia);
object_add_updates(obj, dia);
}
}
/* Break connections from non selected objects to this object: */
for (i=0;i<obj->num_connections;i++) {
connected_list = obj->connections[i]->connected;
while (connected_list != NULL) {
other_obj = (DiaObject *)connected_list->data;
if (g_list_find(dia->data->selected, other_obj) == NULL) {
/* other_obj is not in list, break all connections
to obj from other_obj */
for (j=0;j<other_obj->num_handles;j++) {
ConnectionPoint *con_point;
con_point = other_obj->handles[j]->connected_to;
if (con_point && (con_point->object == obj)) {
Change *change;
connected_list = g_list_previous(connected_list);
change = undo_unconnect(dia, other_obj,
other_obj->handles[j]);
(change->apply)(change, dia);
if (connected_list == NULL)
connected_list = obj->connections[i]->connected;
}
}
}
connected_list = g_list_next(connected_list);
}
}
list = g_list_next(list);
}
}