int
clip_GTK_TREESELECTIONGETSELECTED(ClipMachine * cm)
{
C_object *ctreesel = _fetch_co_arg(cm);
C_object *cmodel = _fetch_cobject(cm, _clip_par(cm, 2));
ClipVar *cviter = _clip_par(cm, 3);
C_object *citer;
GtkTreeModel *model;
gboolean ret;
CHECKOPT2(1, MAP_t, NUMERIC_t); CHECKCOBJ(ctreesel,GTK_IS_TREE_SELECTION(ctreesel->object));
memset(Iter, 0, sizeof(Iter));
if (cmodel)
{
model = GTK_TREE_MODEL(cmodel->object);
ret = gtk_tree_selection_get_selected(GTK_TREE_SELECTION(ctreesel->object),
&model, Iter);
}
else
ret = gtk_tree_selection_get_selected(GTK_TREE_SELECTION(ctreesel->object),
NULL, Iter);
if (ret && Iter)
{
citer = _list_get_cobject(cm,Iter);
if (!citer) citer = _register_object(cm,Iter,GTK_TYPE_TREE_ITER, cviter, NULL);
if (citer) _clip_mclone(cm, cviter,&citer->obj);
}
_clip_retl(cm, ret);
return 0;
err:
return 1;
}
/* file_selected
* Acts as the callback for when a file is selected from the directory treeview.
* Refills the hex buffers with data at the selection. Also allows for folder navigation.
*/
void file_selected (GtkWidget *selection, gpointer data) {
GtkTreeModel *model;
GtkTreeIter iter;
if (gtk_tree_selection_get_selected (GTK_TREE_SELECTION(selection),
&model, &iter)) {
gchar *file_path;
gtk_tree_model_get (model, &iter, FILE_NAME, &file_path, -1);
//g_message("selected %s\n", file_path);
gchar *permissions;
gtk_tree_model_get (model, &iter, PERMISSIONS, &permissions, -1);
if(permissions[0] != '-'){
return;
//This code allows for navigation in the dir view but no thanks.
if(permissions[0] == 'd'){
if(remakeDirectoryView(directory_treeview,file_path) != 0){
fprintf(stderr,"Unable To Build File Directory View Panel.\n");
}
}
return;
}
if(rebuildHexPanel (hex_offset_textview, hex_textview, hex_text_textview,file_path) != 0){
fprintf(stderr,"Unable to Build Hex Panel.\n");
}
}
}
static void cancelDownloadCallback(GtkWidget *button, BrowserDownloadDialog *dialog)
{
GtkTreeModel * model;
GtkTreeIter iter;
WebKitDownload *wkDownload;
if (gtk_tree_selection_get_selected(GTK_TREE_SELECTION(dialog->select), &model, &iter))
{
gtk_tree_model_get (GTK_TREE_MODEL(dialog->model), &iter, 7, &wkDownload, -1);
if(wkDownload)
{
webkit_download_cancel(WEBKIT_DOWNLOAD(wkDownload));
gtk_list_store_remove(dialog->model, &iter);
return;
}
char *treeviewIndex = g_strdup_printf("%s", gtk_tree_model_get_string_from_iter(GTK_TREE_MODEL(dialog->model), &iter));
if(treeviewIndex)
{
size_t listIndex = atoi(treeviewIndex);
DeleteList(dialog->download,listIndex);
}
g_printerr("store_remove\n");
gtk_list_store_remove(dialog->model, &iter);
}
}
void usun_obj(GtkWidget *widget, gpointer selection)
{
GtkListStore *store;
GtkTreeModel *model;
GtkTreeIter iter;
store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW (lista_obj_gui)));
model = gtk_tree_view_get_model(GTK_TREE_VIEW(lista_obj_gui));
if(gtk_tree_model_get_iter_first(model, &iter) == FALSE)
return;
if(gtk_tree_selection_get_selected(GTK_TREE_SELECTION(selection), &model, &iter))
{
wezel *red;
gtk_tree_model_get(model, &iter, 1, &red, -1);
int poz = szukaj_wartosci(lista_obj, red->wartosc);
if(poz != -1)
lista_obj = usun_z_pozycji(lista_obj, poz);
else
{
pokaz_error("Uwaga! Wyciek pamieci spowodowany nieusunieciem obiektu (chociaz uzytkownikowi zniknal on z oczu)!");
// teoretycznie nigdy program nie powinien tutaj dojsc...
}
gtk_list_store_remove(store, &iter);
}
}
/*
* kill the selected connection connection
*/
static void gtkui_connection_kill(void *conn)
{
GtkTreeIter iter;
GtkTreeModel *model;
struct conn_tail *c = NULL;
DEBUG_MSG("gtkui_connection_kill");
model = GTK_TREE_MODEL (ls_conns);
if (gtk_tree_selection_get_selected (GTK_TREE_SELECTION (selection), &model, &iter)) {
gtk_tree_model_get (model, &iter, 9, &c, -1);
} else
return; /* nothing is selected */
if (!c || !c->co)
return;
/* kill it */
switch (user_kill(c->co)) {
case ESUCCESS:
/* set the status */
c->co->status = CONN_KILLED;
gtkui_message("The connection was killed !!");
break;
case -EFATAL:
gtkui_message("Cannot kill UDP connections !!");
break;
}
}
int
clip_GTK_TREEGETSELECTION(ClipMachine * ClipMachineMemory)
{
C_widget *ctree = _fetch_cw_arg(ClipMachineMemory);
GList *list;
CHECKCWID(ctree, GTK_IS_TREE);
list = GTK_TREE_SELECTION(ctree->widget);
if (list)
{
C_widget *citem;
long l = g_list_length(list);
ClipVar *a = RETPTR(ClipMachineMemory);
_clip_array(ClipMachineMemory, a, 1, &l);
for (l = 0; list; list = g_list_next(list), l++)
{
citem = _get_cwidget(ClipMachineMemory, list->data);
if (citem)
_clip_aset(ClipMachineMemory, a, &citem->obj, 1, &l);
}
}
return 0;
err:
return 1;
}
int main(void) {
preparation_t queries[] = {
{ "rate",
"SELECT connectionStrength((select id from mode),$2,$1)" },
{ "getpage",
"select strength,title,songs.id from connections inner join songs on connections.blue = songs.id where red = (select id from mode) order by strength desc OFFSET $1 LIMIT $2;" }
};
PQinit();
gtk_init(NULL,NULL);
prepareQueries(queries);
GtkBuilder* builder = gtk_builder_new_from_string(gladeFile,gladeFileSize);
GtkWidget* top = GTK_WIDGET(gtk_builder_get_object(builder,"top"));
GtkTreeSelection* selection = GTK_TREE_SELECTION(
gtk_builder_get_object(builder,"song-selection"));
GtkButton* rateup = GTK_BUTTON(
gtk_builder_get_object(builder,"rateup"));
GtkButton* ratedown = GTK_BUTTON(
gtk_builder_get_object(builder,"ratedown"));
g_signal_connect(G_OBJECT(rateup),"clicked",G_CALLBACK(yay),selection);
g_signal_connect(G_OBJECT(ratedown),"clicked",G_CALLBACK(nay),selection);
GtkListStore* model = GTK_LIST_STORE(
gtk_builder_get_object(builder,"songs"));
fillNext(selection,model);
gtk_widget_show_all(top);
gtk_main();
}
void button11_treeview_fun(GtkWidget *window,gpointer data)//启动并进入容器
{
GtkTreeIter iter22;
GtkTreeModel *mod22;
GtkMessageType type;
mod22=gtk_tree_view_get_model (GTK_TREE_VIEW(window));
static char *ss=NULL;
static char *tmp=NULL;
ss=(char *)malloc(sizeof(char)*100);
tmp=(char *)malloc(sizeof(char)*100);
//gtk_tree_selection_get_selected (GTK_TREE_SELECTION(data),&mod22,&iter22);
//gtk_tree_model_get(GTK_TREE_MODEL(mod22),&iter22,1,&ss,-1);
if(gtk_tree_selection_get_selected (GTK_TREE_SELECTION(data),&mod22,&iter22))
{
//system("ls");
gtk_tree_model_get(GTK_TREE_MODEL(mod22),&iter22,1,&ss,-1);
sprintf(tmp,"sudo gnome-terminal -x bash -c \"sudo docker start -i %s\"",ss);
g_thread_new("dockr_start",docker_contain_start,tmp);
printf("%s\n",ss);
printf("%s\n",tmp);
g_free(ss);
}
else{
contains_message(GTK_MESSAGE_ERROR,_("Choose a line of content"));
}
}
/*
* If double clicking the PictureEntryView :
* - over a selected row : opens properties window
* - over an empty area : open the adding window
*/
gboolean Picture_Entry_View_Button_Pressed (GtkTreeView *treeview, GdkEventButton *event, gpointer data)
{
if (event->type == GDK_BUTTON_PRESS && event->button == 1)
{
if (event->window == gtk_tree_view_get_bin_window (treeview))
{
if (!gtk_tree_view_get_path_at_pos (treeview, event->x, event->y,
NULL, NULL, NULL, NULL))
{
gtk_tree_selection_unselect_all (gtk_tree_view_get_selection (treeview));
}
}
}
if (event->type==GDK_2BUTTON_PRESS && event->button==1)
{
GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(PictureEntryView));
if (gtk_tree_selection_count_selected_rows (GTK_TREE_SELECTION (selection)) >= 1)
Picture_Properties_Button_Clicked (G_OBJECT (image_properties_toolitem));
else
Picture_Add_Button_Clicked (G_OBJECT (add_image_toolitem));
return TRUE;
}
return FALSE;
}
static void openDirCallback(GtkWidget *button, BrowserDownloadDialog *dialog)
{
GtkTreeModel * model;
GtkTreeIter iter;
gchar *path_file;
if (gtk_tree_selection_get_selected(GTK_TREE_SELECTION(dialog->select), &model, &iter))
{
gtk_tree_model_get (GTK_TREE_MODEL(dialog->model), &iter, 6, &path_file, -1);
if(path_file)
{
int path_len = strlen(path_file) - strlen(g_strrstr(path_file , "/"));
gchar *download_path = (char*)malloc(path_len*sizeof(char)+1);
memset(download_path, 0x00, path_len+1);
memcpy(download_path, path_file, path_len);
char *argv[] = {"xdg-open", download_path, NULL} ;
g_spawn_async( NULL, (gchar **)argv, NULL, (GSpawnFlags)(G_SPAWN_SEARCH_PATH |
G_SPAWN_STDOUT_TO_DEV_NULL |
G_SPAWN_STDERR_TO_DEV_NULL |
G_SPAWN_STDERR_TO_DEV_NULL),
NULL, NULL, NULL, NULL );
g_free(download_path);
g_free(path_file);
}
}
}
static void
net_connection_editor_init (NetConnectionEditor *editor)
{
GError *error = NULL;
GtkTreeSelection *selection;
editor->builder = gtk_builder_new ();
gtk_builder_add_from_resource (editor->builder,
"/org/gnome/control-center/network/connection-editor.ui",
&error);
if (error != NULL) {
g_warning ("Could not load ui file: %s", error->message);
g_error_free (error);
return;
}
editor->window = GTK_WIDGET (gtk_builder_get_object (editor->builder, "details_dialog"));
selection = GTK_TREE_SELECTION (gtk_builder_get_object (editor->builder,
"details_page_list_selection"));
g_signal_connect (selection, "changed",
G_CALLBACK (selection_changed), editor);
editor->scrolled_window = GTK_WIDGET (gtk_builder_get_object (editor->builder, "toplevel_scrolled_window"));
}
Php::Value GtkTreeSelection_::get_tree_view()
{
GtkTreeView *ret = gtk_tree_selection_get_tree_view (GTK_TREE_SELECTION(instance));
GtkTreeView_ *return_parsed = new GtkTreeView_();
return_parsed->set_instance((gpointer *)ret);
return Php::Object("GtkTreeView", return_parsed);
}
void GtkTreeSelection_::unselect_path(Php::Parameters ¶meters)
{
std::string param_path = parameters[0];
GtkTreePath *path = gtk_tree_path_new_from_string(param_path.c_str());
gtk_tree_selection_unselect_path (GTK_TREE_SELECTION(instance), path);
}
void GtkTreeSelection_::set_mode(Php::Parameters ¶meters)
{
int int_type = (int)parameters[0];
GtkSelectionMode type = (GtkSelectionMode)int_type;
gtk_tree_selection_set_mode (GTK_TREE_SELECTION(instance), type);
}
static void
tabu_playlist_init (TabuPlaylist *self)
{
self->tree_view = gtk_tree_view_new ( );
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (self->tree_view), FALSE);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (self->tree_view), TRUE);
gtk_tree_selection_set_mode (
GTK_TREE_SELECTION (
gtk_tree_view_get_selection (GTK_TREE_VIEW (self->tree_view))),
GTK_SELECTION_SINGLE);
self->cell_renderer = gtk_cell_renderer_text_new ();
self->tree_view_column = gtk_tree_view_column_new_with_attributes(
"",
self->cell_renderer,
"markup", 0,
NULL );
gtk_tree_view_insert_column (
GTK_TREE_VIEW (self->tree_view),
self->tree_view_column,
-1);
self->list_store = gtk_list_store_new (
2,
G_TYPE_STRING,
G_TYPE_STRING );
gtk_tree_view_set_model (
GTK_TREE_VIEW (self->tree_view),
GTK_TREE_MODEL (self->list_store));
/*
g_signal_connect (
G_OBJECT (self->tree_view),
"row-activated",
G_CALLBACK (playlist_row_activated_callback),
NULL);
g_signal_connect (
G_OBJECT (self->tree_view),
"key-press-event",
G_CALLBACK (playlist_key_press_callback),
NULL);
*/
gtk_scrolled_window_set_policy (
GTK_SCROLLED_WINDOW (self),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_container_add (
GTK_CONTAINER ( GTK_SCROLLED_WINDOW (self)),
GTK_WIDGET (self->tree_view));
}
static void changed__(GtkWidget * widget, gpointer user_data) {
GtkTreeIter iter;
GtkTreeModel *model;
if (gtk_tree_selection_get_selected(GTK_TREE_SELECTION(widget), &model, &iter)) {
int id = 0;
gtk_tree_model_get(model, &iter, ID_COLUMN, &id, -1);
call_item__(id);
}
}
void GtkTreeSelection_::unselect_iter(Php::Parameters ¶meters)
{
Php::Value object_iter = parameters[0];
GtkTreeIter_ *phpgtk_iter = (GtkTreeIter_ *)object_iter.implementation();
GtkTreeIter iter = phpgtk_iter->get_instance();
gtk_tree_selection_unselect_iter (GTK_TREE_SELECTION(instance), &iter);
}
Php::Value GtkTreeSelection_::path_is_selected(Php::Parameters ¶meters)
{
std::string param_path = parameters[0];
GtkTreePath *path = gtk_tree_path_new_from_string(param_path.c_str());
gboolean ret = gtk_tree_selection_path_is_selected (GTK_TREE_SELECTION(instance), path);
return ret;
}
/**
* called when something change for a fyear
* update the list and the invalid
*
* \param entry the entry wich change
* \param tree_view the tree_view
*
* \return FALSE
* */
gboolean gsb_fyear_config_modify_fyear ( GtkWidget *entry,
GtkWidget *tree_view)
{
GtkTreeModel *model;
GtkTreeIter iter;
gint fyear_number;
GtkWidget *widget;
gchar *invalid;
if (!gtk_tree_selection_get_selected ( GTK_TREE_SELECTION (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view))),
&model,
&iter ))
return FALSE;
gtk_tree_model_get ( GTK_TREE_MODEL (model),
&iter,
FYEAR_NUMBER_COLUMN, &fyear_number,
-1 );
/* normally should not happen */
if (!fyear_number)
return FALSE;
/* check the invalid and show the message if needed */
widget = g_object_get_data ( G_OBJECT (model),
"invalid_label" );
/* check all the fyear to set them invalid if need */
gsb_fyear_update_invalid (tree_view);
/* and check if the current fyear was set as invalid */
if (gsb_data_fyear_get_invalid (fyear_number))
{
/* and now focus on the current fyear */
invalid = GTK_STOCK_DIALOG_WARNING;
gtk_label_set_markup ( GTK_LABEL (widget),
gsb_data_fyear_get_invalid_message (fyear_number));
gtk_widget_show (widget);
}
else
{
invalid = NULL;
gtk_widget_hide (widget);
}
gtk_list_store_set ( GTK_LIST_STORE (model),
&iter,
FYEAR_NAME_COLUMN, gsb_data_fyear_get_name (fyear_number),
FYEAR_BEGIN_DATE_COLUMN, gsb_format_gdate (gsb_data_fyear_get_beginning_date (fyear_number)),
FYEAR_END_DATE_COLUMN, gsb_format_gdate (gsb_data_fyear_get_end_date (fyear_number)) ,
FYEAR_INVALID_COLUMN, invalid,
FYEAR_NUMBER_COLUMN, fyear_number,
-1 );
gsb_file_set_modified ( TRUE );
return FALSE;
}
Php::Value GtkTreeSelection_::iter_is_selected(Php::Parameters ¶meters)
{
Php::Value object_iter = parameters[0];
GtkTreeIter_ *phpgtk_iter = (GtkTreeIter_ *)object_iter.implementation();
GtkTreeIter iter = phpgtk_iter->get_instance();
gboolean ret = gtk_tree_selection_iter_is_selected (GTK_TREE_SELECTION(instance), &iter);
return ret;
}
static void
codec_moved_cb (GtkWidget *widget,
gpointer data)
{
CodecsBox *self = NULL;
GtkTreeIter iter;
GtkTreeIter *iter2 = NULL;
GtkTreeModel *model = NULL;
GtkTreeSelection *selection = NULL;
GtkTreePath *tree_path = NULL;
std::list<std::string> list;
gchar *path_str = NULL;
self = CODECS_BOX (data);
model = gtk_tree_view_get_model (GTK_TREE_VIEW (self->priv->codecs_list));
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (self->priv->codecs_list));
if (!gtk_tree_selection_get_selected (GTK_TREE_SELECTION (selection),
NULL, &iter))
return;
/* Update the tree view */
iter2 = gtk_tree_iter_copy (&iter);
path_str = gtk_tree_model_get_string_from_iter (GTK_TREE_MODEL (model),
&iter);
tree_path = gtk_tree_path_new_from_string (path_str);
if (!g_strcmp0 ((gchar *) g_object_get_data (G_OBJECT (widget), "operation"),
"up"))
gtk_tree_path_prev (tree_path);
else
gtk_tree_path_next (tree_path);
gtk_tree_model_get_iter (GTK_TREE_MODEL (model), &iter, tree_path);
if (gtk_list_store_iter_is_valid (GTK_LIST_STORE (model), &iter)
&& gtk_list_store_iter_is_valid (GTK_LIST_STORE (model), iter2))
gtk_list_store_swap (GTK_LIST_STORE (model), &iter, iter2);
/* Scroll to the new position */
gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (self->priv->codecs_list),
tree_path, NULL, FALSE, 0, 0);
gtk_tree_path_free (tree_path);
gtk_tree_iter_free (iter2);
g_free (path_str);
/* Update the key */
list = codecs_box_to_list (self);
if (self->priv->type == Ekiga::Call::Audio)
self->priv->audio_settings->set_string_list ("media-list", list);
else if (self->priv->type == Ekiga::Call::Video)
self->priv->video_settings->set_string_list ("media-list", list);
}
static void
on_model_row_changed (GtkTreeModel *tree_model,
GtkTreePath *path,
GtkTreeIter *iter,
gpointer user_data)
{
GtkTreeSelection *selection = GTK_TREE_SELECTION (user_data);
gtk_tree_selection_select_iter (selection, iter);
g_signal_handlers_disconnect_by_func (tree_model, G_CALLBACK (on_model_row_changed), user_data);
}
void gtkui_help_selected(GtkTreeSelection *treeselection, gpointer data) {
GtkTreeIter iter;
GtkTreeModel *model;
gchar *file;
if (gtk_tree_selection_get_selected (GTK_TREE_SELECTION (treeselection), &model, &iter)) {
gtk_tree_model_get (model, &iter, 1, &file, -1);
if(!file) return;
gtkui_help_open(file);
}
}
static void
activate (GApplication *app)
{
GtkBuilder *builder;
GtkWindow *window;
GtkWidget *widget;
GtkTreeModel *model;
GtkTreeIter iter;
GError *error = NULL;
static GActionEntry win_entries[] = {
{ "run", activate_run, NULL, NULL, NULL }
};
builder = gtk_builder_new ();
gtk_builder_add_from_resource (builder, "/ui/main.ui", &error);
if (error != NULL)
{
g_critical ("%s", error->message);
exit (1);
}
window = (GtkWindow *)gtk_builder_get_object (builder, "window");
gtk_application_add_window (GTK_APPLICATION (app), window);
g_action_map_add_action_entries (G_ACTION_MAP (window),
win_entries, G_N_ELEMENTS (win_entries),
window);
notebook = (GtkWidget *)gtk_builder_get_object (builder, "notebook");
info_view = (GtkWidget *)gtk_builder_get_object (builder, "info-textview");
source_view = (GtkWidget *)gtk_builder_get_object (builder, "source-textview");
headerbar = (GtkWidget *)gtk_builder_get_object (builder, "headerbar");
treeview = (GtkWidget *)gtk_builder_get_object (builder, "treeview");
model = gtk_tree_view_get_model (GTK_TREE_VIEW (treeview));
load_file (gtk_demos[0].name, gtk_demos[0].filename);
populate_model (model);
g_signal_connect (treeview, "row-activated", G_CALLBACK (row_activated_cb), model);
widget = (GtkWidget *)gtk_builder_get_object (builder, "treeview-selection");
g_signal_connect (widget, "changed", G_CALLBACK (selection_cb), model);
gtk_tree_model_get_iter_first (gtk_tree_view_get_model (GTK_TREE_VIEW (treeview)), &iter);
gtk_tree_selection_select_iter (GTK_TREE_SELECTION (widget), &iter);
gtk_tree_view_collapse_all (GTK_TREE_VIEW (treeview));
gtk_widget_show_all (GTK_WIDGET (window));
g_object_unref (builder);
}
static void replace_click(GtkWidget* widget, gpointer data) {
GtkTreeIter iter;
stateheader* sh;
if (_filePath != NULL && gtk_tree_selection_get_selected(GTK_TREE_SELECTION(selection), NULL, &iter)) {
gtk_tree_model_get(GTK_TREE_MODEL(listStore), &iter, 1, &sh, -1);
GtkWidget* dialog = gtk_file_chooser_dialog_new("Replace", GTK_WINDOW(window), GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL);
gint res = gtk_dialog_run(GTK_DIALOG(dialog));
if (res != GTK_RESPONSE_ACCEPT) {
gtk_widget_destroy(dialog);
return;
}
char* path = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
FILE* f = fopen(path, "rb");
gtk_widget_destroy(dialog);
fseek(f, 0, SEEK_END);
size_t len = ftell(f);
if (len > 65536) len = 65536; // prevent using too much memory on opening big file by accident
char* gbc_data = (char*)malloc(len);
fseek(f, 0, SEEK_SET);
size_t total_bytes_read = 0;
while (total_bytes_read < len) {
size_t bytes_read = fread(gbc_data, 1, len - total_bytes_read, f);
total_bytes_read += bytes_read;
if (bytes_read <= 0) {
error_msg("Could only read %lu bytes from %s", (unsigned long)total_bytes_read, path);
free(gbc_data);
g_free(path);
fclose(f);
return;
}
}
g_free(path);
fclose(f);
// only first X bytes will be used, where X is uncompressed size of current data
void* new_data = goomba_new_sav(loaded_file, sh, gbc_data, len);
free(gbc_data);
if (new_data == NULL) {
error_msg("%s", goomba_last_error());
} else {
memcpy(loaded_file, new_data, GOOMBA_COLOR_SRAM_SIZE);
dirty = true;
free(new_data);
header_scan();
}
}
}
int
clip_GTK_TREESELECTIONGETSELECTEDROWS(ClipMachine * ClipMachineMemory)
{
C_object *ctreesel = _fetch_co_arg(ClipMachineMemory);
ClipVar *mod = ARGPTR(ClipMachineMemory, 2);
GtkTreeModel *model;
C_object *cmodel;
GList *list;
long l;
ClipVar *ret = RETPTR(ClipMachineMemory);
CHECKOPT2(1, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);
CHECKCOBJ(ctreesel, GTK_IS_TREE_SELECTION(ctreesel->object));
list = gtk_tree_selection_get_selected_rows(GTK_TREE_SELECTION(ctreesel->object), &model);
l = g_list_length(list);
_clip_array(ClipMachineMemory, ret, 1, &l);
for (l = 0; list; list = g_list_next(list), l++)
{
C_object *cpath;
GtkTreePath *path;
path = GTK_TREE_PATH(list->data);
cpath = _list_get_cobject(ClipMachineMemory, path);
if (!cpath)
cpath = _register_object(ClipMachineMemory, path, GTK_TYPE_TREE_PATH, NULL, NULL);
if (cpath)
_clip_aset(ClipMachineMemory, ret, &cpath->obj, 1, &l);
}
if (model)
{
cmodel = _list_get_cobject(ClipMachineMemory, model);
if (!cmodel)
cmodel = _register_object(ClipMachineMemory, model, GTK_TYPE_TREE_MODEL, NULL, NULL);
if (cmodel)
_clip_mclone(ClipMachineMemory, mod, &cmodel->obj);
}
g_list_foreach(list, (GFunc) (gtk_tree_path_free), NULL);
g_list_free(list);
return 0;
err:
return 1;
}
bool MainWindow::getSelectedObjName(std::string &name, GtkTreeIter *iter){
if(!gtk_tree_selection_get_selected(GTK_TREE_SELECTION(_treeSelection),
NULL, iter))
return false;
char *_name;
gtk_tree_model_get(_mainModel, iter, 0, &_name, -1);
name = _name;
delete _name;
return true;
}
static gboolean
on_view_button_press (GtkWidget *widget,
GdkEventButton *event,
gpointer data)
{
if (event->type == GDK_BUTTON_PRESS && event->button == 3)
if (gtk_tree_selection_count_selected_rows (GTK_TREE_SELECTION(data))) {
gtk_menu_popup (GTK_MENU(viewpopup), NULL, NULL, NULL, NULL, event->button, event->time);
return TRUE;
}
return FALSE;
}
void
greeter_item_ulist_unset_selected_user (void)
{
GtkTreeSelection *selection;
if (user_list != NULL) {
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (user_list));
gtk_tree_selection_unselect_all (GTK_TREE_SELECTION (selection));
}
if (selected_user != NULL)
g_free (selected_user);
selected_user = NULL;
}
int
clip_GTK_TREESELECTIONCOUNTSELECTEDROWS(ClipMachine * cm)
{
C_object *ctreesel = _fetch_co_arg(cm);
CHECKOPT2(1, MAP_t, NUMERIC_t); CHECKCOBJ(ctreesel,GTK_IS_TREE_SELECTION(ctreesel->object));
_clip_retni(cm, gtk_tree_selection_count_selected_rows(GTK_TREE_SELECTION(ctreesel->object)));
return 0;
err:
return 1;
}
