// This callback is responsible for enabling/disabling the appropriate buttons depending on
// the contents of the selection
static void tree_view_selection_changed (GtkTreeSelection *sel, gpointer data)
  {
  bus_layout_D *dialog = (bus_layout_D *)data ;
  gboolean bSomethingSelected = FALSE ;
  gboolean bBusSelected = FALSE ;
  gboolean bSelectionIsFromBus = FALSE ;
  gboolean bFirstSelected = FALSE ;
  gboolean bLastSelected = FALSE ;
  gboolean bFirstBusSelected = TRUE ;
  gboolean bLastBusSelected = TRUE ;
  GtkTreePath *tpSelBus = NULL, *tp = NULL ;
  GtkTreeModel *tm = NULL ;
  int icChildren = -1, Nix ;

  tm = gtk_tree_view_get_model (gtk_tree_selection_get_tree_view (sel)) ;

  if ((bSelectionIsFromBus = (NULL != (tpSelBus = get_selection_bus (sel, &bSomethingSelected)))))
    if (!(bFirstSelected = bLastSelected = bBusSelected = whole_bus_selected_p (sel, tm, tpSelBus)))
      if ((icChildren = gtk_tree_model_path_n_children (tm, tpSelBus)) > 0)
        {
        gtk_tree_path_down (tp = gtk_tree_path_copy (tpSelBus)) ;
        bFirstSelected = gtk_tree_selection_path_is_selected (sel, tp) ;
        for (Nix = 1 ; Nix < icChildren ; Nix++) gtk_tree_path_next (tp) ;
        bLastSelected = gtk_tree_selection_path_is_selected (sel, tp) ;
        gtk_tree_path_free (tp) ;
        }

  if (bSelectionIsFromBus)
    determine_first_or_last_bus (tm, tpSelBus, &bFirstBusSelected, &bLastBusSelected) ;

  gtk_widget_set_sensitive (dialog->btnCreateBus, bSomethingSelected && !bBusSelected) ;
  gtk_widget_set_sensitive (dialog->btnDeleteBus, bSelectionIsFromBus) ;
  gtk_widget_set_sensitive (dialog->btnMoveBusUp, bSelectionIsFromBus && !bFirstBusSelected) ;
  gtk_widget_set_sensitive (dialog->btnMoveBusDown, bSelectionIsFromBus && !bLastBusSelected) ;
  gtk_widget_set_sensitive (dialog->btnMoveCellsUp, bSelectionIsFromBus && !bFirstSelected) ;
  gtk_widget_set_sensitive (dialog->btnMoveCellsDown, bSelectionIsFromBus && !bLastSelected) ;
  gtk_widget_set_sensitive (dialog->lblBusName, bSelectionIsFromBus) ;
  gtk_widget_set_sensitive (dialog->txtBusName, bSelectionIsFromBus) ;

  // Fill in the text box with the name of the bus
  if (bSelectionIsFromBus)
    {
    GtkTreeIter itr ;
    char *psz = NULL ;

    gtk_tree_model_get_iter (tm, &itr, tpSelBus) ;

    gtk_tree_model_get (tm, &itr, BUS_LAYOUT_MODEL_COLUMN_NAME, &psz, -1) ;

    g_signal_handlers_block_matched (G_OBJECT (dialog->txtBusName), G_SIGNAL_MATCH_FUNC, 0, 0, NULL, (gpointer)bus_name_changed, NULL) ;
    gtk_entry_set_text (GTK_ENTRY (dialog->txtBusName), psz) ;
    g_signal_handlers_unblock_matched (G_OBJECT (dialog->txtBusName), G_SIGNAL_MATCH_FUNC, 0, 0, NULL, (gpointer)bus_name_changed, NULL) ;

    g_free (psz) ;
    }

  if (NULL != (tp = g_object_get_data (G_OBJECT (gtk_tree_selection_get_tree_view (sel)), "tpBus")))
    gtk_tree_path_free (tp) ;
  g_object_set_data (G_OBJECT (gtk_tree_selection_get_tree_view (sel)), "tpBus", tpSelBus) ;
  }
