void handle_changed_special_action ( GtkWidget *special_action_radiobutton, GtkEditable *special_action_combo_entry ) /* input: special_action_radiobutton - The radiobutton which indicates if the value of special_action_combo_entry will be the program_user element of the selected key special_action_combo_entry - This entry could contain the data of the program_user element of the selected key output: - returns: - description: This function changes the program_user element of the selected key to ":" plus the value of special_action_combo_entry. It also toggles special_action_radiobutton to TRUE. */ { char *program_user; /* Create a string for the key settings */ program_user = g_strdup_printf (":%s", gtk_entry_get_text(GTK_ENTRY(special_action_combo_entry)) ); /* Change the key settings */ change_key_program_user ( GTK_WIDGET(special_action_radiobutton), "key_name_label", kbcfg_key_settings_list(¤t_keyboard_config), program_user ); g_free (program_user); /* Block the signal handler of and special_action_radiobutton */ gtk_signal_handler_block_by_func (GTK_OBJECT(special_action_radiobutton), (void *)on_special_action_radiobutton_toggled, NULL); /* Press special_action_radiobutton */ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(special_action_radiobutton), TRUE); /* Unblock the signal handler of and special_action_radiobutton */ gtk_signal_handler_unblock_by_func (GTK_OBJECT(special_action_radiobutton), (void *)on_special_action_radiobutton_toggled, NULL); }
// signal callback functions about GtkPincodeEntry // filter out the invalid characters static void on_gtk_pincode_entry_insert_text(GtkWidget* widget, const gchar* text, gint length, gint* position, gpointer user_data) { GtkEditable *editable = GTK_EDITABLE(widget); int i, count = 0; gchar *result = g_new(gchar, length); for (i = 0; i < length; i++) { if (!isdigit(text[i])) continue; result[count++] = text[i]; } if (count > 0) { gtk_signal_handler_block_by_func(GTK_OBJECT(editable), GTK_SIGNAL_FUNC(on_gtk_pincode_entry_insert_text), user_data); gtk_editable_insert_text(editable, result, count, position); gtk_signal_handler_unblock_by_func(GTK_OBJECT(editable), GTK_SIGNAL_FUNC(on_gtk_pincode_entry_insert_text), user_data); } gtk_signal_emit_stop_by_name(GTK_OBJECT(editable), "insert_text"); g_free(result); }
void mimeview_show_message(MimeView *mimeview, MimeInfo *mimeinfo, const gchar *file) { GtkCTree *ctree = GTK_CTREE(mimeview->ctree); GtkCTreeNode *node; mimeview_clear(mimeview); g_return_if_fail(file != NULL); g_return_if_fail(mimeinfo != NULL); mimeview->mimeinfo = mimeinfo; mimeview->file = g_strdup(file); gtk_signal_handler_block_by_func(GTK_OBJECT(ctree), mimeview_selected, mimeview); mimeview_set_multipart_tree(mimeview, mimeinfo, NULL); icon_list_create(mimeview, mimeinfo); gtk_signal_handler_unblock_by_func(GTK_OBJECT(ctree), mimeview_selected, mimeview); node = GTK_CTREE_NODE(GTK_CLIST(ctree)->row_list); if (node) { gtk_ctree_select(ctree, node); icon_list_toggle_by_mime_info (mimeview, gtk_ctree_node_get_row_data(ctree, node)); gtkut_ctree_set_focus_row(ctree, node); } }
void actionFullScreenToggle(void *data) { GtkWidget *w; gboolean val; zoom_mode = (zoom_mode == ZoomModeResizeAllowed) ? ZoomModeFullScreen : ZoomModeResizeAllowed; val = (zoom_mode == ZoomModeFullScreen) ? TRUE : FALSE; w = get_glade_widget("full_screen"); if(w==NULL) { fprintf(stderr, "xsniffer: failed to lookup_widget();\n"); } gdk_threads_enter(); // Toggle the menu checkbutton. gtk_signal_handler_block_by_func(GTK_OBJECT(w), on_full_screen_activate, NULL); gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(w), val); gtk_signal_handler_unblock_by_func(GTK_OBJECT(w), on_full_screen_activate, NULL); gdk_threads_leave(); DVDSetZoomMode(nav, zoom_mode); }
/* Pops out the bird's-eye view toggle button * Note: This should only be called from camera.c, as the bird's-eye-view * mode flag (local to that module) must be updated in tandem */ void window_birdseye_view_off( void ) { gtk_signal_handler_block_by_func( GTK_OBJECT(birdseye_view_tbutton_w), GTK_SIGNAL_FUNC(on_birdseye_view_togglebutton_toggled), NULL ); gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(birdseye_view_tbutton_w), FALSE ); gtk_signal_handler_unblock_by_func( GTK_OBJECT(birdseye_view_tbutton_w), GTK_SIGNAL_FUNC(on_birdseye_view_togglebutton_toggled), NULL ); }
/* Resets the Color radio menu to the given mode */ void window_set_color_mode( ColorMode mode ) { GtkWidget *rmenu_item_w; GtkSignalFunc handler; switch (mode) { case COLOR_BY_NODETYPE: rmenu_item_w = color_by_nodetype_rmenu_item_w; handler = GTK_SIGNAL_FUNC(on_color_by_nodetype_activate); break; case COLOR_BY_TIMESTAMP: rmenu_item_w = color_by_timestamp_rmenu_item_w; handler = GTK_SIGNAL_FUNC(on_color_by_timestamp_activate); break; case COLOR_BY_WPATTERN: rmenu_item_w = color_by_wpattern_rmenu_item_w; handler = GTK_SIGNAL_FUNC(on_color_by_wildcards_activate); break; SWITCH_FAIL } gtk_signal_handler_block_by_func( GTK_OBJECT(rmenu_item_w), handler, NULL ); gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(rmenu_item_w), TRUE ); gtk_signal_handler_unblock_by_func( GTK_OBJECT(rmenu_item_w), handler, NULL ); }
/* ok, this is pretty wacky: * we need to let the right-mouse-click go through, so it moves the cursor, * but we *can't* let it go through, because GtkText interprets rightclicks as * weird selection modifiers. * * so what do we do? forge rightclicks as leftclicks, then popup the menu. * HACK HACK HACK. */ static gint button_press_intercept_cb(GtkText *gtktext, GdkEvent *e, gpointer d) { GdkEventButton *eb; gboolean retval; if (!gtkspell_running()) return FALSE; if (e->type != GDK_BUTTON_PRESS) return FALSE; eb = (GdkEventButton*) e; if (eb->button != 3) return FALSE; /* forge the leftclick */ eb->button = 1; gtk_signal_handler_block_by_func(GTK_OBJECT(gtktext), GTK_SIGNAL_FUNC(button_press_intercept_cb), d); gtk_signal_emit_by_name(GTK_OBJECT(gtktext), "button-press-event", e, &retval); gtk_signal_handler_unblock_by_func(GTK_OBJECT(gtktext), GTK_SIGNAL_FUNC(button_press_intercept_cb), d); gtk_signal_emit_stop_by_name(GTK_OBJECT(gtktext), "button-press-event"); /* now do the menu wackiness */ popup_menu(gtktext, eb); return TRUE; }
static void change_color(GtkText *gtktext, gint start, gint end, GdkColor *color) { gchar *newtext; /* So we don't need spaces at the very end of the text */ if ( end == gtk_text_get_length(GTK_TEXT(gtktext))+1 ) end--; newtext = gtk_editable_get_chars(GTK_EDITABLE(gtktext), start, end); gtk_text_freeze(gtktext); gtk_signal_handler_block_by_func(GTK_OBJECT(gtktext), GTK_SIGNAL_FUNC(entry_insert_cb), NULL); gtk_text_set_point(gtktext, start); gtk_text_forward_delete(gtktext, end-start); if (newtext && end-start > 0) gtk_text_insert(gtktext, NULL, color, NULL, newtext, end-start); gtk_signal_handler_unblock_by_func(GTK_OBJECT(gtktext), GTK_SIGNAL_FUNC(entry_insert_cb), NULL); gtk_text_thaw(gtktext); g_free(newtext); }
gint activate_plot(GtkWidget *widget, gpointer data) { GtkWidget **widget_list = NULL; GtkWidget *active_widget = NULL; GtkWidget *canvas = NULL; gint n = 0; canvas = GTK_WIDGET(data); widget_list = buttons; active_widget = widget; while(n < nlayers) { gtk_signal_handler_block_by_func(GTK_OBJECT(buttons[n]), GTK_SIGNAL_FUNC(activate_plot), data); if(widget_list[n] == active_widget){ active_plot = plots[n]; gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(buttons[n]), TRUE); }else{ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(buttons[n]), FALSE); } gtk_signal_handler_unblock_by_func(GTK_OBJECT(buttons[n]), GTK_SIGNAL_FUNC(activate_plot), data); n++; } return TRUE; }
void fill_page_from_note_data(note_data *note) { gint len; gchar *buff; if (note->title != NULL) { gtk_entry_set_text(GTK_ENTRY(sp->title_entry), note->title); } if (note->text != NULL) { len = strlen(note->text); gtk_text_insert(GTK_TEXT(sp->text_entry), NULL, NULL, NULL, note->text, len); gtk_editable_set_position(GTK_EDITABLE(sp->text_entry), 0); } time_label_set_time(TIME_LABEL(sp->tlabel_expire), note->expire); time_label_set_time(TIME_LABEL(sp->tlabel_created), note->created); time_label_set_time(TIME_LABEL(sp->tlabel_changed), note->changed); buff = g_strdup_printf("%ld", note->changes); gtk_label_set_text(GTK_LABEL(sp->label_changes), buff); g_free(buff); if (note->id != NULL) { gtk_entry_set_text(GTK_ENTRY(sp->note_id_entry), note->id); } if (note->notetype == CheckNote || note->notetype == TodoNote) { gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(sp->todo_check), note->todo); } if (note->notetype == TodoNote) { gnome_date_edit_set_time(GNOME_DATE_EDIT(sp->de_deadline), note->deadline); gtk_spin_button_set_value(GTK_SPIN_BUTTON(sp->prio_entry), note->prio); gtk_signal_handler_block_by_func( GTK_OBJECT(sp->ad_complete), GTK_SIGNAL_FUNC(cb_complete_updates_done), sp->todo_check); gtk_adjustment_set_value(GTK_ADJUSTMENT(sp->ad_complete), note->complete); gtk_signal_handler_unblock_by_func( GTK_OBJECT(sp->ad_complete), GTK_SIGNAL_FUNC(cb_complete_updates_done), sp->todo_check); } }
static void change_color(GtkText *gtktext, int start, int end, GdkColor *color) { char *newtext = gtk_editable_get_chars(GTK_EDITABLE(gtktext), start, end); gtk_text_freeze(gtktext); gtk_signal_handler_block_by_func(GTK_OBJECT(gtktext), GTK_SIGNAL_FUNC(entry_insert_cb), NULL); gtk_text_set_point(gtktext, start); gtk_text_forward_delete(gtktext, end-start); if (newtext && end-start > 0) gtk_text_insert(gtktext, NULL, color, NULL, newtext, end-start); gtk_signal_handler_unblock_by_func(GTK_OBJECT(gtktext), GTK_SIGNAL_FUNC(entry_insert_cb), NULL); gtk_text_thaw(gtktext); g_free(newtext); }
static int _combo_simple_entry_change(GtkEntry * entry, gpointer data) { GtkCombo *cb = GTK_COMBO(data); int i; i = _combo_simple_find_in_list(cb, gtk_entry_get_text(entry)); if (i == -1) gtk_list_unselect_all(GTK_LIST(cb->list)); else { gtk_signal_handler_block_by_func(GTK_OBJECT(cb->list), GSF(_combo_simple_list_select), data); gtk_list_select_item(GTK_LIST(cb->list), i); gtk_signal_handler_unblock_by_func(GTK_OBJECT(cb->list), GSF(_combo_simple_list_select), data); } return 0; }
static void entry_insert_cb(GtkText *gtktext, gchar *newtext, guint len, guint *ppos, gpointer d) { gint origpos; gtk_signal_handler_block_by_func(GTK_OBJECT(gtktext), GTK_SIGNAL_FUNC(entry_insert_cb), NULL ); gtk_text_insert(GTK_TEXT(gtktext), NULL, &(GTK_WIDGET(gtktext)->style->fg[0]), NULL, newtext, len); gtk_signal_handler_unblock_by_func(GTK_OBJECT(gtktext), GTK_SIGNAL_FUNC(entry_insert_cb), NULL); gtk_signal_emit_stop_by_name(GTK_OBJECT(gtktext), "insert-text"); *ppos += len; origpos = gtk_editable_get_position(GTK_EDITABLE(gtktext)); if (iswordsep(newtext[0])) { /* did we just end a word? */ if (*ppos >= 2) check_at(gtktext, *ppos-2); /* did we just split a word? */ if (*ppos < gtk_text_get_length(gtktext)) check_at(gtktext, *ppos+1); } else { /* check as they type, *except* if they're typing at the end (the most * common case. */ if (*ppos < gtk_text_get_length(gtktext) && !iswordsep(GTK_TEXT_INDEX(gtktext, *ppos))) check_at(gtktext, *ppos-1); } gtk_editable_set_position(GTK_EDITABLE(gtktext), origpos); gtk_editable_select_region(GTK_EDITABLE(gtktext), origpos, origpos); }
/* Helper function */ static void block_colexp_handlers( void ) { gtk_signal_handler_block_by_func( GTK_OBJECT(dir_ctree_w), GTK_SIGNAL_FUNC(dirtree_collapse_cb), NULL ); gtk_signal_handler_block_by_func( GTK_OBJECT(dir_ctree_w), GTK_SIGNAL_FUNC(dirtree_expand_cb), NULL ); }
/* * Refresh provider graphic list. */ void gdisp_refreshSampledSymbolList ( Kernel_T *kernel ) { GList *providerItem = (GList*)NULL; Provider_T *provider = (Provider_T*)NULL; GtkWidget *cTree = (GtkWidget*)NULL; GList *cTreeList = (GList*)NULL; GtkCTreeRow *cTreeRow = (GtkCTreeRow*)NULL; GtkCTreeNode *cTreeNode = (GtkCTreeNode*)NULL; guint cTreeLength = 0; guint cTreeCpt = 0; /* ------------------------ PER PROVIDER ---------------------- */ cTree = kernel->widgets.sampledSymbolHTree; /* * When removing a node, GTK main loop activate the "unselect" * callback, that performs a post recursive action on a node * that has been destroyed. * Avoid that shame by temporarily blocking the signal emission. */ gtk_clist_freeze(GTK_CLIST(cTree)); gtk_signal_handler_block_by_func(GTK_OBJECT(cTree), gdisp_treeUnselectRowCallback, (gpointer)kernel); /* * Remove all top-level node, those that have no parent. * First step : build top-level list. */ cTreeLength = g_list_length(GTK_CTREE(cTree)->clist.row_list); for (cTreeCpt=0; cTreeCpt<cTreeLength; cTreeCpt++) { cTreeNode = gtk_ctree_node_nth(GTK_CTREE(cTree),cTreeCpt); if (cTreeNode != (GtkCTreeNode*)NULL) { cTreeRow = GTK_CTREE_ROW(cTreeNode); if (cTreeRow->parent == (GtkCTreeNode*)NULL) { cTreeList = g_list_append(cTreeList,(gpointer)cTreeNode); } /* node is top-level, ie without parent */ } /* node exists */ } /* loop over all rows */ /* * Second step : remove all top_level nodes. */ cTreeList = g_list_first(cTreeList); while (cTreeList != (GList*)NULL) { gtk_ctree_remove_node(GTK_CTREE(cTree), (GtkCTreeNode*)cTreeList->data); cTreeList = g_list_next(cTreeList); } /* * Loop over all providers. Forget tree node address. */ providerItem = g_list_first(kernel->providerList); while (providerItem != (GList*)NULL) { provider = (Provider_T*)providerItem->data; provider->pNode = (GtkCTreeNode*)NULL; providerItem = g_list_next(providerItem); } /* * Finalise. */ gdisp_finaliseHierarchicalTree(kernel, cTree); /* * Activate again the unselect handler. */ gtk_signal_handler_unblock_by_func(GTK_OBJECT(cTree), gdisp_treeUnselectRowCallback, (gpointer)kernel); gtk_clist_thaw(GTK_CLIST(cTree)); }
/* * Graphically show the status of all sampled symbols. */ static void gdisp_poolSampledSymbolList ( Kernel_T *kernel ) { GtkWidget *cTree = (GtkWidget*)NULL; GString *messageString = (GString*)NULL; GList *providerItem = (GList*)NULL; Provider_T *provider = (Provider_T*)NULL; Symbol_T *symbol = (Symbol_T*)NULL; GtkCTreeNode *pSymbolAnchor = (GtkCTreeNode*)NULL; GtkCTreeNode *pNode = (GtkCTreeNode*)NULL; GtkCTreeNode *sNode = (GtkCTreeNode*)NULL; gint pSampleCpt = 0; SampleList_T *pSampleList = (SampleList_T*)NULL; guint pSampleMax = 0; #define GD_SAMPLE_PGI_AS_STRING_LENGTH 10 gchar samplePGIasStringBuffer[GD_SAMPLE_PGI_AS_STRING_LENGTH]; gchar *samplePGIasString = (gchar*)NULL; TSP_sample_symbol_info_t *symbolInfo = (TSP_sample_symbol_info_t*)NULL; /* ------------------------ PER PROVIDER ---------------------- */ cTree = kernel->widgets.sampledSymbolHTree; /* * When removing a node, GTK main loop activate the "unselect" * callback, that performs a post recursive action on a node * that has been destroyed. * Avoid that shame by temporarily blocking the signal emission. */ gtk_clist_freeze(GTK_CLIST(cTree)); gtk_signal_handler_block_by_func(GTK_OBJECT(cTree), gdisp_treeUnselectRowCallback, (gpointer)kernel); /* * Loop over all providers. */ providerItem = g_list_first(kernel->providerList); while (providerItem != (GList*)NULL) { provider = (Provider_T*)providerItem->data; /* * Look for symbol anchor. */ if (provider->pNode != (GtkCTreeNode*)NULL) { pSymbolAnchor = gdisp_getChildAccordingToItsName(kernel, provider->pNode, "sAnchor"); if (pSymbolAnchor == (GtkCTreeNode*)NULL) { /* should never happen, because I did create this node !! */ messageString = g_string_new((gchar*)NULL); g_string_sprintf(messageString, "%s provider has no anchor for symbols.", provider->pUrl->str); (*kernel->outputFunc)(kernel,messageString,GD_ERROR); } else { /* --------------------- PER SAMPLED SYMBOLS ---------------- */ /* * Loop over all sampled symbol of the current provider. */ pSampleList = &provider->pSampleList; pSampleMax = pSampleList->TSP_sample_symbol_info_list_t_len; symbolInfo = pSampleList->TSP_sample_symbol_info_list_t_val; for (pSampleCpt=0; pSampleCpt<pSampleMax; pSampleCpt++, symbolInfo++) { /* * Get in touch with the symbol through the global index. */ if (symbolInfo->provider_global_index >= 0) { #if defined(GD_LOAD_CONFIGURATION_WITH_ALL_SYMBOLS) symbol = &provider->pSymbolList[symbolInfo->provider_global_index]; #else /* * Convert PGI as an unsigned integer to a string. */ samplePGIasStringBuffer[GD_SAMPLE_PGI_AS_STRING_LENGTH-1] = '\0'; samplePGIasString = gdisp_uIntToStr(symbolInfo->provider_global_index, &samplePGIasStringBuffer[GD_SAMPLE_PGI_AS_STRING_LENGTH-1]); /* * Retreive target symbol. */ if (provider->pSymbolHashTablePGI == (hash_t*)NULL) { symbol = (Symbol_T*)NULL; } else { symbol = (Symbol_T*) hash_get(provider->pSymbolHashTablePGI,samplePGIasString); } #endif /* * If referenced... ie, used by graphic plots... */ if (symbol != (Symbol_T*)NULL) { if (symbol->sReference > 0) { /* * Create the hierarchy for that symbol, if not already done. */ if (symbol->sNode == (GtkCTreeNode*)NULL) { gdisp_createSymbolNode(kernel, kernel->widgets.sampledSymbolScrolledWindow, cTree, pSymbolAnchor, symbol); } else { gdisp_updateSymbolNode(kernel, cTree, symbol); } } /* sReference > 0 */ else { if (symbol->sNode != (GtkCTreeNode*)NULL) { gtk_ctree_remove_node(GTK_CTREE(cTree), symbol->sNode); symbol->sNode = (GtkCTreeNode*)NULL; } } /* sReference == 0 */ } /* symbol not null */ } /* if (index >= 0) */ } /* loop over sampled symbols */ } /* found sAnchor */ } /* pNode is not null */ else { /* * Create a node that will contain all provider information. */ gdisp_createProviderNode(kernel, kernel->widgets.sampledSymbolScrolledWindow, cTree, provider, &pNode, &sNode); } /* * Next provider. */ providerItem = g_list_next(providerItem); } /* loop over all providers */ /* * Finalise. */ gdisp_finaliseHierarchicalTree(kernel, cTree); /* * Activate again the unselect handler. */ gtk_signal_handler_unblock_by_func(GTK_OBJECT(cTree), gdisp_treeUnselectRowCallback, (gpointer)kernel); gtk_clist_thaw(GTK_CLIST(cTree)); }
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(¤t_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); }