kernel/internal.h

Go to the documentation of this file.

#ifndef _KERNEL_INTERNAL_H_
#define _KERNEL_INTERNAL_H_

/*
 * Map of this header file.
 *
 * x String functions.
 *
 * x Properties.
 *
 * x OBJ and GO.
 *   - Inicialization and cleanup
 *   - Selection
 *   - Movement
 *   - Type-cast
 *   - Linking
 *   - Miscellaneous
 *
 * x Topological sort.
 *
 * x Transaction subsystem.
 *
 * x Hook functions.
 *
 * x Declaration of global variables
 */


#include "kernel/kernel.h"
#include "lib/smalloc.h"
#include "kernel/macro.h"
#include "kernel/go_internal.h"

void glt_kernel_init_hanger (struct hanger_info * info);
void glt_kernel_init_anchor (struct anchor_info * info);
        

#define END_OF_ARGS 255


/***************************************
 *                                     *
 *     Properties                      *
 *                                     *
 ***************************************/


struct prop_virtual
{
        struct prop p; 
        uns undo_mask;
        prop_value (*get)(struct o* o); 
        void (*set)(struct o* o, prop_value new_value); 
        void (*set_low)(struct o* o, prop_value new_value); 
        uns (*get_unit)(struct o* o); 
        void (*set_unit)(struct o* o, uns unit); 
};


void property_init(void);
void property_finish(void);

static inline void prop_init(struct o *o, struct prop_virtual* p)
        { o->prop.head.next = &p->p.n; }
void prop_finish(struct o *o);

void prop_name_set_low(struct o* o, string name, struct obj_page *alloc);

void prop_saving_copy(struct o* source, struct o* target);

static inline struct prop_virtual* prop2virt(struct prop* p)
        { ASSERT(p->flags & PTF_VIRTUAL); return (struct prop_virtual*)p; }

static inline prop_value prop_value_ref(uns type, prop_value value)
        { if(type == PT_STRING) string_ref(value.s); return value; }
static inline prop_value prop_value_unref(uns type, prop_value value)
        { if(type == PT_STRING) string_unref(value.s); return value; }


/****************************
 *                          *
 *   OBJ and GO functions   *
 *                          *
 ****************************/


/*
 * Inicialization and cleanup
 */

void object_init(void);
void object_finish(void);
void go_finish(struct go *go);

static inline void o_init(struct o *o, uns kind, uns type, uns subtype, struct prop_virtual *pv)
        { o->kind = kind; o->type = type; o->subtype = subtype; o->ref_count = 1; prop_init(o, pv); }
static inline void o_finish(struct o *o)
        { ASSERT_O(o); prop_finish(o); o->kind = 255; o->type = 255; o->subtype = 255; xfree(o); }

struct go* go_init(struct go *go, uns type, uns subtype, ...);
#ifdef DEBUG_KERNEL
#define go_init(...) go_init(__VA_ARGS__, END_OF_ARGS)
#endif
struct go_group* group_init(struct go_group *group, uns subtype);

static inline void hanger_free(struct hanger *h) { ASSERT_HANGER(h); h->info = NULL; xfree(h); }
static inline void anchor_free(struct anchor *a) { ASSERT_ANCHOR(a); a->info = NULL; xfree(a); }

void go_info_finish(struct go_info *gi, uns count);


/*
 * Selection
 */

void obj_select_low(struct obj* obj);
void obj_unselect_low(struct obj* obj);
void go_select_low(struct go *go);
void go_unselect_low(struct go *go);


/*
 * Movement
 */

static inline struct hanger_smart* tlg_get_first_hanger_smart(struct go_tlg *tlg)
        { cnode *n = clist_head(&tlg->mc); return n ? SKIP_BACK(struct hanger_smart, nhanger, n) : NULL; }

