Пример #1
0
static int explorer_cb(Quark *q, int etype, void *udata)
{
    ExplorerUI *eui = (ExplorerUI *) udata;
    TreeItem *item = quark_get_udata(q);
    TreeItem *parent_item;

    switch (etype) {
    case QUARK_ETYPE_DELETE:
        TreeDeleteItem(eui->tree, item);
        break;
    case QUARK_ETYPE_MODIFY:
        init_item(eui, item, q);
        break;
    case QUARK_ETYPE_NEW:
        create_hook(q, eui, NULL);
        break;
    case QUARK_ETYPE_MOVE:
        explorer_save_quark_state(eui);
        TreeDeleteItem(eui->tree, item);

        parent_item = quark_get_udata(quark_parent_get(q));
        item = TreeInsertItem(eui->tree, parent_item, q, quark_get_id(q));
        init_item(eui, item, q);
        quark_set_udata(q, item);
        storage_traverse(quark_get_children(q), create_children_hook, eui);

        explorer_restore_quark_state(eui);
        break;
    }

    TreeRefresh(eui->tree);

    return TRUE;
}
Пример #2
0
Quark *get_parent_project(const Quark *q)
{
    Quark *p = (Quark *) q;
    
    while (p) {
        if (p->fid == QFlavorProject) {
            return p;
        }
        p = quark_parent_get(p);
    }
    
    return NULL;
}
Пример #3
0
static int create_hook(Quark *q, void *udata, QTraverseClosure *closure)
{
    TreeItem *item;
    ExplorerUI *eui = (ExplorerUI *) udata;
    Quark *qparent = quark_parent_get(q);

    item = TreeInsertItem(eui->tree, quark_get_udata(qparent), q, quark_get_id(q));

    init_item(eui, item, q);

    quark_set_udata(q, item);

    return TRUE;
}
Пример #4
0
static int highlight_cb(TreeEvent *event)
{
    ExplorerUI *ui = (ExplorerUI *) event->anydata;
    TreeItemList items;
    int count;
    Quark *q = NULL;
    int fid = -1;
    int parent_fid = -1;
    int homogeneous_selection = TRUE;

    TreeGetHighlighted(event->w, &items);
    count = items.count;
    
    ui->homogeneous_parent = TRUE;

    if (count > 0) {
        int i;

        q = TreeGetQuark(items.items[0]);
        fid = quark_fid_get(q);
        parent_fid = quark_fid_get(quark_parent_get(q));

        for (i = 1; i < count; i++) {
            Quark *iq = TreeGetQuark(items.items[i]);
            
            if ((int) quark_fid_get(iq) != fid) {
                homogeneous_selection = FALSE;
            }
            if ((int) quark_fid_get(quark_parent_get(iq)) != parent_fid) {
                ui->homogeneous_parent = FALSE;
            }
        }
    }
    xfree(items.items);

    if (!count || !homogeneous_selection) {
        WidgetSetSensitive(ui->aacbuts[0], FALSE);
        WidgetSetSensitive(ui->aacbuts[1], FALSE);
        
        manage_plugin(ui, NULL);
    } else {
        Widget managed_top;

        WidgetSetSensitive(ui->aacbuts[0], TRUE);
        WidgetSetSensitive(ui->aacbuts[1], TRUE);
        
        switch (fid) {
        case QFlavorProject:
            update_project_ui(ui->project_ui, q);
            managed_top = ui->project_ui->top;
            break;
        case QFlavorSSD:
            update_ssd_ui(ui->ssd_ui, q);
            managed_top = ui->ssd_ui->top;
            break;
        case QFlavorFrame:
            update_frame_ui(ui->frame_ui, q);
            managed_top = ui->frame_ui->top;
            break;
        case QFlavorGraph:
            update_graph_ui(ui->graph_ui, q);
            managed_top = ui->graph_ui->top;
            break;
        case QFlavorSet:
            update_set_ui(ui->set_ui, q);
            managed_top = ui->set_ui->top;
            break;
        case QFlavorAGrid:
            update_axisgrid_ui(ui->axisgrid_ui, q);
            managed_top = ui->axisgrid_ui->top;
            break;
        case QFlavorAxis:
            update_axis_ui(ui->axis_ui, q);
            managed_top = ui->axis_ui->top;
            break;
        case QFlavorDObject:
            update_object_ui(ui->object_ui, q);
            managed_top = ui->object_ui->top;
            break;
        case QFlavorAText:
            update_atext_ui(ui->atext_ui, q);
            managed_top = ui->atext_ui->top;
            break;
        case QFlavorRegion:
            update_region_ui(ui->region_ui, q);
            managed_top = ui->region_ui->top;
            break;
        default:
            managed_top = NULL;
            break;
        }

        manage_plugin(ui, managed_top);
    }

    WidgetSetSensitive(ui->insert_frame_bt,    FALSE);
    WidgetSetSensitive(ui->insert_graph_bt,    FALSE);
    WidgetSetSensitive(ui->insert_set_bt,      FALSE);
    WidgetSetSensitive(ui->insert_ssd_bt,      FALSE);
    WidgetSetSensitive(ui->insert_axisgrid_bt, FALSE);
    WidgetSetSensitive(ui->insert_axis_bt,     FALSE);
    WidgetSetSensitive(ui->insert_object_pane, FALSE);
    if (count == 1) {
        WidgetSetSensitive(ui->idstr->form, TRUE);
        TextSetString(ui->idstr, QIDSTR(q));
        switch (fid) {
        case QFlavorProject:
            WidgetSetSensitive(ui->insert_frame_bt,    TRUE);
            WidgetSetSensitive(ui->insert_object_pane, TRUE);
            break;
        case QFlavorFrame:
            WidgetSetSensitive(ui->insert_graph_bt,    TRUE);
            WidgetSetSensitive(ui->insert_object_pane, TRUE);
            break;
        case QFlavorGraph:
            WidgetSetSensitive(ui->insert_ssd_bt,      TRUE);
            WidgetSetSensitive(ui->insert_axisgrid_bt, TRUE);
            WidgetSetSensitive(ui->insert_object_pane, TRUE);
            break;
        case QFlavorAGrid:
            WidgetSetSensitive(ui->insert_axis_bt,     TRUE);
            break;
        case QFlavorAxis:
            WidgetSetSensitive(ui->insert_object_pane, TRUE);
            break;
        }
        
        if (get_parent_ssd(q) &&
            (fid == QFlavorGraph || fid == QFlavorSSD)) {
            WidgetSetSensitive(ui->insert_set_bt,      TRUE);
        }
    } else {
        WidgetSetSensitive(ui->idstr->form, FALSE);
        TextSetString(ui->idstr, NULL);
    }

    return TRUE;
}
Пример #5
0
static int drop_cb(TreeEvent *event)
{
    ExplorerUI *ui = (ExplorerUI *) event->anydata;

    int gpcount = 0;
    GProject **gplist;

    if (ui->homogeneous_parent) {
        int count;
        TreeItemList items;

        TreeGetHighlighted(ui->tree, &items);
        count = items.count;
        if (count > 0) {
            TreeItem *item = (TreeItem *) event->udata;
            Quark *drop_q = TreeGetQuark(item);
            Quark *drop_parent = quark_parent_get(drop_q);
            GProject *drop_gp = gproject_from_quark(drop_q);
            Quark *parent = quark_parent_get(TreeGetQuark(items.items[0]));

            gplist = xmalloc(gapp->gpcount*sizeof(GProject));
            if (!gplist) {
                return FALSE;
            }

            if (parent) {
                int i, id;
                Quark *newparent;

                if (quark_fid_get(parent) == quark_fid_get(drop_q)) {
                    id = 0;
                    newparent = drop_q;
                } else if (quark_fid_get(parent) == quark_fid_get(drop_parent)) {
                    id = quark_get_id(drop_q) + 1;
                    newparent = quark_parent_get(drop_q);
                } else {
                    return FALSE;
                }

                for (i = 0; i < count; i++) {
                    Quark *q = TreeGetQuark(items.items[i]);

                    switch (event->drop_action) {
                    case DROP_ACTION_COPY:
                        quark_copy2(q, newparent, id);
                        break;
                    case DROP_ACTION_MOVE:
                        add_to_list(gplist, &gpcount, gproject_from_quark(q));
                        quark_move2(q, newparent, id);
                        break;
                    default:
                        errmsg("unknown drop type");
                        break;
                    }
                }

                switch (event->drop_action) {
                case DROP_ACTION_COPY:
                    explorer_snapshot(gapp, drop_gp, TRUE);
                    break;
                case DROP_ACTION_MOVE:
                    add_to_list(gplist, &gpcount, drop_gp);
                    for (i = 0; i < gpcount; i++) {
                        explorer_snapshot(gapp, gplist[i], TRUE);
                    }
                    xfree(gplist);
                    break;
                }

                return TRUE;
            }
        }
    }
    return FALSE;
}
Пример #6
0
static int menu_cb(TreeEvent *event)
{
    ExplorerUI *ui = (ExplorerUI *) event->anydata;
    TreeItemList items;
    int count;
    Quark *q = NULL;
    Quark *p = NULL;
    int parent_child_selection = FALSE;
    int all_shown = TRUE;
    int all_hidden = TRUE;

    TreeGetHighlighted(event->w, &items);
    count = items.count;

    if (count > 0) {
        int i, j;

        q = TreeGetQuark(items.items[0]);

        for (i = 0; i < count; i++) {
            Quark *iq = TreeGetQuark(items.items[i]);

            p = quark_parent_get(iq);
            while (p) {
                for (j = 0; j < count; j++) {
                    if (TreeGetQuark(items.items[j]) == p) {
                        parent_child_selection = TRUE;
                    }
                }
                p = quark_parent_get(p);
            }

            if (quark_is_active(iq)) {
                all_hidden = FALSE;
            } else {
                all_shown = FALSE;
            }
        }

        if (count == 1 && quark_fid_get(q) == QFlavorProject) {
            WidgetSetSensitive(ui->project_popup_show_bt,            FALSE);
            WidgetSetSensitive(ui->project_popup_save_bt,            FALSE);
            WidgetSetSensitive(ui->project_popup_save_as_bt,         FALSE);
            WidgetSetSensitive(ui->project_popup_revert_to_saved_bt, FALSE);
            WidgetSetSensitive(ui->project_popup_close_bt,           FALSE);

            if (quark_is_active(q)) {
                WidgetSetSensitive(ui->project_popup_show_bt,   FALSE);
            } else {
                WidgetSetSensitive(ui->project_popup_show_bt,   TRUE);
            }

            WidgetSetSensitive(ui->project_popup_save_bt,            TRUE);
            WidgetSetSensitive(ui->project_popup_save_as_bt,         TRUE);
            WidgetSetSensitive(ui->project_popup_revert_to_saved_bt, TRUE);

            if (gapp->gpcount > 1) {
                WidgetSetSensitive(ui->project_popup_close_bt,  TRUE);
            } else {
                WidgetSetSensitive(ui->project_popup_close_bt,  FALSE);
            }

            PopupMenuShow(ui->project_popup, event->udata);
        } else {
            WidgetSetSensitive(ui->popup_hide_bt, !all_hidden);
            WidgetSetSensitive(ui->popup_show_bt, !all_shown);

            if (parent_child_selection) {
                WidgetSetSensitive(ui->popup_delete_bt,         FALSE);
                WidgetSetSensitive(ui->popup_duplicate_bt,      FALSE);
            } else {
                WidgetSetSensitive(ui->popup_delete_bt,         TRUE);
                WidgetSetSensitive(ui->popup_duplicate_bt,      TRUE);
            }

            PopupMenuShow(ui->popup, event->udata);
        }
    }

    xfree(items.items);

    return TRUE;
}
Пример #7
0
int gapp_set_gproject_id(GraceApp *gapp, GProject *gp, int id)
{
    Quark *q = gproject_get_top(gp);

    return quark_move2(q, quark_parent_get(q), id);
}