Exemplo n.º 2
0
static gboolean cm_try_to_select(CMPathWalkFunc path_func, GtkTreeSelection *selection,
                                 GtkTreeModel *model, GtkTreePath *path)
{
    GtkTreeIter iter;

    if (gtk_tree_path_get_depth(path) <= 0) /* sanity check */
        return FALSE;

    /* modify the path using the passed function */
    if (path_func != NULL)
        path_func(path);

    if (gtk_tree_path_get_depth(path) <= 0) /* sanity check */
        return FALSE;

    /* check whether the path points to something valid and if so, select it */
    if (gtk_tree_model_get_iter(model, &iter, path))
    {
        GtkTreeView *treeview = gtk_tree_selection_get_tree_view(selection);
        gboolean was_expanded = gtk_tree_view_row_expanded(treeview, path);
        /* to get gtk_tree_selection_select_path() working, we need to expand the row first
         * if it isn't expanded yet, at least when the row is a parent item */
        if (! was_expanded)
            gtk_tree_view_expand_to_path(treeview, path);

        gtk_tree_selection_select_path(selection, path);

        if (! was_expanded) /* restore the previous state */
            gtk_tree_view_collapse_row(treeview, path);
        return TRUE;
    }

    return FALSE;
}
Exemplo n.º 3
0
static void
selection_changed (GtkTreeSelection *selection)
{
  GtkTreeView *treeview;
  StockItemDisplay *display;
  GtkTreeModel *model;
  GtkTreeIter iter;
  
  treeview = gtk_tree_selection_get_tree_view (selection);
  display = g_object_get_data (G_OBJECT (treeview), "stock-display");

  if (gtk_tree_selection_get_selected (selection, &model, &iter))
    {
      StockItemInfo *info;
      gchar *str;
      
      gtk_tree_model_get (model, &iter,
                          0, &info,
                          -1);

      if (info->small_icon && info->item.label)
        gtk_label_set_text (GTK_LABEL (display->type_label), "Icon and Item");
      else if (info->small_icon)
        gtk_label_set_text (GTK_LABEL (display->type_label), "Icon Only");
      else if (info->item.label)
        gtk_label_set_text (GTK_LABEL (display->type_label), "Item Only");
      else
        gtk_label_set_text (GTK_LABEL (display->type_label), "???????");

      gtk_label_set_text (GTK_LABEL (display->macro_label), info->macro);
      gtk_label_set_text (GTK_LABEL (display->id_label), info->id);

      if (info->item.label)
        {
          str = g_strdup_printf ("%s %s", info->item.label, info->accel_str);
          gtk_label_set_text_with_mnemonic (GTK_LABEL (display->label_accel_label), str);
          g_free (str);
        }
      else
        {
          gtk_label_set_text (GTK_LABEL (display->label_accel_label), "");
        }

      if (info->small_icon)
        gtk_image_set_from_stock (GTK_IMAGE (display->icon_image), info->id,
                                  get_largest_size (info->id));
      else
        gtk_image_set_from_pixbuf (GTK_IMAGE (display->icon_image), NULL);

      stock_item_info_free (info);
    }
  else
    {
      gtk_label_set_text (GTK_LABEL (display->type_label), "No selected item");
      gtk_label_set_text (GTK_LABEL (display->macro_label), "");
      gtk_label_set_text (GTK_LABEL (display->id_label), "");
      gtk_label_set_text (GTK_LABEL (display->label_accel_label), "");
      gtk_image_set_from_pixbuf (GTK_IMAGE (display->icon_image), NULL);
    }
}
Exemplo n.º 4
0
G_MODULE_EXPORT void
queue_list_selection_changed_cb(GtkTreeSelection *selection, signal_user_data_t *ud)
{
    GtkTreeModel *store;
    GtkTreeIter iter, piter;
    
    g_debug("queue_list_selection_changed_cb ()");
    // A queue entry is made up of a parent and multiple
    // children that are visible when expanded.  When and entry
    // is selected, I want the parent to be selected.
    // This is purely cosmetic.
    if (gtk_tree_selection_get_selected(selection, &store, &iter))
    {
        GtkWidget *widget = GHB_WIDGET (ud->builder, "queue_edit");
        gtk_widget_set_sensitive (widget, TRUE);
        if (gtk_tree_model_iter_parent (store, &piter, &iter))
        {
            GtkTreePath *path;
            GtkTreeView *treeview;
            
            gtk_tree_selection_select_iter (selection, &piter);
            path = gtk_tree_model_get_path (store, &piter);
            treeview = gtk_tree_selection_get_tree_view (selection);
            // Make the parent visible in scroll window if it is not.
            gtk_tree_view_scroll_to_cell (treeview, path, NULL, FALSE, 0, 0);
            gtk_tree_path_free(path);
        }
    }
    else
    {
        GtkWidget *widget = GHB_WIDGET (ud->builder, "queue_edit");
        gtk_widget_set_sensitive (widget, FALSE);
    }
}
static void
gnc_plugin_page_owner_tree_selection_changed_cb (GtkTreeSelection *selection,
        GncPluginPageOwnerTree *page)
{
    GtkActionGroup *action_group;
    GtkTreeView *view;
    GncOwner *owner = NULL;
    gboolean sensitive;
    gboolean is_readwrite = !qof_book_is_readonly(gnc_get_current_book());

    g_return_if_fail(GNC_IS_PLUGIN_PAGE_OWNER_TREE(page));

    if (!selection)
    {
        sensitive = FALSE;
    }
    else
    {
        g_return_if_fail(GTK_IS_TREE_SELECTION(selection));
        view = gtk_tree_selection_get_tree_view (selection);
        owner = gnc_tree_view_owner_get_selected_owner (GNC_TREE_VIEW_OWNER(view));
        sensitive = (owner != NULL);
    }

    action_group = gnc_plugin_page_get_action_group(GNC_PLUGIN_PAGE(page));
    gnc_plugin_update_actions (action_group, actions_requiring_owner_always,
                               "sensitive", sensitive);
    gnc_plugin_update_actions (action_group, actions_requiring_owner_rw,
                               "sensitive", sensitive && is_readwrite);
    g_signal_emit (page, plugin_page_signals[OWNER_SELECTED], 0, owner);
}
Exemplo n.º 6
0
void _fcitx_im_widget_im_selection_changed(GtkTreeSelection *selection, gpointer data)
{
    FcitxImWidget* self = data;
    GtkTreeView *treeView = gtk_tree_selection_get_tree_view(selection);
    GtkTreeModel *model = gtk_tree_view_get_model(treeView);
    GtkTreeIter iter;

    if (gtk_tree_selection_get_selected(selection, &model, &iter)) {
        gtk_widget_set_sensitive(GTK_WIDGET(self->delimbutton), TRUE);
        gtk_widget_set_sensitive(GTK_WIDGET(self->configurebutton), TRUE);
        GtkTreePath* path = gtk_tree_model_get_path(model, &iter);

        gint* ind = gtk_tree_path_get_indices(path);

        gint n = gtk_tree_model_iter_n_children(model, NULL);

        if (ind) {
            gtk_widget_set_sensitive(GTK_WIDGET(self->moveupbutton), (*ind != 0));
            gtk_widget_set_sensitive(GTK_WIDGET(self->movedownbutton), (*ind != n - 1));
        }

        gtk_tree_path_free(path);
    } else {
        gtk_widget_set_sensitive(GTK_WIDGET(self->delimbutton), FALSE);
        gtk_widget_set_sensitive(GTK_WIDGET(self->configurebutton), FALSE);
    }
}
Exemplo n.º 7
0
static void _GuiGtkList_selectionChangedCallback (GtkTreeSelection *sel, gpointer void_me) {
	iam (GuiList);
	if (my selectionChangedCallback != NULL && ! my blockSelectionChangedCallback) {
		//Melder_casual ("Selection changed.");
		struct structGuiListEvent event = { GTK_WIDGET (gtk_tree_selection_get_tree_view (sel)) };
		my selectionChangedCallback (my selectionChangedBoss, & event);
	}
}
Exemplo n.º 8
0
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);
}
Exemplo n.º 9
0
GtkWidget *menu_select(const char *name, MenuInfo *menu_info, GtkTreeSelection *selection)
{
	GtkTreeView *tree = gtk_tree_selection_get_tree_view(selection);
	GtkWidget *menu = menu_connect(name, menu_info, GTK_WIDGET(tree));

	g_signal_connect(selection, "changed", G_CALLBACK(on_selection_changed), menu);
	return menu;
}
Exemplo n.º 10
0
void
fsearch_window_actions_update   (FsearchApplicationWindow *self)
{
    GtkTreeSelection *selection = fsearch_application_window_get_listview_selection (self);
    GtkTreeView *treeview = gtk_tree_selection_get_tree_view (selection);

    gint num_rows = 0;
    if (treeview) {
        GtkTreeModel *model = gtk_tree_view_get_model (treeview);
        if (model) {
            num_rows = gtk_tree_model_iter_n_children (model, NULL);
        }
    }

    GActionGroup *group = gtk_widget_get_action_group (GTK_WIDGET (self), "win");
    g_assert (G_IS_SIMPLE_ACTION_GROUP (group));

    gint num_rows_selected = gtk_tree_selection_count_selected_rows (selection);
    action_set_enabled (group, "select_all", num_rows);
    action_set_enabled (group, "deselect_all", num_rows_selected);
    action_set_enabled (group, "invert_selection", num_rows_selected);
    action_set_enabled (group, "copy_clipboard", num_rows_selected);
    action_set_enabled (group, "cut_clipboard", num_rows_selected);
    action_set_enabled (group, "delete_selection", num_rows_selected);
    action_set_enabled (group, "open", num_rows_selected);
    action_set_enabled (group, "open_with", num_rows_selected);
    action_set_enabled (group, "open_with_other", FALSE);
    action_set_enabled (group, "open_folder", num_rows_selected);
    action_set_enabled (group, "focus_search", TRUE);
    action_set_enabled (group, "toggle_focus", TRUE);
    action_set_enabled (group, "hide_window", TRUE);
    action_set_enabled (group, "update_database", TRUE);
    action_set_enabled (group, "show_menubar", TRUE);
    action_set_enabled (group, "show_statusbar", TRUE);
    action_set_enabled (group, "show_filter", TRUE);
    action_set_enabled (group, "show_search_button", TRUE);
    action_set_enabled (group, "show_name_column", FALSE);
    action_set_enabled (group, "show_path_column", TRUE);
    action_set_enabled (group, "show_type_column", TRUE);
    action_set_enabled (group, "show_size_column", TRUE);
    action_set_enabled (group, "show_modified_column", TRUE);

    FsearchConfig *config = fsearch_application_get_config (FSEARCH_APPLICATION_DEFAULT);
    action_set_active_bool (group, "show_menubar", config->show_menubar);
    action_set_active_bool (group, "show_statusbar", config->show_statusbar);
    action_set_active_bool (group, "show_filter", config->show_filter);
    action_set_active_bool (group, "show_search_button", config->show_search_button);
    action_set_active_bool (group, "search_in_path", config->search_in_path);
    action_set_active_bool (group, "search_mode", config->enable_regex);
    action_set_active_bool (group, "match_case", config->match_case);
    action_set_active_bool (group, "show_name_column", true);
    action_set_active_bool (group, "show_path_column", config->show_path_column);
    action_set_active_bool (group, "show_type_column", config->show_type_column);
    action_set_active_bool (group, "show_size_column", config->show_size_column);
    action_set_active_bool (group, "show_modified_column", config->show_modified_column);
}
Exemplo n.º 11
0
static void
projects_tree_selection_changed (GtkTreeSelection *selection, gpointer user_data)
{
	NotesArea *nadlg = (NotesArea *) user_data;
	GttProjectsTree *gpt = GTT_PROJECTS_TREE (gtk_tree_selection_get_tree_view (selection));
	GttProject *prj = gtt_projects_tree_get_selected_project (gpt);

	notes_area_set_project (nadlg, prj);

}
Exemplo n.º 12
0
void AP_UnixDialog_Styles::event_SelectionChanged(GtkTreeSelection * selection)
{	
	GtkTreeView *tree = gtk_tree_selection_get_tree_view(selection);
	GtkTreeModel *model = gtk_tree_view_get_model(tree);
	GList *list = gtk_tree_selection_get_selected_rows(selection, &model);

	gpointer item = g_list_nth_data(list, 0);
	m_selectedStyle = reinterpret_cast<GtkTreePath *>(item);

	// refresh the previews
	_populatePreviews(false);
}
Exemplo n.º 13
0
/**
 * Fetch data from the selection of a treeview. Returns a GSList containing
 * the user_data pointers from the selected rows. If cfn != NULL, it will
 * be used to determine whether two entries are equal and drop all duplicate
 * items from the result list. Using cfn will significantly increase runtime.
 */
