static gboolean
cell_changed_cb (GtkEditable *editable,
gpointer user_data)
{
char *cell_text;
guint column;
#if GTK_CHECK_VERSION(3,0,0)
GdkRGBA rgba;
#else
GdkColor color;
#endif
gboolean value_valid = FALSE;
const char *colorname = NULL;
cell_text = gtk_editable_get_chars (editable, 0, -1);
/* The Netmask column can also contain prefix */
column = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (user_data), "column"));
if (column == COL_PREFIX) {
/* The COL_PREFIX can contain IP address or prefix */
guint32 tmp_prefix;
errno = 0;
/* Is it a prefix? */
if (!strchr (cell_text, '.')) {
tmp_prefix = strtol (cell_text, NULL, 10);
if (!errno && tmp_prefix >= 0 && tmp_prefix <= 32)
value_valid = TRUE;
} else {
struct in_addr tmp_addr;
/* Is it a netmask? */
if (inet_pton (AF_INET, cell_text, &tmp_addr) > 0)
value_valid = TRUE;
}
} else if (column == COL_METRIC) {
long int tmp_int;
errno = 0;
tmp_int = strtol (cell_text, NULL, 10);
if (errno || tmp_int < 0 || tmp_int > G_MAXUINT32)
value_valid = FALSE;
else
value_valid = TRUE;
} else {
struct in_addr tmp_addr;
if (inet_pton (AF_INET, cell_text, &tmp_addr) > 0)
value_valid = TRUE;
}
/* Change cell's background color while editing */
colorname = value_valid ? "lightgreen" : "red";
#if GTK_CHECK_VERSION(3,0,0)
gdk_rgba_parse (&rgba, colorname);
gtk_widget_override_background_color (GTK_WIDGET (editable), GTK_STATE_NORMAL, &rgba);
#else
gdk_color_parse (colorname, &color);
gtk_widget_modify_base (GTK_WIDGET (editable), GTK_STATE_NORMAL, &color);
#endif
g_free (cell_text);
return FALSE;
}
static void
gimp_file_entry_browse_clicked (GtkWidget *widget,
GimpFileEntry *entry)
{
GtkFileChooser *chooser;
gchar *utf8;
gchar *filename;
utf8 = gtk_editable_get_chars (GTK_EDITABLE (entry->entry), 0, -1);
filename = g_filename_from_utf8 (utf8, -1, NULL, NULL, NULL);
g_free (utf8);
if (! entry->file_dialog)
{
const gchar *title = entry->title;
if (! title)
{
if (entry->dir_only)
title = _("Select Folder");
else
title = _("Select File");
}
entry->file_dialog =
gtk_file_chooser_dialog_new (title, NULL,
entry->dir_only ?
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER :
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (entry->file_dialog),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
chooser = GTK_FILE_CHOOSER (entry->file_dialog);
gtk_window_set_position (GTK_WINDOW (chooser), GTK_WIN_POS_MOUSE);
gtk_window_set_role (GTK_WINDOW (chooser),
"gimp-file-entry-file-dialog");
g_signal_connect (chooser, "response",
G_CALLBACK (gimp_file_entry_chooser_response),
entry);
g_signal_connect (chooser, "delete-event",
G_CALLBACK (gtk_true),
NULL);
g_signal_connect_swapped (entry, "unmap",
G_CALLBACK (gtk_widget_hide),
chooser);
}
else
{
chooser = GTK_FILE_CHOOSER (entry->file_dialog);
}
gtk_file_chooser_set_filename (chooser, filename);
g_free (filename);
gtk_window_set_screen (GTK_WINDOW (chooser), gtk_widget_get_screen (widget));
gtk_window_present (GTK_WINDOW (chooser));
}
static void
on_ok_action_activated (GtkAction *action, GitMergePane *self)
{
Git *plugin;
GtkEditable *merge_revision_entry;
GtkToggleAction *no_commit_action;
GtkToggleAction *squash_action;
GtkToggleButton *use_custom_log_check;
gchar *revision;
gchar *log;
AnjutaColumnTextView *merge_log_view;
GitMergeCommand *merge_command;
plugin = ANJUTA_PLUGIN_GIT (anjuta_dock_pane_get_plugin (ANJUTA_DOCK_PANE (self)));
merge_revision_entry = GTK_EDITABLE (gtk_builder_get_object (self->priv->builder,
"merge_revision_entry"));
no_commit_action = GTK_TOGGLE_ACTION (gtk_builder_get_object (self->priv->builder,
"no_commit_action"));
squash_action = GTK_TOGGLE_ACTION (gtk_builder_get_object (self->priv->builder,
"squash_action"));
use_custom_log_check = GTK_TOGGLE_BUTTON (gtk_builder_get_object (self->priv->builder,
"use_custom_log_check"));
revision = gtk_editable_get_chars (merge_revision_entry, 0, -1);
log = NULL;
if (!git_pane_check_input (GTK_WIDGET (ANJUTA_PLUGIN (plugin)->shell),
GTK_WIDGET (merge_revision_entry), revision,
_("Please enter a revision.")))
{
g_free (revision);
return;
}
if (gtk_toggle_button_get_active (use_custom_log_check))
{
merge_log_view = ANJUTA_COLUMN_TEXT_VIEW (gtk_builder_get_object (self->priv->builder,
"merge_log_view"));
log = anjuta_column_text_view_get_text (merge_log_view);
if (!git_pane_check_input (GTK_WIDGET (ANJUTA_PLUGIN (plugin)->shell),
GTK_WIDGET (merge_log_view), log,
_("Please enter a log message.")))
{
g_free (revision);
g_free (log);
return;
}
}
merge_command = git_merge_command_new (plugin->project_root_directory,
revision, log,
gtk_toggle_action_get_active (no_commit_action),
gtk_toggle_action_get_active (squash_action));
g_free (revision);
g_free (log);
git_pane_create_message_view (plugin);
g_signal_connect (G_OBJECT (merge_command), "data-arrived",
G_CALLBACK (git_pane_on_command_info_arrived),
plugin);
g_signal_connect (G_OBJECT (merge_command), "command-finished",
G_CALLBACK (git_pane_report_errors),
plugin);
g_signal_connect (G_OBJECT (merge_command), "command-finished",
G_CALLBACK (g_object_unref),
NULL);
anjuta_command_start (ANJUTA_COMMAND (merge_command));
git_pane_remove_from_dock (GIT_PANE (self));
}
void *reader_loop(void* wojd) {
mkfifo(fpipeout, S_IRWXU);
FILE *fileout = fopen(fpipeout, "a+");
if(!fileout) {
fprintf(stderr, "Error opening pipe %s !\n", fpipeout);
pthread_exit(NULL);
}
mkfifo(fpipein, S_IRWXU);
FILE *filein = fopen(fpipein, "r+");
if(!filein) {
fprintf(stderr, "Error opening pipe %s !\n", fpipein);
pthread_exit(NULL);
}
if(VERBOSE)
fprintf(stderr, "Using pipes out:%s in:%s\n", fpipeout, fpipein);
char input[1024];
char *operanda = NULL;
char *object = NULL;
char *command = NULL;
while(RUNNING) {
fgets(input, 1024, filein);
if(!RUNNING)
break;
object = input;
command = input;
operanda = input;
while(*command && *command != ' ')
command++;
*command = '\0';
operanda = ++command;
while(*operanda && *operanda != ' ')
operanda++;
*operanda++ = '\0';
if(VERBOSE)
fprintf(stderr, "Command:> %s %s %s\n", object, command, operanda);
GtkWidget *widget = GTK_WIDGET(gtk_builder_get_object(builder, object));
//window set title
if(!strcmp(command, "set_window_title")) {
gtk_window_set_title(GTK_WINDOW(widget), operanda);
} else
//window show
if(!strcmp(command, "show")) {
gtk_widget_show(widget);
} else
//window hide
if(!strcmp(command, "hide")) {
gtk_widget_hide(widget);
} else
//textview set text
if(!strcmp(command, "set_textview_text")) {
gtk_text_buffer_set_text(gtk_text_view_get_buffer(GTK_TEXT_VIEW(widget)), operanda, -1);
} else
//textview get text
if(!strcmp(command, "get_textview_text")) {
GtkTextIter a, b;
GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(widget));
gtk_text_buffer_get_iter_at_offset(buffer, &a, 0);
gtk_text_buffer_get_iter_at_offset(buffer, &b, -1);
gchar* mtext = gtk_text_buffer_get_text(buffer, &a, &b, FALSE);
fprintf(fileout, "%s\n", mtext);
fflush(fileout);
} else
//
//spinner activate/deactivate
if(!strcmp(command, "spinner_start")) {
gtk_spinner_start(GTK_SPINNER(widget));
} else
if(!strcmp(command, "spinner_stop")) {
gtk_spinner_stop(GTK_SPINNER(widget));
} else
//label set/get
if(!strcmp(command, "set_label_text")) {
gtk_label_set_text(GTK_LABEL(widget), operanda);
} else
//set button label
if(!strcmp(command, "set_button_label")) {
gtk_button_set_label(GTK_BUTTON(widget), operanda);
} else
//entrytext set/get
if(!strcmp(command, "get_entry_text")) {
gchar* mtext = gtk_editable_get_chars(GTK_EDITABLE(widget), 0, -1);
fprintf(fileout, "%s\n", mtext);
fflush(fileout);
} else
if(!strcmp(command, "set_entry_text")) {
gtk_entry_set_text(GTK_ENTRY(widget), operanda);
} else
//combobox add options, get/set selected
if(!strcmp(command, "set_combobox_items")) {
//GtkTreeModel *tree_model;
//gtk_combo_box_model_set(GTK_COMBO_BOX(widget), tree_model);
} else if(!strcmp(command, "get_selected_combobox_item")) {
fprintf(fileout, "%d\n", gtk_combo_box_get_active(GTK_COMBO_BOX(widget)));
fflush(fileout);
} else
//image set image TODO doesn't work
if(!strcmp(command, "set_image")) {
gtk_image_set_from_file(GTK_IMAGE(widget), operanda);
gtk_widget_show(widget);
} else
//progressbar set, show/hide
if(!strcmp(command, "set_progressbar")) {
} else
//togglebutton istoggled //toggle, check, radio button
if(!strcmp(command, "get_button_state")) {
if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)))
fprintf(fileout, "1\n");
else
fprintf(fileout, "0\n");
fflush(fileout);
}
}
fclose(filein);
fflush(fileout);
fclose(fileout);
pthread_exit(NULL);
}
static int
gtk_combo_entry_key_press (GtkEntry * entry, GdkEventKey * event, GtkCombo * combo)
{
GList *li;
/* completion */
if ((event->keyval == GDK_Tab) && (event->state & GDK_MOD1_MASK))
{
GCompletion * cmpl;
gchar* prefix;
gchar* nprefix = NULL;
gint pos;
if ( !GTK_LIST (combo->list)->children )
return FALSE;
gtk_signal_emit_stop_by_name (GTK_OBJECT (entry), "key_press_event");
cmpl = g_completion_new ((GCompletionFunc)gtk_combo_func);
g_completion_add_items (cmpl, GTK_LIST (combo->list)->children);
pos = GTK_EDITABLE (entry)->current_pos;
prefix = gtk_editable_get_chars (GTK_EDITABLE (entry), 0, pos);
g_completion_complete(cmpl, prefix, &nprefix);
if (nprefix && strlen (nprefix) > strlen (prefix))
{
gtk_editable_insert_text (GTK_EDITABLE (entry), nprefix + pos,
strlen (nprefix) - strlen (prefix), &pos);
GTK_EDITABLE (entry)->current_pos = pos;
}
if (nprefix)
g_free (nprefix);
g_free (prefix);
g_completion_free (cmpl);
return TRUE;
}
if (!combo->use_arrows || !GTK_LIST (combo->list)->children)
return FALSE;
li = g_list_find (GTK_LIST (combo->list)->children, gtk_combo_find (combo));
if ((event->keyval == GDK_Up)
|| (event->keyval == GDK_KP_Up)
|| ((event->state & GDK_MOD1_MASK) && ((event->keyval == 'p') || (event->keyval == 'P'))))
{
if (li)
li = li->prev;
if (!li && combo->use_arrows_always)
{
li = g_list_last (GTK_LIST (combo->list)->children);
}
if (li)
{
gtk_list_select_child (GTK_LIST (combo->list), GTK_WIDGET (li->data));
gtk_signal_emit_stop_by_name (GTK_OBJECT (entry), "key_press_event");
return TRUE;
}
}
else if ((event->keyval == GDK_Down)
|| (event->keyval == GDK_KP_Down)
|| ((event->state & GDK_MOD1_MASK) && ((event->keyval == 'n') || (event->keyval == 'N'))))
{
if (li)
li = li->next;
if (!li && combo->use_arrows_always)
{
li = GTK_LIST (combo->list)->children;
}
if (li)
{
gtk_list_select_child (GTK_LIST (combo->list), GTK_WIDGET (li->data));
gtk_signal_emit_stop_by_name (GTK_OBJECT (entry), "key_press_event");
return TRUE;
}
}
return FALSE;
}
static void
on_pull_dialog_response (GtkDialog *dialog, gint response_id,
GitUIData *data)
{
GtkWidget *pull_remote_toggle;
GtkWidget *pull_url_toggle;
GtkWidget *pull_remote_view;
GtkWidget *pull_origin_check;
GtkWidget *pull_rebase_check;
GtkWidget *pull_url_entry;
GtkWidget *pull_no_commit_check;
GtkWidget *pull_squash_check;
GtkWidget *pull_fast_forward_commit_check;
GtkWidget *pull_append_fetch_data_check;
GtkWidget *pull_force_check;
GtkWidget *pull_no_follow_tags_check;
GtkTreeModel *remote_list_model;
GtkWidget *input_widget;
const gchar *input_error;
gchar *url;
GtkTreeSelection *selection;
GtkTreeIter iter;
GitPullCommand *pull_command;
if (response_id == GTK_RESPONSE_OK)
{
pull_remote_toggle = GTK_WIDGET (gtk_builder_get_object (data->bxml,
"pull_remote_toggle"));
pull_url_toggle = GTK_WIDGET (gtk_builder_get_object (data->bxml,
"pull_url_toggle"));
pull_remote_view = GTK_WIDGET (gtk_builder_get_object (data->bxml,
"pull_remote_view"));
pull_origin_check = GTK_WIDGET (gtk_builder_get_object (data->bxml,
"pull_origin_check"));
pull_rebase_check = GTK_WIDGET (gtk_builder_get_object (data->bxml,
"pull_rebase_check"));
pull_url_entry = GTK_WIDGET (gtk_builder_get_object (data->bxml,
"pull_url_entry"));
pull_no_commit_check = GTK_WIDGET (gtk_builder_get_object (data->bxml,
"pull_no_commit_check"));
pull_squash_check = GTK_WIDGET (gtk_builder_get_object (data->bxml,
"pull_squash_check"));
pull_fast_forward_commit_check = GTK_WIDGET (gtk_builder_get_object (data->bxml,
"pull_fast_forward_commit_check"));
pull_append_fetch_data_check = GTK_WIDGET (gtk_builder_get_object (data->bxml,
"pull_append_fetch_data_check"));
pull_force_check = GTK_WIDGET (gtk_builder_get_object (data->bxml,
"pull_force_check"));
pull_no_follow_tags_check = GTK_WIDGET (gtk_builder_get_object (data->bxml,
"pull_no_follow_tags_check"));
remote_list_model = GTK_TREE_MODEL (gtk_builder_get_object (data->bxml,
"remote_list_model"));
/* The "input widget" is the widget that should receive focus if the
* user does not properly enter anything */
input_error = _("Please select a remote to pull from.");
input_widget = pull_remote_view;
url = NULL;
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (pull_origin_check)))
url = g_strdup ("origin");
else if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (pull_remote_toggle)))
{
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (pull_remote_view));
if (gtk_tree_selection_get_selected (selection, NULL, &iter))
gtk_tree_model_get (remote_list_model, &iter, 0, &url, -1);
}
else if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (pull_url_toggle)))
{
url = gtk_editable_get_chars (GTK_EDITABLE (pull_url_entry), 0, -1);
input_widget = pull_url_entry;
input_error = _("Please enter the URL of the repository to pull from.");
}
if (!git_check_input (GTK_WIDGET (dialog), input_widget, url,
input_error))
{
g_free (url);
return;
}
pull_command = git_pull_command_new (data->plugin->project_root_directory,
url,
gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (pull_rebase_check)),
gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (pull_no_commit_check)),
gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (pull_squash_check)),
gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (pull_fast_forward_commit_check)),
gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (pull_append_fetch_data_check)),
gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (pull_force_check)),
gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (pull_no_follow_tags_check)));
g_free (url);
git_create_message_view (data->plugin);
g_signal_connect (G_OBJECT (pull_command), "command-finished",
G_CALLBACK (on_pull_command_finished),
data->plugin);
g_signal_connect (G_OBJECT (pull_command), "data-arrived",
G_CALLBACK (on_git_command_info_arrived),
data->plugin);
anjuta_command_start (ANJUTA_COMMAND (pull_command));
}
gtk_widget_destroy (GTK_WIDGET (dialog));
git_ui_data_free (data);
}
static void save_archiver_prefs(PrefsPage * _page)
{
struct ArchiverPrefsPage *page = (struct ArchiverPrefsPage *) _page;
PrefFile *pref_file;
gchar *rc_file_path = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
COMMON_RC, NULL);
archiver_prefs.save_folder = gtk_editable_get_chars(GTK_EDITABLE(page->save_folder), 0, -1);
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->zip_radiobtn)))
archiver_prefs.compression = COMPRESSION_ZIP;
else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->bzip_radiobtn)))
archiver_prefs.compression = COMPRESSION_BZIP;
else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->compress_radiobtn)))
archiver_prefs.compression = COMPRESSION_COMPRESS;
else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->none_radiobtn)))
archiver_prefs.compression = COMPRESSION_NONE;
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->tar_radiobtn)))
archiver_prefs.format = FORMAT_TAR;
else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->shar_radiobtn)))
archiver_prefs.format = FORMAT_SHAR;
else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->cpio_radiobtn)))
archiver_prefs.format = FORMAT_CPIO;
else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->pax_radiobtn)))
archiver_prefs.format = FORMAT_PAX;
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->recursive_chkbtn)))
archiver_prefs.recursive = TRUE;
else
archiver_prefs.recursive = FALSE;
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->md5sum_chkbtn)))
archiver_prefs.md5sum = TRUE;
else
archiver_prefs.md5sum = FALSE;
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->rename_chkbtn)))
archiver_prefs.rename = TRUE;
else
archiver_prefs.rename = FALSE;
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->unlink_chkbtn)))
archiver_prefs.unlink = TRUE;
else
archiver_prefs.unlink = FALSE;
pref_file = prefs_write_open(rc_file_path);
g_free(rc_file_path);
if (!(pref_file) ||
(prefs_set_block_label(pref_file, PREFS_BLOCK_NAME) < 0))
return;
if (prefs_write_param(param, pref_file->fp) < 0) {
g_warning("failed to write Archiver Plugin configuration\n");
prefs_file_close_revert(pref_file);
return;
}
if (fprintf(pref_file->fp, "\n") < 0) {
FILE_OP_ERROR(rc_file_path, "fprintf");
prefs_file_close_revert(pref_file);
} else
prefs_file_close(pref_file);
}
static bool
handle_link(GtkEntry* entry, girara_session_t* session,
zathura_link_action_t action)
{
g_return_val_if_fail(session != NULL, FALSE);
g_return_val_if_fail(session->global.data != NULL, FALSE);
zathura_t* zathura = session->global.data;
bool eval = true;
char* input = gtk_editable_get_chars(GTK_EDITABLE(entry), 0, -1);
if (input == NULL || strlen(input) == 0) {
eval = false;
}
int index = 0;
if (eval == true) {
index = atoi(input);
if (index == 0 && g_strcmp0(input, "0") != 0) {
girara_notify(session, GIRARA_WARNING, _("Invalid input '%s' given."), input);
eval = false;
}
index = index - 1;
}
/* set pages to draw links */
bool invalid_index = true;
unsigned int number_of_pages = zathura_document_get_number_of_pages(zathura->document);
for (unsigned int page_id = 0; page_id < number_of_pages; page_id++) {
zathura_page_t* page = zathura_document_get_page(zathura->document, page_id);
if (page == NULL || zathura_page_get_visibility(page) == false) {
continue;
}
GtkWidget* page_widget = zathura_page_get_widget(zathura, page);
g_object_set(page_widget, "draw-links", FALSE, NULL);
if (eval == true) {
zathura_link_t* link = zathura_page_widget_link_get(ZATHURA_PAGE(page_widget), index);
if (link != NULL) {
invalid_index = false;
switch (action) {
case ZATHURA_LINK_ACTION_FOLLOW:
zathura_jumplist_save(zathura);
zathura_link_evaluate(zathura, link);
zathura_jumplist_add(zathura);
break;
case ZATHURA_LINK_ACTION_DISPLAY:
zathura_link_display(zathura, link);
break;
}
}
}
}
if (eval == true && invalid_index == true) {
girara_notify(session, GIRARA_WARNING, _("Invalid index '%s' given."), input);
}
g_free(input);
return (eval == TRUE) ? TRUE : FALSE;
}
uint8_t DIA_Preferences(void)
{
uint8_t ret=0;
gint r;
char *str;
const char *nullstring="";
dialog=create_dialog1();
gtk_transient(dialog);
#define CONNECT(A,B) gtk_signal_connect (GTK_OBJECT(lookup_widget(dialog,#A)), "clicked", \
GTK_SIGNAL_FUNC (B), (void *) NULL);
CONNECT(buttonLame,on_callback_lame);
CONNECT(buttonToolame,on_callback_toolame);
CONNECT(buttonLvemux,on_callback_lvemux);
CONNECT(buttonRequant,on_callback_requant);
CONNECT(button_audioDevice,on_callback_audio);
// prepare
if(!prefs->get(TOOLAME_PATH, &str))
{
str=(char *)nullstring;
}
gtk_write_entry_string(WID(entryToolame), str);
if(!prefs->get(LAME_PATH, &str))
{
str=(char *)nullstring;
}
gtk_write_entry_string(WID(entryLame), str);
if(!prefs->get(LVEMUX_PATH, &str))
{
str=(char *)nullstring;
}
gtk_write_entry_string(WID(entryLvemux), str);
if(!prefs->get(REQUANT_PATH, &str))
{
str=(char *)nullstring;
}
gtk_write_entry_string(WID(entryRequant), str);
if(gtk_dialog_run(GTK_DIALOG(dialog))==GTK_RESPONSE_OK)
{
ret=1;
str = gtk_editable_get_chars(GTK_EDITABLE (WID(entryToolame)), 0, -1);
prefs->set(TOOLAME_PATH, str);
str = gtk_editable_get_chars(GTK_EDITABLE (WID(entryLame)), 0, -1);
prefs->set(LAME_PATH, str);
str = gtk_editable_get_chars(GTK_EDITABLE (WID(entryLvemux)), 0, -1);
prefs->set(LVEMUX_PATH, str);
str = gtk_editable_get_chars(GTK_EDITABLE (WID(entryRequant)), 0, -1);
prefs->set(REQUANT_PATH, str);
}
gtk_widget_destroy(dialog);
dialog=NULL;
return ret;
}
note_data *
fill_note_data_from_page(_notetype notetype)
{
note_data *note;
gchar *l_ptr;
note = (note_data *) malloc(sizeof (note_data));
if (note == NULL)
{
g_warning(_("Error while allocating memory for note (0)"));
return (NULL);
}
note->notetype = notetype;
note->title = g_strdup(gtk_entry_get_text(GTK_ENTRY(sp->title_entry)));
if (note->title == NULL)
{
g_warning(_("Error while allocating memory for note (1)"));
return (NULL);
}
note->text = gtk_editable_get_chars(GTK_EDITABLE(sp->text_entry), 0,
gtk_text_get_length(GTK_TEXT(
sp->text_entry)));
if (note->text == NULL)
{
g_warning(_("Error while allocating memory for note (2)"));
return (NULL);
}
if (notetype == CheckNote || notetype == TodoNote)
{
note->todo = gtk_toggle_button_get_active(
GTK_TOGGLE_BUTTON(sp->todo_check));
}
else
{
note->todo = 0;
}
note->expire = time_label_get_time(TIME_LABEL(sp->tlabel_expire));
note->created = time_label_get_time(TIME_LABEL(sp->tlabel_created));
note->changed = time(NULL);
time_label_set_time(TIME_LABEL(sp->tlabel_changed), note->changed);
gtk_label_get(GTK_LABEL(sp->label_changes), &l_ptr);
note->changes = atoi(l_ptr);
note->changes++;
l_ptr = g_strdup_printf("%ld", note->changes);
gtk_label_set_text(GTK_LABEL(sp->label_changes), l_ptr);
g_free(l_ptr);
note->id = g_strdup(gtk_entry_get_text(GTK_ENTRY(sp->note_id_entry)));
if (note->id == NULL)
{
g_warning(_("Error while allocating memory for note (3)"));
return (NULL);
}
if (notetype == TodoNote)
{
note->deadline = gnome_date_edit_get_date(
GNOME_DATE_EDIT(sp->de_deadline));
note->prio = gtk_spin_button_get_value_as_int(
GTK_SPIN_BUTTON(sp->prio_entry));
note->complete = GTK_ADJUSTMENT(sp->ad_complete)->value;
}
else
{
note->deadline = 0;
note->prio = 0;
note->complete = 0;
}
return (note);
}
void
window_open_display_cmd_callback (GtkAction *action,
gpointer data)
{
GtkWidget *widget;
GtkWidget *dialog;
GtkWidget *entry;
return_if_no_widget (widget, data);
dialog = gimp_message_dialog_new ("Open Display", GIMP_STOCK_WILBER_EEK,
widget, GTK_DIALOG_MODAL,
NULL, NULL,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
gimp_message_box_set_primary_text (GIMP_MESSAGE_DIALOG (dialog)->box,
"Experimental multi-display stuff!\n"
"Click OK and have fun crashing GIMP...");
gimp_message_box_set_text (GIMP_MESSAGE_DIALOG (dialog)->box,
"Please enter the name of the new display:");
entry = gtk_entry_new ();
gtk_entry_set_activates_default (GTK_ENTRY (entry), TRUE);
gtk_box_pack_start (GTK_BOX (GIMP_MESSAGE_DIALOG (dialog)->box), entry,
TRUE, TRUE, 0);
gtk_widget_grab_focus (entry);
gtk_widget_show_all (dialog);
while (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK)
{
gchar *screen_name;
screen_name = gtk_editable_get_chars (GTK_EDITABLE (entry), 0, -1);
if (strcmp (screen_name, ""))
{
GdkDisplay *display;
gtk_widget_set_sensitive (dialog, FALSE);
display = gdk_display_open (screen_name);
if (! display)
gimp_message_box_set_text (GIMP_MESSAGE_DIALOG (dialog)->box,
"Can't open display '%s'. "
"Please try another one:",
screen_name);
g_free (screen_name);
gtk_widget_set_sensitive (dialog, TRUE);
if (display)
break;
}
gtk_widget_grab_focus (entry);
}
gtk_widget_destroy (dialog);
}
static void dt_time_edit_window(GtkWidget *button, cbdata *cbd)
{
GtkWidget *hbox = cbd->hbox;
GtkWidget *inputbox = dt_time_retrieve_inputbox(hbox);
GtkWidget *editwindow, *main_vbox, *calendar, *w;
GtkWidget *hbox2, *button2;
GtkAdjustment *adj;
char titlebuffer[1024]; /* FIXME: fixed buffer length */
struct tm tm;
int y, m, d, offset;
int ofs_h, ofs_m, ofs_sign;
time_t t;
struct tm *l;
gchar *content;
#if ! defined(HAVE_TM_GMTOFF) && defined(HAVE_TIMEZONE)
extern long timezone;
#endif
time(&t);
l = localtime(&t); /* implicitly calls tzset() for us */
y = l->tm_year + 1900;
m = l->tm_mon + 1;
d = l->tm_mday;
#ifdef HAVE_TM_GMTOFF
ofs_sign = l->TM_GMTOFF < 0 ? 1 : -1;
ofs_m = (l->TM_GMTOFF > 0 ? l->TM_GMTOFF : -l->TM_GMTOFF) / 60;
ofs_h = ofs_m / 60;
ofs_m = ofs_m % 60;
#else /* HAVE_TM_GMTOFF */
# ifdef HAVE_TIMEZONE
ofs_sign = timezone > 0 ? 1 : -1;
ofs_m = (timezone > 0 ? timezone : -timezone) / 60;
ofs_h = ofs_m / 60;
ofs_m = ofs_m % 60;
/* extern long timezone does not take DST into account */
if (l->tm_isdst) {
ofs_h++;
}
# else /* HAVE_TIMEZONE */
ofs_h = ofs_m = 0;
# endif /* HAVE_TIMEZONE */
#endif /* HAVE_TM_GMTOFF */
/* NOTE: generalizedTime includes offset relative to GMT while
the timezone variable hold seconds west of GMT */
offset = -ofs_sign * (100 * ofs_h + ofs_m);
#ifdef GTK_WINDOW_DIALOG
editwindow = gtk_window_new(GTK_WINDOW_DIALOG);
#else
editwindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
#endif
cbd->editwindow = editwindow;
g_snprintf(titlebuffer, sizeof(titlebuffer),
_("%s: choose date and time"), cbd->form->attrname);
gtk_window_set_title(GTK_WINDOW(editwindow), titlebuffer);
gtk_window_set_policy(GTK_WINDOW(editwindow), TRUE, TRUE, FALSE);
main_vbox = gtk_vbox_new(FALSE, 0);
gtk_container_border_width(GTK_CONTAINER(main_vbox), 5);
gtk_widget_show(main_vbox);
gtk_container_add(GTK_CONTAINER(editwindow), main_vbox);
calendar = gtk_calendar_new();
gtk_box_pack_start(GTK_BOX(main_vbox), calendar, TRUE, TRUE, 0);
gtk_widget_show(calendar);
gtk_object_set_data(GTK_OBJECT(editwindow), "calendar", calendar);
content = gtk_editable_get_chars(GTK_EDITABLE(inputbox), 0, -1);
if (content) {
int n = parse_time(content, &tm, &offset);
/* printf("n=%d\n", n); */
if (n >= 1)
y = tm.tm_year + 1900;
if (n >= 2)
m = tm.tm_mon + 1;
if (n >= 3)
d = tm.tm_mday;
g_free(content);
}
gtk_calendar_select_month(GTK_CALENDAR(calendar), m - 1, y);
gtk_calendar_select_day(GTK_CALENDAR(calendar), d);
hbox2 = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(main_vbox), hbox2, TRUE, TRUE, 5);
gtk_widget_show(hbox2);
w = gtk_label_new(_("Time [hh:mm:ss]"));
gtk_box_pack_start(GTK_BOX(hbox2), w, FALSE, TRUE, 0);
gtk_widget_show(w);
w = gtk_spin_button_new(GTK_ADJUSTMENT(gtk_adjustment_new(0.0,
0.0, 23.0,
1.0, 1.0,
1.0)),
1.0, 0);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(w), tm.tm_hour);
gtk_box_pack_start(GTK_BOX(hbox2), w, FALSE, FALSE, 10);
gtk_widget_show(w);
gtk_object_set_data(GTK_OBJECT(editwindow), "hour", w);
w = gtk_label_new(_(":"));
gtk_box_pack_start(GTK_BOX(hbox2), w, FALSE, TRUE, 0);
gtk_widget_show(w);
w = gtk_spin_button_new(GTK_ADJUSTMENT(gtk_adjustment_new(0.0,
0.0, 59.0,
1.0, 1.0,
1.0)),
1.0, 0);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(w), tm.tm_min);
gtk_box_pack_start(GTK_BOX(hbox2), w, FALSE, FALSE, 10);
gtk_widget_show(w);
gtk_object_set_data(GTK_OBJECT(editwindow), "minute", w);
w = gtk_label_new(_(":"));
gtk_box_pack_start(GTK_BOX(hbox2), w, FALSE, TRUE, 0);
gtk_widget_show(w);
w = gtk_spin_button_new(GTK_ADJUSTMENT(gtk_adjustment_new(0.0,
0.0, 59.0,
1.0, 1.0,
1.0)),
1.0, 0);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(w), tm.tm_sec);
gtk_box_pack_start(GTK_BOX(hbox2), w, FALSE, FALSE, 10);
gtk_widget_show(w);
gtk_object_set_data(GTK_OBJECT(editwindow), "second", w);
hbox2 = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(main_vbox), hbox2, TRUE, TRUE, 0);
gtk_widget_show(hbox2);
w = gtk_label_new(_("Timezone (Offset) [+-hhmm]"));
gtk_box_pack_start(GTK_BOX(hbox2), w, FALSE, TRUE, 0);
gtk_widget_show(w);
adj = GTK_ADJUSTMENT(gtk_adjustment_new(0.0,
-1259.0, 1259.0,
100.0, 100.0,
100.0));
w = gtk_spin_button_new(adj, 100.0, 0);
gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(w), FALSE);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(w), offset);
g_signal_connect(adj, "value-changed",
G_CALLBACK(tz_value_changed_callback),
w);
gtk_box_pack_start(GTK_BOX(hbox2), w, TRUE, TRUE, 10);
gtk_widget_show(w);
gtk_object_set_data(GTK_OBJECT(editwindow), "timezone", w);
hbox2 = gtk_hbutton_box_new();
gtk_box_pack_start(GTK_BOX(main_vbox), hbox2, FALSE, TRUE, 5);
gtk_widget_show(hbox2);
button2 = gtk_button_new_from_stock(GTK_STOCK_OK);
gtk_widget_show(button2);
g_signal_connect(button2, "clicked",
G_CALLBACK(dt_time_ok_callback),
cbd);
gtk_box_pack_start(GTK_BOX(hbox2), button2, FALSE, TRUE, 0);
GTK_WIDGET_SET_FLAGS(button2, GTK_CAN_DEFAULT);
gtk_widget_grab_default(button2);
button2 = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
gtk_box_pack_end(GTK_BOX(hbox2), button2, FALSE, TRUE, 0);
g_signal_connect_swapped(button2, "clicked",
G_CALLBACK(gtk_widget_destroy),
editwindow);
gtk_widget_show(button2);
gtk_widget_show(editwindow);
}
static void gnc_ui_to_employee (EmployeeWindow *ew, GncEmployee *employee)
{
GncAddress *addr;
addr = gncEmployeeGetAddr (employee);
gnc_suspend_gui_refresh ();
gncEmployeeBeginEdit (employee);
if (ew->dialog_type == NEW_EMPLOYEE)
qof_event_gen(QOF_INSTANCE(employee), QOF_EVENT_ADD, NULL);
gncEmployeeSetID (employee, gtk_editable_get_chars
(GTK_EDITABLE (ew->id_entry), 0, -1));
gncEmployeeSetUsername (employee, gtk_editable_get_chars
(GTK_EDITABLE (ew->username_entry), 0, -1));
gncAddressSetName (addr, gtk_editable_get_chars
(GTK_EDITABLE (ew->name_entry), 0, -1));
gncAddressSetAddr1 (addr, gtk_editable_get_chars
(GTK_EDITABLE (ew->addr1_entry), 0, -1));
gncAddressSetAddr2 (addr, gtk_editable_get_chars
(GTK_EDITABLE (ew->addr2_entry), 0, -1));
gncAddressSetAddr3 (addr, gtk_editable_get_chars
(GTK_EDITABLE (ew->addr3_entry), 0, -1));
gncAddressSetAddr4 (addr, gtk_editable_get_chars
(GTK_EDITABLE (ew->addr4_entry), 0, -1));
gncAddressSetPhone (addr, gtk_editable_get_chars
(GTK_EDITABLE (ew->phone_entry), 0, -1));
gncAddressSetFax (addr, gtk_editable_get_chars
(GTK_EDITABLE (ew->fax_entry), 0, -1));
gncAddressSetEmail (addr, gtk_editable_get_chars
(GTK_EDITABLE (ew->email_entry), 0, -1));
gncEmployeeSetActive (employee, gtk_toggle_button_get_active
(GTK_TOGGLE_BUTTON (ew->active_check)));
gncEmployeeSetLanguage (employee, gtk_editable_get_chars
(GTK_EDITABLE (ew->language_entry), 0, -1));
/* Parse and set the workday and rate amounts */
gncEmployeeSetWorkday (employee, gnc_amount_edit_get_amount
(GNC_AMOUNT_EDIT (ew->workday_amount)));
gncEmployeeSetRate (employee, gnc_amount_edit_get_amount
(GNC_AMOUNT_EDIT (ew->rate_amount)));
gncEmployeeSetCurrency (employee, gnc_currency_edit_get_currency
(GNC_CURRENCY_EDIT (ew->currency_edit)));
/* Fill in the CCard Acct */
gncEmployeeSetCCard (employee,
(gtk_toggle_button_get_active
(GTK_TOGGLE_BUTTON (ew->ccard_acct_check)) ?
gnc_account_sel_get_account
(GNC_ACCOUNT_SEL (ew->ccard_acct_sel)) : NULL));
gncEmployeeCommitEdit (employee);
gnc_resume_gui_refresh ();
}
static gboolean
command_key_event (GtkEntry *entry,
GdkEventKey *event,
MCData *mc)
{
guint key = event->keyval;
char *command;
static char current_command[MC_MAX_COMMAND_LENGTH];
char buffer[MC_MAX_COMMAND_LENGTH];
gboolean propagate_event = TRUE;
const gchar *str;
if (mc->error) {
mc->error = FALSE;
str = gtk_editable_get_chars (GTK_EDITABLE (entry), 0, -1);
gtk_entry_set_text (entry, (gchar *) str + 3);
gtk_editable_set_position (GTK_EDITABLE (entry), strlen (str));
}
if(key == GDK_Tab
|| key == GDK_KP_Tab
|| key == GDK_ISO_Left_Tab)
{
if(event->state == GDK_CONTROL_MASK)
{
/*
* Move focus to the next widget (browser) button.
*/
gtk_widget_child_focus (GTK_WIDGET (mc->applet), GTK_DIR_TAB_FORWARD);
propagate_event = FALSE;
}
else if(event->state != GDK_SHIFT_MASK)
{
/* tab key pressed */
strcpy(buffer, (char *) gtk_entry_get_text(GTK_ENTRY(entry)));
mc_cmd_completion (mc, buffer);
gtk_entry_set_text(GTK_ENTRY(entry), (gchar *) buffer);
propagate_event = FALSE;
}
}
else if(key == GDK_Up
|| key == GDK_KP_Up
|| key == GDK_ISO_Move_Line_Up
|| key == GDK_Pointer_Up)
{
/* up key pressed */
if(history_position == MC_HISTORY_LIST_LENGTH)
{
/* store current command line */
strcpy(current_command, (char *) gtk_entry_get_text(entry));
}
if(history_position > 0 && exists_history_entry(history_position - 1))
{
gtk_entry_set_text(entry, (gchar *) get_history_entry(--history_position));
}
propagate_event = FALSE;
}
else if(key == GDK_Down
|| key == GDK_KP_Down
|| key == GDK_ISO_Move_Line_Down
|| key == GDK_Pointer_Down)
{
/* down key pressed */
if(history_position < MC_HISTORY_LIST_LENGTH - 1)
{
gtk_entry_set_text(entry, (gchar *) get_history_entry(++history_position));
}
else if(history_position == MC_HISTORY_LIST_LENGTH - 1)
{
gtk_entry_set_text(entry, (gchar *) current_command);
++history_position;
}
propagate_event = FALSE;
}
else if(key == GDK_Return
|| key == GDK_KP_Enter
|| key == GDK_ISO_Enter
|| key == GDK_3270_Enter)
{
/* enter pressed -> exec command */
command = (char *) malloc(sizeof(char) * MC_MAX_COMMAND_LENGTH);
strcpy(command, (char *) gtk_entry_get_text(entry));
mc_exec_command(mc, command);
history_position = MC_HISTORY_LIST_LENGTH;
free(command);
strcpy(current_command, "");
propagate_event = FALSE;
}
else if (mc->preferences.auto_complete_history && key >= GDK_space && key <= GDK_asciitilde )
{
char *completed_command;
gint current_position = gtk_editable_get_position(GTK_EDITABLE(entry));
if(current_position != 0)
{
gtk_editable_delete_text( GTK_EDITABLE(entry), current_position, -1 );
completed_command = history_auto_complete(GTK_WIDGET (entry), event);
if(completed_command != NULL)
{
gtk_entry_set_text(entry, completed_command);
gtk_editable_set_position(GTK_EDITABLE(entry), current_position + 1);
propagate_event = FALSE;
}
}
}
return !propagate_event;
}
ReplyType glyphToText(admGlyph *glyph,admGlyph *head,char *decodedString)
{
admGlyph *cand;
//printf("2t: %d x %d\n",glyph->width,glyph->height);
if(glyph->width<2 && glyph->height<2)
{
delete glyph;
return ReplyOk;
}
cand=searchGlyph(head,glyph);
if(!cand) // New glyph
{
char *string;
// Draw it
displaySmall(glyph);
gtk_label_set_text(GTK_LABEL(WID(labelText)),decodedString);
gtk_editable_delete_text(GTK_EDITABLE(WID(entry)), 0,-1);
//gtk_widget_set_sensitive(WID(buttonAccept),1);
//gtk_widget_set_sensitive(WID(buttonSkip),1);
//gtk_widget_set_sensitive(WID(entryEntry),1);
gtk_widget_grab_focus (WID(entry));
gtk_widget_grab_default (WID(buttonOk));
//printf("i\n");
switch(gtk_dialog_run(GTK_DIALOG(dialog)))
{
case actionIgnore:
glyph->code=NULL;
insertInGlyphTree(head,glyph);
//*nbGl++;
break;
case actionCalibrate: return ReplyCalibrate;
case actionAccept:
string =gtk_editable_get_chars(GTK_EDITABLE (WID(entry)), 0, -1);
if(string&& strlen(string))
{
glyph->code=ADM_strdup(string);
insertInGlyphTree(head,glyph);
//printf("New glyph:%s\n",glyph->code);
strcat(decodedString,glyph->code);
//*nbGl++;
}
else delete glyph;
break;
case actionSkip: //SKIP
return ReplySkip;
break;
case actionSkipAll:
return ReplySkipAll;
break;
case GTK_RESPONSE_CLOSE:
if(GUI_Question(QT_TR_NOOP("Sure ?"))) return ReplyClose;
break; // Abort
}
gtk_editable_delete_text(GTK_EDITABLE(WID(entry)), 0,-1);
//gtk_widget_set_sensitive(WID(buttonAccept),0);
//gtk_widget_set_sensitive(WID(buttonSkip),0);
//gtk_widget_set_sensitive(WID(entryEntry),0);
}
else
{
//printf("Glyph known :%s \n",cand->code);
if(cand->code)
strcat(decodedString,cand->code);
delete glyph;
}
return ReplyOk;
}
static void spamassassin_save_func(PrefsPage *_page)
{
struct SpamAssassinPage *page = (struct SpamAssassinPage *) _page;
SpamAssassinConfig *config;
debug_print("Saving SpamAssassin Page\n");
config = spamassassin_get_config();
/* enable */
config->enable = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->enable_sa_checkbtn));
config->transport = page->trans;
/* username */
g_free(config->username);
config->username = gtk_editable_get_chars(GTK_EDITABLE(page->username), 0, -1);
spamassassin_check_username();
/* hostname */
g_free(config->hostname);
config->hostname = gtk_editable_get_chars(GTK_EDITABLE(page->hostname), 0, -1);
/* port */
config->port = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(page->port));
/* hostname */
g_free(config->socket);
config->socket = gtk_editable_get_chars(GTK_EDITABLE(page->socket), 0, -1);
/* process_emails */
config->process_emails = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->process_emails));
/* receive_spam */
config->receive_spam = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->receive_spam));
/* save_folder */
g_free(config->save_folder);
config->save_folder = gtk_editable_get_chars(GTK_EDITABLE(page->save_folder), 0, -1);
/* max_size */
config->max_size = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(page->max_size));
/* timeout */
config->timeout = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(page->timeout));
/* mark_as_read */
config->mark_as_read = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->mark_as_read));
/* whitelist_ab */
config->whitelist_ab = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->whitelist_ab));
g_free(config->whitelist_ab_folder);
config->whitelist_ab_folder = gtk_editable_get_chars(
GTK_EDITABLE(gtk_bin_get_child(GTK_BIN((page->whitelist_ab_folder_combo)))), 0, -1);
/* store UNtranslated "Any" */
if (g_utf8_collate(config->whitelist_ab_folder, _("Any")) == 0) {
g_free(config->whitelist_ab_folder);
config->whitelist_ab_folder = g_strdup("Any");
}
if (config->process_emails) {
spamassassin_register_hook();
} else {
spamassassin_unregister_hook();
}
if (!config->enable) {
procmsg_unregister_spam_learner(spamassassin_learn);
procmsg_spam_set_folder(NULL, NULL);
} else {
if (config->transport == SPAMASSASSIN_TRANSPORT_TCP)
debug_print("enabling learner with a remote spamassassin server requires spamc/spamd 3.1.x\n");
procmsg_register_spam_learner(spamassassin_learn);
procmsg_spam_set_folder(config->save_folder, spamassassin_get_spam_folder);
}
spamassassin_save_config();
}
/*!
*\brief Returns action from the content of the dialog
*
*\param alert specifies whether alert dialog boxes should be shown
* or not.
*
*\return FilteringAction * action entered in the dialog box.
*/
static FilteringAction * prefs_filtering_action_dialog_to_action(gboolean alert)
{
Action action_id;
gint action_type;
gint list_id;
gint account_id;
gchar * destination = NULL;
gint labelcolor = 0;
FilteringAction * action;
gint score;
gchar * header = NULL;
action_id = combobox_get_active_data(GTK_COMBO_BOX(filtering_action.action_combo));
action_type = prefs_filtering_action_get_matching_from_action(action_id);
list_id = gtk_combo_box_get_active(GTK_COMBO_BOX(filtering_action.account_combo));
account_id = get_account_id_from_list_id(list_id);
score = 0;
destination = NULL;
switch (action_id) {
case ACTION_MOVE:
case ACTION_COPY:
case ACTION_EXECUTE:
destination = gtk_editable_get_chars(GTK_EDITABLE(filtering_action.dest_entry), 0, -1);
if (*destination == '\0') {
if (alert)
alertpanel_error(action_id == ACTION_EXECUTE
? _("Command-line not set")
: _("Destination is not set."));
g_free(destination);
return NULL;
}
break;
case ACTION_FORWARD:
case ACTION_FORWARD_AS_ATTACHMENT:
case ACTION_REDIRECT:
destination = gtk_editable_get_chars(GTK_EDITABLE(filtering_action.dest_entry), 0, -1);
if (*destination == '\0') {
if (alert)
alertpanel_error(_("Recipient is not set."));
g_free(destination);
return NULL;
}
break;
#if !GTK_CHECK_VERSION(3, 0, 0)
case ACTION_COLOR:
labelcolor = colorlabel_get_color_menu_active_item(
gtk_cmoption_menu_get_menu(GTK_CMOPTION_MENU(filtering_action.color_optmenu)));
destination = NULL;
break;
#endif
case ACTION_CHANGE_SCORE:
case ACTION_SET_SCORE:
score = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(
filtering_action.score_entry));
if (!score && action_id == ACTION_CHANGE_SCORE) {
if (alert)
alertpanel_error(_("Score is not set"));
return NULL;
}
break;
case ACTION_ADD_TO_ADDRESSBOOK:
header = gtk_editable_get_chars(GTK_EDITABLE(filtering_action.header_entry), 0, -1);
if (*header == '\0') {
if (alert)
alertpanel_error(_("Header is not set."));
g_free(header);
return NULL;
}
destination = gtk_editable_get_chars(GTK_EDITABLE(filtering_action.dest_entry), 0, -1);
if (*destination == '\0') {
if (alert)
alertpanel_error(_("Target addressbook/folder is not set."));
g_free(destination);
return NULL;
}
break;
case ACTION_SET_TAG:
case ACTION_UNSET_TAG:
#if !GTK_CHECK_VERSION(2, 24, 0)
destination = gtk_combo_box_get_active_text(GTK_COMBO_BOX(filtering_action.tags_combo));
#else
destination = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(filtering_action.tags_combo));
#endif
if (!destination || *destination == '\0') {
if (alert)
alertpanel_error(_("Tag name is empty."));
g_free(destination);
return NULL;
}
break;
case ACTION_STOP:
case ACTION_HIDE:
case ACTION_IGNORE:
case ACTION_WATCH:
case ACTION_DELETE:
case ACTION_MARK:
case ACTION_UNMARK:
case ACTION_LOCK:
case ACTION_UNLOCK:
case ACTION_MARK_AS_READ:
case ACTION_MARK_AS_UNREAD:
case ACTION_MARK_AS_SPAM:
case ACTION_MARK_AS_HAM:
case ACTION_CLEAR_TAGS:
default:
break;
}
action = filteringaction_new(action_type, account_id,
destination, labelcolor, score, header);
g_free(destination);
return action;
}
static void sync_pattern_data (void) {
struct player_pattern *pp;
char *pattern;
char *comment;
enum pattern_mode mode;
int update_pattern = FALSE;
int update_comment = FALSE;
GSList *list;
if (current_row < 0)
return;
list = g_slist_nth (curplrs, current_row);
pp = (struct player_pattern *) list->data;
if (GTK_TOGGLE_BUTTON (mode_buttons[PATTERN_MODE_STRING])->active)
mode = PATTERN_MODE_STRING;
else if (GTK_TOGGLE_BUTTON (mode_buttons[PATTERN_MODE_SUBSTR])->active)
mode = PATTERN_MODE_SUBSTR;
else
mode = PATTERN_MODE_REGEXP;
pattern = strdup_strip (gtk_entry_get_text (GTK_ENTRY (pattern_entry)));
comment = gtk_editable_get_chars (GTK_EDITABLE (comment_text), 0, -1);
update_pattern = (pp->pattern && pp->pattern[0])?
!pattern || !pattern[0] || strcmp (pp->pattern, pattern) :
pattern && pattern[0];
update_comment = (pp->comment && pp->comment[0])?
!comment || !comment[0] || strcmp (pp->comment, comment) :
comment && comment[0];
/*
* Test everything but groups.
* They are synchronized by pattern_set_groups()
*/
if (mode != pp->mode || update_comment || update_pattern) {
if (!pp->dirty) {
pp = player_pattern_new (pp);
list->data = pp;
}
if (update_pattern) {
if (pp->pattern) g_free (pp->pattern);
pp->pattern = pattern;
}
if (update_comment) {
if (pp->comment) g_free (pp->comment);
pp->comment = comment;
}
if (pp->mode != mode || update_pattern) {
free_player_pattern_compiled_data (pp);
pp->mode = mode;
player_pattern_compile (pp);
}
pattern_clist_update_row (pp, current_row);
}
if (!update_comment)
g_free (comment);
if (!update_pattern)
g_free (pattern);
}
int
xfsm_splash_screen_choose (XfsmSplashScreen *splash,
GList *sessions,
const gchar *default_session,
gchar **name_return)
{
GtkWidget *chooser;
GtkWidget *label;
GtkWidget *dialog;
GtkWidget *entry;
gchar title[256];
int result;
g_assert (default_session != NULL);
if (splash->engine.choose != NULL)
{
result = splash->engine.choose (&splash->engine,
sessions,
default_session,
name_return);
}
else
{
again:
xfsm_splash_screen_next (splash, _("Choose session"));
chooser = g_object_new (XFSM_TYPE_CHOOSER,
"screen", splash->engine.primary_screen,
"type", GTK_WINDOW_POPUP,
NULL);
xfsm_window_add_border (GTK_WINDOW (chooser));
xfsm_chooser_set_sessions (XFSM_CHOOSER (chooser),
sessions, default_session);
result = xfsm_splash_screen_run (splash, chooser);
if (result == XFSM_RESPONSE_LOAD)
{
if (name_return != NULL)
*name_return = xfsm_chooser_get_session (XFSM_CHOOSER (chooser));
result = XFSM_CHOOSE_LOAD;
}
else if (result == XFSM_RESPONSE_NEW)
{
result = XFSM_CHOOSE_NEW;
}
else
{
result = XFSM_CHOOSE_LOGOUT;
}
gtk_widget_destroy (chooser);
if (result == XFSM_CHOOSE_NEW)
{
xfsm_splash_screen_next (splash, _("Choose session name"));
dialog = gtk_dialog_new_with_buttons (NULL,
NULL,
GTK_DIALOG_NO_SEPARATOR,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
GTK_STOCK_OK,
GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_default_response (GTK_DIALOG (dialog),
GTK_RESPONSE_OK);
g_snprintf (title, 256, "<big>%s</big>",
_("Choose a name for the new session:"));
label = gtk_label_new (title);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox),
label, TRUE, TRUE, 6);
gtk_widget_show (label);
entry = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox),
entry, TRUE, TRUE, 6);
gtk_widget_show (entry);
xfsm_window_add_border (GTK_WINDOW (dialog));
again1:
result = xfsm_splash_screen_run (splash, dialog);
if (result != GTK_RESPONSE_OK)
{
gtk_widget_destroy (dialog);
goto again;
}
if (name_return != NULL)
{
*name_return = gtk_editable_get_chars (GTK_EDITABLE (entry),
0, -1);
if (strlen (*name_return) == 0)
{
g_free (*name_return);
goto again1;
}
}
gtk_widget_destroy (dialog);
result = XFSM_CHOOSE_NEW;
}
}
return result;
}
static gchar *input_dialog_open(const gchar *title, const gchar *message,
const gchar *checkbtn_label,
const gchar *default_string,
gboolean default_checkbtn_state,
gboolean *remember)
{
gchar *str;
if (dialog && gtk_widget_get_visible(dialog)) return NULL;
if (!dialog)
input_dialog_create(FALSE);
if (checkbtn_label)
gtk_button_set_label(GTK_BUTTON(remember_checkbtn), checkbtn_label);
else
gtk_button_set_label(GTK_BUTTON(remember_checkbtn), _("Remember this"));
input_dialog_set(title, message, default_string);
gtk_window_present(GTK_WINDOW(dialog));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(remember_checkbtn),
default_checkbtn_state);
if (remember)
gtk_widget_show(remember_checkbtn);
else
gtk_widget_hide(remember_checkbtn);
gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
manage_window_set_transient(GTK_WINDOW(dialog));
ack = fin = FALSE;
while (fin == FALSE)
gtk_main_iteration();
manage_window_focus_out(dialog, NULL, NULL);
if (ack) {
GtkEditable *editable;
if (type == INPUT_DIALOG_COMBO)
editable = GTK_EDITABLE(gtk_bin_get_child(GTK_BIN((combo))));
else
editable = GTK_EDITABLE(entry);
str = gtk_editable_get_chars(editable, 0, -1);
if (str && *str == '\0' && !is_pass) {
g_free(str);
str = NULL;
}
} else
str = NULL;
GTK_EVENTS_FLUSH();
if (remember) {
*remember = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(remember_checkbtn));
}
gtk_widget_destroy(dialog);
dialog = NULL;
if (is_pass)
debug_print("return string = %s\n", str ? "********": ("none"));
else
debug_print("return string = %s\n", str ? str : "(none)");
return str;
}
static void
integer_tie_cb(GtkEditable *e, SettingsWidget *sw) {
char *text = gtk_editable_get_chars(e, 0, -1);
*(int*)sw->conf = atoi(text);
g_free(text);
}
static gboolean
gdict_applet_draw (GdictApplet *applet)
{
GdictAppletPrivate *priv = applet->priv;
GtkWidget *box;
GtkWidget *hbox;
gchar *text = NULL;
if (priv->entry)
text = gtk_editable_get_chars (GTK_EDITABLE (priv->entry), 0, -1);
if (priv->box)
gtk_widget_destroy (priv->box);
#if GTK_CHECK_VERSION (3, 0, 0)
box = gtk_box_new (priv->orient, 0);
#else
switch (priv->orient)
{
case GTK_ORIENTATION_VERTICAL:
box = gtk_vbox_new (FALSE, 0);
break;
case GTK_ORIENTATION_HORIZONTAL:
box = gtk_hbox_new (FALSE, 0);
break;
default:
g_assert_not_reached ();
break;
}
#endif
gtk_container_add (GTK_CONTAINER (applet), box);
gtk_widget_show (box);
/* toggle button */
priv->toggle = gtk_toggle_button_new ();
gtk_widget_set_tooltip_text (priv->toggle, _("Click to view the dictionary window"));
set_atk_name_description (priv->toggle,
_("Toggle dictionary window"),
_("Show or hide the definition window"));
gtk_button_set_relief (GTK_BUTTON (priv->toggle),
GTK_RELIEF_NONE);
g_signal_connect (priv->toggle, "toggled",
G_CALLBACK (gdict_applet_icon_toggled_cb),
applet);
g_signal_connect (priv->toggle, "button-press-event",
G_CALLBACK (gdict_applet_icon_button_press_event_cb),
applet);
gtk_box_pack_start (GTK_BOX (box), priv->toggle, FALSE, FALSE, 0);
gtk_widget_show (priv->toggle);
#if GTK_CHECK_VERSION (3, 0, 0)
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
#else
hbox = gtk_hbox_new (FALSE, 0);
#endif
gtk_container_set_border_width (GTK_CONTAINER (hbox), 0);
gtk_container_add (GTK_CONTAINER (priv->toggle), hbox);
gtk_widget_show (hbox);
if (priv->icon)
{
GdkPixbuf *scaled;
priv->image = gtk_image_new ();
gtk_image_set_pixel_size (GTK_IMAGE (priv->image), priv->size - 10);
scaled = gdk_pixbuf_scale_simple (priv->icon,
priv->size - 5,
priv->size - 5,
GDK_INTERP_BILINEAR);
gtk_image_set_from_pixbuf (GTK_IMAGE (priv->image), scaled);
g_object_unref (scaled);
gtk_box_pack_start (GTK_BOX (hbox), priv->image, FALSE, FALSE, 0);
gtk_widget_show (priv->image);
}
else
{
priv->image = gtk_image_new ();
gtk_image_set_pixel_size (GTK_IMAGE (priv->image), priv->size - 10);
gtk_image_set_from_icon_name (GTK_IMAGE (priv->image),
"image-missing", -1);
gtk_box_pack_start (GTK_BOX (hbox), priv->image, FALSE, FALSE, 0);
gtk_widget_show (priv->image);
}
/* entry */
priv->entry = gtk_entry_new ();
gtk_widget_set_tooltip_text (priv->entry, _("Type the word you want to look up"));
set_atk_name_description (priv->entry,
_("Dictionary entry"),
_("Look up words in dictionaries"));
gtk_editable_set_editable (GTK_EDITABLE (priv->entry), TRUE);
gtk_entry_set_width_chars (GTK_ENTRY (priv->entry), 12);
g_signal_connect (priv->entry, "activate",
G_CALLBACK (gdict_applet_entry_activate_cb),
applet);
g_signal_connect (priv->entry, "button-press-event",
G_CALLBACK (gdict_applet_entry_button_press_event_cb),
applet);
g_signal_connect (priv->entry, "key-press-event",
G_CALLBACK (gdict_applet_entry_key_press_cb),
applet);
gtk_box_pack_end (GTK_BOX (box), priv->entry, FALSE, FALSE, 0);
gtk_widget_show (priv->entry);
if (text)
{
gtk_entry_set_text (GTK_ENTRY (priv->entry), text);
g_free (text);
}
priv->box = box;
#if 0
gtk_widget_grab_focus (priv->entry);
#endif
gtk_widget_show_all (GTK_WIDGET (applet));
return FALSE;
}
static gboolean
entry_event (GtkEditable *entry,
GdkEventKey *event,
PanelRunDialog *dialog)
{
GtkTreeSelection *selection;
char *prefix;
char *nospace_prefix;
char *nprefix;
char *temp;
int pos, tmp;
if (event->type != GDK_KEY_PRESS)
return FALSE;
/* if user typed something we're not using the list anymore */
dialog->use_program_list = FALSE;
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (dialog->program_list));
gtk_tree_selection_unselect_all (selection);
if (!panel_profile_get_enable_autocompletion ())
return FALSE;
/* tab completion */
if (event->keyval == GDK_KEY_Tab) {
gtk_editable_get_selection_bounds (entry, &pos, &tmp);
if (dialog->completion_started &&
pos != tmp &&
pos != 1 &&
tmp == strlen (gtk_entry_get_text (GTK_ENTRY (entry)))) {
gtk_editable_select_region (entry, 0, 0);
gtk_editable_set_position (entry, -1);
return TRUE;
}
} else if (event->length > 0) {
gtk_editable_get_selection_bounds (entry, &pos, &tmp);
if (dialog->completion_started &&
pos != tmp &&
pos != 0 &&
tmp == strlen (gtk_entry_get_text (GTK_ENTRY (entry)))) {
temp = gtk_editable_get_chars (entry, 0, pos);
prefix = g_strconcat (temp, event->string, NULL);
g_free (temp);
} else if (pos == tmp &&
tmp == strlen (gtk_entry_get_text (GTK_ENTRY (entry)))) {
prefix = g_strconcat (gtk_entry_get_text (GTK_ENTRY (entry)),
event->string, NULL);
} else {
return FALSE;
}
nospace_prefix = prefix;
while (*nospace_prefix != '\0' &&
g_ascii_isspace (*nospace_prefix))
nospace_prefix++;
if (*nospace_prefix == '\0')
return FALSE;
panel_run_dialog_update_completion (dialog, nospace_prefix);
if (!dialog->completion) {
g_free (prefix);
return FALSE;
}
pos = strlen (prefix);
nprefix = NULL;
g_completion_complete_utf8 (dialog->completion, nospace_prefix,
&nprefix);
if (nprefix) {
int insertpos;
insertpos = 0;
temp = g_strndup (prefix, nospace_prefix - prefix);
g_free (prefix);
prefix = g_strconcat (temp, nprefix, NULL);
g_signal_handler_block (dialog->combobox,
dialog->changed_id);
gtk_editable_delete_text (entry, 0, -1);
g_signal_handler_unblock (dialog->combobox,
dialog->changed_id);
gtk_editable_insert_text (entry,
prefix, strlen (prefix),
&insertpos);
gtk_editable_set_position (entry, pos);
gtk_editable_select_region (entry, pos, -1);
dialog->completion_started = TRUE;
g_free (temp);
g_free (nprefix);
g_free (prefix);
return TRUE;
}
g_free (prefix);
}
return FALSE;
}
/**************************************************************************
Make a chat link at the current position or make the current selection
clickable.
**************************************************************************/
void inputline_make_chat_link(struct tile *ptile, bool unit)
{
char buf[MAX_LEN_MSG];
GtkWidget *entry = toolkit.entry;
GtkEditable *editable = GTK_EDITABLE(entry);
gint start_pos, end_pos;
gchar *chars;
struct unit *punit;
/* Get the target. */
if (unit) {
punit = find_visible_unit(ptile);
if (!punit) {
output_window_append(ftc_client, _("No visible unit on this tile."));
return;
}
} else {
punit = NULL;
}
if (gtk_editable_get_selection_bounds(editable, &start_pos, &end_pos)) {
/* There is a selection, make it clickable. */
gpointer target;
enum text_link_type type;
chars = gtk_editable_get_chars(editable, start_pos, end_pos);
if (punit) {
type = TLT_UNIT;
target = punit;
} else if (tile_city(ptile)) {
type = TLT_CITY;
target = tile_city(ptile);
} else {
type = TLT_TILE;
target = ptile;
}
if (0 != featured_text_apply_tag(chars, buf, sizeof(buf), TTT_LINK,
0, FT_OFFSET_UNSET, type, target)) {
/* Replace the selection. */
gtk_editable_delete_text(editable, start_pos, end_pos);
end_pos = start_pos;
gtk_editable_insert_text(editable, buf, -1, &end_pos);
gtk_widget_grab_focus(entry);
gtk_editable_select_region(editable, start_pos, end_pos);
}
} else {
/* Just insert the link at the current position. */
start_pos = gtk_editable_get_position(editable);
end_pos = start_pos;
chars = gtk_editable_get_chars(editable, MAX(start_pos - 1, 0),
start_pos + 1);
if (punit) {
sz_strlcpy(buf, unit_link(punit));
} else if (tile_city(ptile)) {
sz_strlcpy(buf, city_link(tile_city(ptile)));
} else {
sz_strlcpy(buf, tile_link(ptile));
}
if (start_pos > 0 && strlen(chars) > 0 && chars[0] != ' ') {
/* Maybe insert an extra space. */
gtk_editable_insert_text(editable, " ", 1, &end_pos);
}
gtk_editable_insert_text(editable, buf, -1, &end_pos);
if (chars[start_pos > 0 ? 1 : 0] != '\0'
&& chars[start_pos > 0 ? 1 : 0] != ' ') {
/* Maybe insert an extra space. */
gtk_editable_insert_text(editable, " ", 1, &end_pos);
}
gtk_widget_grab_focus(entry);
gtk_editable_set_position(editable, end_pos);
}
g_free(chars);
}
static void
thunar_uca_editor_command_clicked (ThunarUcaEditor *uca_editor)
{
GtkFileFilter *filter;
GtkWidget *chooser;
gchar *filename;
gchar **argv = NULL;
gchar *s;
gint argc;
g_return_if_fail (THUNAR_UCA_IS_EDITOR (uca_editor));
chooser = gtk_file_chooser_dialog_new (_("Select an Application"),
GTK_WINDOW (uca_editor),
GTK_FILE_CHOOSER_ACTION_OPEN,
_("_Cancel"), GTK_RESPONSE_CANCEL,
_("_Open"), GTK_RESPONSE_ACCEPT,
NULL);
gtk_dialog_set_default_response (GTK_DIALOG (chooser), GTK_RESPONSE_ACCEPT);
gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (chooser), TRUE);
/* add file chooser filters */
filter = gtk_file_filter_new ();
gtk_file_filter_set_name (filter, _("All Files"));
gtk_file_filter_add_pattern (filter, "*");
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter);
filter = gtk_file_filter_new ();
gtk_file_filter_set_name (filter, _("Executable Files"));
gtk_file_filter_add_mime_type (filter, "application/x-csh");
gtk_file_filter_add_mime_type (filter, "application/x-executable");
gtk_file_filter_add_mime_type (filter, "application/x-perl");
gtk_file_filter_add_mime_type (filter, "application/x-python");
gtk_file_filter_add_mime_type (filter, "application/x-ruby");
gtk_file_filter_add_mime_type (filter, "application/x-shellscript");
gtk_file_filter_add_pattern (filter, "*.pl");
gtk_file_filter_add_pattern (filter, "*.py");
gtk_file_filter_add_pattern (filter, "*.rb");
gtk_file_filter_add_pattern (filter, "*.sh");
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter);
gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (chooser), filter);
filter = gtk_file_filter_new ();
gtk_file_filter_set_name (filter, _("Perl Scripts"));
gtk_file_filter_add_mime_type (filter, "application/x-perl");
gtk_file_filter_add_pattern (filter, "*.pl");
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter);
filter = gtk_file_filter_new ();
gtk_file_filter_set_name (filter, _("Python Scripts"));
gtk_file_filter_add_mime_type (filter, "application/x-python");
gtk_file_filter_add_pattern (filter, "*.py");
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter);
filter = gtk_file_filter_new ();
gtk_file_filter_set_name (filter, _("Ruby Scripts"));
gtk_file_filter_add_mime_type (filter, "application/x-ruby");
gtk_file_filter_add_pattern (filter, "*.rb");
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter);
filter = gtk_file_filter_new ();
gtk_file_filter_set_name (filter, _("Shell Scripts"));
gtk_file_filter_add_mime_type (filter, "application/x-csh");
gtk_file_filter_add_mime_type (filter, "application/x-shellscript");
gtk_file_filter_add_pattern (filter, "*.sh");
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter);
/* use the bindir as default folder */
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (chooser), BINDIR);
/* setup the currently selected file */
filename = gtk_editable_get_chars (GTK_EDITABLE (uca_editor->command_entry), 0, -1);
if (G_LIKELY (filename != NULL))
{
/* use only the first argument */
s = strchr (filename, ' ');
if (G_UNLIKELY (s != NULL))
*s = '\0';
/* check if we have a file name */
if (G_LIKELY (*filename != '\0'))
{
/* check if the filename is not an absolute path */
if (G_LIKELY (!g_path_is_absolute (filename)))
{
/* try to lookup the filename in $PATH */
s = g_find_program_in_path (filename);
if (G_LIKELY (s != NULL))
{
/* use the absolute path instead */
g_free (filename);
filename = s;
}
}
/* check if we have an absolute path now */
if (G_LIKELY (g_path_is_absolute (filename)))
gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (chooser), filename);
}
/* release the filename */
g_free (filename);
}
/* run the chooser dialog */
if (gtk_dialog_run (GTK_DIALOG (chooser)) == GTK_RESPONSE_ACCEPT)
{
/* determine the path to the selected file */
filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (chooser));
/* check if we need to quote the filename */
if (!g_shell_parse_argv (filename, &argc, &argv, NULL) || argc > 1)
{
/* shell is unable to interpret properly without quoting */
s = g_shell_quote (filename);
g_free (filename);
filename = s;
}
g_strfreev (argv);
/* append %f to filename, user may change that afterwards */
s = g_strconcat (filename, " %f", NULL);
gtk_entry_set_text (GTK_ENTRY (uca_editor->command_entry), s);
g_free (filename);
g_free (s);
}
gtk_widget_destroy (chooser);
}
G_MODULE_EXPORT gboolean create_tick_group_event(GtkWidget * widget, gpointer data)
{
GtkWidget *dialog = NULL;
GtkWidget *dummy = NULL;
MtxTickGroup *tgroup = NULL;
gchar * filename = NULL;
gfloat tmp1 = 0.0;
gfloat tmp2 = 0.0;
gint result = 0;
MtxGaugeFace *g = NULL;
GError *error = NULL;
if (GTK_IS_WIDGET(gauge))
g = MTX_GAUGE_FACE(gauge);
if (!GTK_IS_WIDGET(gauge))
return FALSE;
filename = get_file(g_build_filename(GAUGEDESIGNER_GLADE_DIR,"tgroup.ui",NULL),NULL);
if (filename)
{
tgroups = gtk_builder_new();
if(!gtk_builder_add_from_file(tgroups,filename, &error))
{
g_warning ("Couldn't load builder file: %s", error->message);
g_error_free(error);
exit(-1);
}
g_free(filename);
}
else
{
printf("Can't locate primary ui file!!!!\n");
exit(-1);
}
gtk_builder_connect_signals(tgroups,NULL);
dialog = GTK_WIDGET (gtk_builder_get_object(tgroups,"tgroup_dialog"));
gtk_color_button_set_color(GTK_COLOR_BUTTON(gtk_builder_get_object(tgroups,"tg_text_day_colorbutton")),&white);
gtk_color_button_set_color(GTK_COLOR_BUTTON(gtk_builder_get_object(tgroups,"tg_text_nite_colorbutton")),&black);
gtk_color_button_set_color(GTK_COLOR_BUTTON(gtk_builder_get_object(tgroups,"tg_maj_tick_day_colorbutton")),&white);
gtk_color_button_set_color(GTK_COLOR_BUTTON(gtk_builder_get_object(tgroups,"tg_maj_tick_nite_colorbutton")),&black);
gtk_color_button_set_color(GTK_COLOR_BUTTON(gtk_builder_get_object(tgroups,"tg_min_tick_day_colorbutton")),&white);
gtk_color_button_set_color(GTK_COLOR_BUTTON(gtk_builder_get_object(tgroups,"tg_min_tick_nite_colorbutton")),&black);
OBJ_SET((gtk_builder_get_object(tgroups,"tg_start_angle_spin")),"lowpartner",gtk_builder_get_object(tgroups,"tg_lowpoint_spin"));
OBJ_SET((gtk_builder_get_object(tgroups,"tg_start_angle_spin")),"highpartner",gtk_builder_get_object(tgroups,"tg_highpoint_spin"));
OBJ_SET((gtk_builder_get_object(tgroups,"tg_start_angle_spin")),"high_angle",gtk_builder_get_object(tgroups,"tg_sweep_angle_spin"));
OBJ_SET((gtk_builder_get_object(tgroups,"tg_start_angle_spin")),"spin_handler", GINT_TO_POINTER(ADJ_LOW_UNIT_PARTNER));
OBJ_SET((gtk_builder_get_object(tgroups,"tg_sweep_angle_spin")),"highpartner",gtk_builder_get_object(tgroups,"tg_highpoint_spin"));
OBJ_SET((gtk_builder_get_object(tgroups,"tg_sweep_angle_spin")),"low_angle",gtk_builder_get_object(tgroups,"tg_start_angle_spin"));
OBJ_SET((gtk_builder_get_object(tgroups,"tg_sweep_angle_spin")),"spin_handler", GINT_TO_POINTER(ADJ_HIGH_UNIT_PARTNER));
OBJ_SET((gtk_builder_get_object(tgroups,"tg_lowpoint_spin")),"lowpartner",gtk_builder_get_object(tgroups,"tg_start_angle_spin"));
OBJ_SET((gtk_builder_get_object(tgroups,"tg_lowpoint_spin")),"spin_handler", GINT_TO_POINTER(ADJ_START_ANGLE_PARTNER));
OBJ_SET((gtk_builder_get_object(tgroups,"tg_highpoint_spin")),"highpartner",gtk_builder_get_object(tgroups,"tg_sweep_angle_spin"));
OBJ_SET((gtk_builder_get_object(tgroups,"tg_highpoint_spin")),"start_angle",gtk_builder_get_object(tgroups,"tg_start_angle_spin"));
OBJ_SET((gtk_builder_get_object(tgroups,"tg_highpoint_spin")),"spin_handler", GINT_TO_POINTER(ADJ_SWEEP_ANGLE_PARTNER));
if (MTX_IS_GAUGE_FACE(g))
{
mtx_gauge_face_get_attribute(g,START_ANGLE,&tmp1);
mtx_gauge_face_get_attribute(g,SWEEP_ANGLE,&tmp2);
dummy = GTK_WIDGET(gtk_builder_get_object(tgroups,"tg_start_angle_spin"));
gtk_spin_button_set_value(GTK_SPIN_BUTTON(dummy),tmp1);
dummy = GTK_WIDGET(gtk_builder_get_object(tgroups,"tg_sweep_angle_spin"));
gtk_spin_button_set_value(GTK_SPIN_BUTTON(dummy),tmp2);
}
if (!GTK_IS_WIDGET(dialog))
{
return FALSE;
}
result = gtk_dialog_run(GTK_DIALOG(dialog));
switch (result)
{
case GTK_RESPONSE_APPLY:
tgroup = g_new0(MtxTickGroup, 1);
tgroup->font = (gchar *)gtk_font_button_get_font_name (GTK_FONT_BUTTON(gtk_builder_get_object(tgroups,"tg_tick_fontbutton")));
tgroup->font = g_strchomp(g_strdelimit(tgroup->font,"0123456789",' '));
tgroup->text = gtk_editable_get_chars(GTK_EDITABLE(gtk_builder_get_object(tgroups,"tg_tick_textentry")),0,-1);
gtk_color_button_get_color(GTK_COLOR_BUTTON(gtk_builder_get_object(tgroups,"tg_text_day_colorbutton")),&tgroup->text_color[MTX_DAY]);
gtk_color_button_get_color(GTK_COLOR_BUTTON(gtk_builder_get_object(tgroups,"tg_text_nite_colorbutton")),&tgroup->text_color[MTX_NITE]);
tgroup->font_scale = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(tgroups,"tg_font_scale_spin")));
tgroup->text_inset = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(tgroups,"tg_text_inset_spin")));
gtk_color_button_get_color(GTK_COLOR_BUTTON(gtk_builder_get_object(tgroups,"tg_maj_tick_day_colorbutton")),&tgroup->maj_tick_color[MTX_DAY]);
gtk_color_button_get_color(GTK_COLOR_BUTTON(gtk_builder_get_object(tgroups,"tg_maj_tick_nite_colorbutton")),&tgroup->maj_tick_color[MTX_NITE]);
gtk_color_button_get_color(GTK_COLOR_BUTTON(gtk_builder_get_object(tgroups,"tg_min_tick_day_colorbutton")),&tgroup->min_tick_color[MTX_DAY]);
gtk_color_button_get_color(GTK_COLOR_BUTTON(gtk_builder_get_object(tgroups,"tg_min_tick_nite_colorbutton")),&tgroup->min_tick_color[MTX_NITE]);
tgroup->maj_tick_inset = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(tgroups,"tg_maj_tick_inset_spin")));
tgroup->min_tick_inset = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(tgroups,"tg_min_tick_inset_spin")));
tgroup->maj_tick_width = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(tgroups,"tg_maj_tick_width_spin")));
tgroup->min_tick_width = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(tgroups,"tg_min_tick_width_spin")));
tgroup->maj_tick_length = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(tgroups,"tg_maj_tick_length_spin")));
tgroup->min_tick_length = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(tgroups,"tg_min_tick_length_spin")));
tgroup->start_angle = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(tgroups,"tg_start_angle_spin")));
tgroup->sweep_angle = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(tgroups,"tg_sweep_angle_spin")));
tgroup->num_maj_ticks = (gint)gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(tgroups,"tg_num_maj_ticks_spin")));
tgroup->num_min_ticks = (gint)gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(tgroups,"tg_num_min_ticks_spin")));
changed = TRUE;
mtx_gauge_face_set_tick_group_struct(MTX_GAUGE_FACE(gauge),tgroup);
g_free(tgroup->text);
g_free(tgroup);
update_onscreen_tgroups();
break;
default:
break;
}
if (GTK_IS_WIDGET(dialog))
gtk_widget_destroy(dialog);
return (FALSE);
}
uint8_t DIA_ass(ASSParams *param)
{
uint8_t r=0;
GtkWidget *dialog=create_dialog1();
gtk_register_dialog(dialog);
SPIN_SET(spinbuttonScale,font_scale);
SPIN_SET(spinbuttonSpacing,line_spacing);
SPIN_SET(spinbuttonTop,top_margin);
SPIN_SET(spinbuttonBottom,bottom_margin);
if(param->subfile)
{
int r;
char *s=(char *)(param->subfile);
gtk_editable_delete_text(GTK_EDITABLE(WID(entrySub)), 0,-1);
gtk_editable_insert_text(GTK_EDITABLE(WID(entrySub)), s, strlen(s), &r);
}
ASSOCIATE(button1,LOADSUB);
/* Upload */
int x=0,d;
while(!x)
{
d=gtk_dialog_run(GTK_DIALOG(dialog));
switch(d)
{
case LOADSUB:
{
char *name=NULL;
GUI_FileSelRead("Select ASS/SSA file",&name);
if(name)
{
int r;
gtk_editable_delete_text(GTK_EDITABLE(WID(entrySub)), 0,-1);
gtk_editable_insert_text(GTK_EDITABLE(WID(entrySub)), name, strlen(name), &r);
ADM_dealloc(name);
}
}
break;
case GTK_RESPONSE_OK:
case GTK_RESPONSE_APPLY:
{
SPIN_GET(spinbuttonScale,font_scale);
SPIN_GET(spinbuttonSpacing,line_spacing);
SPIN_GETI(spinbuttonTop,top_margin);
SPIN_GETI(spinbuttonBottom,bottom_margin);
char *n;
if(param->subfile)
{
ADM_dealloc(param->subfile);
param->subfile=NULL;
}
n=gtk_editable_get_chars(GTK_EDITABLE (WID(entrySub)), 0, -1);
printf("Name :%s\n",n);
param->subfile=(ADM_filename *)ADM_strdup(n);
r=1;
x=1;
break;
}
default:
r=0;
x=1;
break;
}
}
gtk_unregister_dialog(dialog);
gtk_widget_destroy(dialog);
return r;
}
void
request_command_and_user (GksuContext *context)
{
GtkWidget *dialog;
GtkWidget *hbox;
GtkWidget *lvbox;
GtkWidget *rvbox;
GtkWidget *image;
GtkWidget *label_cmd;
GtkWidget *entry_cmd;
GtkWidget *label_user;
GtkWidget *combo_user;
/* advanced stuff */
GtkWidget *advanced_button;
gint response;
gchar *tmp = NULL;
dialog = gtk_dialog_new_with_buttons (_("Run program"), NULL, 0,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
GTK_STOCK_OK,
GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_has_separator (GTK_DIALOG(dialog), FALSE);
/* horizontal box */
hbox = gtk_hbox_new (FALSE, 4);
gtk_container_set_border_width (GTK_CONTAINER(hbox), 5);
gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
hbox, TRUE, TRUE, 2);
/* left vertical box */
lvbox = gtk_vbox_new (FALSE, 2);
gtk_box_pack_start (GTK_BOX(hbox), lvbox, TRUE, TRUE, 0);
/* command */
label_cmd = gtk_label_new (_("Run:"));
gtk_label_set_justify (GTK_LABEL(label_cmd), GTK_JUSTIFY_LEFT);
gtk_box_pack_start (GTK_BOX(lvbox), label_cmd, TRUE, TRUE, 0);
entry_cmd = gtk_entry_new ();
gtk_signal_connect (GTK_OBJECT(entry_cmd), "activate",
GTK_SIGNAL_FUNC(response_ok_cb),
dialog);
gtk_box_pack_start (GTK_BOX(lvbox), entry_cmd, TRUE, TRUE, 0);
/* user name */
label_user = gtk_label_new (_("As user:"******"/pixmaps/gksu-icon.png");
gtk_box_pack_start (GTK_BOX(rvbox), image, TRUE, TRUE, 0);
/* advanced button */
advanced_button = gtk_button_new_with_mnemonic (_("_Advanced"));
g_signal_connect (G_OBJECT(advanced_button), "clicked",
G_CALLBACK(show_hide_advanced), context);
gtk_box_pack_start (GTK_BOX(rvbox), advanced_button, TRUE, FALSE, 0);
/* let the magic begin! */
gtk_widget_show_all (dialog);
while (TRUE)
{
response = gtk_dialog_run (GTK_DIALOG(dialog));
switch (response)
{
case GTK_RESPONSE_CANCEL:
case GTK_RESPONSE_DELETE_EVENT:
case GTK_RESPONSE_NONE:
exit (0);
}
tmp = gtk_editable_get_chars (GTK_EDITABLE(entry_cmd), 0, -1);
if (tmp)
{
gksu_context_set_command (context, tmp);
g_free (tmp);
}
tmp = gtk_combo_box_get_active_text (GTK_COMBO_BOX(combo_user));
if (tmp)
{
gksu_context_set_user (context, tmp);
g_free (tmp);
}
if (!strcmp (gksu_context_get_user (context), ""))
{
gk_dialog (GTK_MESSAGE_ERROR, _("Missing command to run."));
}
else
{
gtk_widget_destroy (dialog);
break;
}
}
}
static getEndTuple
sxftd_get_end_info(SXFromTransInfo *sxfti)
{
getEndTuple retval;
GtkWidget *w;
retval.type = BAD_END;
g_date_clear( &(retval.end_date), 1 );
retval.n_occurrences = 0;
w = glade_xml_get_widget(sxfti->gxml, SXFTD_NEVER_END_BUTTON);
if (gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(w)))
{
retval.type = NEVER_END;
return retval;
}
w = glade_xml_get_widget(sxfti->gxml, SXFTD_END_ON_DATE_BUTTON);
if (gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(w)))
{
time_t end_tt;
retval.type = END_ON_DATE;
g_date_clear( &(retval.end_date), 1 );
end_tt = gnc_date_edit_get_date(sxfti->endDateGDE);
g_date_set_time_t( &(retval.end_date), end_tt);
return retval;
}
w = glade_xml_get_widget(sxfti->gxml, SXFTD_N_OCCURRENCES_BUTTON);
if (gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(w) ))
{
gchar *text, *endptr;
guint n_occs;
w = glade_xml_get_widget(sxfti->gxml, SXFTD_N_OCCURRENCES_ENTRY);
text = gtk_editable_get_chars(GTK_EDITABLE(w), 0, -1);
if (text == NULL || strlen(text) == 0)
{
n_occs = 0;
}
else
{
n_occs = strtoul(text, &endptr, 10);
if ( !endptr )
{
n_occs = -1;
}
}
g_free(text);
if (n_occs > 0)
{
retval.type = END_AFTER_N_OCCS;
retval.n_occurrences = n_occs;
return retval;
}
}
return retval;
}
static void
search_entry_insert_text (GtkEditable *editable,
const gchar *text,
gint length,
gint *position,
GeditViewFrame *frame)
{
if (frame->priv->search_mode == GOTO_LINE)
{
gunichar c;
const gchar *p;
const gchar *end;
const gchar *next;
p = text;
end = text + length;
if (p == end)
return;
c = g_utf8_get_char (p);
if (((c == '-' || c == '+') && *position == 0) ||
(c == ':' && *position != 0))
{
gchar *s = NULL;
if (c == ':')
{
s = gtk_editable_get_chars (editable, 0, -1);
s = g_utf8_strchr (s, -1, ':');
}
if (s == NULL || s == p)
{
next = g_utf8_next_char (p);
p = next;
}
g_free (s);
}
while (p != end)
{
next = g_utf8_next_char (p);
c = g_utf8_get_char (p);
if (!g_unichar_isdigit (c))
{
g_signal_stop_emission_by_name (editable, "insert_text");
gtk_widget_error_bell (frame->priv->search_entry);
break;
}
p = next;
}
}
else
{
/* SEARCH mode */
static gboolean insert_text = FALSE;
gchar *escaped_text;
gint new_len;
gedit_debug_message (DEBUG_SEARCH, "Text: %s", text);
/* To avoid recursive behavior */
if (insert_text)
return;
escaped_text = gedit_utils_escape_search_text (text);
gedit_debug_message (DEBUG_SEARCH, "Escaped Text: %s", escaped_text);
new_len = strlen (escaped_text);
if (new_len == length)
{
g_free (escaped_text);
return;
}
insert_text = TRUE;
g_signal_stop_emission_by_name (editable, "insert_text");
gtk_editable_insert_text (editable, escaped_text, new_len, position);
insert_text = FALSE;
g_free (escaped_text);
}
}
