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);
}