#define WALK_GO_DEPENDENT_BEGIN(_go, _walk) do { \
        struct anchor *_a; struct hanger *_h; \
        WALK_GO_HANGER_BEGIN(_go, _h) \
                WALK_HANGER_ANCHOR(_h, _a) { \
                        _walk = anchor_get_go(_a); \
                        do {

#define WALK_GO_DEPENDENT_END } while(0); } WALK_GO_HANGER_END } while(0);

#define WALK_HANGER_ANCHOR_DELSAFE(_hanger, _walk, _tmp) for(_walk = hanger_get_first_anchor(_hanger); _walk && (_tmp = hanger_get_next_anchor(_walk), 1); _walk = _tmp)

static inline int go_is_father(struct go *go, struct go *father)
        { for(; go; go = &go_get_group(go)->go) if(go == father) return 1; return 0; }


/*
 * Type-cast
 */

static inline struct go_tlg* go2tlg(struct go *go)
        { ASSERT_GROUP(go); return (struct go_tlg*)go; }
static inline struct go_tlg* void2tlg(void *go)
        { ASSERT_GROUP(go); return go; }
static inline struct go* tlg2go(struct go_tlg *tlg)
        { ASSERT_GROUP(tlg); return &tlg->group.go; }
static inline struct go* group2go(struct go_group *group)
        { ASSERT_GROUP(group); return &group->go; }


/*
 * Linking
 */

void go_insert(struct go *go, struct go_group *group, struct go *after);
void go_relink_low(struct go *go, struct go_group *group, struct go *prev);
void obj_relink_low(struct obj *obj, struct obj *father, struct obj *old_father, struct obj *after);
void anchor_rehang_mc_no_recompute(struct anchor* a, struct geom_point *gp);
void anchor_rehang_copy_no_recompute(struct anchor* a, struct hanger *h);

/*
 * Miscellaneous
 */

static inline int go_can_work(struct go *go)
        { ASSERT_GO(go); struct go_tlg *tlg = go_get_root(go); return trans_present && tlg2go(tlg)->subtype == GOST_GROUP_TLG && tlg->page == trans_page; }
static inline int obj_can_work(struct obj *obj)
        { return trans_present && trans_page == page_universum && obj_get_root(obj) == obj_universum; }

void kernel_cache_init(void);
void kernel_cache_finish(void);
void go_altered(struct go* go);
void go_cache_remove(struct go *go);

struct hanger* hanger_new_mc_copy(struct hanger *h);


void clipboard_init(void);
void clipboard_finish(void);

static inline struct hanger* hanger_get_same_hanger(struct go *go1, struct hanger *h, struct go *go2)
        { return go_get_hanger(go2, h - go_get_hanger(go1, 0)); }

static inline struct hanger* hanger_copy_clipboard(struct hanger* orig)
{
        struct go *orig_go = hanger_get_go(orig), *copy_go = (struct go*)orig_go->temp_data;
        return copy_go ? hanger_get_same_hanger(orig_go, orig, copy_go) : hanger_new_mc_copy(orig);
}


/**********************
 *                    *
 *  Topological sort  *
 *                    *
 **********************/

void tsort_trans_start(struct obj_page *page);
void tsort_trans_end(void);
void tsort_trans_fail(struct obj_page *page);

void tsort_dirty(struct go *go);
void tsort_dirty_hanger(struct hanger *h);

static inline void tsort_dirty_recompute(struct go *go)
        { TSORT_NO_RECOMPUTE_BEGIN tsort_dirty(go); TSORT_NO_RECOMPUTE_END }

static inline void tsort_dirty_hanger_recompute(struct hanger *h)
        { TSORT_NO_RECOMPUTE_BEGIN tsort_dirty_hanger(h); TSORT_NO_RECOMPUTE_END }

void tsort_remove(struct go *go, struct go_group *old_group, struct obj_page *page);

static inline int tsort_is_go_flag(struct go *go)
        { return go->flags & GOF_TSORT; }



/*****************************
 *                           *
 *   Transaction subsystem   *
 *                           *
 *****************************/


enum trans_undo
{
// Meta commands
        TRANS_OBJ_SELECT,
        TRANS_OBJ_UNSELECT,
        TRANS_OBJ_LINK,
        TRANS_OBJ_UNLINK,

// Non-meta commands
        TRANS_GO_SELECT,
        TRANS_GO_UNSELECT,
        TRANS_GO_LINK,
        TRANS_GO_UNLINK,
        TRANS_GO_RELINK,
        TRANS_ANCHOR_REHANG,
        TRANS_MOUSE_CLICK_MOVE,

// Propetry (meta and non-meta) commands
        TRANS_PROP_CREATE,
        TRANS_PROP_CHANGE,
        TRANS_PROP_DELETE,
        TRANS_PROP_VIRTUAL,
        TRANS_PROP_VIRTUAL_START_UNDO,
        TRANS_PROP_VIRTUAL_END_UNDO,

// For document-save detection
        TRANS_DOC_SAVED_START,
        TRANS_DOC_SAVED_END,

// Only for the function trans_command_redo
        TRANS_UNDO = 0x20,
        TRANS_REDO = 0x40,
};

struct trans
{
        struct trans *prev;
        uns type;
        jmp_buf *jb;
        char* es;                       
        struct undo_kernel *uk;         
        clist llog;
        struct obj_page *page;
};


struct undo_kernel
{
        cnode nk;                       
        uns type;
        union undo_kernel_union
        {
                struct undo_kernel_union_obj_select
                {
                        struct obj *obj;
                } obj_select;
                struct undo_kernel_union_obj_link
                {
                        struct obj *obj, *father, *after;
                } obj_link;
                struct undo_kernel_union_go_link
                {
                        struct go *go;
                        struct go_group *group;
                        struct go *after;
                } go_link;
                struct undo_kernel_union_go_select
                {
                        struct go *go;
                } go_select;
                struct undo_kernel_union_anchor_rehang
                {
                        struct hanger* hanger;
                        struct anchor* anchor;
                } anchor_rehang;
                struct undo_kernel_union_mc_move
                {
                        struct hanger_smart *mc;
                        struct geom_point gp;
                } mc_move;
                struct undo_kernel_union_prop
                {
                        struct o* o;
                        struct prop* prop;
                        prop_value value;
                } prop;
                struct undo_kernel_union_doc_save
                {
                        struct obj_doc *doc;
                } doc_save;
        } u;
};

struct trans_log
{
        cnode nlog;
        uns when;
        void (*func)(uintptr_t arg);
        uintptr_t arg;
};

void trans_delete_all(struct obj_page *page);
void trans_command_kernel_delete(struct obj_page *page, struct undo_kernel* uk);
struct trans* page_is_in_trans_stack(struct obj_page* page);

struct undo_kernel* trans_new_undo(uns trans_type);
void trans_new_undo_prop_virtual(struct o* o, struct prop_virtual* prop, prop_value value);
#define TRANS_NEW_UNDO(_type, _struct, ...) trans_new_undo(_type)->u._struct = (struct undo_kernel_union_ ## _struct) { __VA_ARGS__ }
void trans_new_undo_start(struct o *o, struct prop_virtual *prop, prop_value value);
void trans_new_undo_end(struct o *o, struct prop_virtual *prop, prop_value value);
struct undo_kernel* trans_new_undo_page_changed(struct obj_doc *doc, struct undo_kernel *after, uns type);

#define WALK_TRANS_STACK(_walk) for(_walk = trans_present; _walk; _walk = _walk->prev)
#define WALK_UNDO_GUI(_page, _walk) for(_walk = trans_get_first_gui(_page); _walk; _walk = trans_get_next_gui(_page, _walk))
#define WALK_UNDO_KERNEL(_ug, _walk) for(_walk = trans_get_first_kernel(_ug); _walk; _walk = trans_get_next_kernel(_ug, _walk))

static inline struct undo_kernel* trans_get_first_kernel(struct undo_gui* u)
        { cnode *n = clist_head(&u->lk); return n ? SKIP_BACK(struct undo_kernel, nk, n) : NULL; }
static inline struct undo_kernel* trans_get_next_kernel(struct undo_gui* ug, struct undo_kernel *uk)
        { cnode *n = clist_next(&ug->lk, &uk->nk); return n ? SKIP_BACK(struct undo_kernel, nk, n) : NULL; }
static inline struct undo_kernel* trans_get_last_kernel(struct undo_gui* u)
        { cnode *n = clist_tail(&u->lk); return n ? SKIP_BACK(struct undo_kernel, nk, n) : NULL; }
static inline struct undo_kernel* trans_get_prev_kernel(struct undo_gui* ug, struct undo_kernel *uk)
        { cnode *n = clist_prev(&ug->lk, &uk->nk); return n ? SKIP_BACK(struct undo_kernel, nk, n) : NULL; }

void obj_changed(struct obj *obj);

int trans_is_undo_write_protected(void);
void trans_undo_limit_control(struct obj_page *page);


/******************
 *                *
 *     Hooks      *
 *                *
 ******************/


#define WALK_GO_HOOK(_page, _walk) for(_walk = (struct go_hook*)(_page)->go_hooks.head.next; _walk; _walk = (struct go_hook*)_walk->n.next)
#define WALK_TRANS_HOOK(_page, _walk) for(_walk = (struct trans_hook*)(_page)->trans_hooks.head.next; _walk; _walk = (struct trans_hook*)_walk->n.next)

void hook_call_obj_link(struct obj* obj);
void hook_call_obj_unlink(struct obj* obj, struct obj* father, struct obj* next);
void hook_call_obj_selected(struct obj* obj);
void hook_call_obj_unselected(struct obj* obj);

void hook_call_go_link(struct go* go);
void hook_call_go_unlink(struct go* go, struct go_group* owner, struct go *prev);
void hook_call_go_relink(struct go* go, struct go_group *group, struct go *prev);
void hook_call_go_selected(struct go* go);
void hook_call_go_unselected(struct go* go);

// don't call this hook directly, use go_changed(), go_altered (), go_transformed ().
void hook_call_go_changed_generic(struct go* go, const struct changed_data_generic *d);
void hook_call_go_changed(struct go* go, const struct geom_rectangle *old_bbox, const struct geom_rectangle *new_bbox);
void hook_call_go_altered(struct go* go, const struct geom_rectangle *where);
void hook_call_go_transformed(struct go* go, const struct geom_rectangle *old_bbox, const struct geom_rectangle *new_bbox, const struct geom_transform2 *t);

void hook_call_prop_create(struct o* o, struct prop* p);
void hook_call_prop_change(struct o* o);
void hook_call_prop_delete(struct o* o, struct prop* p);


void hook_call_undo_new(struct obj_page* page, struct undo_gui* ug);
void hook_call_undo_delete(struct obj_page* page, struct undo_gui* ug, struct undo_gui* prev_item);
void hook_call_undo_update(struct obj_page* page, struct undo_gui* ug);
void hook_call_undo(struct obj_page* page);
void hook_call_redo(struct obj_page* page);
void hook_call_saved(struct obj * obj);

void hook_call_unit_add(uns slot);
void hook_call_unit_deleted(uns slot);
void hook_call_unit_changed(uns slot);
void hook_call_unit_default(uns def);

void hook_init(void);
void hook_finish(void);


/*
 * Setting
 */

void settings_init(void);
void settings_finish(void);

/***************************************
 *                                     *
 *   Declaration of global variables   *
 *                                     *
 ***************************************/


extern struct prop_virtual o_prop_name, *page_universum_prop_virtual;
extern const uns prop_hash_name_size, go_rtree_bbox_size;

#endif

---