GSList *
tree_selection_collect_data(GtkTreeSelection *selection,
	tree_selection_get_data_func gdf, GCompareFunc cfn)
{
	collect_data_struct_t cdata;

    g_assert(NULL != selection);

	cdata.results = NULL;
	cdata.to_unselect = NULL;
	cdata.cfn = cfn;
	cdata.gdf = gdf;
	cdata.tv = gtk_tree_selection_get_tree_view(selection);
	if (GUI_PROPERTY(gui_debug) >= 3) {
		cdata.name = gtk_widget_get_name(
			GTK_WIDGET(gtk_tree_selection_get_tree_view(selection)));
		if (NULL == cdata.name)
			cdata.name = "<UNKNOWN>";
	} else
		cdata.name = NULL;

    /*
     * Browse selected rows and gather data.
     */
	gtk_tree_selection_selected_foreach(selection,
		tree_selection_collect_data_helper, &cdata);

    /*
     * Now unselect the rows from which we got data.
     */
	g_slist_foreach(cdata.to_unselect,
		tree_selection_unselect_helper, selection);

    /*
     * Cleanup before exit.
     */
    gm_slist_free_null(&cdata.to_unselect);

    return cdata.results;
}
Exemplo n.º 14
0
 /**
 *
 *
 * \param
 * \param
 *
 * \return
 **/
