qi-hardware/fped
1
0
Fork 0
mirror of git://projects.qi-hardware.com/fped.git synced 2024-11-05 08:27:09 +02:00
Code
347ef8aad5
fped/delete.c
werner 347ef8aad5 When deleting frame "foo" in root->foo->bar and then linking bar from root, 
bar didn't automatically become active, which was rather confusing. We now
also try harder to keep a frame active. 

- when deleting a frame, also reset all outbound active references
- when removing the active frame reference, search for a suitable replacement
  instead of just setting it to NULL
- gui_style.c: made inactive frames a little more visible



git-svn-id: http://svn.openmoko.org/trunk/eda/fped@5516 99fdad57-331a-0410-800a-d7fa5415bdb3
2009-08-21 19:50:45 +00:00

667 lines
12 KiB
C
Raw Blame History

/*
* delete.c - Object deletion
*
* Written 2009 by Werner Almesberger
* Copyright 2009 by Werner Almesberger
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*/
#include <stdlib.h>
#include <assert.h>
#include "util.h"
#include "error.h"
#include "expr.h"
#include "obj.h"
#include "delete.h"
static struct deletion {
enum del_type {
dt_vec,
dt_obj,
dt_frame,
dt_table,
dt_row,
dt_column,
dt_loop,
} type;
union {
struct {
struct frame *ref;
struct frame *prev;
} frame;
struct {
struct vec *ref;
struct vec *prev;
} vec;
struct {
struct obj *ref;
struct obj *prev;
} obj;
struct {
struct table *ref;
struct table *prev;
} table;
struct {
struct row *ref;
struct row *prev;
} row;
struct column {
struct var *var;
struct value *values;
struct table *table;
int n;
} col;
struct {
struct loop *ref;
struct loop *prev;
} loop;
} u;
int group;
struct deletion *next;
} *deletions = NULL;
static int groups = 0;
static void do_delete_vec(struct vec *vec);
static void do_delete_obj(struct obj *obj);
/* ----- helper functions -------------------------------------------------- */
static struct deletion *new_deletion(enum del_type type)
{
struct deletion *del;
del = alloc_type(struct deletion);
del->type = type;
del->group = groups;
del->next = deletions;
deletions = del;
return del;
}
static void reset_active_ref(struct frame *ref)
{
const struct frame *frame;
struct obj *obj = NULL;
for (frame = frames; frame; frame = frame->next)
for (obj = frame->objs; obj; obj = obj->next)
if (obj->type == ot_frame && obj->u.frame.ref == ref)
break;
ref->active_ref = obj;
}
/* ----- vectors ----------------------------------------------------------- */
static void destroy_vec(struct vec *vec)
{
free_expr(vec->x);
free_expr(vec->y);
free(vec);
}
static void delete_vecs_by_ref(struct vec *vecs, const struct vec *ref)
{
while (vecs) {
if (vecs->base == ref)
do_delete_vec(vecs);
vecs = vecs->next;
}
}
static int obj_has_ref(const struct obj *obj, const struct vec *ref)
{
if (obj->base == ref)
return 1;
switch (obj->type) {
case ot_frame:
return 0;
case ot_line:
return obj->u.line.other == ref;
case ot_rect:
return obj->u.rect.other == ref;
case ot_pad:
return obj->u.pad.other == ref;
case ot_arc:
return obj->u.arc.start == ref || obj->u.arc.end == ref;
case ot_meas:
return obj->u.meas.high == ref;
default:
abort();
}
}
static void delete_objs_by_ref(struct obj **objs, const struct vec *ref)
{
struct obj *obj;
for (obj = *objs; obj; obj = obj->next)
if (obj_has_ref(obj, ref))
do_delete_obj(obj);
}
static void do_delete_vec(struct vec *vec)
{
struct vec *walk, *prev;
struct deletion *del;
prev = NULL;
for (walk = vec->frame->vecs; walk != vec; walk = walk->next)
prev = walk;
if (prev)
prev->next = vec->next;
else
vec->frame->vecs = vec->next;
del = new_deletion(dt_vec);
del->u.vec.ref = vec;
del->u.vec.prev = prev;
delete_vecs_by_ref(vec->frame->vecs, vec);
delete_objs_by_ref(&vec->frame->objs, vec);
}
void delete_vec(struct vec *vec)
{
groups++;
do_delete_vec(vec);
}
static void undelete_vec(struct vec *vec, struct vec *prev)
{
if (prev) {
assert(vec->next == prev->next);
prev->next = vec;
} else {
assert(vec->next == vec->frame->vecs);
vec->frame->vecs = vec;
}
}
/* ----- objects ----------------------------------------------------------- */
static void destroy_obj(struct obj *obj)
{
switch (obj->type) {
case ot_frame:
if (obj->u.frame.ref->active_ref == obj)
reset_active_ref(obj->u.frame.ref);
break;
case ot_pad:
free(obj->u.pad.name);
break;
case ot_line:
free_expr(obj->u.line.width);
break;
case ot_rect:
free_expr(obj->u.rect.width);
break;
case ot_arc:
free_expr(obj->u.arc.width);
break;
case ot_meas:
if (obj->u.meas.label)
free(obj->u.meas.label);
if (obj->u.meas.offset)
free_expr(obj->u.meas.offset);
break;
default:
abort();
}
free(obj);
}
static void do_delete_obj(struct obj *obj)
{
struct obj *walk, *prev;
struct deletion *del;
prev = NULL;
for (walk = obj->frame->objs; walk != obj; walk = walk->next)
prev = walk;
if (prev)
prev->next = obj->next;
else
obj->frame->objs = obj->next;
del = new_deletion(dt_obj);
del->u.obj.ref = obj;
del->u.obj.prev = prev;
if (obj->type == ot_frame && obj->u.frame.ref->active_ref == obj)
reset_active_ref(obj->u.frame.ref);
}
void delete_obj(struct obj *obj)
{
groups++;
do_delete_obj(obj);
}
static void undelete_obj(struct obj *obj, struct obj *prev)
{
if (prev) {
assert(obj->next == prev->next);
prev->next = obj;
} else {
assert(obj->next == obj->frame->objs);
obj->frame->objs = obj;
}
}
/* ----- rows -------------------------------------------------------------- */
static void destroy_row(struct row *row)
{
struct value *next_value;
while (row->values) {
next_value = row->values->next;
free_expr(row->values->expr);
free(row->values);
row->values = next_value;
}
free(row);
}
void delete_row(struct row *row)
{
struct deletion *del;
struct row *walk, *prev;
groups++;
prev = NULL;
for (walk = row->table->rows; walk != row; walk = walk->next)
prev = walk;
if (prev)
prev->next = row->next;
else
row->table->rows = row->next;
del = new_deletion(dt_row);
del->u.row.ref = row;
del->u.row.prev = prev;
}
static void undelete_row(struct row *row, struct row *prev)
{
if (prev) {
assert(row->next == prev->next);
prev->next = row;
} else {
assert(row->next == row->table->rows);
row->table->rows = row;
}
}
/* ----- columns ----------------------------------------------------------- */
void delete_column(struct table *table, int n)
{
struct deletion *del;
struct column *col;
struct var **var;
struct row *row;
struct value **next, **value;
int i;
groups++;
del = new_deletion(dt_column);
col = &del->u.col;
col->table = table;
col->n = n;
var = &table->vars;
for (i = 0; i != n; i++)
var = &(*var)->next;
col->var = *var;
*var = (*var)->next;
next = &col->values;
for (row = table->rows; row; row = row->next) {
value = &row->values;
for (i = 0; i != n; i++)
value = &(*value)->next;
*next = *value;
*value = (*value)->next;
next = &(*next)->next;
}
*next = NULL;
}
static void undelete_column(const struct column *col)
{
struct var **var;
struct row *row;
struct value **anchor, *value, *next;
int i;
var = &col->table->vars;
for (i = 0; i != col->n; i++)
var = &(*var)->next;
col->var->next = *var;
*var = col->var;
value = col->values;
for (row = col->table->rows; row; row = row->next) {
anchor = &row->values;
for (i = 0; i != col->n; i++)
anchor = &(*anchor)->next;
next = value->next;
value->next = *anchor;
*anchor = value;
value = next;
}
}
/* ----- tables ------------------------------------------------------------ */
static void destroy_table(struct table *table)
{
struct var *next_var;
while (table->vars) {
next_var = table->vars->next;
free(table->vars);
table->vars = next_var;
}
while (table->rows) {
delete_row(table->rows);
destroy();
}
free(table);
}
void delete_table(struct table *table)
{
struct frame *frame = table->vars->frame;
struct deletion *del;
struct table *walk, *prev;
groups++;
prev = NULL;
for (walk = frame->tables; walk != table; walk = walk->next)
prev = walk;
if (prev)
prev->next = table->next;
else
frame->tables = table->next;
del = new_deletion(dt_table);
del->u.table.ref = table;
del->u.table.prev = prev;
}
static void undelete_table(struct table *table, struct table *prev)
{
struct frame *frame = table->vars->frame;
if (prev) {
assert(table->next == prev->next);
prev->next = table;
} else {
assert(table->next == frame->tables);
frame->tables = table;
}
}
/* ----- loops ------------------------------------------------------------- */
static void destroy_loop(struct loop *loop)
{
free_expr(loop->from.expr);
free_expr(loop->to.expr);
free(loop);
}
void delete_loop(struct loop *loop)
{
struct frame *frame = loop->var.frame;
struct deletion *del;
struct loop *walk, *prev;
groups++;
prev = NULL;
for (walk = frame->loops; walk != loop; walk = walk->next)
prev = walk;
if (prev)
prev->next = loop->next;
else
frame->loops = loop->next;
del = new_deletion(dt_loop);
del->u.loop.ref = loop;
del->u.loop.prev = prev;
}
static void undelete_loop(struct loop *loop, struct loop *prev)
{
struct frame *frame = loop->var.frame;
if (prev) {
assert(loop->next == prev->next);
prev->next = loop;
} else {
assert(loop->next == frame->loops);
frame->loops = loop;
}
}
/* ----- frames ------------------------------------------------------------ */
static void destroy_frame(struct frame *frame)
{
while (frame->tables) {
delete_table(frame->tables);
destroy();
}
while (frame->loops) {
delete_loop(frame->loops);
destroy();
}
while (frame->vecs) {
delete_vec(frame->vecs);
destroy();
}
while (frame->objs) {
delete_obj(frame->objs);
destroy();
}
free(frame);
}
static void delete_references(const struct frame *ref)
{
struct frame *frame;
struct obj *obj;
for (frame = frames; frame; frame = frame->next)
for (obj = frame->objs; obj; obj = obj->next)
if (obj->type == ot_frame)
if (obj->u.frame.ref == ref)
do_delete_obj(obj);
for (obj = ref->objs; obj; obj = obj->next)
if (obj->type == ot_frame)
if (obj->u.frame.ref->active_ref == obj)
reset_active_ref(obj->u.frame.ref);
}
void delete_frame(struct frame *frame)
{
struct deletion *del;
groups++;
del = new_deletion(dt_frame);
del->u.frame.ref = frame;
del->u.frame.prev = frame->prev;
if (frame->next)
frame->next->prev = frame->prev;
if (frame->prev)
frame->prev->next = frame->next;
else
frames = frame->next;
delete_references(frame);
}
static void undelete_frame(struct frame *frame, struct frame *prev)
{
if (prev) {
assert(frame->next == prev->next);
prev->next = frame;
} else {
assert(frame->next == frames);
frames = frame;
}
frame->next->prev = frame;
}
/* ----- destroy/undelete interface ---------------------------------------- */
static void destroy_one(void)
{
struct deletion *del;
del = deletions;
switch (del->type) {
case dt_vec:
destroy_vec(del->u.vec.ref);
break;
case dt_obj:
destroy_obj(del->u.obj.ref);
break;
case dt_frame:
destroy_frame(del->u.frame.ref);
break;
case dt_loop:
destroy_loop(del->u.loop.ref);
break;
case dt_table:
destroy_table(del->u.table.ref);
break;
case dt_row:
destroy_row(del->u.row.ref);
break;
case dt_column:
abort(); /* @@@ later */
break;
default:
abort();
}
deletions = del->next;
free(del);
}
void destroy(void)
{
int group;
assert(deletions);
group = deletions->group;
while (deletions && deletions->group == group)
destroy_one();
}
static int undelete_one(void)
{
struct deletion *del;
if (!deletions)
return 0;
del = deletions;
switch (del->type) {
case dt_vec:
undelete_vec(del->u.vec.ref, del->u.vec.prev);
break;
case dt_obj:
undelete_obj(del->u.obj.ref, del->u.obj.prev);
break;
case dt_frame:
undelete_frame(del->u.frame.ref, del->u.frame.prev);
break;
case dt_loop:
undelete_loop(del->u.loop.ref, del->u.loop.prev);
break;
case dt_table:
undelete_table(del->u.table.ref, del->u.table.prev);
break;
case dt_row:
undelete_row(del->u.row.ref, del->u.row.prev);
break;
case dt_column:
undelete_column(&del->u.col);
break;
default:
abort();
}
deletions = del->next;
free(del);
return 1;
}
int undelete(void)
{
int group;
if (!deletions)
return 0;
group = deletions->group;
while (deletions && deletions->group == group)
undelete_one();
return 1;
}
void purge(void)
{
while (deletions)
destroy();
}
View Git Blame Copy Permalink