//! convert db data to gtk data
static GtkTreeModel *tableConDbTre (){
GtkTreeIter iter;
guint max_columns = count(column_Type);
table->store = gtk_tree_store_newv (max_columns, column_Type );
char ** data = databaseGetData();
int i ;
for(i=0;i<databaseGetTotalCol();i++){
data++;
}
int count_row , count_column , urutan;
if (table->store){
const int max_rows = databaseGetTotalRow();
for ( count_row = 1; count_row < max_rows; count_row++ ){
gtk_tree_store_append(table->store, &iter, NULL);
for ( count_column = 0; count_column < max_columns; count_column++) {
if(count_column == 0 ){
gint fu = globalConStrToInt(*data);
// gint fu = globalConStrToInt("1");
gtk_tree_store_set(table->store, &iter,count_column, fu ,-1);
}
else{
gtk_tree_store_set(table->store, &iter,count_column, *data,-1);
}
++data;
}
}
}
GtkTreeModel *model_new = GTK_TREE_MODEL (table->store);
databaseFreeData();
return model_new;
}
GtkTreeModel* create_i2c_model(void)
{
int i = 0;
int j = 0;
int numOfRows = mix_number_of_i2c_rows();
int numOfB = mix_number_of_i2c_headers();
int numOfHeaders = I2C_NUM_COLS + numOfB - 1;
char ign[1024], com[1024], var[1024], dev[1024], sub[1024], inter[1024], blk[1024], dir[1024], spc[1024], clk[1024], rst[1024], bsy[1024], init[1024], rec[1024];
char **b;
char *row[] = {ign, com, var, dev, sub, inter, blk, dir, spc, clk, rst, bsy, init, rec};
GtkTreeStore *treestore;
GtkTreeIter toplevel;
GType *header_types;
// dynamically allocate header
b = (char**) malloc(sizeof(char*) * numOfB);
while(i < numOfB) {
b[i] = (char*) malloc(numOfHeaders * sizeof(G_TYPE_STRING));
i++;
}
header_types = (GType*) malloc(numOfHeaders * sizeof(G_TYPE_STRING));
i = 0;
while(i < numOfHeaders) {
header_types[i] = G_TYPE_STRING;
i++;
}
treestore = gtk_tree_store_newv(numOfHeaders, header_types);
i = 0;
while(i < numOfRows) {
mix_get_i2c_sta_row(i, row);
mix_get_i2c_dyn_row(i, b);
// Append a top level row and leave it empty
gtk_tree_store_append(treestore, &toplevel, NULL);
gtk_tree_store_set(treestore, &toplevel, I2C_IGN, ign, I2C_COM, com, I2C_VAR, var, I2C_DEV, dev,
I2C_SUB, sub, I2C_INT, inter, I2C_BLOCK, blk, I2C_DIR, dir, I2C_SPEC, spc,
I2C_CLOCK, clk, I2C_RESET, rst, I2C_BUSY, bsy, I2C_INIT, init, I2C_REC, rec, -1);
// g_error_free(error);
j = I2C_B;
while(j < numOfHeaders) {
gtk_tree_store_set(treestore, &toplevel, j, b[j - I2C_B], -1);
j++;
}
i++;
}
i = 0;
while(i < numOfB) {
free(b[i]);
i++;
}
free(b);
free(header_types);
return GTK_TREE_MODEL(treestore);
}
/****************************************************************************
Create a citizens dialog store.
FIXME: copy of players_dialog_store_new();
****************************************************************************/
static GtkTreeStore *citizens_dialog_store_new(void)
{
GtkTreeStore *store;
GType model_types[num_citizens_cols + 3];
int i;
for (i = 0; i < num_citizens_cols; i++) {
switch (citizens_cols[i].type) {
case COL_FLAG:
model_types[i] = GDK_TYPE_PIXBUF;
break;
case COL_COLOR:
model_types[i] = GDK_TYPE_PIXBUF;
break;
case COL_BOOLEAN:
model_types[i] = G_TYPE_BOOLEAN;
break;
case COL_TEXT:
case COL_RIGHT_TEXT:
model_types[i] = G_TYPE_STRING;
break;
}
}
/* special (invisible rows) - Text style, weight and player id */
model_types[i++] = G_TYPE_INT; /* CITIZENS_DLG_COL_STYLE. */
model_types[i++] = G_TYPE_INT; /* CITIZENS_DLG_COL_WEIGHT. */
model_types[i++] = G_TYPE_INT; /* CITIZENS_DLG_COL_ID. */
store = gtk_tree_store_newv(i, model_types);
return store;
}
static GtkWidget *
create_tree_view(int n, n_list_store *list, int tree)
{
GType *tarray;
GtkTreeModel *lstore;
GtkWidget *tview;
GtkTreeViewColumn *col;
GtkTreeSelection *sel;
int i;
if (n < 1 || list == NULL)
return NULL;
tarray = g_malloc(sizeof(*tarray) * n);
if (tarray == NULL)
return NULL;
for (i = 0; i < n; i++) {
if (list[i].type == G_TYPE_DOUBLE || list[i].type == G_TYPE_ENUM || list[i].type == G_TYPE_PARAM) {
tarray[i] = G_TYPE_STRING;
} else {
tarray[i] = list[i].type;
}
list[i].edited_id = 0;
}
if (tree) {
lstore = GTK_TREE_MODEL(gtk_tree_store_newv(n, tarray));
} else {
lstore = GTK_TREE_MODEL(gtk_list_store_newv(n, tarray));
}
g_free(tarray);
tview = gtk_tree_view_new_with_model(lstore);
#if ! GTK_CHECK_VERSION(3, 14, 0)
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tview), TRUE);
#endif
gtk_tree_view_set_rubber_banding(GTK_TREE_VIEW(tview), TRUE);
gtk_tree_view_set_grid_lines(GTK_TREE_VIEW(tview), GTK_TREE_VIEW_GRID_LINES_VERTICAL);
sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(tview));
gtk_tree_selection_set_mode(sel, GTK_SELECTION_SINGLE);
for (i = 0; i < n; i++) {
if (list[i].visible) {
col = create_column(list, i);
gtk_tree_view_column_set_visible(col, list[i].visible);
gtk_tree_view_append_column(GTK_TREE_VIEW(tview), col);
}
}
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tview), n > 1);
return tview;
}
static void
cryptui_key_store_init (CryptUIKeyStore *ckstore)
{
/* init private vars */
ckstore->priv = g_new0 (CryptUIKeyStorePriv, 1);
/* Our key -> row ref mapping */
ckstore->priv->rows = g_hash_table_new_full (g_str_hash, g_str_equal, NULL,
(GDestroyNotify)gtk_tree_row_reference_free);
/* The base store */
ckstore->priv->store = gtk_tree_store_newv (CRYPTUI_KEY_STORE_NCOLS, (GType*)col_types);
/* The filtering model */
ckstore->priv->filter = GTK_TREE_MODEL_FILTER (gtk_tree_model_filter_new (GTK_TREE_MODEL (ckstore->priv->store), NULL));
gtk_tree_model_filter_set_visible_func (ckstore->priv->filter, (GtkTreeModelFilterVisibleFunc)filter_callback, ckstore, NULL);
}
/**
* Called from
* org.gnome.gtk.GtkTreeModeOverride.gtk_tree_store_new(String[])
* called from
* org.gnome.gtk.GtkTreeModeOverride.createTreeStore(Class[])
* called from
* org.gnome.gtk.TreeStore.<init>(???)
*
* You should already have established Java side that ther array is bigger
* that 0 elements before calling this.
*/
JNIEXPORT jlong JNICALL
Java_org_gnome_gtk_GtkTreeModelOverride_gtk_1tree_1store_1new
(
JNIEnv* env,
jclass cls,
jobjectArray _columns
)
{
GtkTreeStore* result;
gint num_columns;
GType* columns; // GType[]
gint i;
jstring _name;
const gchar* name;
num_columns = (gint) (*env)->GetArrayLength(env, _columns);
columns = g_newa(GType, num_columns);
for (i = 0; i < num_columns; i++) {
_name = (jstring) (*env)->GetObjectArrayElement(env, _columns, i);
name = bindings_java_getString(env, _name);
if (name == NULL) {
return 0L; // OutOfMemory already thrown
}
columns[i] = bindings_java_type_lookup(name);
if (columns[i] == G_TYPE_INVALID) {
bindings_java_throw(env, "Don't know how to map %s into a GType", name);
return 0L;
}
bindings_java_releaseString(name);
(*env)->DeleteLocalRef(env, _name);
}
// call constructor
result = gtk_tree_store_newv(num_columns, columns);
// clean up of columns is automatic
// and finally
return (jlong) result;
}
/**
@brief copy a liststore or treestore
This is for when reffing is not enough e.g. need independent sorting in
attached views. Pointers to data are simply copied, so if the "source" data will
be cleared before fhe new store, then all such data must be replicated or otherwise
preserved by code elsewhere which understands what that data really is.
Officially, the new store will be unsorted, though in practice it will be the
same as the old store.
@param model treemodel of the store being copied
@param treetype TRUE for treestore, FALSE for liststore
@param newstore store for pointer to new store
@a return
*/
void e2_tree_store_copy (GtkTreeModel *model, gboolean treetype, gpointer *newstore)
{
GtkTreeIter src;
gint i, ncols = gtk_tree_model_get_n_columns (model);
gint colnums[ncols];
GType types[ncols];
GValue values[ncols];
for (i = 0; i < ncols; i++)
{
colnums[i] = i;
types[i] = gtk_tree_model_get_column_type (model, i);
memset (&values[i], 0, sizeof (GValue));
}
if (treetype)
{
GtkTreeStore *newtstore = gtk_tree_store_newv (ncols, types);
if (gtk_tree_model_get_iter_first (model, &src))
_e2_tree_copy_descendants (model, NULL, newtstore, NULL,
ncols, colnums, types, values);
*newstore = newtstore;
}
else
{
GtkListStore *newlstore = gtk_list_store_newv (ncols, types);
if (gtk_tree_model_get_iter_first (model, &src))
{
GtkTreeIter dest;
do
{
for (i = 0; i < ncols; i++)
gtk_tree_model_get_value (model, &src, i, &values[i]);
gtk_list_store_insert_with_valuesv (newlstore, &dest, -1, colnums, values, ncols);
for (i = 0; i < ncols; i++)
g_value_unset (&values[i]);
} while (gtk_tree_model_iter_next (model, &src));
}
*newstore = newlstore;
}
}
static VALUE
rg_initialize(int argc, VALUE *argv, VALUE self)
{
gint cnt;
GtkTreeStore* store;
GType* buf;
if (argc == 0) rb_raise(rb_eArgError, "need more than 1 class type.");
buf = ALLOCA_N(GType, argc);
for (cnt = 0; cnt < argc; cnt++) {
buf[cnt] = CLASS2GTYPE(argv[cnt]);
}
store = gtk_tree_store_newv(argc, buf);
G_INITIALIZE(self, store);
return Qnil;
}
/**
* Create the model containing CSV file preview.
*
* \param tree_preview GtkTreeView to associate model to.
* \param contents Contents to place into model
*
*
*/
GtkTreeModel * csv_import_create_model ( GtkTreeView * tree_preview, gchar * contents,
gchar * separator )
{
GtkWidget * assistant;
GtkTreeStore *model;
GtkTreeViewColumn * col;
GtkCellRenderer * cell;
GType *types;
gint size, i;
GList *list;
size = csv_import_count_columns ( contents, separator );
if ( ! size || ! contents)
return NULL;
csv_fields_config = csv_import_update_fields_config ( contents, size, separator );
assistant = g_object_get_data ( G_OBJECT(tree_preview), "assistant" );
/* Remove previous columns if any. */
list = gtk_tree_view_get_columns ( GTK_TREE_VIEW ( tree_preview ) );
while ( list )
{
gtk_tree_view_remove_column ( tree_preview, list -> data );
list = list -> next;
}
types = (GType *) g_malloc0 ( ( size + 2 ) * sizeof ( GType * ) );
types[0] = G_TYPE_BOOLEAN;
cell = gtk_cell_renderer_toggle_new ();
col = gtk_tree_view_column_new_with_attributes ( _("Skip"),
cell,
"active", 0,
NULL);
gtk_tree_view_append_column ( tree_preview, col );
g_object_set_data ( G_OBJECT ( col ), "assistant", assistant );
g_signal_connect ( cell,
"toggled",
G_CALLBACK ( skip_line_toggled ),
tree_preview );
for ( i = 0 ; i < size ; i ++ )
{
GtkWidget *label;
gchar *name;
types[i+1] = G_TYPE_STRING;
cell = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes (
NULL,
cell,
"text", i + 1,
"strikethrough", 0,
NULL);
if ( csv_fields_config[i] > 0 )
{
name = g_strconcat ( "<b><u>", _( csv_fields [ csv_fields_config[i] ] . name ),
"</u></b>", NULL );
}
else
{
name = my_strdup (_( csv_fields [ csv_fields_config[i] ] . name ));
}
label = gtk_label_new ( NULL );
gtk_label_set_markup ( GTK_LABEL(label), name );
gtk_widget_show ( label );
g_free ( name );
gtk_tree_view_column_set_widget ( col, label );
gtk_tree_view_append_column ( tree_preview, col );
gtk_tree_view_column_set_clickable ( col, TRUE );
g_object_set_data ( G_OBJECT ( col ), "column", col );
g_object_set_data ( G_OBJECT ( col ), "assistant", assistant );
g_signal_connect ( G_OBJECT ( col ),
"clicked",
G_CALLBACK ( csv_import_header_on_click ),
GINT_TO_POINTER ( i + 1 ) );
}
model = gtk_tree_store_newv ( size + 1, types );
return (GtkTreeModel *) model;
}
orcaData orcaGtk::ex_set_attr(orcaVM* vm, int n)/*{{{*/
{
if (n < 2) vm->need_param();
orcaData key = vm->get_param(0);
orcaData val = vm->get_param(1);
attr[key] = val;
if ((type == GUI_LIST || type == GUI_TREE) && is<TYPE_STR>(key)) {
if (key.s() == "column") {
orcaList* lp = castobj<orcaList>(val);
if (lp == NULL) {
throw orcaException(vm, "orca.type", "list type is required");
}
int width = lp->size();
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
vector<pair<GtkCellRenderer*, orcaObject*> > signals;
GType* types = new GType[width];
for (int i=0; i<width; i++) {
orcaTuple* tp = NULL;
if (is<TYPE_STR>(lp->at(i))) {
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(lp->at(i).String().c_str(), renderer, "text", i, NULL);
types[i] = G_TYPE_STRING;
}
else if (tp = castobj<orcaTuple>(lp->at(i))) {
string type = tp->at(1).String();
if (type == "string") {
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(tp->at(0).String().c_str(), renderer, "text", i, NULL);
types[i] = G_TYPE_STRING;
}
else if (type == "toggle") {
renderer = gtk_cell_renderer_toggle_new();
column = gtk_tree_view_column_new_with_attributes(tp->at(0).String().c_str(), renderer, "active", i, NULL);
if (tp->size() >= 3) {
pair<GtkCellRenderer*, orcaObject*> p;
p.first = renderer;
p.second = tp->at(2).Object();
signals.push_back(p);
}
types[i] = G_TYPE_BOOLEAN;
}
}
gtk_tree_view_append_column(GTK_TREE_VIEW(handle), column);
}
if (type == GUI_LIST)
store = GTK_TREE_MODEL(gtk_list_store_newv(width, types));
else
store = GTK_TREE_MODEL(gtk_tree_store_newv(width, types));
delete types;
gtk_tree_view_set_model(GTK_TREE_VIEW(handle), store);
// register toggle signal
if (!signals.empty()) {
GtkTreeModel *model = gtk_tree_view_get_model (GTK_TREE_VIEW(handle));
for (int i=0; i<signals.size(); i++) {
signal_t* p = new signal_t;
p->fun = signals[i].second;
p->tree = model;
p->owner = this;
m_signals.push_back(p);
if (type == GUI_LIST) {
g_signal_connect(signals[i].first, "toggled",
G_CALLBACK(gui_list_toggled_callback), (gpointer)p);
}
else {
g_signal_connect(signals[i].first, "toggled",
G_CALLBACK(gui_tree_toggled_callback), (gpointer)p);
}
}
}
}
}
else if (type == GUI_WINDOW && is<TYPE_STR>(key)) {
if (key.s() == "wh") {
if (isobj<orcaTuple>(val)) {
orcaTuple* tp = castobj<orcaTuple>(val);
int w = tp->at(0).Integer();
int h = tp->at(1).Integer();
gtk_window_set_default_size(GTK_WINDOW(handle), w, h);
gtk_window_resize(GTK_WINDOW(handle), w, h);
}
}
else if (key.s() == "xy") {
if (isobj<orcaTuple>(val)) {
orcaTuple* tp = castobj<orcaTuple>(val);
int x = tp->at(0).Integer();
int y = tp->at(1).Integer();
gtk_window_move(GTK_WINDOW(handle), x, y);
}
}
else if (key.s() == "resizable") {
bool flag = val.Boolean();
gtk_window_set_resizable(GTK_WINDOW(handle), flag);
}
}
else if (type == GUI_RADIO && is<TYPE_STR>(key)) {
if (key.s() == "group") {
orcaObject* op = attr["group"].Object();
orcaGtk* gp = castobj<orcaGtk>(op->get_member("handle"));
if (gp == NULL) {
throw orcaException(vm, "orca.param", "invalid radio");
}
GSList* group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(gp->handle));
gtk_radio_button_set_group(GTK_RADIO_BUTTON(handle), group);
}
}
else if (type == GUI_TABLE && is<TYPE_STR>(key)) {
if (key.s() == "wh") {
orcaData d = attr["wh"];
if (isobj<orcaTuple>(d)) {
orcaTuple* tp = castobj<orcaTuple>(d);
int w = tp->at(0).Integer();
int h = tp->at(1).Integer();
handle = gtk_table_new(w, h, TRUE);
}
}
}
else if (type == GUI_BUTTON && is<TYPE_STR>(key)) {
if (key.s() == "wh") {
orcaData d = attr["wh"];
if (isobj<orcaTuple>(d)) {
orcaTuple* tp = castobj<orcaTuple>(val);
int w = tp->at(0).Integer();
int h = tp->at(1).Integer();
gtk_widget_set_size_request(handle, w, h);
}
}
}
else if (type == GUI_IMAGE && is<TYPE_STR>(key)) {
if (key.s() == "file") {
gtk_image_set_from_file(GTK_IMAGE(handle), val.String().c_str());
}
if (key.s() == "file" || key.s() == "wh") {
orcaData d = attr["wh"];
if (isobj<orcaTuple>(d)) {
orcaTuple* tp = castobj<orcaTuple>(d);
int w = tp->at(0).Integer();
int h = tp->at(1).Integer();
GdkPixbuf *pixbuf = gtk_image_get_pixbuf(GTK_IMAGE(handle));
if (pixbuf == NULL) {
return NIL;
}
pixbuf = gdk_pixbuf_scale_simple(pixbuf, w, h, GDK_INTERP_BILINEAR);
gtk_image_set_from_pixbuf(GTK_IMAGE(handle), pixbuf);
}
}
}
return NIL;
}
/* TREE_TYPE_PIXBUF */
int
/******************************************************************************
* gtk_TreeStoreNew(map, ncolumns, type1, ...)
******************************************************************************/
clip_GTK_TREESTORENEW(ClipMachine * ClipMachineMemory)
{
ClipVar *cv = _clip_spar(ClipMachineMemory, 1);
gint ncolumns = _clip_parni(ClipMachineMemory, 2);
ClipArrVar *cvcol = (ClipArrVar *) _clip_vptr(_clip_spar(ClipMachineMemory, 3));
ClipVar *utypes;
GType types[ncolumns];
int i;
long d;
GtkTreeStore *tree;
C_object *ctree;
CHECKOPT(1, MAP_type_of_ClipVarType);
CHECKARG(2, NUMERIC_type_of_ClipVarType);
memset(types, 0, sizeof(types));
utypes = NEW(ClipVar);
if (_clip_parinfo(ClipMachineMemory, 3) == ARRAY_type_of_ClipVarType && cvcol->count_of_ClipArrVar != ncolumns)
return 1;
if (_clip_parinfo(ClipMachineMemory, 3) != UNDEF_type_of_ClipVarType) // defined column types as parameters or in array
__tree_store_set_types(ClipMachineMemory, ncolumns, types, utypes);
else
{ // if third parameter is empty - use column with G_TYPE_STRING type
ClipVar type;
d = ncolumns;
memset(&type, 0, sizeof(type));
type.ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType = NUMERIC_type_of_ClipVarType;
type.ClipNumVar_n_of_ClipVar.double_of_ClipNumVar = 0;
_clip_array(ClipMachineMemory, utypes, 1, &d);
for (i = 0, d = 0; i < ncolumns; i++, d++)
{
types[i] = G_TYPE_STRING;
_clip_aset(ClipMachineMemory, utypes, &type, 1, &d);
}
_clip_destroy(ClipMachineMemory, &type);
}
tree = gtk_tree_store_newv(ncolumns, types);
if (tree)
{
ctree = _list_get_cobject(ClipMachineMemory, tree);
if (!ctree)
ctree = _register_object(ClipMachineMemory, tree, GTK_TYPE_TREE_STORE, cv, __tree_store_destroy);
if (ctree)
{
_clip_madd(ClipMachineMemory, &ctree->obj, HASH_UTYPES, utypes);
_clip_mclone(ClipMachineMemory, RETPTR(ClipMachineMemory), &ctree->obj);
}
}
free(utypes);
return 0;
err:
return 1;
}
PluginEditorDialog *
edit_plugin_dialog_new (void)
{
PluginEditorDialog *dlg;
GladeXML *gtxml;
GtkWidget *e;
int i;
const char *col_titles[NCOLUMNS];
dlg = g_malloc(sizeof(PluginEditorDialog));
dlg->app = GNOME_APP (app_window);
gtxml = gtt_glade_xml_new ("glade/plugin_editor.glade", "Plugin Editor");
dlg->gtxml = gtxml;
dlg->dialog = GTK_DIALOG (glade_xml_get_widget (gtxml, "Plugin Editor"));
/* ------------------------------------------------------ */
/* Dialog dismissal buttons */
glade_xml_signal_connect_data (gtxml, "on_ok_button_clicked",
GTK_SIGNAL_FUNC (edit_plugin_commit_cb), dlg);
glade_xml_signal_connect_data (gtxml, "on_apply_button_clicked",
GTK_SIGNAL_FUNC (edit_plugin_apply_cb), dlg);
glade_xml_signal_connect_data (gtxml, "on_cancel_button_clicked",
GTK_SIGNAL_FUNC (edit_plugin_cancel_cb), dlg);
/* ------------------------------------------------------ */
/* Menu item add/delete buttons */
glade_xml_signal_connect_data (gtxml, "on_add_button_clicked",
GTK_SIGNAL_FUNC (edit_plugin_add_cb), dlg);
glade_xml_signal_connect_data (gtxml, "on_delete_button_clicked",
GTK_SIGNAL_FUNC (edit_plugin_delete_cb), dlg);
/* ------------------------------------------------------ */
/* Grab the various entry boxes and hook them up */
e = glade_xml_get_widget (gtxml, "plugin name");
dlg->plugin_name = GTK_ENTRY(e);
e = glade_xml_get_widget (gtxml, "plugin path");
dlg->plugin_path = GTK_FILE_CHOOSER(e);
e = glade_xml_get_widget (gtxml, "plugin tooltip");
dlg->plugin_tooltip = GTK_ENTRY(e);
/* ------------------------------------------------------ */
/* Inpout widget changed events */
glade_xml_signal_connect_data (gtxml, "on_plugin_name_changed",
GTK_SIGNAL_FUNC (edit_plugin_changed_cb), dlg);
glade_xml_signal_connect_data (gtxml, "on_plugin_path_changed",
GTK_SIGNAL_FUNC (edit_plugin_changed_cb), dlg);
glade_xml_signal_connect_data (gtxml, "on_plugin_tooltip_changed",
GTK_SIGNAL_FUNC (edit_plugin_changed_cb), dlg);
/* ------------------------------------------------------ */
/* Menu order change buttons */
glade_xml_signal_connect_data (gtxml, "on_up_button_clicked",
GTK_SIGNAL_FUNC (edit_plugin_up_button_cb), dlg);
glade_xml_signal_connect_data (gtxml, "on_down_button_clicked",
GTK_SIGNAL_FUNC (edit_plugin_down_button_cb), dlg);
glade_xml_signal_connect_data (gtxml, "on_left_button_clicked",
GTK_SIGNAL_FUNC (edit_plugin_left_button_cb), dlg);
glade_xml_signal_connect_data (gtxml, "on_right_button_clicked",
GTK_SIGNAL_FUNC (edit_plugin_right_button_cb), dlg);
/* ------------------------------------------------------ */
/* Set up the Treeview Widget */
e = glade_xml_get_widget (gtxml, "editor treeview");
dlg->treeview = GTK_TREE_VIEW (e);
{
GType col_type[NCOLUMNS];
for (i=0;i<NCOLUMNS-1;i++) { col_type[i] = G_TYPE_STRING; }
col_type[NCOLUMNS-1] = G_TYPE_POINTER;
dlg->treestore = gtk_tree_store_newv (NCOLUMNS, col_type);
}
gtk_tree_view_set_model (dlg->treeview, GTK_TREE_MODEL(dlg->treestore));
/* Set up the columns in the treeview widget */
col_titles[0] = "Name";
col_titles[1] = "Path";
col_titles[2] = "Tooltip";
for (i=0; i<NCOLUMNS-1; i++)
{
GtkTreeViewColumn *col;
GtkCellRenderer *renderer;
renderer = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes (
col_titles[i],
renderer, "text", i, NULL);
gtk_tree_view_insert_column (dlg->treeview, col, i);
}
/* Copy-in existing menus from the system */
edit_plugin_setup (dlg);
/* Hook up the row-selection callback */
dlg->have_selection = FALSE;
dlg->selection = gtk_tree_view_get_selection (dlg->treeview);
gtk_tree_selection_set_mode (dlg->selection, GTK_SELECTION_SINGLE);
g_signal_connect (G_OBJECT (dlg->selection), "changed",
G_CALLBACK (edit_plugin_tree_selection_changed_cb), dlg);
gtk_widget_hide_on_delete (GTK_WIDGET(dlg->dialog));
return dlg;
}