static void gsb_reconcile_button_collapse_row_clicked (GtkButton *button,
													   GtkTreeSelection *selection)
{
	GtkTreeView *tree_view;
    GtkTreeModel *model;
    GtkTreeIter iter;
	GtkTreePath *path;

	if ( !gtk_tree_selection_get_selected (selection, &model, &iter))
        return;
	path = gtk_tree_model_get_path (model, &iter);
	tree_view = gtk_tree_selection_get_tree_view (selection);
	gtk_tree_view_collapse_row (tree_view, path);
}
Exemplo n.º 15
0
/* Called when Add... button is clicked */
static void add_exclude(GtkButton *button, gpointer user_data)
{
  /* Append new item */
  GtkTreeIter row_iter;
  gtk_list_store_append(exclude_list, &row_iter);
  /* Add a %s to the command */
  //gtk_list_store_set(actions_list, &row_iter, 1, "", -1);
  /* Set the first column to editing */
  GtkTreePath* row_path = gtk_tree_model_get_path((GtkTreeModel*)exclude_list, &row_iter);
  GtkTreeView* treeview = gtk_tree_selection_get_tree_view(exclude_selection);
  GtkTreeViewColumn* column = gtk_tree_view_get_column(treeview, 0);
  gtk_tree_view_set_cursor(treeview, row_path, column, TRUE);
  gtk_tree_path_free(row_path);
}
Exemplo n.º 16
0
G_MODULE_EXPORT void
subtitle_list_selection_changed_cb(GtkTreeSelection *ts, signal_user_data_t *ud)
{
    GtkTreeModel *tm;
    GtkTreeIter iter;
    GValue *subsettings = NULL;
    int row;

    g_debug("subtitle_list_selection_changed_cb()");
    if (gtk_tree_selection_get_selected(ts, &tm, &iter))
    {
        GtkTreeIter piter;

        if (gtk_tree_model_iter_parent(tm, &piter, &iter))
        {
            GtkTreePath *path;
            GtkTreeView *tv;

            gtk_tree_selection_select_iter(ts, &piter);
            path = gtk_tree_model_get_path(tm, &piter);
            tv = gtk_tree_selection_get_tree_view(ts);
            // Make the parent visible in scroll window if it is not.
            gtk_tree_view_scroll_to_cell(tv, path, NULL, FALSE, 0, 0);
            gtk_tree_path_free(path);
            return;
        }

        GtkTreePath *tp;
        gint *indices;
        GValue *subtitle_list;

        tp = gtk_tree_model_get_path(tm, &iter);
        indices = gtk_tree_path_get_indices(tp);
        row = indices[0];
        gtk_tree_path_free(tp);

        subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
        if (row >= 0 && row < ghb_array_len(subtitle_list))
            subsettings = ghb_array_get_nth(subtitle_list, row);
    }
    subtitle_update_dialog_widgets(ud, subsettings);
    if (subsettings)
    {
        if (ghb_settings_get_boolean(subsettings, "SubtitleBurned"))
        {
            ghb_subtitle_exclusive_burn(ud, row);
        }
    }
}
Exemplo n.º 17
0
/**
@brief (de)sensitize option tree buttons for selected option tree row
Config dialog page buttons are de-sensitized if the row is the toolbar 'parent'
@param selection pointer to selection
@param model UNUSED
@param path
@param path_currently_selected UNUSED
@param set data struct for the keybings option
@return TRUE always (the row is always selectable)
*/
static gboolean _e2_bookmark_tree_selection_check_cb (GtkTreeSelection *selection,
	GtkTreeModel *model, GtkTreePath *path,
	gboolean path_currently_selected, E2_OptionSet *set)
{
	GtkTreeIter iter;
	if (gtk_tree_model_get_iter (set->ex.tree.model, &iter, path))
	{
		gchar *label;
		gtk_tree_model_get (set->ex.tree.model, &iter, 0, &label, -1);
		gboolean result = strcmp (label, _C(41));
		g_free (label);
		GtkTreeView *view = gtk_tree_selection_get_tree_view (selection);
		NEEDCLOSEBGL
		e2_option_tree_adjust_buttons (view, result);
		NEEDOPENBGL
	}
Exemplo n.º 18
0
/*! \brief Handles changes in the treeview selection.
 *  \par Function Description
 *  This is the callback function that is called every time the user
 *  select a row the library treeview of the dialog.
 *
 *  If the selection is not a selection of a footprint, it does
 *  nothing. Otherwise it updates the preview and Element data.
 *
 *  \param [in] selection The current selection in the treeview.
 *  \param [in] user_data The library dialog.
 */
static void
library_window_callback_tree_selection_changed (GtkTreeSelection * selection,
						gpointer user_data)
{
  GtkTreeView *view;
  GtkTreeModel *model;
  GtkTreeIter iter;
  GhidLibraryWindow *library_window = (GhidLibraryWindow *) user_data;
  LibraryEntryType *entry = NULL;
  gchar *m4_args;

  if (!gtk_tree_selection_get_selected (selection, &model, &iter))
    return;

  view = gtk_tree_selection_get_tree_view (selection);
  gtk_tree_model_get (model, &iter, MENU_ENTRY_COLUMN, &entry, -1);

  if (entry == NULL)
    return;

  /* -1 flags this is an element file part and the file path is in
     |  entry->AllocateMemory.
   */
  if (entry->Template == (char *) -1)
    {
      if (LoadElementToBuffer (PASTEBUFFER, entry->AllocatedMemory, true))
	SetMode (PASTEBUFFER_MODE);
      goto out;
    }

  /* Otherwise, it's a m4 element and we need to create a string of
     |  macro arguments to be passed to the library command in
     |  LoadElementToBuffer()
   */
  m4_args = g_strdup_printf ("'%s' '%s' '%s'", EMPTY (entry->Template),
			     EMPTY (entry->Value), EMPTY (entry->Package));

  if (LoadElementToBuffer (PASTEBUFFER, m4_args, false))
    SetMode (PASTEBUFFER_MODE);
  g_free (m4_args);

out:

  /* update the preview with new symbol data */
  g_object_set (library_window->preview,
		"element-data", PASTEBUFFER->Data->Element, NULL);
}
Exemplo n.º 19
0
int
clip_GTK_TREESELECTIONGETTREEVIEW(ClipMachine * cm)
{
	C_object *ctreesel = _fetch_co_arg(cm);
        GtkTreeView *view;
        C_widget *cwid;

	CHECKOPT2(1, MAP_t, NUMERIC_t); CHECKCOBJ(ctreesel,GTK_IS_TREE_SELECTION(ctreesel->object));

	view = gtk_tree_selection_get_tree_view(GTK_TREE_SELECTION(ctreesel->object));

	if (!view) goto err;
	cwid = _register_widget(cm, GTK_WIDGET(view), NULL);
	_clip_mclone(cm,RETPTR(cm),&cwid->obj);

	return 0;
err:
	return 1;
}
Exemplo n.º 20
0
static void
onAbsenceSelectionChanged (GtkTreeSelection *sel,gpointer user_data)
{
  GtkTreeIter  selected_row;
  GtkWidget *text_view;
  GtkWidget *view;
  GtkWidget *entry;
  GtkTreeModel *model;
  GtkTextBuffer *buffer;
  gint index;
  gchar *title;
  gchar *message;

  view=GTK_WIDGET(gtk_tree_selection_get_tree_view(sel));
  g_assert(view);
  g_assert(gtk_tree_selection_get_mode(sel) == GTK_SELECTION_SINGLE);
  entry=GTK_WIDGET(lookup_widget(view,"AbsenceTitleEntry"));
  g_assert(entry);
  text_view=GTK_WIDGET(lookup_widget(view,"fuzaiText"));
  g_assert(text_view);

  if (gtk_tree_selection_get_selected(sel, &model, &selected_row))
    {
      gtk_tree_model_get (model, &selected_row, 
                          1, &index,
                          -1);
      dbg_out("Selected index:%d\n",index);
      if (!hostinfo_get_absent_title(index,(const char **)&title)) {
	gtk_entry_set_text(GTK_ENTRY(entry), title); 
	g_free(title);
      }
      if (!hostinfo_get_absent_message(index, &message)) {
	buffer=gtk_text_view_get_buffer(GTK_TEXT_VIEW(text_view));
	gtk_text_buffer_set_text(buffer,message,-1);
	g_free(message);
      }
    }
  else
    {
      g_assert_not_reached();
    }
}
Exemplo n.º 21
0
    gint Meaning::_wordclick
    (GtkTreeSelection *sel, gpointer data)
    throw(std::bad_alloc)
    {
        Meaning *m = static_cast<Meaning*>(data);
		GtkTreeView *tv = gtk_tree_selection_get_tree_view(sel);
		GtkTreeModel *model = gtk_tree_view_get_model(tv);
        m->d_display._handleSelection(GTK_WIDGET(tv));

		GtkTreeIter iter;
		if (gtk_tree_selection_get_selected (sel, &model, &iter))
		{
            char* text;
            gtk_tree_model_get (model, 0, &text, -1);
		    GdkEvent *e = gtk_get_current_event ();
            m->d_display._handleClick((e->type == GDK_2BUTTON_PRESS), text);
		}

        return 0;
    }
Exemplo n.º 22
0
static void
relation_list_sel_cb(GtkTreeSelection *sel, gpointer user_data _U_)
{
    GtkWidget *window = gtk_widget_get_toplevel(GTK_WIDGET(gtk_tree_selection_get_tree_view(sel)));
    GtkWidget *range_label =
        (GtkWidget *)g_object_get_data(G_OBJECT(window), E_DFILTER_EXPR_RANGE_LABEL_KEY);
    GtkWidget *range_entry =
        (GtkWidget *)g_object_get_data(G_OBJECT(window), E_DFILTER_EXPR_RANGE_ENTRY_KEY);
    GtkWidget *value_label =
        (GtkWidget *)g_object_get_data(G_OBJECT(window), E_DFILTER_EXPR_VALUE_LABEL_KEY);
    GtkWidget *value_entry =
        (GtkWidget *)g_object_get_data(G_OBJECT(window), E_DFILTER_EXPR_VALUE_ENTRY_KEY);
    GtkWidget *value_list_label =
        (GtkWidget *)g_object_get_data(G_OBJECT(window), E_DFILTER_EXPR_VALUE_LIST_LABEL_KEY);
    GtkWidget *value_list =
        (GtkWidget *)g_object_get_data(G_OBJECT(window), E_DFILTER_EXPR_VALUE_LIST_KEY);
    GtkWidget *value_list_scrolled_win =
        (GtkWidget *)g_object_get_data(G_OBJECT(window), E_DFILTER_EXPR_VALUE_LIST_SW_KEY);
    header_field_info *hfinfo =
        (header_field_info *)g_object_get_data(G_OBJECT(window), E_DFILTER_EXPR_CURRENT_VAR_KEY);
    gchar *item_str;
    GtkTreeModel *model;
    GtkTreeIter   iter;

    /*
     * What's the relation?
     */
    if (!gtk_tree_selection_get_selected(sel, &model, &iter))
        return;
    gtk_tree_model_get(model, &iter, 0, &item_str, -1);

    /*
     * Update the display of various items for the value, as appropriate.
     */
    display_value_fields(hfinfo,
                         !relation_is_presence_test(item_str),
                         value_label, value_entry, value_list_label, value_list,
                         value_list_scrolled_win, range_label, range_entry);
    g_free(item_str);
}
Exemplo n.º 23
0
void _fcitx_main_window_addon_selection_changed(GtkTreeSelection *selection, gpointer data)
{
    GtkTreeView *treeView = gtk_tree_selection_get_tree_view(selection);
    GtkTreeModel *model = gtk_tree_view_get_model(treeView);
    GtkTreeIter iter;
    FcitxAddon *addon = NULL;
    FcitxMainWindow* self = data;

    if (!self->button)
        return;

    if (gtk_tree_selection_get_selected(selection, &model, &iter)) {
        gtk_tree_model_get(model, &iter,
                           LIST_ADDON, &addon,
                           -1);
        gchar* config_desc_name = g_strdup_printf("%s.desc", addon->name);
        FcitxConfigFileDesc* cfdesc = get_config_desc(config_desc_name);
        g_free(config_desc_name);
        gboolean configurable = (gboolean)(cfdesc != NULL || strlen(addon->subconfig) != 0);
        gtk_widget_set_sensitive(self->button, configurable);
    } else {
        gtk_widget_set_sensitive(self->button, FALSE);
    }
}
static void
treeview_selection_changed_callback (GtkTreeSelection *selection, guint data)
{
  GSettings *settings;
  gchar *key;
  GtkTreeIter iter;
  GtkTreeModel *model;
  GtkTreeView *list;

  list = gtk_tree_selection_get_tree_view (selection);

  settings = g_object_get_data (G_OBJECT (list), GSETTINGS_SETTINGS);
  key = g_object_get_data (G_OBJECT (list), GSETTINGS_KEY);

  if (gtk_tree_selection_get_selected (selection, &model, &iter)) {
    gchar *list_value;

    gtk_tree_model_get (model, &iter, COL_NAME, &list_value, -1);

    if (list_value) {
      g_settings_set_string (settings, key, list_value);
    }
  }
}
Exemplo n.º 25
0
/**
 * called when change the selection of the fyear
 *
 * \param tree_selection
 * \param null
 *
 * \return FALSE
 * */
gboolean gsb_fyear_config_select ( GtkTreeSelection *tree_selection,
				   gpointer null )
{
    GtkTreeModel *model;
    GtkTreeIter iter;
    gint fyear_number;
    GtkWidget *tree_view;
    GtkWidget *widget;

    if (!gtk_tree_selection_get_selected ( GTK_TREE_SELECTION (tree_selection),
					   &model,
					   &iter ))
	return FALSE;

    gtk_tree_model_get ( GTK_TREE_MODEL (model),
			 &iter,
			 FYEAR_NUMBER_COLUMN, &fyear_number,
			 -1 );

    tree_view = GTK_WIDGET (gtk_tree_selection_get_tree_view (tree_selection));

    /* set the name */
    widget = g_object_get_data ( G_OBJECT (model),
				 "fyear_name_entry" );
    gsb_autofunc_entry_set_value ( widget,
				   gsb_data_fyear_get_name (fyear_number),
				   fyear_number );

    /* set the beginning date */
    widget = g_object_get_data ( G_OBJECT (model),
				 "fyear_begin_date_entry" );
    gsb_calendar_entry_set_color (widget, TRUE);
    gsb_autofunc_date_set ( widget,
			    gsb_data_fyear_get_beginning_date (fyear_number),
			    fyear_number );

    /* set the end date */
    widget = g_object_get_data ( G_OBJECT (model),
				 "fyear_end_date_entry" );
    gsb_calendar_entry_set_color (widget, TRUE);
    gsb_autofunc_date_set ( widget,
			    gsb_data_fyear_get_end_date (fyear_number),
			    fyear_number );

    /* set the button */
    widget = g_object_get_data ( G_OBJECT (model),
				 "fyear_show_button" );
    gsb_autofunc_checkbutton_set_value ( widget,
					 gsb_data_fyear_get_form_show (fyear_number),
					 fyear_number );

    /* set the invalid label */
    widget = g_object_get_data ( G_OBJECT (model),
				 "invalid_label" );
    if (gsb_data_fyear_get_invalid (fyear_number))
    {
	gtk_label_set_markup ( GTK_LABEL (widget),
			       gsb_data_fyear_get_invalid_message (fyear_number));
	gtk_widget_show (widget);
    }
    else
	gtk_widget_hide (widget);

    /* sensitive what is needed */
    gtk_widget_set_sensitive ( g_object_get_data ( G_OBJECT (model),
						   "paddingbox_details" ),
			       TRUE );
    gtk_widget_set_sensitive ( g_object_get_data ( G_OBJECT (model),
						   "remove_fyear_button" ),
			       TRUE );

    return FALSE;
}
Exemplo n.º 26
0
gboolean
on_key_treeview_selection (	GtkTreeSelection	*selection,
				GtkTreeModel		*model,
				GtkTreePath		*path,
				gboolean		path_currently_selected,
				gpointer		userdata )
/*
Global input:
	key_list	- The list containing the settings for every key
Global output:
	selected_key	- Will point to the KTKeySettings in 'key_list' that
			  corresponds to the selected key (if a key is selected)
Description:
	This function sets all the settings of the selected key (if one selected) to
	the GUI and sets 'selected_key' to the address of the selected key settings.
	The key settings will be found in 'key_list'.
*/
{
	GtkEntry		*program_entry = NULL,
				*default_entry,
				*plugin_combo_entry,
				*plugin_function_combo_entry;
	GtkRadioButton		*radiobutton,
				*default_radiobutton,
				*program_radiobutton,
				*special_action_radiobutton;
	GtkList			*plugin_combo_list,
				*plugin_function_combo_list;
	GtkTreeView		*key_treeview;
	GtkTreeIter		iter;
	char			*key_name,
				*program_user = "",
				*default_action;
	KTPluginInfoEntry	*plugin;
	
	/* If a row was selected instead of deselected */
	if (gtk_tree_model_get_iter(model, &iter, path)) 
	{
		/* Get the name of the selected key */
		gtk_tree_model_get (model, &iter, FIRST_COLUMN, &key_name, -1);
		if (key_name != NULL) /* If a listitem was selected instead of deselected */
		{
			key_treeview = gtk_tree_selection_get_tree_view(selection);
			program_entry = KTGUI_program_entry();
			default_entry = KTGUI_default_entry();
			plugin_combo_entry = KTGUI_plugin_combo_entry();
			plugin_function_combo_entry = KTGUI_plugin_function_combo_entry();
			default_radiobutton = KTGUI_default_radiobutton();
			program_radiobutton = KTGUI_program_radiobutton();
			special_action_radiobutton = KTGUI_special_action_radiobutton();
			plugin_combo_list = KTGUI_plugin_combo_list();
			plugin_function_combo_list = KTGUI_plugin_function_combo_list();
			
			/* Block the signal handlers of the entries and the radiobuttons */
			g_signal_handlers_block_by_func (GTK_OBJECT(program_entry),
			                                  (void *)on_program_entry_changed, NULL);
			g_signal_handlers_block_by_func (GTK_OBJECT(default_radiobutton),
			                                  (void *)on_default_radiobutton_toggled, NULL);
			g_signal_handlers_block_by_func (GTK_OBJECT(program_radiobutton),
			                                  (void *)on_program_radiobutton_toggled, NULL);
			g_signal_handlers_block_by_func (GTK_OBJECT(special_action_radiobutton), 
			                                  (void *)on_special_action_radiobutton_toggled, NULL);
			g_signal_handlers_block_by_func (GTK_OBJECT(plugin_combo_entry),
			                                  (void *)on_plugin_combo_entry_changed, NULL);
			g_signal_handlers_block_by_func (GTK_OBJECT(plugin_function_combo_entry),
			                                  (void *)on_plugin_function_combo_entry_changed, NULL);
			
			gtk_entry_set_text (plugin_combo_entry, "");
			gtk_entry_set_text (plugin_function_combo_entry, "");
			/* Clear the plugin function list */
			gtk_list_clear_items (plugin_function_combo_list, 0, -1); /* Clear the whole list */
			/* Select the key in the linked list */
			selected_key = find_key_settings(key_name, &key_list);
			/* Read the settings of the key */
			if (!memcmp(&selected_key->action, &selected_key->default_action, sizeof(KTAction)))
			{
				radiobutton = default_radiobutton;
			}
			else if (selected_key->action.type == KTActionTypeProgram)
			{
				program_user = selected_key->action.program.command;
				radiobutton = GTK_RADIO_BUTTON( lookup_widget(GTK_WIDGET(key_treeview), "program_radiobutton") );
			}
			else if (selected_key->action.type == KTActionTypePlugin)
			{
				plugin = find_plugin (selected_key->action.plugin.plugin_name, &plugin_list);
				if (plugin_function_exists (selected_key->action.plugin.plugin_name,
				                            selected_key->action.plugin.function_name,
				                            &plugin_list))
				{
					reload_plugin_function_list (KTGUI_plugin_function_combo_list(),
					                             GTK_OBJECT( KTGUI_plugin_function_combo_entry() ),
					                             on_plugin_function_combo_entry_changed,
					                             plugin);
					gtk_entry_set_text (plugin_combo_entry,
					                    selected_key->action.plugin.plugin_name);
					gtk_entry_set_text (plugin_function_combo_entry,
					                    selected_key->action.plugin.function_name);
					radiobutton = special_action_radiobutton;
				}
				else
				{
					radiobutton = default_radiobutton;
				}
			}
			
			/* Show the settings of the key */
			gtk_label_set_text (KTGUI_key_name_label(), key_name);
			gtk_entry_set_text (GTK_ENTRY(program_entry), program_user);
			gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(radiobutton), TRUE);
			
			if (selected_key->default_action.type == KTActionTypePlugin)
			{
				/* If the plugin is not available on this system */
				if (selected_key->default_action.plugin.plugin_name == NULL)
				{
					default_action = "";
				}
				else
				{
					default_action = (char *)g_strdup_printf ("%s - %s",
							selected_key->default_action.plugin.plugin_name,
							selected_key->default_action.plugin.function_name);
				}
			}
			else if (selected_key->default_action.type == KTActionTypeProgram)
			{
				default_action = (char *)g_strdup_printf(
						selected_key->default_action.program.command);
			}
			/* Show the default action */
			gtk_entry_set_text (GTK_ENTRY(default_entry), default_action);
			if (default_action[0] != '\0')
			{
				g_free (default_action);
			}
			
			/* Unblock the signal handlers of the entries and the radiobuttons */
			g_signal_handlers_unblock_by_func (GTK_OBJECT(program_entry),
			                                    (void *)on_program_entry_changed, NULL);
			g_signal_handlers_unblock_by_func (GTK_OBJECT(default_radiobutton),
			                                    (void *)on_default_radiobutton_toggled, NULL);
			g_signal_handlers_unblock_by_func (GTK_OBJECT(program_radiobutton),
			                                    (void *)on_program_radiobutton_toggled, NULL);
			g_signal_handlers_unblock_by_func (GTK_OBJECT(special_action_radiobutton),
			                                    (void *)on_special_action_radiobutton_toggled, NULL);
			g_signal_handlers_unblock_by_func (GTK_OBJECT(plugin_combo_entry), 
			                                    (void *)on_plugin_combo_entry_changed, NULL);
			g_signal_handlers_unblock_by_func (GTK_OBJECT(plugin_function_combo_entry), 
			                                    (void *)on_plugin_function_combo_entry_changed, NULL);
			
			g_free (key_name);
		}
	}
	
	return (TRUE);
}
Exemplo n.º 27
0
// start helpers
static void swap_buses (GtkTreeModel *tm, GtkTreeSelection *sel, bus_layout_D *dialog, GtkTreePath *tpSrc, GtkTreePath *tpDst)
  {
  int Nix ;
  GtkTreeIter itr ;
  SWAP_BUSES_STRUCT src, dst ;
  SWAP_BUSES_STRUCT *min = NULL, *max = NULL ;
  EXP_ARRAY *ar_bSelSrc = NULL, *ar_bSelDst = NULL ;
  gboolean bDstExpanded = TRUE ;

  if (!gtk_tree_model_get_iter (tm, &(src.itr), tpSrc)) return ;
  src.tp = gtk_tree_path_copy (tpSrc) ;
  src.icChildren = gtk_tree_model_iter_n_children (tm, &(src.itr)) ;

  if (!gtk_tree_model_get_iter (tm, &(dst.itr), tpDst))
    {
    gtk_tree_path_free (src.tp) ;
    return ;
    }
  dst.tp = gtk_tree_path_copy (tpDst) ;
  dst.icChildren = gtk_tree_model_iter_n_children (tm, &(dst.itr)) ;

  if (dst.icChildren < src.icChildren)
    {
    min = &dst ;
    max = &src ;
    }
  else
    {
    min = &src ;
    max = &dst ;
    }

  bDstExpanded = gtk_tree_view_row_expanded (gtk_tree_selection_get_tree_view (sel), dst.tp) ;

  g_signal_handlers_block_matched (G_OBJECT (sel), G_SIGNAL_MATCH_FUNC, 0, 0, NULL, (gpointer)tree_view_selection_changed, NULL) ;

  for (Nix = 0 ; Nix < max->icChildren - min->icChildren ; Nix++)
    gtk_tree_store_append (GTK_TREE_STORE (tm), &itr, &(min->itr)) ;

  gtk_tree_path_down (src.tp) ;
  gtk_tree_path_down (dst.tp) ;

  ar_bSelSrc = exp_array_new (sizeof (gboolean), 1) ;
  ar_bSelDst = exp_array_new (sizeof (gboolean), 1) ;
  exp_array_1d_insert_vals (ar_bSelSrc, NULL, max->icChildren, 0) ;
  exp_array_1d_insert_vals (ar_bSelDst, NULL, max->icChildren, 0) ;

  for (Nix = 0 ; Nix < max->icChildren ; Nix++)
    {
    exp_array_index_1d (ar_bSelSrc, gboolean, Nix) =
      gtk_tree_selection_path_is_selected (sel, src.tp) ;
    exp_array_index_1d (ar_bSelDst, gboolean, Nix) =
      gtk_tree_selection_path_is_selected (sel, dst.tp) ;

    gtk_tree_path_next (src.tp) ;
    gtk_tree_path_next (dst.tp) ;
    }

  if (!gtk_tree_path_up (src.tp)) goto swap_buses_quit ;
  if (!gtk_tree_path_up (dst.tp)) goto swap_buses_quit ;
  gtk_tree_path_down (src.tp) ;
  gtk_tree_path_down (dst.tp) ;

  for (Nix = 0 ; Nix < max->icChildren ; Nix++)
    {
    if (exp_array_index_1d (ar_bSelDst, gboolean, Nix))
      gtk_tree_view_expand_to_path (gtk_tree_selection_get_tree_view (sel), src.tp) ;

    if (exp_array_index_1d (ar_bSelSrc, gboolean, Nix))
      gtk_tree_view_expand_to_path (gtk_tree_selection_get_tree_view (sel), dst.tp) ;

    gtk_tree_path_next (src.tp) ;
    gtk_tree_path_next (dst.tp) ;
    }

  if (!gtk_tree_path_up (src.tp)) goto swap_buses_quit ;
  if (!gtk_tree_path_up (dst.tp)) goto swap_buses_quit ;
  gtk_tree_path_down (src.tp) ;
  gtk_tree_path_down (dst.tp) ;

  for (Nix = 0 ; Nix < max->icChildren ; Nix++)
    {
    swap_model_paths_contents (tm, src.tp, dst.tp) ;
    gtk_tree_path_next (src.tp) ;
    gtk_tree_path_next (dst.tp) ;
    }

  if (!gtk_tree_path_up (src.tp)) goto swap_buses_quit ;
  if (!gtk_tree_path_up (dst.tp)) goto swap_buses_quit ;
  gtk_tree_path_down (src.tp) ;
  gtk_tree_path_down (dst.tp) ;

  for (Nix = 0 ; Nix < max->icChildren ; Nix++)
    {
    GTK_TREE_SELECTION_SET_PATH_SELECTED (sel, src.tp, exp_array_index_1d (ar_bSelDst, gboolean, Nix)) ;
    GTK_TREE_SELECTION_SET_PATH_SELECTED (sel, dst.tp, exp_array_index_1d (ar_bSelSrc, gboolean, Nix)) ;
    gtk_tree_path_next (src.tp) ;
    gtk_tree_path_next (dst.tp) ;
    }

  if (!gtk_tree_path_up (src.tp)) goto swap_buses_quit ;
  if (!gtk_tree_path_up (dst.tp)) goto swap_buses_quit ;

  swap_model_paths_contents (tm, src.tp, dst.tp) ;

  gtk_tree_path_down (src.tp) ;
  gtk_tree_path_down (dst.tp) ;

  for (Nix = 0 ; Nix < min->icChildren ; Nix++)
    gtk_tree_path_next (max->tp) ;
  if (gtk_tree_model_get_iter (tm, &itr, max->tp))
    while (gtk_tree_store_remove (GTK_TREE_STORE (tm), &itr)) ;

  if (!bDstExpanded)
    {
    for (Nix = 0 ; Nix < ar_bSelDst->icUsed ; Nix++)
      if (exp_array_index_1d (ar_bSelDst, gboolean, Nix))
        break ;

    if (Nix == ar_bSelDst->icUsed)
      if (gtk_tree_path_up (src.tp))
        gtk_tree_view_collapse_row (gtk_tree_selection_get_tree_view (sel), src.tp) ;
    }

swap_buses_quit:

  exp_array_free (ar_bSelSrc) ;
  exp_array_free (ar_bSelDst) ;
  gtk_tree_path_free (src.tp) ;
  gtk_tree_path_free (dst.tp) ;
  g_signal_handlers_unblock_matched (G_OBJECT (sel), G_SIGNAL_MATCH_FUNC, 0, 0, NULL, (gpointer)tree_view_selection_changed, NULL) ;
  tree_view_selection_changed (sel, dialog) ;
  }
Exemplo n.º 28
0
static void
pn_move (struct pan_node *xq, gint x, gint y, gint nx, gint ny)
{
  GtkWidget *dia;
  char mes[0x100];
  int isover;
  struct xq_move *move;
  GtkTreeIter iter[1];
  GtkTreePath *path;
  GtkTreeView *tree;

  acc_debug ("move [%s] [%d:%d] -> [%d:%d]\n", zi_chinese[(int) xq->cur_pan[y][x]], x, y, nx, ny);

  if (xq->move_count >= sizeof (xq->moves) / sizeof (xq->moves[0]))
    {
      acc_err ( _("move count error.\n"));
      return;
    }

  move = xq->moves + xq->move_count;
  xq->move_count ++;

  move->dead = xq->cur_pan[ny][nx];
  move->isred = IS_RED (xq->cur_pan[y][x]);
  move->fromx = x;
  move->fromy = y;
  move->tox = nx;
  move->toy = ny;

  move_to_desc (xq->cur_pan, move, mes, sizeof mes);
  gtk_list_store_append (GTK_LIST_STORE (xq->qipu_list), iter);
  gtk_list_store_set (GTK_LIST_STORE (xq->qipu_list), iter, 1, mes, -1);

  path = gtk_tree_model_get_path (GTK_TREE_MODEL (xq->qipu_list), iter);
  if (path)
    {
      tree = gtk_tree_selection_get_tree_view (GTK_TREE_SELECTION (xq->qipu_sel));
      gtk_tree_view_scroll_to_cell (tree, path, NULL, FALSE, 0, 0);
      gtk_tree_path_free (path);
    }

  pan_move (xq->cur_pan, x, y, nx, ny);

  if (move->dead)
    {
      xq->cur_moves = NULL;
      memcpy (xq->cur_fen, xq->cur_pan, 10 * 9 * sizeof (char));
      xq->cur_fen->half_count = 0;
      if (IS_RED (move->dead))
        {
          xq->cur_fen->is_redturn = 1;
        }
      else
        {
          xq->cur_fen->is_redturn = 0;
        }
    }
  else
    {
      xq->cur_moves = g_list_append (xq->cur_moves, move);
      xq->cur_fen->half_count ++;
    }

  isover = zgxq_is_over (xq->cur_pan);
  if (isover)
    {
      xq->state = PAN_STATE_GAME_OVER;

      g_snprintf (mes, sizeof mes, _("!!!Game over. You %s.\n"),
                  isover > 0 ? _("WIN") : _("LOSE"));
      dia =
        gtk_message_dialog_new (NULL,
                                GTK_DIALOG_DESTROY_WITH_PARENT,
                                GTK_MESSAGE_INFO, GTK_BUTTONS_CLOSE, mes);
      gtk_dialog_run (GTK_DIALOG (dia));
      gtk_widget_destroy (dia);
      g_signal_emit_by_name (xq->bstop, "clicked", xq);
    }
}
Exemplo n.º 29
0
gboolean
on_key_treeview_selection (	GtkTreeSelection	*selection,
				GtkTreeModel		*model,
				GtkTreePath		*path,
				gboolean		path_currently_selected,
				gpointer		userdata                    )
{
	GtkLabel		*key_name_label = NULL;
	GtkEntry		*program_entry = NULL,
				*default_entry,
				*special_action_combo_entry;
	GtkRadioButton		*radiobutton,
				*default_radiobutton,
				*program_radiobutton,
				*special_action_radiobutton;
	GtkList			*special_action_list;
	GtkTreeView		*key_treeview;
	GtkTreeIter		iter;
	char			*key_name,
				*program_user = "",
				*program_default;
	KEY_SETTINGS		*selected_key;

	key_treeview = gtk_tree_selection_get_tree_view(selection);
	key_name_label = GTK_LABEL( lookup_widget(GTK_WIDGET(key_treeview), "key_name_label") );
	program_entry = GTK_ENTRY( lookup_widget(GTK_WIDGET(key_treeview), "program_entry") );
	default_entry = GTK_ENTRY( lookup_widget(GTK_WIDGET(key_treeview), "default_entry") );
	
	if ( gtk_tree_model_get_iter(model, &iter, path) ) /* If a row was selected instead of deselected */
	{
		/* Get the name of the selected key */
		gtk_tree_model_get (model, &iter, FIRST_COLUMN, &key_name, -1);
		if (key_name) /* If a listitem was selected instead of deselected */
		{
			default_radiobutton = GTK_RADIO_BUTTON( lookup_widget(GTK_WIDGET(key_treeview), "default_radiobutton") );
			program_radiobutton = GTK_RADIO_BUTTON( lookup_widget(GTK_WIDGET(key_treeview), "program_radiobutton") );
			special_action_radiobutton = GTK_RADIO_BUTTON(
				lookup_widget(GTK_WIDGET(key_treeview), "special_action_radiobutton") );
			special_action_combo_entry = GTK_ENTRY( lookup_widget(GTK_WIDGET(key_treeview), "special_action_combo_entry") );
			special_action_list = GTK_COMBO(lookup_widget(GTK_WIDGET(key_treeview), "special_action_combo"))->list;
			
			/* Block the signal handlers of the entries and the radiobuttons */
			gtk_signal_handler_block_by_func (	GTK_OBJECT(program_entry),
								(void *)on_program_entry_changed, NULL  );
			gtk_signal_handler_block_by_func (	GTK_OBJECT(default_radiobutton),
								(void *)on_default_radiobutton_toggled, NULL  );
			gtk_signal_handler_block_by_func (	GTK_OBJECT(program_radiobutton),
								(void *)on_program_radiobutton_toggled, NULL  );
			gtk_signal_handler_block_by_func (	GTK_OBJECT(special_action_radiobutton), 
								(void *)on_special_action_radiobutton_toggled, NULL  );
			gtk_signal_handler_block_by_func (	GTK_OBJECT(special_action_combo_entry),
								(void *)on_special_action_combo_entry_changed, NULL  );
			
			/* Select the first item of special_action_list */
			/* Select the matching list item of special_action_list */
			gtk_list_select_item (GTK_LIST(special_action_list), 0);
			/* Select the key in the linked list */
			selected_key = ksl_find_key( kbcfg_key_settings_list(&current_keyboard_config), key_name );
			/* Read the settings of the key */
			if ( strcmp( ks_get_program_user(selected_key), "default" ) == EQUAL )
			{
				radiobutton = default_radiobutton;
			}
			else if ( (*ks_get_program_user(selected_key) ==  ':') &&
				  (select_special_action(&plugin_list, ks_get_program_user(selected_key), special_action_list)) )
			{
				radiobutton = special_action_radiobutton;
			}
			else
			{
				program_user = ks_get_program_user(selected_key);
				radiobutton = GTK_RADIO_BUTTON( lookup_widget(GTK_WIDGET(key_treeview), "program_radiobutton") );
			}
			
			/* Show the settings of the key */
			gtk_label_set_text (GTK_LABEL(key_name_label), key_name);
			gtk_entry_set_text (GTK_ENTRY(program_entry), program_user);
			gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(radiobutton), TRUE);
			program_default = ks_get_program_default(selected_key);
			if (program_default[0] == ':') /* If program_default is a special action */
			{
				program_default++; /* Now the user only sees the name of the special action */
			}
			gtk_entry_set_text (GTK_ENTRY(default_entry), program_default);
			/* Unblock the signal handlers of the entries and the radiobuttons */
			gtk_signal_handler_unblock_by_func (	GTK_OBJECT(program_entry),
								(void *)on_program_entry_changed, NULL  );
			gtk_signal_handler_unblock_by_func (	GTK_OBJECT(default_radiobutton),
								(void *)on_default_radiobutton_toggled, NULL  );
			gtk_signal_handler_unblock_by_func (	GTK_OBJECT(program_radiobutton),
								(void *)on_program_radiobutton_toggled, NULL  );
			gtk_signal_handler_unblock_by_func (	GTK_OBJECT(special_action_radiobutton),
								(void *)on_special_action_radiobutton_toggled, NULL  );
			gtk_signal_handler_unblock_by_func (	GTK_OBJECT(special_action_combo_entry), 
								(void *)on_special_action_combo_entry_changed, NULL  );
		}
	}
	
	return (TRUE);
}
/**
 * called when select a link
 *
 * \param tree_selection
 * \param null not used
 *
 * \return FALSE
 * */
gboolean gsb_currency_link_config_select_currency ( GtkTreeSelection *tree_selection,
						    gpointer null )
{
    GtkTreeModel *model;
    GtkTreeIter iter;
    gint link_number;
    GtkWidget *combobox_1;
    GtkWidget *combobox_2;
    GtkWidget *exchange_entry;
    GtkWidget *tree_view;
    GtkWidget *label;
    GtkWidget *button;
	gchar* tmpstr;

    if (!gtk_tree_selection_get_selected ( GTK_TREE_SELECTION (tree_selection),
					   &model,
					   &iter ))
	return FALSE;

    gtk_tree_model_get ( GTK_TREE_MODEL (model),
			 &iter,
			 LINK_NUMBER_COLUMN, &link_number,
			 -1 );

    /* normally should not happen */
    if (!link_number)
	    return FALSE;

    gtk_widget_set_sensitive (  GTK_WIDGET (
                        g_object_get_data ( G_OBJECT ( model ), "hbox_line") ),
			            TRUE );

    combobox_1 = g_object_get_data ( G_OBJECT (model),
				     "combobox_1" );
    combobox_2 = g_object_get_data ( G_OBJECT (model),
				     "combobox_2" );
    exchange_entry = g_object_get_data ( G_OBJECT (model),
					 "exchange_entry" );
    button = g_object_get_data ( G_OBJECT (model), "fixed_button" );
    gtk_widget_set_sensitive ( button, TRUE );

    tree_view = GTK_WIDGET ( gtk_tree_selection_get_tree_view ( tree_selection ) );

    g_signal_handlers_block_by_func ( G_OBJECT (combobox_1),
				      G_CALLBACK (gsb_currency_link_config_modify_link),
				      tree_view );
    gsb_currency_set_combobox_history ( combobox_1,
					gsb_data_currency_link_get_first_currency (link_number));
    g_signal_handlers_unblock_by_func ( G_OBJECT (combobox_1),
					G_CALLBACK (gsb_currency_link_config_modify_link),
					tree_view );
    
    g_signal_handlers_block_by_func ( G_OBJECT (combobox_2),
				      G_CALLBACK (gsb_currency_link_config_modify_link),
				      tree_view );
    gsb_currency_set_combobox_history ( combobox_2,
					gsb_data_currency_link_get_second_currency (link_number));
    g_signal_handlers_unblock_by_func ( G_OBJECT (combobox_2),
					G_CALLBACK (gsb_currency_link_config_modify_link),
					tree_view );

    g_signal_handlers_block_by_func ( G_OBJECT (exchange_entry),
				      G_CALLBACK (gsb_currency_link_config_modify_link),
				      tree_view );
    tmpstr = utils_real_get_string (gsb_data_currency_link_get_change_rate (link_number));
    gtk_entry_set_text ( GTK_ENTRY (exchange_entry), tmpstr);
    g_free ( tmpstr );
    g_signal_handlers_unblock_by_func ( G_OBJECT (exchange_entry),
					G_CALLBACK (gsb_currency_link_config_modify_link),
					tree_view );

    /* set the fixed_link flag */
    g_signal_handlers_block_by_func ( G_OBJECT ( button ),
				      G_CALLBACK ( gsb_currency_link_config_button_fixed_changed ),
				      tree_view );
    gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON ( button ),
					gsb_data_currency_link_get_fixed_link ( link_number ) );
    g_signal_handlers_unblock_by_func ( G_OBJECT ( button ),
				      G_CALLBACK ( gsb_currency_link_config_button_fixed_changed ),
				      tree_view );

    /* set or hide the warning label */
    label = g_object_get_data (G_OBJECT (model),
			       "warning_label");

    if ( gsb_data_currency_link_get_invalid_link (link_number))
    {
	gtk_label_set_markup ( GTK_LABEL (label),
			       gsb_data_currency_link_get_invalid_message (link_number));
	gtk_widget_show (label);
    }
    else
	gtk_widget_hide (label);

    return FALSE;
}