minecraft-pi-reborn
/
zenity
1
0
Fork 0
Code Pull Requests Activity

Fix style 

Fixing style in all zenity code, removing useless spaces,
empty lines, all code in 80 columns, etc.
This commit is contained in:
Arx Cruz 2017-04-07 14:00:42 +02:00
parent 8c5e60de83
commit 4eddb202ca
19 changed files with 5273 additions and 5363 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

153
src/about.c
View File

@ -25,10 +25,10 @@
*/
#include "config.h"
#include "zenity.h"
#include "util.h"
#include <string.h>
#include "zenity.h"
#include <gdk/gdkkeysyms.h>
#include <string.h>
#define GTK_RESPONSE_CREDITS 0
#define ZENITY_HELP_PATH ZENITY_DATADIR "/help/"
@ -39,39 +39,38 @@
static GtkWidget *dialog;
static void zenity_about_dialog_response (GtkWidget *widget, int response, gpointer data);
static void zenity_about_dialog_response (
GtkWidget *widget, int response, gpointer data);
/* Sync with the people in the THANKS file */
static const gchar *const authors[] = {
"Glynn Foster <glynn foster sun com>",
"Lucas Rocha <lucasr gnome org>",
"Mike Newman <mikegtn gnome org>",
NULL
};
static const gchar *const authors[] = {"Glynn Foster <glynn foster sun com>",
"Lucas Rocha <lucasr gnome org>",
"Mike Newman <mikegtn gnome org>",
NULL};
static const char *documenters[] = {
"Glynn Foster <glynn.foster@sun.com>",
"Lucas Rocha <lucasr@gnome.org>",
"Java Desktop System Documentation Team",
"GNOME Documentation Project",
NULL
};
static const char *documenters[] = {"Glynn Foster <glynn.foster@sun.com>",
"Lucas Rocha <lucasr@gnome.org>",
"Java Desktop System Documentation Team",
"GNOME Documentation Project",
NULL};
static gchar *translators;
static const char *license[] = {
N_("This program is free software; you can redistribute it and/or modify "
"it under the terms of the GNU Lesser General Public License as published by "
"the Free Software Foundation; either version 2 of the License, or "
"(at your option) any later version.\n"),
N_("This program is distributed in the hope that it will be useful, "
"but WITHOUT ANY WARRANTY; without even the implied warranty of "
"MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the "
"GNU Lesser General Public License for more details.\n"),
N_("You should have received a copy of the GNU Lesser General Public License "
"along with this program; if not, write to the Free Software "
"Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.")
};
N_ ("This program is free software; you can redistribute it and/or modify "
"it under the terms of the GNU Lesser General Public License as "
"published by "
"the Free Software Foundation; either version 2 of the License, or "
"(at your option) any later version.\n"),
N_ ("This program is distributed in the hope that it will be useful, "
"but WITHOUT ANY WARRANTY; without even the implied warranty of "
"MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the "
"GNU Lesser General Public License for more details.\n"),
N_ ("You should have received a copy of the GNU Lesser General Public "
"License "
"along with this program; if not, write to the Free Software "
"Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA "
"02110-1301, USA.")};
#if 0
static gint
@ -253,66 +252,78 @@ zenity_zen_wisdom (GtkDialog *dialog, GdkEventKey *event, gpointer user_data)
}
#endif
void
zenity_about (ZenityData *data)
{
GdkPixbuf *logo;
char *license_trans;
void
zenity_about (ZenityData *data) {
GdkPixbuf *logo;
char *license_trans;
translators = _ ("translator-credits");
logo =
gdk_pixbuf_new_from_file (ZENITY_IMAGE_FULLPATH ("zenity.png"), NULL);
translators = _("translator-credits");
logo = gdk_pixbuf_new_from_file (ZENITY_IMAGE_FULLPATH ("zenity.png"), NULL);
license_trans = g_strconcat (
_ (license[0]), "\n", _ (license[1]), "\n", _ (license[2]), "\n", NULL);
license_trans = g_strconcat (_(license[0]), "\n", _(license[1]), "\n",
_(license[2]), "\n", NULL);
dialog = gtk_about_dialog_new ();
dialog = gtk_about_dialog_new ();
g_object_set (G_OBJECT (dialog),
"name", "Zenity",
"version", VERSION,
"copyright", "Copyright \xc2\xa9 2003 Sun Microsystems",
"comments", _("Display dialog boxes from shell scripts"),
"authors", authors,
"documenters", documenters,
"translator-credits", translators,
"website", "http://live.gnome.org/Zenity",
"logo", logo,
"wrap-license", TRUE,
"license", license_trans,
g_object_set (G_OBJECT (dialog),
"name",
"Zenity",
"version",
VERSION,
"copyright",
"Copyright \xc2\xa9 2003 Sun Microsystems",
"comments",
_ ("Display dialog boxes from shell scripts"),
"authors",
authors,
"documenters",
documenters,
"translator-credits",
translators,
"website",
"http://live.gnome.org/Zenity",
"logo",
logo,
"wrap-license",
TRUE,
"license",
license_trans,
NULL);
g_free (license_trans);
zenity_util_set_window_icon (dialog, NULL, ZENITY_IMAGE_FULLPATH ("zenity.png"));
g_free (license_trans);
g_signal_connect (G_OBJECT (dialog), "response",
G_CALLBACK (zenity_about_dialog_response), data);
zenity_util_set_window_icon (
dialog, NULL, ZENITY_IMAGE_FULLPATH ("zenity.png"));
g_signal_connect (G_OBJECT (dialog),
"response",
G_CALLBACK (zenity_about_dialog_response),
data);
#if 0
g_signal_connect (G_OBJECT (dialog), "key_press_event",
G_CALLBACK (zenity_zen_wisdom), NULL);
#endif
zenity_util_show_dialog (dialog, data->attach);
gtk_main ();
zenity_util_show_dialog (dialog, data->attach);
gtk_main ();
}
static void
zenity_about_dialog_response (GtkWidget *widget, int response, gpointer data)
{
ZenityData *zen_data = data;
zenity_about_dialog_response (GtkWidget *widget, int response, gpointer data) {
ZenityData *zen_data = data;
switch (response) {
case GTK_RESPONSE_CLOSE:
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_OK);
break;
switch (response) {
case GTK_RESPONSE_CLOSE:
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_OK);
break;
default:
/* Esc dialog */
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_ESC);
break;
}
default:
/* Esc dialog */
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_ESC);
break;
}
gtk_main_quit ();
gtk_main_quit ();
}

220
src/calendar.c
View File

@ -23,146 +23,158 @@
#include "config.h"
#include <time.h>
#include "zenity.h"
#include "util.h"
#include "zenity.h"
#include <time.h>
static GtkWidget *calendar;
static ZenityCalendarData *zen_cal_data;
static void zenity_calendar_dialog_response (GtkWidget *widget, int response, gpointer data);
static void zenity_calendar_dialog_response (
GtkWidget *widget, int response, gpointer data);
static void zenity_calendar_double_click (GtkCalendar *calendar, gpointer data);
void
zenity_calendar (ZenityData *data, ZenityCalendarData *cal_data)
{
GtkBuilder *builder;
GtkWidget *dialog;
GtkWidget *button;
GObject *text;
void
zenity_calendar (ZenityData *data, ZenityCalendarData *cal_data) {
GtkBuilder *builder;
GtkWidget *dialog;
GtkWidget *button;
GObject *text;
zen_cal_data = cal_data;
zen_cal_data = cal_data;
builder = zenity_util_load_ui_file ("zenity_calendar_dialog", NULL);
builder = zenity_util_load_ui_file ("zenity_calendar_dialog", NULL);
if (builder == NULL) {
data->exit_code = zenity_util_return_exit_code (ZENITY_ERROR);
return;
}
gtk_builder_connect_signals (builder, NULL);
if (builder == NULL) {
data->exit_code = zenity_util_return_exit_code (ZENITY_ERROR);
return;
}
dialog = GTK_WIDGET (gtk_builder_get_object (builder,
"zenity_calendar_dialog"));
gtk_builder_connect_signals (builder, NULL);
g_signal_connect (G_OBJECT (dialog), "response",
G_CALLBACK (zenity_calendar_dialog_response), data);
dialog =
GTK_WIDGET (gtk_builder_get_object (builder, "zenity_calendar_dialog"));
if (data->dialog_title)
gtk_window_set_title (GTK_WINDOW (dialog), data->dialog_title);
g_signal_connect (G_OBJECT (dialog),
"response",
G_CALLBACK (zenity_calendar_dialog_response),
data);
zenity_util_set_window_icon (dialog, data->window_icon, ZENITY_IMAGE_FULLPATH ("zenity-calendar.png"));
if (data->dialog_title)
gtk_window_set_title (GTK_WINDOW (dialog), data->dialog_title);
if (data->width > -1 || data->height > -1)
gtk_window_set_default_size (GTK_WINDOW (dialog), data->width, data->height);
zenity_util_set_window_icon (dialog,
data->window_icon,
ZENITY_IMAGE_FULLPATH ("zenity-calendar.png"));
if (data->modal)
gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
if (data->width > -1 || data->height > -1)
gtk_window_set_default_size (
GTK_WINDOW (dialog), data->width, data->height);
text = gtk_builder_get_object (builder, "zenity_calendar_text");
if (data->modal)
gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
if (cal_data->dialog_text)
gtk_label_set_markup (GTK_LABEL (text), g_strcompress (cal_data->dialog_text));
text = gtk_builder_get_object (builder, "zenity_calendar_text");
calendar = GTK_WIDGET (gtk_builder_get_object (builder, "zenity_calendar"));
if (cal_data->month > 0 || cal_data->year > 0)
gtk_calendar_select_month (GTK_CALENDAR (calendar), cal_data->month - 1, cal_data->year);
if (cal_data->day > 0)
gtk_calendar_select_day (GTK_CALENDAR (calendar), cal_data->day);
if (cal_data->dialog_text)
gtk_label_set_markup (
GTK_LABEL (text), g_strcompress (cal_data->dialog_text));
g_signal_connect (calendar, "day-selected-double-click",
G_CALLBACK (zenity_calendar_double_click), data);
calendar = GTK_WIDGET (gtk_builder_get_object (builder, "zenity_calendar"));
gtk_label_set_mnemonic_widget (GTK_LABEL (text), calendar);
zenity_util_show_dialog (dialog, data->attach);
if (cal_data->month > 0 || cal_data->year > 0)
gtk_calendar_select_month (
GTK_CALENDAR (calendar), cal_data->month - 1, cal_data->year);
if (cal_data->day > 0)
gtk_calendar_select_day (GTK_CALENDAR (calendar), cal_data->day);
if (data->timeout_delay > 0) {
g_timeout_add_seconds (data->timeout_delay, (GSourceFunc) zenity_util_timeout_handle, dialog);
}
if (data->extra_label) {
gint i=0;
while(data->extra_label[i]!=NULL){
gtk_dialog_add_button (GTK_DIALOG (dialog), data->extra_label[i], i);
i++;
}
}
if (data->ok_label) {
button = GTK_WIDGET (gtk_builder_get_object (builder, "zenity_calendar_ok_button"));
gtk_button_set_label (GTK_BUTTON (button), data->ok_label);
}
g_signal_connect (calendar,
"day-selected-double-click",
G_CALLBACK (zenity_calendar_double_click),
data);
if (data->cancel_label) {
button = GTK_WIDGET (gtk_builder_get_object (builder, "zenity_calendar_cancel_button"));
gtk_button_set_label (GTK_BUTTON (button), data->cancel_label);
}
gtk_label_set_mnemonic_widget (GTK_LABEL (text), calendar);
zenity_util_show_dialog (dialog, data->attach);
g_object_unref (builder);
if (data->timeout_delay > 0) {
g_timeout_add_seconds (data->timeout_delay,
(GSourceFunc) zenity_util_timeout_handle,
dialog);
}
gtk_main ();
if (data->extra_label) {
gint i = 0;
while (data->extra_label[i] != NULL) {
gtk_dialog_add_button (
GTK_DIALOG (dialog), data->extra_label[i], i);
i++;
}
}
if (data->ok_label) {
button = GTK_WIDGET (
gtk_builder_get_object (builder, "zenity_calendar_ok_button"));
gtk_button_set_label (GTK_BUTTON (button), data->ok_label);
}
if (data->cancel_label) {
button = GTK_WIDGET (
gtk_builder_get_object (builder, "zenity_calendar_cancel_button"));
gtk_button_set_label (GTK_BUTTON (button), data->cancel_label);
}
g_object_unref (builder);
gtk_main ();
}
static void
zenity_calendar_dialog_output (void)
{
guint day, month, year;
gchar time_string[128];
GDate *date = NULL;
gtk_calendar_get_date (GTK_CALENDAR (calendar), &day, &month, &year);
date = g_date_new_dmy (year, month + 1, day);
g_date_strftime (time_string, 127, zen_cal_data->date_format, date);
g_print ("%s\n", time_string);
static void
zenity_calendar_dialog_output (void) {
guint day, month, year;
gchar time_string[128];
GDate *date = NULL;
if (date != NULL)
g_date_free (date);
gtk_calendar_get_date (GTK_CALENDAR (calendar), &day, &month, &year);
date = g_date_new_dmy (year, month + 1, day);
g_date_strftime (time_string, 127, zen_cal_data->date_format, date);
g_print ("%s\n", time_string);
if (date != NULL)
g_date_free (date);
}
static void
zenity_calendar_dialog_response (GtkWidget *widget, int response, gpointer data)
{
ZenityData *zen_data;
zenity_calendar_dialog_response (
GtkWidget *widget, int response, gpointer data) {
ZenityData *zen_data;
zen_data = data;
zen_data = data;
switch (response) {
case GTK_RESPONSE_OK:
zenity_calendar_dialog_output ();
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_OK);
break;
switch (response) {
case GTK_RESPONSE_OK:
zenity_calendar_dialog_output ();
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_OK);
break;
case GTK_RESPONSE_CANCEL:
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_CANCEL);
break;
case GTK_RESPONSE_CANCEL:
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_CANCEL);
break;
case ZENITY_TIMEOUT:
zenity_calendar_dialog_output ();
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_TIMEOUT);
break;
case ZENITY_TIMEOUT:
zenity_calendar_dialog_output ();
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_TIMEOUT);
break;
default:
if (zen_data->extra_label && response < g_strv_length(zen_data->extra_label))
printf("%s\n",zen_data->extra_label[response]);
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_ESC);
break;
}
gtk_main_quit ();
default:
if (zen_data->extra_label &&
response < g_strv_length (zen_data->extra_label))
printf ("%s\n", zen_data->extra_label[response]);
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_ESC);
break;
}
gtk_main_quit ();
}
static void
zenity_calendar_double_click (GtkCalendar *cal, gpointer data)
{
zenity_calendar_dialog_response (NULL, GTK_RESPONSE_OK, data);
zenity_calendar_double_click (GtkCalendar *cal, gpointer data) {
zenity_calendar_dialog_response (NULL, GTK_RESPONSE_OK, data);
}

132
src/color.c
View File

@ -23,92 +23,96 @@
#include "config.h"
#include <string.h>
#include "zenity.h"
#include "util.h"
#include "zenity.h"
#include <string.h>
static ZenityData *zen_data;
static void zenity_colorselection_dialog_response (GtkWidget *widget, int response, gpointer data);
static void zenity_colorselection_dialog_response (
GtkWidget *widget, int response, gpointer data);
void zenity_colorselection (ZenityData *data, ZenityColorData *color_data)
{
GtkWidget *dialog;
GtkWidget *button;
GdkRGBA color;
void
zenity_colorselection (ZenityData *data, ZenityColorData *color_data) {
GtkWidget *dialog;
GtkWidget *button;
GdkRGBA color;
zen_data = data;
zen_data = data;
dialog = gtk_color_chooser_dialog_new (data->dialog_title, NULL);
dialog = gtk_color_chooser_dialog_new (data->dialog_title, NULL);
g_signal_connect (G_OBJECT (dialog), "response",
G_CALLBACK (zenity_colorselection_dialog_response),
color_data);
g_signal_connect (G_OBJECT (dialog),
"response",
G_CALLBACK (zenity_colorselection_dialog_response),
color_data);
if (color_data->color) {
if (gdk_rgba_parse (&color, color_data->color)) {
gtk_color_chooser_set_rgba (GTK_COLOR_CHOOSER (dialog), &color);
}
}
if (color_data->color) {
if (gdk_rgba_parse (&color, color_data->color)) {
gtk_color_chooser_set_rgba (GTK_COLOR_CHOOSER (dialog), &color);
}
}
if (data->extra_label) {
gint i=0;
while(data->extra_label[i]!=NULL){
gtk_dialog_add_button (GTK_DIALOG (dialog), data->extra_label[i], i);
i++;
}
}
if (data->extra_label) {
gint i = 0;
while (data->extra_label[i] != NULL) {
gtk_dialog_add_button (
GTK_DIALOG (dialog), data->extra_label[i], i);
i++;
}
}
if (data->ok_label) {
g_object_get (G_OBJECT (dialog), "ok-button", &button, NULL);
gtk_button_set_label (GTK_BUTTON (button), data->ok_label);
g_object_unref (G_OBJECT (button));
}
if (data->ok_label) {
g_object_get (G_OBJECT (dialog), "ok-button", &button, NULL);
gtk_button_set_label (GTK_BUTTON (button), data->ok_label);
g_object_unref (G_OBJECT (button));
}
if (data->cancel_label) {
g_object_get (G_OBJECT (dialog), "cancel-button", &button, NULL);
gtk_button_set_label (GTK_BUTTON (button), data->cancel_label);
g_object_unref (G_OBJECT (button));
}
if (data->cancel_label) {
g_object_get (G_OBJECT (dialog), "cancel-button", &button, NULL);
gtk_button_set_label (GTK_BUTTON (button), data->cancel_label);
g_object_unref (G_OBJECT (button));
}
if (data->modal)
gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
if (data->modal)
gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
g_object_set (dialog, "show-editor", !color_data->show_palette, NULL);
g_object_set (dialog, "show-editor", !color_data->show_palette, NULL);
zenity_util_show_dialog (dialog, data->attach);
zenity_util_show_dialog (dialog, data->attach);
if (data->timeout_delay > 0) {
g_timeout_add_seconds (data->timeout_delay,
(GSourceFunc) zenity_util_timeout_handle,
dialog);
}
if (data->timeout_delay > 0) {
g_timeout_add_seconds (data->timeout_delay,
(GSourceFunc) zenity_util_timeout_handle,
dialog);
}
gtk_main();
gtk_main ();
}
static void
zenity_colorselection_dialog_response (GtkWidget *widget, int response, gpointer data)
{
GdkRGBA color;
zenity_colorselection_dialog_response (
GtkWidget *widget, int response, gpointer data) {
GdkRGBA color;
switch (response) {
case GTK_RESPONSE_OK:
zenity_util_exit_code_with_data(ZENITY_OK, zen_data);
gtk_color_chooser_get_rgba (GTK_COLOR_CHOOSER (widget), &color);
g_print ("%s\n", gdk_rgba_to_string (&color));
break;
switch (response) {
case GTK_RESPONSE_OK:
zenity_util_exit_code_with_data (ZENITY_OK, zen_data);
gtk_color_chooser_get_rgba (GTK_COLOR_CHOOSER (widget), &color);
g_print ("%s\n", gdk_rgba_to_string (&color));
break;
case GTK_RESPONSE_CANCEL:
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_CANCEL);
break;
case GTK_RESPONSE_CANCEL:
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_CANCEL);
break;
default:
if (zen_data->extra_label && response < g_strv_length(zen_data->extra_label))
printf("%s\n",zen_data->extra_label[response]);
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_ESC);
break;
}
default:
if (zen_data->extra_label &&
response < g_strv_length (zen_data->extra_label))
printf ("%s\n", zen_data->extra_label[response]);
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_ESC);
break;
}
gtk_main_quit ();
gtk_main_quit ();
}

268
src/entry.c
View File

@ -23,179 +23,189 @@
#include "config.h"
#include "zenity.h"
#include "util.h"
#include "zenity.h"
static void zenity_entry_dialog_response (GtkWidget *widget, int response, gpointer data);
static void zenity_entry_dialog_response (
GtkWidget *widget, int response, gpointer data);
static GtkWidget *entry;
static gint n_entries = 0;
static void
zenity_entry_fill_entries (GSList **entries, const gchar **args)
{
gint i = 0;
zenity_entry_fill_entries (GSList **entries, const gchar **args) {
gint i = 0;
while (args[i] != NULL) {
*entries = g_slist_append (*entries, (gchar *) args[i]);
i++;
}
while (args[i] != NULL) {
*entries = g_slist_append (*entries, (gchar *) args[i]);
i++;
}
}
static void
zenity_entry_combo_activate_default (GtkEntry *entry, gpointer window)
{
gtk_window_activate_default (GTK_WINDOW (window));
zenity_entry_combo_activate_default (GtkEntry *entry, gpointer window) {
gtk_window_activate_default (GTK_WINDOW (window));
}
void
zenity_entry (ZenityData *data, ZenityEntryData *entry_data)
{
GtkBuilder *builder = NULL;
GtkWidget *dialog;
GtkWidget *button;
GObject *text;
GSList *entries = NULL;
GSList *tmp;
GObject *vbox;
builder = zenity_util_load_ui_file ("zenity_entry_dialog", NULL);
void
zenity_entry (ZenityData *data, ZenityEntryData *entry_data) {
GtkBuilder *builder = NULL;
GtkWidget *dialog;
GtkWidget *button;
GObject *text;
GSList *entries = NULL;
GSList *tmp;
GObject *vbox;
if (builder == NULL) {
data->exit_code = zenity_util_return_exit_code (ZENITY_ERROR);
return;
}
gtk_builder_connect_signals (builder, NULL);
dialog = GTK_WIDGET (gtk_builder_get_object (builder, "zenity_entry_dialog"));
g_signal_connect (G_OBJECT (dialog), "response",
G_CALLBACK (zenity_entry_dialog_response), data);
builder = zenity_util_load_ui_file ("zenity_entry_dialog", NULL);
if (data->dialog_title)
gtk_window_set_title (GTK_WINDOW (dialog), data->dialog_title);
zenity_util_set_window_icon (dialog, data->window_icon, ZENITY_IMAGE_FULLPATH ("zenity-entry.png"));
if (builder == NULL) {
data->exit_code = zenity_util_return_exit_code (ZENITY_ERROR);
return;
}
if (data->width > -1 || data->height > -1)
gtk_window_set_default_size (GTK_WINDOW (dialog), data->width, data->height);
gtk_builder_connect_signals (builder, NULL);
if (data->modal)
gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
dialog =
GTK_WIDGET (gtk_builder_get_object (builder, "zenity_entry_dialog"));
if (data->extra_label) {
gint i=0;
while(data->extra_label[i]!=NULL){
gtk_dialog_add_button (GTK_DIALOG (dialog), data->extra_label[i], i);
i++;
}
}
g_signal_connect (G_OBJECT (dialog),
"response",
G_CALLBACK (zenity_entry_dialog_response),
data);
if (data->ok_label) {
button = GTK_WIDGET (gtk_builder_get_object (builder, "zenity_entry_ok_button"));
gtk_button_set_label (GTK_BUTTON (button), data->ok_label);
}
if (data->dialog_title)
gtk_window_set_title (GTK_WINDOW (dialog), data->dialog_title);
if (data->cancel_label) {
button = GTK_WIDGET (gtk_builder_get_object (builder, "zenity_entry_cancel_button"));
gtk_button_set_label (GTK_BUTTON (button), data->cancel_label);
}
zenity_util_set_window_icon (
dialog, data->window_icon, ZENITY_IMAGE_FULLPATH ("zenity-entry.png"));
text = gtk_builder_get_object (builder, "zenity_entry_text");
if (data->width > -1 || data->height > -1)
gtk_window_set_default_size (
GTK_WINDOW (dialog), data->width, data->height);
if (entry_data->dialog_text)
gtk_label_set_text_with_mnemonic (GTK_LABEL (text), g_strcompress (entry_data->dialog_text));
vbox = gtk_builder_get_object (builder, "vbox4");
zenity_entry_fill_entries(&entries, entry_data->data);
n_entries = g_slist_length (entries);
if (data->modal)
gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
if (n_entries > 1) {
entry = gtk_combo_box_text_new_with_entry ();
if (data->extra_label) {
gint i = 0;
while (data->extra_label[i] != NULL) {
gtk_dialog_add_button (
GTK_DIALOG (dialog), data->extra_label[i], i);
i++;
}
}
for (tmp = entries; tmp; tmp = tmp->next) {
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (entry), tmp->data);
}
if (data->ok_label) {
button = GTK_WIDGET (
gtk_builder_get_object (builder, "zenity_entry_ok_button"));
gtk_button_set_label (GTK_BUTTON (button), data->ok_label);
}
if (entry_data->entry_text) {
gtk_combo_box_text_prepend_text (GTK_COMBO_BOX_TEXT (entry), entry_data->entry_text);
gtk_combo_box_set_active (GTK_COMBO_BOX (entry), 0);
}
if (data->cancel_label) {
button = GTK_WIDGET (
gtk_builder_get_object (builder, "zenity_entry_cancel_button"));
gtk_button_set_label (GTK_BUTTON (button), data->cancel_label);
}
g_signal_connect (gtk_bin_get_child (GTK_BIN (entry)), "activate",
G_CALLBACK (zenity_entry_combo_activate_default),
GTK_WINDOW (dialog));
} else {
entry = gtk_entry_new();
text = gtk_builder_get_object (builder, "zenity_entry_text");
gtk_entry_set_activates_default (GTK_ENTRY (entry), TRUE);
if (entry_data->entry_text)
gtk_entry_set_text (GTK_ENTRY (entry), entry_data->entry_text);
if (entry_data->dialog_text)
gtk_label_set_text_with_mnemonic (
GTK_LABEL (text), g_strcompress (entry_data->dialog_text));
if (entry_data->hide_text)
g_object_set (G_OBJECT (entry), "visibility", FALSE, NULL);
}
vbox = gtk_builder_get_object (builder, "vbox4");
gtk_widget_show (entry);
zenity_entry_fill_entries (&entries, entry_data->data);
gtk_box_pack_end (GTK_BOX (vbox), entry, FALSE, FALSE, 0);
n_entries = g_slist_length (entries);
gtk_label_set_mnemonic_widget (GTK_LABEL (text), entry);
if (n_entries > 1) {
entry = gtk_combo_box_text_new_with_entry ();
g_object_unref (builder);
for (tmp = entries; tmp; tmp = tmp->next) {
gtk_combo_box_text_append_text (
GTK_COMBO_BOX_TEXT (entry), tmp->data);
}
zenity_util_show_dialog (dialog, data->attach);
if (entry_data->entry_text) {
gtk_combo_box_text_prepend_text (
GTK_COMBO_BOX_TEXT (entry), entry_data->entry_text);
gtk_combo_box_set_active (GTK_COMBO_BOX (entry), 0);
}
if(data->timeout_delay > 0) {
g_timeout_add_seconds (data->timeout_delay, (GSourceFunc) zenity_util_timeout_handle, dialog);
}
g_signal_connect (gtk_bin_get_child (GTK_BIN (entry)),
"activate",
G_CALLBACK (zenity_entry_combo_activate_default),
GTK_WINDOW (dialog));
} else {
entry = gtk_entry_new ();
gtk_main ();
gtk_entry_set_activates_default (GTK_ENTRY (entry), TRUE);
if (entry_data->entry_text)
gtk_entry_set_text (GTK_ENTRY (entry), entry_data->entry_text);
if (entry_data->hide_text)
g_object_set (G_OBJECT (entry), "visibility", FALSE, NULL);
}
gtk_widget_show (entry);
gtk_box_pack_end (GTK_BOX (vbox), entry, FALSE, FALSE, 0);
gtk_label_set_mnemonic_widget (GTK_LABEL (text), entry);
g_object_unref (builder);
zenity_util_show_dialog (dialog, data->attach);
if (data->timeout_delay > 0) {
g_timeout_add_seconds (data->timeout_delay,
(GSourceFunc) zenity_util_timeout_handle,
dialog);
}
gtk_main ();
}
static void
zenity_entry_dialog_output (void)
{
const gchar *text;
if (n_entries > 1)
text = gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT (entry));
else
text = gtk_entry_get_text (GTK_ENTRY (entry));
if (text != NULL)
g_print ("%s\n", text);
zenity_entry_dialog_output (void) {
const gchar *text;
if (n_entries > 1)
text = gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT (entry));
else
text = gtk_entry_get_text (GTK_ENTRY (entry));
if (text != NULL)
g_print ("%s\n", text);
}
static void
zenity_entry_dialog_response (GtkWidget *widget, int response, gpointer data)
{
ZenityData *zen_data = data;
zenity_entry_dialog_response (GtkWidget *widget, int response, gpointer data) {
ZenityData *zen_data = data;
switch (response) {
case GTK_RESPONSE_OK:
zenity_entry_dialog_output ();
zenity_util_exit_code_with_data(ZENITY_OK, zen_data);
break;
switch (response) {
case GTK_RESPONSE_OK:
zenity_entry_dialog_output ();
zenity_util_exit_code_with_data (ZENITY_OK, zen_data);
break;
case GTK_RESPONSE_CANCEL:
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_CANCEL);
break;
case GTK_RESPONSE_CANCEL:
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_CANCEL);
break;
case ZENITY_TIMEOUT:
zenity_entry_dialog_output ();
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_TIMEOUT);
break;
case ZENITY_TIMEOUT:
zenity_entry_dialog_output ();
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_TIMEOUT);
break;
default:
if (zen_data->extra_label && response < g_strv_length(zen_data->extra_label))
printf("%s\n",zen_data->extra_label[response]);
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_ESC);
break;
}
gtk_main_quit ();
default:
if (zen_data->extra_label &&
response < g_strv_length (zen_data->extra_label))
printf ("%s\n", zen_data->extra_label[response]);
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_ESC);
break;
}
gtk_main_quit ();
}

282
src/fileselection.c
View File

@ -23,176 +23,192 @@
#include "config.h"
#include <string.h>
#include "zenity.h"
#include "util.h"
#include "zenity.h"
#include <string.h>
static ZenityData *zen_data;
static ZenityData *zen_data;
static void zenity_fileselection_dialog_response (GtkWidget *widget, int response, gpointer data);
static void zenity_fileselection_dialog_response (
GtkWidget *widget, int response, gpointer data);
void zenity_fileselection (ZenityData *data, ZenityFileData *file_data)
{
GtkWidget *dialog;
gchar *dir;
gchar *basename;
GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_OPEN;
void
zenity_fileselection (ZenityData *data, ZenityFileData *file_data) {
GtkWidget *dialog;
gchar *dir;
gchar *basename;
GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_OPEN;
zen_data = data;
zen_data = data;
if (file_data->directory) {
if (file_data->save)
action = GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER;
else
action = GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER;
} else {
if (file_data->save)
action = GTK_FILE_CHOOSER_ACTION_SAVE;
}
if (file_data->directory) {
if (file_data->save)
action = GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER;
else
action = GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER;
} else {
if (file_data->save)
action = GTK_FILE_CHOOSER_ACTION_SAVE;
}
dialog = gtk_file_chooser_dialog_new (NULL, NULL,
action,
_("_Cancel"), GTK_RESPONSE_CANCEL,
_("_OK"), GTK_RESPONSE_OK,
NULL);
dialog = gtk_file_chooser_dialog_new (NULL,
NULL,
action,
_ ("_Cancel"),
GTK_RESPONSE_CANCEL,
_ ("_OK"),
GTK_RESPONSE_OK,
NULL);
gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog),
file_data->confirm_overwrite);
gtk_file_chooser_set_do_overwrite_confirmation (
GTK_FILE_CHOOSER (dialog), file_data->confirm_overwrite);
g_signal_connect (G_OBJECT (dialog), "response",
G_CALLBACK (zenity_fileselection_dialog_response), file_data);
g_signal_connect (G_OBJECT (dialog),
"response",
G_CALLBACK (zenity_fileselection_dialog_response),
file_data);
if (data->extra_label) {
gint i=0;
while(data->extra_label[i]!=NULL){
gtk_dialog_add_button (GTK_DIALOG (dialog), data->extra_label[i], i);
i++;
}
}
if (data->extra_label) {
gint i = 0;
while (data->extra_label[i] != NULL) {
gtk_dialog_add_button (
GTK_DIALOG (dialog), data->extra_label[i], i);
i++;
}
}
if (data->dialog_title)
gtk_window_set_title (GTK_WINDOW (dialog), data->dialog_title);
zenity_util_set_window_icon (dialog, data->window_icon, ZENITY_IMAGE_FULLPATH ("zenity-file.png"));
if (data->dialog_title)
gtk_window_set_title (GTK_WINDOW (dialog), data->dialog_title);
if (data->modal)
gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
zenity_util_set_window_icon (
dialog, data->window_icon, ZENITY_IMAGE_FULLPATH ("zenity-file.png"));
if (file_data->uri) {
dir = g_path_get_dirname (file_data->uri);
if (data->modal)
gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
if (g_path_is_absolute (file_data->uri) == TRUE)
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), dir);
if (file_data->uri) {
dir = g_path_get_dirname (file_data->uri);
if (file_data->uri[strlen (file_data->uri) - 1] != '/') {
basename = g_path_get_basename (file_data->uri);
if (file_data->save)
gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog), basename);
else
(void) gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (dialog), file_data->uri);
g_free (basename);
}
g_free (dir);
}
if (g_path_is_absolute (file_data->uri) == TRUE)
gtk_file_chooser_set_current_folder (
GTK_FILE_CHOOSER (dialog), dir);
if (file_data->multi)
gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (dialog), TRUE);
if (file_data->uri[strlen (file_data->uri) - 1] != '/') {
basename = g_path_get_basename (file_data->uri);
if (file_data->save)
gtk_file_chooser_set_current_name (
GTK_FILE_CHOOSER (dialog), basename);
else
(void) gtk_file_chooser_set_filename (
GTK_FILE_CHOOSER (dialog), file_data->uri);
g_free (basename);
}
g_free (dir);
}
if (file_data->filter) {
/* Filter format: Executables | *.exe *.bat *.com */
gint filter_i;
if (file_data->multi)
gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (dialog), TRUE);
for (filter_i = 0; file_data->filter [filter_i]; filter_i++) {
GtkFileFilter *filter = gtk_file_filter_new();
gchar *filter_str = file_data->filter [filter_i];
gchar **pattern, **patterns;
gchar *name = NULL;
gint i;
if (file_data->filter) {
/* Filter format: Executables | *.exe *.bat *.com */
gint filter_i;
/* Set name */
for (i = 0; filter_str[i] != '\0'; i++)
if (filter_str[i] == '|')
break;
for (filter_i = 0; file_data->filter[filter_i]; filter_i++) {
GtkFileFilter *filter = gtk_file_filter_new ();
gchar *filter_str = file_data->filter[filter_i];
gchar **pattern, **patterns;
gchar *name = NULL;
gint i;
if (filter_str[i] == '|') {
name = g_strndup (filter_str, i);
g_strstrip (name);
}
/* Set name */
for (i = 0; filter_str[i] != '\0'; i++)
if (filter_str[i] == '|')
break;
if (name) {
gtk_file_filter_set_name (filter, name);
if (filter_str[i] == '|') {
name = g_strndup (filter_str, i);
g_strstrip (name);
}
/* Point i to the right position for split */
for (++i; filter_str[i] == ' '; i++);
} else {
gtk_file_filter_set_name (filter, filter_str);
i = 0;
}
if (name) {
gtk_file_filter_set_name (filter, name);
/* Get patterns */
patterns = g_strsplit_set (filter_str + i, " ", -1);
/* Point i to the right position for split */
for (++i; filter_str[i] == ' '; i++)
;
} else {
gtk_file_filter_set_name (filter, filter_str);
i = 0;
}
for (pattern = patterns; *pattern; pattern++)
gtk_file_filter_add_pattern (filter, *pattern);
/* Get patterns */
patterns = g_strsplit_set (filter_str + i, " ", -1);
if (name)
g_free (name);
for (pattern = patterns; *pattern; pattern++)
gtk_file_filter_add_pattern (filter, *pattern);
g_strfreev (patterns);
if (name)
g_free (name);
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);
}
}
g_strfreev (patterns);
zenity_util_show_dialog (dialog, data->attach);
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);
}
}
if(data->timeout_delay > 0) {
g_timeout_add_seconds (data->timeout_delay, (GSourceFunc) zenity_util_timeout_handle, dialog);
}
zenity_util_show_dialog (dialog, data->attach);
gtk_main ();
if (data->timeout_delay > 0) {
g_timeout_add_seconds (data->timeout_delay,
(GSourceFunc) zenity_util_timeout_handle,
dialog);
}
gtk_main ();
}
static void
zenity_fileselection_dialog_output (GtkWidget *widget, ZenityFileData *file_data)
{
GSList *selections, *iter;
selections = gtk_file_chooser_get_filenames (GTK_FILE_CHOOSER (widget));
for (iter = selections;iter != NULL; iter = iter->next) {
g_print ("%s", g_filename_to_utf8 ((gchar*)iter->data, -1, NULL, NULL, NULL));
g_free (iter->data);
if (iter->next != NULL)
g_print ("%s",file_data->separator);
}
g_print("\n");
g_slist_free(selections);
zenity_fileselection_dialog_output (
GtkWidget *widget, ZenityFileData *file_data) {
GSList *selections, *iter;
selections = gtk_file_chooser_get_filenames (GTK_FILE_CHOOSER (widget));
for (iter = selections; iter != NULL; iter = iter->next) {
g_print ("%s",
g_filename_to_utf8 ((gchar *) iter->data, -1, NULL, NULL, NULL));
g_free (iter->data);
if (iter->next != NULL)
g_print ("%s", file_data->separator);
}
g_print ("\n");
g_slist_free (selections);
}
static void
zenity_fileselection_dialog_response (GtkWidget *widget, int response, gpointer data)
{
ZenityFileData *file_data = data;
switch (response) {
case GTK_RESPONSE_OK:
zenity_fileselection_dialog_output (widget, file_data);
zenity_util_exit_code_with_data(ZENITY_OK, zen_data);
break;
zenity_fileselection_dialog_response (
GtkWidget *widget, int response, gpointer data) {
ZenityFileData *file_data = data;
case GTK_RESPONSE_CANCEL:
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_CANCEL);
break;
switch (response) {
case GTK_RESPONSE_OK:
zenity_fileselection_dialog_output (widget, file_data);
zenity_util_exit_code_with_data (ZENITY_OK, zen_data);
break;
case ZENITY_TIMEOUT:
zenity_fileselection_dialog_output (widget, file_data);
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_TIMEOUT);
break;
case GTK_RESPONSE_CANCEL:
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_CANCEL);
break;
default:
if (zen_data->extra_label && response < g_strv_length(zen_data->extra_label))
printf("%s\n",zen_data->extra_label[response]);
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_ESC);
break;
}
gtk_main_quit ();
case ZENITY_TIMEOUT:
zenity_fileselection_dialog_output (widget, file_data);
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_TIMEOUT);
break;
default:
if (zen_data->extra_label &&
response < g_strv_length (zen_data->extra_label))
printf ("%s\n", zen_data->extra_label[response]);
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_ESC);
break;
}
gtk_main_quit ();
}

620
src/forms.c
View File

@ -22,360 +22,390 @@
*/
#include "config.h"
#include <string.h>
#include "zenity.h"
#include "util.h"
#include "zenity.h"
#include <string.h>
static ZenityData *zen_data;
static GSList *selected;
static void zenity_forms_dialog_response (GtkWidget *widget, int response, gpointer data);
static void zenity_forms_dialog_response (
GtkWidget *widget, int response, gpointer data);
static void zenity_forms_dialog_get_selected (GtkTreeModel *model, GtkTreePath *path_buf, GtkTreeIter *iter, GtkTreeView *tree_view)
{
gint n_columns = 0;
gint i = 0;
GValue value = {0, };
static void
zenity_forms_dialog_get_selected (GtkTreeModel *model, GtkTreePath *path_buf,
GtkTreeIter *iter, GtkTreeView *tree_view) {
gint n_columns = 0;
gint i = 0;
GValue value = {
0,
};
n_columns = gtk_tree_model_get_n_columns (model);
for (i = 0; i < n_columns; i++) {
gtk_tree_model_get_value (model, iter, i, &value);
selected = g_slist_append (selected, g_value_dup_string (&value));
g_value_unset (&value);
}
n_columns = gtk_tree_model_get_n_columns (model);
for (i = 0; i < n_columns; i++) {
gtk_tree_model_get_value (model, iter, i, &value);
selected = g_slist_append (selected, g_value_dup_string (&value));
g_value_unset (&value);
}
}
static GtkWidget *
zenity_forms_create_and_fill_combo (ZenityFormsData *forms_data, int combo_number)
{
GtkListStore *list_store;
GtkWidget *combo_box;
GtkCellRenderer *renderer;
gchar *combo_values;
zenity_forms_create_and_fill_combo (
ZenityFormsData *forms_data, int combo_number) {
GtkListStore *list_store;
GtkWidget *combo_box;
GtkCellRenderer *renderer;
gchar *combo_values;
list_store = gtk_list_store_new (1, G_TYPE_STRING);
list_store = gtk_list_store_new (1, G_TYPE_STRING);
if (forms_data->combo_values) {
combo_values = g_slist_nth_data (forms_data->combo_values, combo_number);
if (combo_values) {
gchar **row_values = g_strsplit_set (combo_values, "|", -1);
if (row_values) {
gint i = 0;
GtkTreeIter iter;
gchar *row = row_values[i];
if (forms_data->combo_values) {
combo_values =
g_slist_nth_data (forms_data->combo_values, combo_number);
if (combo_values) {
gchar **row_values = g_strsplit_set (combo_values, "|", -1);
if (row_values) {
gint i = 0;
GtkTreeIter iter;
gchar *row = row_values[i];
while (row != NULL) {
gtk_list_store_append (list_store, &iter);
gtk_list_store_set (list_store, &iter, 0, row, -1);
row = row_values[++i];
}
g_strfreev (row_values);
}
g_free (combo_values);
}
}
while (row != NULL) {
gtk_list_store_append (list_store, &iter);
gtk_list_store_set (list_store, &iter, 0, row, -1);
row = row_values[++i];
}
g_strfreev (row_values);
}
g_free (combo_values);
}
}
combo_box = gtk_combo_box_new_with_model (GTK_TREE_MODEL (list_store));
g_object_unref (G_OBJECT (list_store));
combo_box = gtk_combo_box_new_with_model (GTK_TREE_MODEL (list_store));
g_object_unref (G_OBJECT (list_store));
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo_box), renderer, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo_box), renderer, "text", 0, NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo_box), renderer, TRUE);
gtk_cell_layout_set_attributes (
GTK_CELL_LAYOUT (combo_box), renderer, "text", 0, NULL);
return combo_box;
return combo_box;
}
static GtkWidget *
zenity_forms_create_and_fill_list (ZenityFormsData *forms_data,
int list_number, gchar *header)
{
GtkListStore *list_store;
GtkWidget *tree_view;
GtkWidget *scrolled_window;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GType *column_types = NULL;
gchar *list_values;
gchar *column_values;
static GtkWidget *
zenity_forms_create_and_fill_list (
ZenityFormsData *forms_data, int list_number, gchar *header) {
GtkListStore *list_store;
GtkWidget *tree_view;
GtkWidget *scrolled_window;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GType *column_types = NULL;
gchar *list_values;
gchar *column_values;
gint i = 0;
/* If no column names available, default is one */
gint n_columns = 1;
gint column_index = 0;
gint i = 0;
/* If no column names available, default is one */
gint n_columns = 1;
gint column_index = 0;
tree_view = gtk_tree_view_new ();
tree_view = gtk_tree_view_new ();
if (forms_data->column_values) {
column_values = g_slist_nth_data (forms_data->column_values, list_number);
if (column_values) {
gchar **values = g_strsplit_set (column_values, "|", -1);
if (values) {
n_columns = g_strv_length (values);
column_types = g_new (GType, n_columns);
for (i = 0; i < n_columns; i++)
column_types[i] = G_TYPE_STRING;
if (forms_data->column_values) {
column_values =
g_slist_nth_data (forms_data->column_values, list_number);
if (column_values) {
gchar **values = g_strsplit_set (column_values, "|", -1);
if (values) {
n_columns = g_strv_length (values);
column_types = g_new (GType, n_columns);
for (i = 0; i < n_columns; i++)
column_types[i] = G_TYPE_STRING;
for (i = 0; i < n_columns; i++) {
gchar *column_name = values[i];
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (column_name,
renderer,
"text", column_index,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column);
column_index++;
}
}
}
}
for (i = 0; i < n_columns; i++) {
gchar *column_name = values[i];
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (
column_name, renderer, "text", column_index, NULL);
gtk_tree_view_append_column (
GTK_TREE_VIEW (tree_view), column);
column_index++;
}
}
}
}
list_store = g_object_new (GTK_TYPE_LIST_STORE, NULL);
list_store = g_object_new (GTK_TYPE_LIST_STORE, NULL);
gtk_list_store_set_column_types (list_store, n_columns, column_types);
gtk_list_store_set_column_types (list_store, n_columns, column_types);
if (forms_data->list_values) {
list_values = g_slist_nth_data (forms_data->list_values, list_number);
if (list_values) {
gchar **row_values = g_strsplit_set (list_values, "|", -1);
if (row_values) {
GtkTreeIter iter;
gchar *row = row_values[0];
gint position = -1;
i = 0;
while (row != NULL) {
if (position >= n_columns || position == -1) {
position = 0;
gtk_list_store_append (list_store, &iter);
}
gtk_list_store_set (list_store, &iter, position, row, -1);
position++;
row = row_values[++i];
}
g_strfreev (row_values);
}
g_free (list_values);
}
}
if (forms_data->list_values) {
list_values = g_slist_nth_data (forms_data->list_values, list_number);
if (list_values) {
gchar **row_values = g_strsplit_set (list_values, "|", -1);
if (row_values) {
GtkTreeIter iter;
gchar *row = row_values[0];
gint position = -1;
i = 0;
gtk_tree_view_set_model (GTK_TREE_VIEW (tree_view), GTK_TREE_MODEL (list_store));
g_object_unref (list_store);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
//gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_window),
// GTK_WIDGET (tree_view));
gtk_container_add (GTK_CONTAINER (scrolled_window), GTK_WIDGET (tree_view));
gtk_widget_set_size_request (GTK_WIDGET (scrolled_window), -1, 100);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tree_view), forms_data->show_header);
while (row != NULL) {
if (position >= n_columns || position == -1) {
position = 0;
gtk_list_store_append (list_store, &iter);
}
gtk_list_store_set (list_store, &iter, position, row, -1);
position++;
row = row_values[++i];
}
g_strfreev (row_values);
}
g_free (list_values);
}
}
return scrolled_window;
gtk_tree_view_set_model (
GTK_TREE_VIEW (tree_view), GTK_TREE_MODEL (list_store));
g_object_unref (list_store);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
// gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW
// (scrolled_window),
// GTK_WIDGET (tree_view));
gtk_container_add (GTK_CONTAINER (scrolled_window), GTK_WIDGET (tree_view));
gtk_widget_set_size_request (GTK_WIDGET (scrolled_window), -1, 100);
gtk_tree_view_set_headers_visible (
GTK_TREE_VIEW (tree_view), forms_data->show_header);
return scrolled_window;
}
void zenity_forms_dialog (ZenityData *data, ZenityFormsData *forms_data)
{
GtkBuilder *builder = NULL;
GtkWidget *dialog;
GtkWidget *grid;
GtkWidget *text;
GtkWidget *button;
void
zenity_forms_dialog (ZenityData *data, ZenityFormsData *forms_data) {
GtkBuilder *builder = NULL;
GtkWidget *dialog;
GtkWidget *grid;
GtkWidget *text;
GtkWidget *button;
GSList *tmp;
GSList *tmp;
int list_count = 0;
int combo_count = 0;
int i = 0;
int list_count = 0;
int combo_count = 0;
int i = 0;
zen_data = data;
zen_data = data;
builder = zenity_util_load_ui_file("zenity_forms_dialog", NULL);
builder = zenity_util_load_ui_file ("zenity_forms_dialog", NULL);
if (builder == NULL) {
data->exit_code = zenity_util_return_exit_code (ZENITY_ERROR);
return;
}
if (builder == NULL) {
data->exit_code = zenity_util_return_exit_code (ZENITY_ERROR);
return;
}
gtk_builder_connect_signals(builder, NULL);
dialog = GTK_WIDGET (gtk_builder_get_object (builder, "zenity_forms_dialog"));
gtk_builder_connect_signals (builder, NULL);
g_signal_connect (G_OBJECT(dialog), "response",
G_CALLBACK (zenity_forms_dialog_response), forms_data);
if (data->dialog_title)
gtk_window_set_title (GTK_WINDOW (dialog), data->dialog_title);
dialog =
GTK_WIDGET (gtk_builder_get_object (builder, "zenity_forms_dialog"));
if (data->width > -1 || data->height > -1)
gtk_window_set_default_size (GTK_WINDOW (dialog), data->width, data->height);
g_signal_connect (G_OBJECT (dialog),
"response",
G_CALLBACK (zenity_forms_dialog_response),
forms_data);
if (data->extra_label) {
gint i=0;
while(data->extra_label[i]!=NULL){
gtk_dialog_add_button (GTK_DIALOG (dialog), data->extra_label[i], i);
i++;
}
}
if (data->dialog_title)
gtk_window_set_title (GTK_WINDOW (dialog), data->dialog_title);
if (data->ok_label) {
button = GTK_WIDGET (gtk_builder_get_object (builder, "zenity_forms_ok_button"));
gtk_button_set_label (GTK_BUTTON (button), data->ok_label);
}
if (data->width > -1 || data->height > -1)
gtk_window_set_default_size (
GTK_WINDOW (dialog), data->width, data->height);
if (data->cancel_label) {
button = GTK_WIDGET (gtk_builder_get_object (builder, "zenity_forms_cancel_button"));
gtk_button_set_label (GTK_BUTTON (button), data->cancel_label);
}
if (data->extra_label) {
gint i = 0;
while (data->extra_label[i] != NULL) {
gtk_dialog_add_button (
GTK_DIALOG (dialog), data->extra_label[i], i);
i++;
}
}
text = GTK_WIDGET (gtk_builder_get_object (builder, "zenity_forms_text"));
if (data->ok_label) {
button = GTK_WIDGET (
gtk_builder_get_object (builder, "zenity_forms_ok_button"));
gtk_button_set_label (GTK_BUTTON (button), data->ok_label);
}
if (forms_data->dialog_text)
gtk_label_set_markup (GTK_LABEL (text), g_strcompress (forms_data->dialog_text));
grid = GTK_WIDGET (gtk_builder_get_object (builder, "zenity_forms_grid"));
if (data->cancel_label) {
button = GTK_WIDGET (
gtk_builder_get_object (builder, "zenity_forms_cancel_button"));
gtk_button_set_label (GTK_BUTTON (button), data->cancel_label);
}
for (tmp = forms_data->list; tmp; tmp = tmp->next) {
ZenityFormsValue *zenity_value = (ZenityFormsValue *) tmp->data;
GtkWidget *label;
label = gtk_label_new(zenity_value->option_value);
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_grid_attach (GTK_GRID (grid),
label,
0, i,
1, 1);
switch(zenity_value->type)
{
case ZENITY_FORMS_ENTRY:
zenity_value->forms_widget = gtk_entry_new();
break;
case ZENITY_FORMS_PASSWORD:
zenity_value->forms_widget = gtk_entry_new();
gtk_entry_set_visibility(GTK_ENTRY(zenity_value->forms_widget),
FALSE);
break;
case ZENITY_FORMS_CALENDAR:
zenity_value->forms_widget = gtk_calendar_new();
break;
case ZENITY_FORMS_LIST:
zenity_value->forms_widget = zenity_forms_create_and_fill_list (forms_data, list_count,
zenity_value->option_value);
list_count++;
break;
case ZENITY_FORMS_COMBO:
zenity_value->forms_widget = zenity_forms_create_and_fill_combo (forms_data, combo_count);
combo_count++;
break;
default:
zenity_value->forms_widget = gtk_entry_new();
break;
}
text = GTK_WIDGET (gtk_builder_get_object (builder, "zenity_forms_text"));
gtk_grid_attach_next_to (GTK_GRID (grid),
GTK_WIDGET (zenity_value->forms_widget),
label,
GTK_POS_RIGHT,
1, 1);
i++;
}
if (forms_data->dialog_text)
gtk_label_set_markup (
GTK_LABEL (text), g_strcompress (forms_data->dialog_text));
gtk_widget_show_all (GTK_WIDGET (dialog));
g_object_unref (builder);
grid = GTK_WIDGET (gtk_builder_get_object (builder, "zenity_forms_grid"));
if (data->timeout_delay > 0) {
g_timeout_add_seconds (data->timeout_delay, (GSourceFunc) zenity_util_timeout_handle, dialog);
}
for (tmp = forms_data->list; tmp; tmp = tmp->next) {
ZenityFormsValue *zenity_value = (ZenityFormsValue *) tmp->data;
GtkWidget *label;
gtk_main();
label = gtk_label_new (zenity_value->option_value);
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_grid_attach (GTK_GRID (grid), label, 0, i, 1, 1);
switch (zenity_value->type) {
case ZENITY_FORMS_ENTRY:
zenity_value->forms_widget = gtk_entry_new ();
break;
case ZENITY_FORMS_PASSWORD:
zenity_value->forms_widget = gtk_entry_new ();
gtk_entry_set_visibility (
GTK_ENTRY (zenity_value->forms_widget), FALSE);
break;
case ZENITY_FORMS_CALENDAR:
zenity_value->forms_widget = gtk_calendar_new ();
break;
case ZENITY_FORMS_LIST:
zenity_value->forms_widget = zenity_forms_create_and_fill_list (
forms_data, list_count, zenity_value->option_value);
list_count++;
break;
case ZENITY_FORMS_COMBO:
zenity_value->forms_widget =
zenity_forms_create_and_fill_combo (
forms_data, combo_count);
combo_count++;
break;
default:
zenity_value->forms_widget = gtk_entry_new ();
break;
}
gtk_grid_attach_next_to (GTK_GRID (grid),
GTK_WIDGET (zenity_value->forms_widget),
label,
GTK_POS_RIGHT,
1,
1);
i++;
}
gtk_widget_show_all (GTK_WIDGET (dialog));
g_object_unref (builder);
if (data->timeout_delay > 0) {
g_timeout_add_seconds (data->timeout_delay,
(GSourceFunc) zenity_util_timeout_handle,
dialog);
}
gtk_main ();
}
static void
zenity_forms_dialog_output (ZenityFormsData *forms_data)
{
GSList *tmp, *tmp2;
guint day, year, month;
GDate *date = NULL;
gchar time_string[128];
gchar *combo_value = NULL;
GtkTreeSelection *selection;
GtkListStore *list_store;
GtkTreeIter iter;
zenity_forms_dialog_output (ZenityFormsData *forms_data) {
GSList *tmp, *tmp2;
guint day, year, month;
GDate *date = NULL;
gchar time_string[128];
gchar *combo_value = NULL;
GtkTreeSelection *selection;
GtkListStore *list_store;
GtkTreeIter iter;
for (tmp = forms_data->list; tmp; tmp = tmp->next) {
ZenityFormsValue *zenity_value = (ZenityFormsValue *) tmp->data;
switch (zenity_value->type) {
case ZENITY_FORMS_PASSWORD:
case ZENITY_FORMS_ENTRY:
g_print("%s", gtk_entry_get_text (GTK_ENTRY (zenity_value->forms_widget)));
break;
case ZENITY_FORMS_LIST:
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (gtk_bin_get_child (GTK_BIN (zenity_value->forms_widget))));
gtk_tree_selection_selected_foreach (selection,
(GtkTreeSelectionForeachFunc) zenity_forms_dialog_get_selected,
GTK_TREE_VIEW (gtk_bin_get_child (GTK_BIN (zenity_value->forms_widget))));
for (tmp = forms_data->list; tmp; tmp = tmp->next) {
ZenityFormsValue *zenity_value = (ZenityFormsValue *) tmp->data;
switch (zenity_value->type) {
case ZENITY_FORMS_PASSWORD:
case ZENITY_FORMS_ENTRY:
g_print ("%s",
gtk_entry_get_text (
GTK_ENTRY (zenity_value->forms_widget)));
break;
case ZENITY_FORMS_LIST:
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (
gtk_bin_get_child (GTK_BIN (zenity_value->forms_widget))));
gtk_tree_selection_selected_foreach (selection,
(GtkTreeSelectionForeachFunc)
zenity_forms_dialog_get_selected,
GTK_TREE_VIEW (gtk_bin_get_child (
GTK_BIN (zenity_value->forms_widget))));
for (tmp2 = selected; tmp2; tmp2 = tmp2->next) {
if (tmp->next != NULL) {
g_print ("%s,", (gchar *) tmp2->data);
}
else
g_print ("%s", (gchar *) tmp2->data);
}
for (tmp2 = selected; tmp2; tmp2 = tmp2->next) {
if (tmp->next != NULL) {
g_print ("%s,", (gchar *) tmp2->data);
} else
g_print ("%s", (gchar *) tmp2->data);
}
g_slist_foreach (selected, (GFunc) g_free, NULL);
selected = NULL;
g_slist_foreach (selected, (GFunc) g_free, NULL);
selected = NULL;
break;
case ZENITY_FORMS_CALENDAR:
gtk_calendar_get_date (GTK_CALENDAR (zenity_value->forms_widget), &day, &month, &year);
date = g_date_new_dmy (year, month + 1, day);
g_date_strftime (time_string, 127, forms_data->date_format, date);
g_print ("%s", time_string);
break;
case ZENITY_FORMS_COMBO:
if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (zenity_value->forms_widget), &iter)) {
list_store = GTK_LIST_STORE (gtk_combo_box_get_model (GTK_COMBO_BOX (zenity_value->forms_widget)));
gtk_tree_model_get (GTK_TREE_MODEL (list_store), &iter, 0, &combo_value, -1);
g_object_unref (G_OBJECT (list_store));
g_print ("%s", combo_value);
g_free (combo_value);
} else
g_print (" ");
break;
}
if (tmp->next != NULL)
g_print("%s", forms_data->separator);
}
g_print("\n");
break;
case ZENITY_FORMS_CALENDAR:
gtk_calendar_get_date (
GTK_CALENDAR (zenity_value->forms_widget),
&day,
&month,
&year);
date = g_date_new_dmy (year, month + 1, day);
g_date_strftime (
time_string, 127, forms_data->date_format, date);
g_print ("%s", time_string);
break;
case ZENITY_FORMS_COMBO:
if (gtk_combo_box_get_active_iter (
GTK_COMBO_BOX (zenity_value->forms_widget), &iter)) {
list_store = GTK_LIST_STORE (gtk_combo_box_get_model (
GTK_COMBO_BOX (zenity_value->forms_widget)));
gtk_tree_model_get (GTK_TREE_MODEL (list_store),
&iter,
0,
&combo_value,
-1);
g_object_unref (G_OBJECT (list_store));
g_print ("%s", combo_value);
g_free (combo_value);
} else
g_print (" ");
break;
}
if (tmp->next != NULL)
g_print ("%s", forms_data->separator);
}
g_print ("\n");
}
static void
zenity_forms_dialog_response (GtkWidget *widget, int response, gpointer data)
{
ZenityFormsData *forms_data = (ZenityFormsData *) data;
zenity_forms_dialog_response (GtkWidget *widget, int response, gpointer data) {
ZenityFormsData *forms_data = (ZenityFormsData *) data;
switch (response) {
case GTK_RESPONSE_OK:
zenity_forms_dialog_output (forms_data);
zenity_util_exit_code_with_data(ZENITY_OK, zen_data);
break;
switch (response) {
case GTK_RESPONSE_OK:
zenity_forms_dialog_output (forms_data);
zenity_util_exit_code_with_data (ZENITY_OK, zen_data);
break;
case GTK_RESPONSE_CANCEL:
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_CANCEL);
break;
case GTK_RESPONSE_CANCEL:
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_CANCEL);
break;
case ZENITY_TIMEOUT:
zenity_forms_dialog_output (forms_data);
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_TIMEOUT);
break;
case ZENITY_TIMEOUT:
zenity_forms_dialog_output (forms_data);
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_TIMEOUT);
break;
default:
if (zen_data->extra_label && response < g_strv_length(zen_data->extra_label))
printf("%s\n",zen_data->extra_label[response]);
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_ESC);
break;
}
default:
if (zen_data->extra_label &&
response < g_strv_length (zen_data->extra_label))
printf ("%s\n", zen_data->extra_label[response]);
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_ESC);
break;
}
gtk_main_quit ();
gtk_main_quit ();
}

145
src/main.c
View File

@ -23,97 +23,98 @@
#include <config.h>
#include "zenity.h"
#include "option.h"
#include "zenity.h"
#include <stdlib.h>
#include <glib.h>
#include <gtk/gtk.h>
#include <langinfo.h>
#include <stdlib.h>
#ifdef HAVE_LOCALE_H
#include <locale.h>
#endif
gint
gint
main (gint argc, gchar **argv) {
ZenityParsingOptions *results;
gint retval;
ZenityParsingOptions *results;
gint retval;
#ifdef HAVE_LOCALE_H
setlocale(LC_ALL,"");
setlocale (LC_ALL, "");
#endif
bindtextdomain(GETTEXT_PACKAGE, GNOMELOCALEDIR);
bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
textdomain(GETTEXT_PACKAGE);
bindtextdomain (GETTEXT_PACKAGE, GNOMELOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
gtk_init (&argc, &argv);
gtk_init (&argc, &argv);
results = zenity_option_parse (argc, argv);
results = zenity_option_parse (argc, argv);
switch (results->mode) {
case MODE_CALENDAR:
zenity_calendar (results->data, results->calendar_data);
break;
case MODE_ENTRY:
results->entry_data->data = (const gchar **) argv + 1;
zenity_entry (results->data, results->entry_data);
break;
case MODE_ERROR:
case MODE_QUESTION:
case MODE_WARNING:
case MODE_INFO:
zenity_msg (results->data, results->msg_data);
break;
case MODE_SCALE:
zenity_scale (results->data, results->scale_data);
break;
case MODE_FILE:
zenity_fileselection (results->data, results->file_data);
break;
case MODE_LIST:
results->tree_data->data = (const gchar **) argv + 1;
zenity_tree (results->data, results->tree_data);
break;
switch (results->mode) {
case MODE_CALENDAR:
zenity_calendar (results->data, results->calendar_data);
break;
case MODE_ENTRY:
results->entry_data->data = (const gchar **) argv + 1;
zenity_entry (results->data, results->entry_data);
break;
case MODE_ERROR:
case MODE_QUESTION:
case MODE_WARNING:
case MODE_INFO:
zenity_msg (results->data, results->msg_data);
break;
case MODE_SCALE:
zenity_scale (results->data, results->scale_data);
break;
case MODE_FILE:
zenity_fileselection (results->data, results->file_data);
break;
case MODE_LIST:
results->tree_data->data = (const gchar **) argv + 1;
zenity_tree (results->data, results->tree_data);
break;
#ifdef HAVE_LIBNOTIFY
case MODE_NOTIFICATION:
zenity_notification (results->data, results->notification_data);
break;
case MODE_NOTIFICATION:
zenity_notification (results->data, results->notification_data);
break;
#endif
case MODE_PROGRESS:
zenity_progress (results->data, results->progress_data);
break;
case MODE_TEXTINFO:
zenity_text (results->data, results->text_data);
break;
case MODE_COLOR:
zenity_colorselection (results->data, results->color_data);
break;
case MODE_PASSWORD:
zenity_password_dialog (results->data, results->password_data);
break;
case MODE_ABOUT:
zenity_about (results->data);
break;
case MODE_FORMS:
zenity_forms_dialog (results->data, results->forms_data);
break;
case MODE_VERSION:
g_print ("%s\n", VERSION);
break;
case MODE_LAST:
g_printerr (_("You must specify a dialog type. See 'zenity --help' for details\n"));
zenity_option_free ();
exit (-1);
default:
g_assert_not_reached ();
zenity_option_free ();
exit (-1);
}
case MODE_PROGRESS:
zenity_progress (results->data, results->progress_data);
break;
case MODE_TEXTINFO:
zenity_text (results->data, results->text_data);
break;
case MODE_COLOR:
zenity_colorselection (results->data, results->color_data);
break;
case MODE_PASSWORD:
zenity_password_dialog (results->data, results->password_data);
break;
case MODE_ABOUT:
zenity_about (results->data);
break;
case MODE_FORMS:
zenity_forms_dialog (results->data, results->forms_data);
break;
case MODE_VERSION:
g_print ("%s\n", VERSION);
break;
case MODE_LAST:
g_printerr (_ ("You must specify a dialog type. See 'zenity "
"--help' for details\n"));
zenity_option_free ();
exit (-1);
default:
g_assert_not_reached ();
zenity_option_free ();
exit (-1);
}
retval = results->data->exit_code;
zenity_option_free ();
retval = results->data->exit_code;
exit (retval);
zenity_option_free ();
exit (retval);
}

389
src/msg.c
View File

@ -23,228 +23,247 @@
#include "config.h"
#include "zenity.h"
#include "util.h"
#include "zenity.h"
static void zenity_msg_dialog_response (GtkWidget *widget, int response, gpointer data);
static void zenity_msg_dialog_response (
GtkWidget *widget, int response, gpointer data);
static void
zenity_msg_construct_question_dialog (GtkWidget *dialog, ZenityMsgData *msg_data, ZenityData *data)
{
zenity_msg_construct_question_dialog (
GtkWidget *dialog, ZenityMsgData *msg_data, ZenityData *data) {
GtkWidget *cancel_button, *ok_button;
GtkWidget *cancel_button, *ok_button;
cancel_button = gtk_dialog_add_button (GTK_DIALOG (dialog), _("_No"), GTK_RESPONSE_CANCEL);
ok_button = gtk_dialog_add_button (GTK_DIALOG (dialog), _("_Yes"), GTK_RESPONSE_OK);
cancel_button = gtk_dialog_add_button (
GTK_DIALOG (dialog), _ ("_No"), GTK_RESPONSE_CANCEL);
ok_button = gtk_dialog_add_button (
GTK_DIALOG (dialog), _ ("_Yes"), GTK_RESPONSE_OK);
gtk_widget_grab_focus (msg_data->default_cancel ? cancel_button : ok_button);
gtk_widget_grab_focus (
msg_data->default_cancel ? cancel_button : ok_button);
if (data->cancel_label) {
gtk_button_set_label (GTK_BUTTON (cancel_button), data->cancel_label);
}
if (data->ok_label) {
gtk_button_set_label (GTK_BUTTON (ok_button), data->ok_label);
}
if (data->cancel_label) {
gtk_button_set_label (GTK_BUTTON (cancel_button), data->cancel_label);
}
if (data->ok_label) {
gtk_button_set_label (GTK_BUTTON (ok_button), data->ok_label);
}
}
static void
zenity_label_widget_clipboard_selection(GtkWidget *widget)
{
/* Workaround hotfix for suspected toolkit issue:
since focus change of the dialog's focussed widget (text)
somehow currently chooses to destroy
a pre-existing (read: foreign, user-initiated) X11 primary selection
(via gtk_label_select_region() -> ...
-> gtk_clipboard_set_contents()/gtk_clipboard_clear()),
we need to ensure
that the widget does have its gtk-label-select-on-focus property off,
in order to avoid having the label become selected automatically
and thereby having pre-existing clipboard content nullified.
Side note: this selection issue only applies to widgets
which have both
<property name="can_focus">True</property>
<property name="selectable">True</property>
.
*/
g_object_set(gtk_widget_get_settings (widget),
"gtk-label-select-on-focus",
FALSE,
NULL);
zenity_label_widget_clipboard_selection (GtkWidget *widget) {
/* Workaround hotfix for suspected toolkit issue:
since focus change of the dialog's focussed widget (text)
somehow currently chooses to destroy
a pre-existing (read: foreign, user-initiated) X11 primary selection
(via gtk_label_select_region() -> ...
-> gtk_clipboard_set_contents()/gtk_clipboard_clear()),
we need to ensure
that the widget does have its gtk-label-select-on-focus property off,
in order to avoid having the label become selected automatically
and thereby having pre-existing clipboard content nullified.
Side note: this selection issue only applies to widgets
which have both
<property name="can_focus">True</property>
<property name="selectable">True</property>
.
*/
g_object_set (gtk_widget_get_settings (widget),
"gtk-label-select-on-focus",
FALSE,
NULL);
}
void
zenity_msg (ZenityData *data, ZenityMsgData *msg_data)
{
GtkBuilder *builder;
GtkWidget *dialog;
GtkWidget *ok_button;
GObject *text;
GObject *image;
void
zenity_msg (ZenityData *data, ZenityMsgData *msg_data) {
GtkBuilder *builder;
GtkWidget *dialog;
GtkWidget *ok_button;
GObject *text;
GObject *image;
switch (msg_data->mode) {
case ZENITY_MSG_WARNING:
builder = zenity_util_load_ui_file ("zenity_warning_dialog", NULL);
dialog = GTK_WIDGET (gtk_builder_get_object (builder, "zenity_warning_dialog"));
text = gtk_builder_get_object (builder, "zenity_warning_text");
image = gtk_builder_get_object (builder, "zenity_warning_image");
ok_button = GTK_WIDGET (gtk_builder_get_object (builder, "zenity_warning_ok_button"));
break;
switch (msg_data->mode) {
case ZENITY_MSG_WARNING:
builder = zenity_util_load_ui_file ("zenity_warning_dialog", NULL);
dialog = GTK_WIDGET (
gtk_builder_get_object (builder, "zenity_warning_dialog"));
text = gtk_builder_get_object (builder, "zenity_warning_text");
image = gtk_builder_get_object (builder, "zenity_warning_image");
ok_button = GTK_WIDGET (
gtk_builder_get_object (builder, "zenity_warning_ok_button"));
break;
case ZENITY_MSG_QUESTION:
case ZENITY_MSG_SWITCH:
builder = zenity_util_load_ui_file ("zenity_question_dialog", NULL);
dialog = GTK_WIDGET (gtk_builder_get_object (builder, "zenity_question_dialog"));
text = gtk_builder_get_object (builder, "zenity_question_text");
image = gtk_builder_get_object (builder, "zenity_question_image");
ok_button = NULL;
break;
case ZENITY_MSG_QUESTION:
case ZENITY_MSG_SWITCH:
builder = zenity_util_load_ui_file ("zenity_question_dialog", NULL);
dialog = GTK_WIDGET (
gtk_builder_get_object (builder, "zenity_question_dialog"));
text = gtk_builder_get_object (builder, "zenity_question_text");
image = gtk_builder_get_object (builder, "zenity_question_image");
ok_button = NULL;
break;
case ZENITY_MSG_ERROR:
builder = zenity_util_load_ui_file ("zenity_error_dialog", NULL);
dialog = GTK_WIDGET (gtk_builder_get_object (builder, "zenity_error_dialog"));
text = gtk_builder_get_object (builder, "zenity_error_text");
image = gtk_builder_get_object (builder, "zenity_error_image");
ok_button = GTK_WIDGET (gtk_builder_get_object (builder, "zenity_error_ok_button"));
break;
case ZENITY_MSG_ERROR:
builder = zenity_util_load_ui_file ("zenity_error_dialog", NULL);
dialog = GTK_WIDGET (
gtk_builder_get_object (builder, "zenity_error_dialog"));
text = gtk_builder_get_object (builder, "zenity_error_text");
image = gtk_builder_get_object (builder, "zenity_error_image");
ok_button = GTK_WIDGET (
gtk_builder_get_object (builder, "zenity_error_ok_button"));
break;
case ZENITY_MSG_INFO:
builder = zenity_util_load_ui_file ("zenity_info_dialog", NULL);
dialog = GTK_WIDGET (gtk_builder_get_object (builder, "zenity_info_dialog"));
text = gtk_builder_get_object (builder, "zenity_info_text");
image = gtk_builder_get_object (builder, "zenity_info_image");
ok_button = GTK_WIDGET (gtk_builder_get_object (builder, "zenity_info_ok_button"));
break;
default:
builder = NULL;
dialog = NULL;
text = NULL;
image = NULL;
ok_button = NULL;
g_assert_not_reached ();
break;
}
case ZENITY_MSG_INFO:
builder = zenity_util_load_ui_file ("zenity_info_dialog", NULL);
dialog = GTK_WIDGET (
gtk_builder_get_object (builder, "zenity_info_dialog"));
text = gtk_builder_get_object (builder, "zenity_info_text");
image = gtk_builder_get_object (builder, "zenity_info_image");
ok_button = GTK_WIDGET (
gtk_builder_get_object (builder, "zenity_info_ok_button"));
break;
if (data->extra_label) {
gint i=0;
while(data->extra_label[i]!=NULL){
gtk_dialog_add_button (GTK_DIALOG (dialog), data->extra_label[i], i);
i++;
}
}
default:
builder = NULL;
dialog = NULL;
text = NULL;
image = NULL;
ok_button = NULL;
g_assert_not_reached ();
break;
}
if (builder == NULL) {
data->exit_code = zenity_util_return_exit_code (ZENITY_ERROR);
return;
}
if (data->extra_label) {
gint i = 0;
while (data->extra_label[i] != NULL) {
gtk_dialog_add_button (
GTK_DIALOG (dialog), data->extra_label[i], i);
i++;
}
}
g_signal_connect (G_OBJECT (dialog), "response",
G_CALLBACK (zenity_msg_dialog_response), data);
if (builder == NULL) {
data->exit_code = zenity_util_return_exit_code (ZENITY_ERROR);
return;
}
gtk_builder_connect_signals (builder, NULL);
if (data->dialog_title)
gtk_window_set_title (GTK_WINDOW (dialog), data->dialog_title);
g_signal_connect (G_OBJECT (dialog),
"response",
G_CALLBACK (zenity_msg_dialog_response),
data);
if (ok_button) {
if (data->ok_label) {
gtk_button_set_label (GTK_BUTTON (ok_button), data->ok_label);
}
}
gtk_builder_connect_signals (builder, NULL);
switch (msg_data->mode) {
case ZENITY_MSG_WARNING:
zenity_util_set_window_icon_from_icon_name (dialog, data->window_icon, "dialog-warning");
break;
if (data->dialog_title)
gtk_window_set_title (GTK_WINDOW (dialog), data->dialog_title);
case ZENITY_MSG_QUESTION:
zenity_util_set_window_icon_from_icon_name (dialog, data->window_icon, "dialog-question");
zenity_msg_construct_question_dialog (dialog, msg_data, data);
break;
case ZENITY_MSG_SWITCH:
zenity_util_set_window_icon_from_icon_name (dialog, data->window_icon, "dialog-question");
break;
case ZENITY_MSG_ERROR:
zenity_util_set_window_icon_from_icon_name (dialog, data->window_icon, "dialog-error");
break;
case ZENITY_MSG_INFO:
zenity_util_set_window_icon_from_icon_name (dialog, data->window_icon, "dialog-information");
break;
default:
break;
}
if (data->width > -1 || data->height > -1)
gtk_window_set_default_size (GTK_WINDOW (dialog), data->width, data->height);
if (ok_button) {
if (data->ok_label) {
gtk_button_set_label (GTK_BUTTON (ok_button), data->ok_label);
}
}
if (data->width > -1)
gtk_widget_set_size_request (GTK_WIDGET (text), data->width, -1);
else
if (!msg_data->ellipsize && !msg_data->no_wrap) {
// the magic number 60 is picked from gtk+/gtk/ui/gtkmessagedialog.ui
// however, 60 would increase the distance between the icon and the text,
// decreasing to 10 fix it.
gtk_label_set_width_chars (text, 10);
gtk_label_set_max_width_chars (text, 10);
}
switch (msg_data->mode) {
case ZENITY_MSG_WARNING:
zenity_util_set_window_icon_from_icon_name (
dialog, data->window_icon, "dialog-warning");
break;
if (data->modal)
gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
if (msg_data->dialog_text) {
if (msg_data->no_markup)
gtk_label_set_text (GTK_LABEL (text), msg_data->dialog_text);
else
gtk_label_set_markup (GTK_LABEL (text), g_strcompress (msg_data->dialog_text));
zenity_label_widget_clipboard_selection(GTK_WIDGET (text));
}
case ZENITY_MSG_QUESTION:
zenity_util_set_window_icon_from_icon_name (
dialog, data->window_icon, "dialog-question");
zenity_msg_construct_question_dialog (dialog, msg_data, data);
break;
if (msg_data->ellipsize)
gtk_label_set_ellipsize (GTK_LABEL(text), PANGO_ALIGN_RIGHT);
case ZENITY_MSG_SWITCH:
zenity_util_set_window_icon_from_icon_name (
dialog, data->window_icon, "dialog-question");
break;
if (msg_data->dialog_icon)
gtk_image_set_from_icon_name (GTK_IMAGE (image), msg_data->dialog_icon, GTK_ICON_SIZE_DIALOG);
case ZENITY_MSG_ERROR:
zenity_util_set_window_icon_from_icon_name (
dialog, data->window_icon, "dialog-error");
break;
if (msg_data->no_wrap)
gtk_label_set_line_wrap (GTK_LABEL (text), FALSE);
case ZENITY_MSG_INFO:
zenity_util_set_window_icon_from_icon_name (
dialog, data->window_icon, "dialog-information");
break;
zenity_util_show_dialog (dialog, data->attach);
default:
break;
}
if(data->timeout_delay > 0) {
g_timeout_add_seconds (data->timeout_delay, (GSourceFunc) zenity_util_timeout_handle, NULL);
}
if (data->width > -1 || data->height > -1)
gtk_window_set_default_size (
GTK_WINDOW (dialog), data->width, data->height);
g_object_unref (builder);
if (data->width > -1)
gtk_widget_set_size_request (GTK_WIDGET (text), data->width, -1);
else if (!msg_data->ellipsize && !msg_data->no_wrap) {
// the magic number 60 is picked from gtk+/gtk/ui/gtkmessagedialog.ui
// however, 60 would increase the distance between the icon and the
// text,
// decreasing to 10 fix it.
gtk_label_set_width_chars (text, 10);
gtk_label_set_max_width_chars (text, 10);
}
gtk_main ();
if (data->modal)
gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
if (msg_data->dialog_text) {
if (msg_data->no_markup)
gtk_label_set_text (GTK_LABEL (text), msg_data->dialog_text);
else
gtk_label_set_markup (
GTK_LABEL (text), g_strcompress (msg_data->dialog_text));
zenity_label_widget_clipboard_selection (GTK_WIDGET (text));
}
if (msg_data->ellipsize)
gtk_label_set_ellipsize (GTK_LABEL (text), PANGO_ALIGN_RIGHT);
if (msg_data->dialog_icon)
gtk_image_set_from_icon_name (
GTK_IMAGE (image), msg_data->dialog_icon, GTK_ICON_SIZE_DIALOG);
if (msg_data->no_wrap)
gtk_label_set_line_wrap (GTK_LABEL (text), FALSE);
zenity_util_show_dialog (dialog, data->attach);
if (data->timeout_delay > 0) {
g_timeout_add_seconds (data->timeout_delay,
(GSourceFunc) zenity_util_timeout_handle,
NULL);
}
g_object_unref (builder);
gtk_main ();
}
static void
zenity_msg_dialog_response (GtkWidget *widget, int response, gpointer data)
{
ZenityData *zen_data = data;
zenity_msg_dialog_response (GtkWidget *widget, int response, gpointer data) {
ZenityData *zen_data = data;
switch (response) {
case GTK_RESPONSE_OK:
zenity_util_exit_code_with_data(ZENITY_OK, zen_data);
break;
switch (response) {
case GTK_RESPONSE_OK:
zenity_util_exit_code_with_data (ZENITY_OK, zen_data);
break;
case GTK_RESPONSE_CANCEL:
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_CANCEL);
break;
case GTK_RESPONSE_CANCEL:
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_CANCEL);
break;
default:
if (zen_data->extra_label && response < g_strv_length(zen_data->extra_label))
printf("%s\n",zen_data->extra_label[response]);
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_ESC);
break;
}
gtk_main_quit ();
default:
if (zen_data->extra_label &&
response < g_strv_length (zen_data->extra_label))
printf ("%s\n", zen_data->extra_label[response]);
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_ESC);
break;
}
gtk_main_quit ();
}

560
src/notification.c
View File

@ -24,16 +24,16 @@
#include <config.h>
#include <unistd.h>
#include <stdlib.h>
#include <gtk/gtk.h>
#include <time.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#ifdef HAVE_LIBNOTIFY
#include <libnotify/notify.h>
#include "zenity.h"
#include "util.h"
#include "zenity.h"
#define MAX_HINTS 16
@ -41,337 +41,331 @@ static char *icon_file;
static GHashTable *notification_hints;
static NotifyNotification *
zenity_notification_new(gchar *message, gchar *icon_file)
{
NotifyNotification *notif;
gchar **text;
zenity_notification_new (gchar *message, gchar *icon_file) {
NotifyNotification *notif;
gchar **text;
text = g_strsplit (g_strcompress (message), "\n", 2);
if (*text == NULL) {
g_printerr (_("Could not parse message\n"));
return NULL;
}
notif = notify_notification_new (text[0], /* title */
text[1], /* summary */
icon_file);
g_strfreev (text);
return notif;
text = g_strsplit (g_strcompress (message), "\n", 2);
if (*text == NULL) {
g_printerr (_ ("Could not parse message\n"));
return NULL;
}
notif = notify_notification_new (text[0], /* title */
text[1], /* summary */
icon_file);
g_strfreev (text);
return notif;
}
static void
on_notification_default_action (NotifyNotification *n,
const char *action,
void *user_data)
{
ZenityData *zen_data;
on_notification_default_action (
NotifyNotification *n, const char *action, void *user_data) {
ZenityData *zen_data;
zen_data = (ZenityData *)user_data;
notify_notification_close (n, NULL);
zen_data = (ZenityData *) user_data;
notify_notification_close (n, NULL);
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_OK);
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_OK);
gtk_main_quit ();
gtk_main_quit ();
}
static GHashTable *
zenity_notification_parse_hints_array (gchar **hints)
{
GHashTable *result;
gchar** pair;
int i;
zenity_notification_parse_hints_array (gchar **hints) {
GHashTable *result;
gchar **pair;
int i;
result = g_hash_table_new_full (g_str_hash,
g_str_equal,
g_free,
g_free);
result = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
for(i = 0; i < g_strv_length (hints); i++) {
pair = g_strsplit (hints[i], ":", 2);
g_hash_table_replace (result, g_strdup (pair[0]), g_strdup (pair[1]));
g_strfreev (pair);
}
if (g_hash_table_size (result) == 0) {
g_hash_table_unref (result);
return NULL;
} else {
return result;
}
for (i = 0; i < g_strv_length (hints); i++) {
pair = g_strsplit (hints[i], ":", 2);
g_hash_table_replace (result, g_strdup (pair[0]), g_strdup (pair[1]));
g_strfreev (pair);
}
if (g_hash_table_size (result) == 0) {
g_hash_table_unref (result);
return NULL;
} else {
return result;
}
}
static GHashTable *
zenity_notification_parse_hints (gchar *hints)
{
GHashTable *result;
gchar** hint_array;
zenity_notification_parse_hints (gchar *hints) {
GHashTable *result;
gchar **hint_array;
hint_array = g_strsplit (g_strcompress (hints), "\n", MAX_HINTS);
result = zenity_notification_parse_hints_array (hint_array);
g_strfreev (hint_array);
return result;
hint_array = g_strsplit (g_strcompress (hints), "\n", MAX_HINTS);
result = zenity_notification_parse_hints_array (hint_array);
g_strfreev (hint_array);
return result;
}
static void
zenity_notification_set_hint(gpointer key, gpointer value, gpointer user_data)
{
NotifyNotification *notification;
gchar *hint_name;
GVariant *hint_value;
zenity_notification_set_hint (
gpointer key, gpointer value, gpointer user_data) {
NotifyNotification *notification;
gchar *hint_name;
GVariant *hint_value;
gchar *string_value;
gboolean boolean_value;
gint32 int_value;
guchar byte_value;
gchar *string_value;
gboolean boolean_value;
gint32 int_value;
guchar byte_value;
hint_name = (gchar *) key;
string_value = (gchar *) value;
notification = (NotifyNotification *) user_data;
hint_name = (gchar *) key;
string_value = (gchar *) value;
notification = (NotifyNotification *) user_data;
if ((g_ascii_strcasecmp ("action-icons", hint_name) == 0)
|| (g_ascii_strcasecmp ("resident", hint_name) == 0)
|| (g_ascii_strcasecmp ("suppress-sound", hint_name) == 0)
|| (g_ascii_strcasecmp ("transient", hint_name) == 0)) {
/* boolean hints */
if (g_ascii_strcasecmp ("true", string_value) == 0) {
boolean_value = TRUE;
} else if (g_ascii_strcasecmp ("false", string_value) == 0) {
boolean_value = FALSE;
} else {
g_printerr (_("Invalid value for a boolean typed hint.\nSupported values are 'true' or 'false'.\n"));
return;
}
hint_value = g_variant_new_boolean (boolean_value);
} else if ((g_ascii_strcasecmp ("category", hint_name) == 0)
|| (g_ascii_strcasecmp ("desktop-entry", hint_name) == 0)
|| (g_ascii_strcasecmp ("image-path", hint_name) == 0)
|| (g_ascii_strcasecmp ("image_path", hint_name) == 0)
|| (g_ascii_strcasecmp ("sound-file", hint_name) == 0)
|| (g_ascii_strcasecmp ("sound-name", hint_name) == 0)) {
/* string hints */
hint_value = g_variant_new_string (string_value);
} else if ((g_ascii_strcasecmp ("image-data", hint_name) == 0)
|| (g_ascii_strcasecmp ("image_data", hint_name) == 0)
|| (g_ascii_strcasecmp ("icon-data", hint_name) == 0)) {
/* (iibiiay) */
g_printerr (_("Unsupported hint. Skipping.\n"));
return;
} else if ((g_ascii_strcasecmp ("x", hint_name) == 0)
|| (g_ascii_strcasecmp ("y", hint_name) == 0)) {
/* int hints */
if (string_value == NULL)
string_value = "";
int_value = (gint32) g_ascii_strtoll (string_value, NULL, 0);
hint_value = g_variant_new_int32 (int_value);
} else if ((g_ascii_strcasecmp ("urgency", hint_name) == 0)) {
/* byte hints */
if (string_value == NULL)
string_value = "";
byte_value = (guchar) g_ascii_strtoll (string_value, NULL, 0);
hint_value = g_variant_new_byte (byte_value);
} else {
/* unknown hints */
g_printerr (_("Unknown hint name. Skipping.\n"));
return;
}
if ((g_ascii_strcasecmp ("action-icons", hint_name) == 0) ||
(g_ascii_strcasecmp ("resident", hint_name) == 0) ||
(g_ascii_strcasecmp ("suppress-sound", hint_name) == 0) ||
(g_ascii_strcasecmp ("transient", hint_name) == 0)) {
/* boolean hints */
if (g_ascii_strcasecmp ("true", string_value) == 0) {
boolean_value = TRUE;
} else if (g_ascii_strcasecmp ("false", string_value) == 0) {
boolean_value = FALSE;
} else {
g_printerr (_ ("Invalid value for a boolean typed hint.\nSupported "
"values are 'true' or 'false'.\n"));
return;
}
hint_value = g_variant_new_boolean (boolean_value);
} else if ((g_ascii_strcasecmp ("category", hint_name) == 0) ||
(g_ascii_strcasecmp ("desktop-entry", hint_name) == 0) ||
(g_ascii_strcasecmp ("image-path", hint_name) == 0) ||
(g_ascii_strcasecmp ("image_path", hint_name) == 0) ||
(g_ascii_strcasecmp ("sound-file", hint_name) == 0) ||
(g_ascii_strcasecmp ("sound-name", hint_name) == 0)) {
/* string hints */
hint_value = g_variant_new_string (string_value);
} else if ((g_ascii_strcasecmp ("image-data", hint_name) == 0) ||
(g_ascii_strcasecmp ("image_data", hint_name) == 0) ||
(g_ascii_strcasecmp ("icon-data", hint_name) == 0)) {
/* (iibiiay) */
g_printerr (_ ("Unsupported hint. Skipping.\n"));
return;
} else if ((g_ascii_strcasecmp ("x", hint_name) == 0) ||
(g_ascii_strcasecmp ("y", hint_name) == 0)) {
/* int hints */
if (string_value == NULL)
string_value = "";
int_value = (gint32) g_ascii_strtoll (string_value, NULL, 0);
hint_value = g_variant_new_int32 (int_value);
} else if ((g_ascii_strcasecmp ("urgency", hint_name) == 0)) {
/* byte hints */
if (string_value == NULL)
string_value = "";
byte_value = (guchar) g_ascii_strtoll (string_value, NULL, 0);
hint_value = g_variant_new_byte (byte_value);
} else {
/* unknown hints */
g_printerr (_ ("Unknown hint name. Skipping.\n"));
return;
}
notify_notification_set_hint (notification,
hint_name,
hint_value);
notify_notification_set_hint (notification, hint_name, hint_value);
}
static void
zenity_notification_set_hints (NotifyNotification *notification, GHashTable *hints)
{
if (hints == NULL) {
return;
}
zenity_notification_set_hints (
NotifyNotification *notification, GHashTable *hints) {
if (hints == NULL) {
return;
}
g_hash_table_foreach (hints, zenity_notification_set_hint, notification);
g_hash_table_foreach (hints, zenity_notification_set_hint, notification);
}
static gboolean
zenity_notification_handle_stdin (GIOChannel *channel,
GIOCondition condition,
gpointer user_data)
{
if ((condition & G_IO_IN) != 0) {
GString *string;
GError *error = NULL;
zenity_notification_handle_stdin (
GIOChannel *channel, GIOCondition condition, gpointer user_data) {
if ((condition & G_IO_IN) != 0) {
GString *string;
GError *error = NULL;
string = g_string_new (NULL);
while (channel->is_readable == FALSE)
;
do {
gint status;
gchar *command, *value, *colon;
string = g_string_new (NULL);
while (channel->is_readable == FALSE)
;
do {
gint status;
gchar *command, *value, *colon;
do {
status = g_io_channel_read_line_string (channel, string, NULL, &error);
while (gdk_events_pending ())
gtk_main_iteration ();
do {
status = g_io_channel_read_line_string (
channel, string, NULL, &error);
while (gdk_events_pending ())
gtk_main_iteration ();
} while (status == G_IO_STATUS_AGAIN);
} while (status == G_IO_STATUS_AGAIN);
if (status != G_IO_STATUS_NORMAL) {
if (error) {
g_warning ("zenity_notification_handle_stdin () : %s",
error->message);
g_error_free (error);
error = NULL;
if (status != G_IO_STATUS_NORMAL) {
if (error) {
g_warning ("zenity_notification_handle_stdin () : %s",
error->message);
g_error_free (error);
error = NULL;
}
continue;
}
zenity_util_strip_newline (string->str);
colon = strchr (string->str, ':');
if (colon == NULL) {
g_printerr (_ ("Could not parse command from stdin\n"));
continue;
}
/* split off the command and value */
command = g_strstrip (g_strndup (string->str, colon - string->str));
value = colon + 1;
while (*value && g_ascii_isspace (*value))
value++;
if (!g_ascii_strcasecmp (command, "icon")) {
g_free (icon_file);
icon_file = g_strdup (value);
} else if (!g_ascii_strcasecmp (command, "hints")) {
if (notification_hints != NULL) {
g_hash_table_unref (notification_hints);
}
notification_hints = zenity_notification_parse_hints (value);
} else if (!g_ascii_strcasecmp (command, "message")) {
/* display a notification bubble */
if (!g_utf8_validate (value, -1, NULL)) {
g_warning ("Invalid UTF-8 in input!");
} else {
NotifyNotification *notif;
error = NULL;
notif = zenity_notification_new (value, icon_file);
if (notif == NULL)
continue;
zenity_notification_set_hints (notif, notification_hints);
notify_notification_show (notif, &error);
if (error) {
g_warning (
"Error showing notification: %s", error->message);
g_error_free (error);
error = NULL;
}
g_object_unref (notif);
}
} else if (!g_ascii_strcasecmp (command, "tooltip")) {
if (!g_utf8_validate (value, -1, NULL)) {
g_warning ("Invalid UTF-8 in input!");
} else {
NotifyNotification *notif;
notif = zenity_notification_new (value, icon_file);
if (notif == NULL)
continue;
zenity_notification_set_hints (notif, notification_hints);
notify_notification_show (notif, &error);
if (error) {
g_warning (
"Error showing notification: %s", error->message);
g_error_free (error);
error = NULL;
}
}
} else if (!g_ascii_strcasecmp (command, "visible")) {
} else {
g_warning ("Unknown command '%s'", command);
}
g_free (command);
} while (g_io_channel_get_buffer_condition (channel) == G_IO_IN);
g_string_free (string, TRUE);
}
continue;
}
zenity_util_strip_newline (string->str);
colon = strchr(string->str, ':');
if (colon == NULL) {
g_printerr (_("Could not parse command from stdin\n"));
continue;
}
/* split off the command and value */
command = g_strstrip (g_strndup (string->str, colon - string->str));
if ((condition & G_IO_HUP) != 0) {
g_io_channel_shutdown (channel, TRUE, NULL);
return FALSE;
}
value = colon + 1;
while (*value && g_ascii_isspace (*value)) value++;
if (!g_ascii_strcasecmp (command, "icon")) {
g_free (icon_file);
icon_file = g_strdup (value);
} else if (!g_ascii_strcasecmp (command, "hints")) {
if (notification_hints != NULL) {
g_hash_table_unref (notification_hints);
}
notification_hints = zenity_notification_parse_hints (value);
} else if (!g_ascii_strcasecmp (command, "message")) {
/* display a notification bubble */
if (!g_utf8_validate (value, -1, NULL)) {
g_warning ("Invalid UTF-8 in input!");
} else {
NotifyNotification *notif;
error = NULL;
notif = zenity_notification_new (value, icon_file);
if (notif == NULL)
continue;
zenity_notification_set_hints (notif, notification_hints);
notify_notification_show (notif, &error);
if (error) {
g_warning ("Error showing notification: %s", error->message);
g_error_free (error);
error = NULL;
}
g_object_unref (notif);
}
} else if (!g_ascii_strcasecmp (command, "tooltip")) {
if (!g_utf8_validate (value, -1, NULL)) {
g_warning ("Invalid UTF-8 in input!");
} else {
NotifyNotification *notif;
notif = zenity_notification_new (value, icon_file);
if (notif == NULL)
continue;
zenity_notification_set_hints (notif, notification_hints);
notify_notification_show (notif, &error);
if (error) {
g_warning ("Error showing notification: %s", error->message);
g_error_free (error);
error = NULL;
}
}
} else if (!g_ascii_strcasecmp (command, "visible")) {
} else {
g_warning ("Unknown command '%s'", command);
}
g_free (command);
} while (g_io_channel_get_buffer_condition (channel) == G_IO_IN);
g_string_free (string, TRUE);
}
if ((condition & G_IO_HUP) != 0) {
g_io_channel_shutdown (channel, TRUE, NULL);
return FALSE;
}
return TRUE;
return TRUE;
}
static void
zenity_notification_listen_on_stdin (ZenityData *data)
{
GIOChannel *channel;
zenity_notification_listen_on_stdin (ZenityData *data) {
GIOChannel *channel;
channel = g_io_channel_unix_new (0);
g_io_channel_set_encoding (channel, NULL, NULL);
g_io_channel_set_flags (channel, G_IO_FLAG_NONBLOCK, NULL);
g_io_add_watch (channel, G_IO_IN | G_IO_HUP,
zenity_notification_handle_stdin, data);
channel = g_io_channel_unix_new (0);
g_io_channel_set_encoding (channel, NULL, NULL);
g_io_channel_set_flags (channel, G_IO_FLAG_NONBLOCK, NULL);
g_io_add_watch (
channel, G_IO_IN | G_IO_HUP, zenity_notification_handle_stdin, data);
}
void
zenity_notification (ZenityData *data, ZenityNotificationData *notification_data)
{
GError *error;
NotifyNotification *notification;
GHashTable *notification_hints;
zenity_notification (
ZenityData *data, ZenityNotificationData *notification_data) {
GError *error;
NotifyNotification *notification;
GHashTable *notification_hints;
/* create the notification widget */
if (!notify_is_initted ()) {
notify_init (_("Zenity notification"));
}
/* create the notification widget */
if (!notify_is_initted ()) {
notify_init (_ ("Zenity notification"));
}
if (notification_data->listen) {
zenity_notification_listen_on_stdin (data);
gtk_main();
} else {
if (notification_data->notification_text == NULL) {
exit (1);
}
if (notification_data->listen) {
zenity_notification_listen_on_stdin (data);
gtk_main ();
} else {
if (notification_data->notification_text == NULL) {
exit (1);
}
notification = zenity_notification_new (notification_data->notification_text,
data->window_icon);
notification = zenity_notification_new (
notification_data->notification_text, data->window_icon);
if (notification == NULL) {
exit (1);
}
if (notification == NULL) {
exit (1);
}
/* if we aren't listening for changes, then close on default action */
notify_notification_add_action (notification,
"default",
"Do Default Action",
(NotifyActionCallback) on_notification_default_action,
data,
NULL);
/* if we aren't listening for changes, then close on default action */
notify_notification_add_action (notification,
"default",
"Do Default Action",
(NotifyActionCallback) on_notification_default_action,
data,
NULL);
/* set the notification hints for the displayed notification */
if (notification_data->notification_hints != NULL) {
notification_hints = zenity_notification_parse_hints_array (notification_data->notification_hints);
zenity_notification_set_hints(notification, notification_hints);
g_hash_table_unref (notification_hints);
}
/* set the notification hints for the displayed notification */
if (notification_data->notification_hints != NULL) {
notification_hints = zenity_notification_parse_hints_array (
notification_data->notification_hints);
zenity_notification_set_hints (notification, notification_hints);
g_hash_table_unref (notification_hints);
}
/* Show icon and wait */
error = NULL;
if (!notify_notification_show (notification, &error)) {
if (error != NULL) {
g_warning ("Error showing notification: %s", error->message);
g_error_free (error);
}
exit (1);
}
/* Show icon and wait */
error = NULL;
if (!notify_notification_show (notification, &error)) {
if (error != NULL) {
g_warning ("Error showing notification: %s", error->message);
g_error_free (error);
}
exit (1);
}
}
}
if (data->timeout_delay > 0) {
g_timeout_add_seconds (data->timeout_delay, (GSourceFunc) zenity_util_timeout_handle, NULL);
gtk_main();
}
if (data->timeout_delay > 0) {
g_timeout_add_seconds (data->timeout_delay,
(GSourceFunc) zenity_util_timeout_handle,
NULL);
gtk_main ();
}
}
#endif

4014
src/option.c
View File

File diff suppressed because it is too large Load Diff

80
src/option.h
View File

@ -31,61 +31,59 @@
#endif
typedef enum {
MODE_CALENDAR,
MODE_ENTRY,
MODE_ERROR,
MODE_FILE,
MODE_LIST,
MODE_PROGRESS,
MODE_QUESTION,
MODE_TEXTINFO,
MODE_WARNING,
MODE_SCALE,
MODE_INFO,
MODE_CALENDAR,
MODE_ENTRY,
MODE_ERROR,
MODE_FILE,
MODE_LIST,
MODE_PROGRESS,
MODE_QUESTION,
MODE_TEXTINFO,
MODE_WARNING,
MODE_SCALE,
MODE_INFO,
#ifdef HAVE_LIBNOTIFY
MODE_NOTIFICATION,
MODE_NOTIFICATION,
#endif
MODE_COLOR,
MODE_PASSWORD,
MODE_FORMS,
MODE_ABOUT,
MODE_VERSION,
MODE_LAST
MODE_COLOR,
MODE_PASSWORD,
MODE_FORMS,
MODE_ABOUT,
MODE_VERSION,
MODE_LAST
} ZenityDialogMode;
typedef enum {
ERROR_SYNTAX,
ERROR_SUPPORT,
ERROR_DIALOG,
ERROR_LAST
ERROR_SYNTAX,
ERROR_SUPPORT,
ERROR_DIALOG,
ERROR_LAST
} ZenityError;
typedef struct {
ZenityDialogMode mode;
ZenityData *data;
ZenityDialogMode mode;
ZenityData *data;
ZenityCalendarData *calendar_data;
ZenityMsgData *msg_data;
ZenityScaleData *scale_data;
ZenityFileData *file_data;
ZenityEntryData *entry_data;
ZenityProgressData *progress_data;
ZenityTextData *text_data;
ZenityTreeData *tree_data;
ZenityCalendarData *calendar_data;
ZenityMsgData *msg_data;
ZenityScaleData *scale_data;
ZenityFileData *file_data;
ZenityEntryData *entry_data;
ZenityProgressData *progress_data;
ZenityTextData *text_data;
ZenityTreeData *tree_data;
#ifdef HAVE_LIBNOTIFY
ZenityNotificationData *notification_data;
ZenityNotificationData *notification_data;
#endif
ZenityColorData *color_data;
ZenityPasswordData *password_data;
ZenityFormsData *forms_data;
ZenityColorData *color_data;
ZenityPasswordData *password_data;
ZenityFormsData *forms_data;
} ZenityParsingOptions;
void zenity_option_error (gchar *string,
ZenityError error);
void zenity_option_error (gchar *string, ZenityError error);
ZenityParsingOptions * zenity_option_parse (gint argc,
gchar **argv);
ZenityParsingOptions *zenity_option_parse (gint argc, gchar **argv);
void zenity_option_free (void);
void zenity_option_free (void);
#endif /* OPTION_H */

258
src/password.c
View File

@ -22,168 +22,152 @@
*/
#include "config.h"
#include <string.h>
#include "zenity.h"
#include "util.h"
#include "zenity.h"
#include <string.h>
static ZenityData *zen_data;
static void zenity_password_dialog_response (GtkWidget *widget, int response, gpointer data);
static void zenity_password_dialog_response (
GtkWidget *widget, int response, gpointer data);
void zenity_password_dialog (ZenityData *data, ZenityPasswordData *password_data)
{
GtkWidget *dialog;
GtkWidget *image;
GtkWidget *hbox;
GtkWidget *vbox_labels;
GtkWidget *vbox_entries;
GtkWidget *label;
void
zenity_password_dialog (ZenityData *data, ZenityPasswordData *password_data) {
GtkWidget *dialog;
GtkWidget *image;
GtkWidget *hbox;
GtkWidget *vbox_labels;
GtkWidget *vbox_entries;
GtkWidget *label;
zen_data = data;
zen_data = data;
dialog = gtk_dialog_new ();
dialog = gtk_dialog_new ();
if (data->extra_label) {
gint i=0;
while(data->extra_label[i]!=NULL){
gtk_dialog_add_button (GTK_DIALOG (dialog), data->extra_label[i], i);
i++;
}
}
if (data->extra_label) {
gint i = 0;
while (data->extra_label[i] != NULL) {
gtk_dialog_add_button (
GTK_DIALOG (dialog), data->extra_label[i], i);
i++;
}
}
gtk_dialog_add_button(GTK_DIALOG(dialog),
data->cancel_label != NULL ? data->cancel_label : _("_Cancel"),
GTK_RESPONSE_CANCEL);
gtk_dialog_add_button(GTK_DIALOG(dialog),
data->ok_label != NULL ? data->ok_label : _("_OK"),
GTK_RESPONSE_OK);
image = gtk_image_new_from_icon_name("dialog-password",
GTK_ICON_SIZE_DIALOG);
gtk_dialog_set_default_response(GTK_DIALOG(dialog),
GTK_RESPONSE_OK);
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
gtk_box_pack_start(GTK_BOX(hbox),
image,
FALSE,
FALSE,
12);
gtk_dialog_add_button (GTK_DIALOG (dialog),
data->cancel_label != NULL ? data->cancel_label : _ ("_Cancel"),
GTK_RESPONSE_CANCEL);
gtk_dialog_add_button (GTK_DIALOG (dialog),
data->ok_label != NULL ? data->ok_label : _ ("_OK"),
GTK_RESPONSE_OK);
/* Checks if username has been passed as a parameter */
gchar *title_text = N_("Type your password");
image =
gtk_image_new_from_icon_name ("dialog-password", GTK_ICON_SIZE_DIALOG);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 12);
if(password_data->username)
title_text = N_("Type your username and password");
/* Checks if username has been passed as a parameter */
gchar *title_text = N_ ("Type your password");
label = gtk_label_new(title_text);
if (password_data->username)
title_text = N_ ("Type your username and password");
gtk_box_pack_start(GTK_BOX(hbox),
label,
FALSE,
FALSE,
12);
gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))),
hbox,
FALSE,
TRUE,
5);
vbox_labels = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
vbox_entries = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
label = gtk_label_new (title_text);
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))),
hbox,
FALSE,
TRUE,
5);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 12);
gtk_box_pack_start (
GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
hbox,
FALSE,
TRUE,
5);
gtk_box_pack_start(GTK_BOX(hbox),
vbox_labels,
FALSE,
TRUE,
12);
gtk_box_pack_start(GTK_BOX(hbox),
vbox_entries,
TRUE,
TRUE,
12);
vbox_labels = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
vbox_entries = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
if(password_data->username) {
label = gtk_label_new(_("Username:"));
gtk_box_pack_start(GTK_BOX(vbox_labels),
label,
TRUE,
FALSE,
12);
password_data->entry_username = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(vbox_entries),
password_data->entry_username,
TRUE,
TRUE,
12);
}
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
gtk_box_pack_start (
GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
hbox,
FALSE,
TRUE,
5);
label = gtk_label_new(_("Password:"));
gtk_box_pack_start(GTK_BOX(vbox_labels),
label,
TRUE,
FALSE,
12);
password_data->entry_password = gtk_entry_new();
gtk_entry_set_visibility(GTK_ENTRY(password_data->entry_password),
FALSE);
gtk_entry_set_activates_default (GTK_ENTRY(password_data->entry_password),
TRUE);
gtk_box_pack_start(GTK_BOX(vbox_entries),
password_data->entry_password,
TRUE,
TRUE,
12);
gtk_box_pack_start (GTK_BOX (hbox), vbox_labels, FALSE, TRUE, 12);
gtk_box_pack_start (GTK_BOX (hbox), vbox_entries, TRUE, TRUE, 12);
if (data->dialog_title)
gtk_window_set_title (GTK_WINDOW (dialog), data->dialog_title);
if (password_data->username) {
label = gtk_label_new (_ ("Username:"));
gtk_box_pack_start (GTK_BOX (vbox_labels), label, TRUE, FALSE, 12);
password_data->entry_username = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX (vbox_entries),
password_data->entry_username,
TRUE,
TRUE,
12);
}
if (data->modal)
gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
label = gtk_label_new (_ ("Password:"));
gtk_box_pack_start (GTK_BOX (vbox_labels), label, TRUE, FALSE, 12);
password_data->entry_password = gtk_entry_new ();
gtk_entry_set_visibility (GTK_ENTRY (password_data->entry_password), FALSE);
gtk_entry_set_activates_default (
GTK_ENTRY (password_data->entry_password), TRUE);
gtk_box_pack_start (
GTK_BOX (vbox_entries), password_data->entry_password, TRUE, TRUE, 12);
g_signal_connect (G_OBJECT (dialog), "response",
G_CALLBACK (zenity_password_dialog_response),
password_data);
gtk_widget_show_all(GTK_WIDGET(gtk_dialog_get_content_area(GTK_DIALOG(dialog))));
zenity_util_show_dialog (dialog, data->attach);
if (data->dialog_title)
gtk_window_set_title (GTK_WINDOW (dialog), data->dialog_title);
if (data->timeout_delay > 0) {
g_timeout_add_seconds (data->timeout_delay,
(GSourceFunc) zenity_util_timeout_handle,
dialog);
}
gtk_main();
if (data->modal)
gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
g_signal_connect (G_OBJECT (dialog),
"response",
G_CALLBACK (zenity_password_dialog_response),
password_data);
gtk_widget_show_all (
GTK_WIDGET (gtk_dialog_get_content_area (GTK_DIALOG (dialog))));
zenity_util_show_dialog (dialog, data->attach);
if (data->timeout_delay > 0) {
g_timeout_add_seconds (data->timeout_delay,
(GSourceFunc) zenity_util_timeout_handle,
dialog);
}
gtk_main ();
}
static void
zenity_password_dialog_response (GtkWidget *widget, int response, gpointer data)
{
ZenityPasswordData *password_data = (ZenityPasswordData *) data;
switch (response) {
case GTK_RESPONSE_OK:
zenity_util_exit_code_with_data(ZENITY_OK, zen_data);
if (password_data->username)
g_print("%s|%s\n", gtk_entry_get_text (GTK_ENTRY(password_data->entry_username)), gtk_entry_get_text (GTK_ENTRY(password_data->entry_password)));
else
g_print ("%s\n", gtk_entry_get_text (GTK_ENTRY(password_data->entry_password)));
break;
zenity_password_dialog_response (
GtkWidget *widget, int response, gpointer data) {
ZenityPasswordData *password_data = (ZenityPasswordData *) data;
switch (response) {
case GTK_RESPONSE_OK:
zenity_util_exit_code_with_data (ZENITY_OK, zen_data);
if (password_data->username)
g_print ("%s|%s\n",
gtk_entry_get_text (
GTK_ENTRY (password_data->entry_username)),
gtk_entry_get_text (
GTK_ENTRY (password_data->entry_password)));
else
g_print ("%s\n",
gtk_entry_get_text (
GTK_ENTRY (password_data->entry_password)));
break;
case GTK_RESPONSE_CANCEL:
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_CANCEL);
break;
case GTK_RESPONSE_CANCEL:
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_CANCEL);
break;
default:
if (zen_data->extra_label && response < g_strv_length(zen_data->extra_label))
printf("%s\n",zen_data->extra_label[response]);
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_ESC);
break;
}
default:
if (zen_data->extra_label &&
response < g_strv_length (zen_data->extra_label))
printf ("%s\n", zen_data->extra_label[response]);
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_ESC);
break;
}
gtk_main_quit ();
gtk_main_quit ();
}

571
src/progress.c
View File

@ -23,15 +23,15 @@
#include "config.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
#include <signal.h>
#include <time.h>
#include "zenity.h"
#include "util.h"
#include "zenity.h"
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <time.h>
#include <unistd.h>
static GtkBuilder *builder;
static ZenityData *zen_data;
@ -45,358 +45,385 @@ static gboolean auto_close;
gint zenity_progress_timeout (gpointer data);
gint zenity_progress_pulsate_timeout (gpointer data);
static void zenity_progress_dialog_response (GtkWidget *widget, int response, gpointer data);
static void zenity_progress_dialog_response (
GtkWidget *widget, int response, gpointer data);
static gboolean
zenity_progress_pulsate_progress_bar (gpointer user_data)
{
gtk_progress_bar_pulse (GTK_PROGRESS_BAR (user_data));
return TRUE;
zenity_progress_pulsate_progress_bar (gpointer user_data) {
gtk_progress_bar_pulse (GTK_PROGRESS_BAR (user_data));
return TRUE;
}
static void
zenity_progress_pulsate_stop (void)
{
if (pulsate_timeout > 0) {
g_source_remove (pulsate_timeout);
pulsate_timeout = -1;
}
zenity_progress_pulsate_stop (void) {
if (pulsate_timeout > 0) {
g_source_remove (pulsate_timeout);
pulsate_timeout = -1;
}
}
static void
zenity_progress_pulsate_start (GObject *progress_bar)
{
if (pulsate_timeout == -1) {
pulsate_timeout = g_timeout_add (100,
zenity_progress_pulsate_progress_bar,
progress_bar);
}
zenity_progress_pulsate_start (GObject *progress_bar) {
if (pulsate_timeout == -1) {
pulsate_timeout = g_timeout_add (
100, zenity_progress_pulsate_progress_bar, progress_bar);
}
}
static void
zenity_progress_update_time_remaining (ZenityProgressData *progress_data)
{
static GObject *progress_time = NULL;
static time_t start_time = (time_t)(-1);
float percentage = progress_data->percentage;
zenity_progress_update_time_remaining (ZenityProgressData *progress_data) {
static GObject *progress_time = NULL;
static time_t start_time = (time_t) (-1);
float percentage = progress_data->percentage;
if (progress_time == NULL)
progress_time = gtk_builder_get_object (builder, "zenity_progress_time");
if (start_time == (time_t)(-1) || percentage <= 0.0 || percentage >= 100.0) {
start_time = time(NULL);
gtk_label_set_text (GTK_LABEL (progress_time), "");
} else {
time_t current_time = time (NULL);
time_t elapsed_time = current_time - start_time;
time_t total_time = (time_t) (100.0*elapsed_time/progress_data->percentage);
time_t remaining_time = total_time - elapsed_time;
gulong hours, minutes, seconds;
gchar *remaining_message;
if (progress_time == NULL)
progress_time =
gtk_builder_get_object (builder, "zenity_progress_time");
if (start_time == (time_t) (-1) || percentage <= 0.0 ||
percentage >= 100.0) {
start_time = time (NULL);
gtk_label_set_text (GTK_LABEL (progress_time), "");
} else {
time_t current_time = time (NULL);
time_t elapsed_time = current_time - start_time;
time_t total_time =
(time_t) (100.0 * elapsed_time / progress_data->percentage);
time_t remaining_time = total_time - elapsed_time;
gulong hours, minutes, seconds;
gchar *remaining_message;
seconds = (gulong) (remaining_time%60);
remaining_time /= 60;
minutes = (gulong) (remaining_time%60);
remaining_time /= 60;
hours = (gulong) remaining_time;
seconds = (gulong) (remaining_time % 60);
remaining_time /= 60;
minutes = (gulong) (remaining_time % 60);
remaining_time /= 60;
hours = (gulong) remaining_time;
remaining_message = g_strdup_printf (_("Time remaining: %lu:%02lu:%02lu"),
hours, minutes, seconds);
gtk_label_set_text (GTK_LABEL (progress_time), remaining_message);
g_free (remaining_message);
}
remaining_message = g_strdup_printf (
_ ("Time remaining: %lu:%02lu:%02lu"), hours, minutes, seconds);
gtk_label_set_text (GTK_LABEL (progress_time), remaining_message);
g_free (remaining_message);
}
}
static gboolean
zenity_progress_handle_stdin (GIOChannel *channel,
GIOCondition condition,
gpointer data)
{
static ZenityProgressData *progress_data;
static GObject *progress_bar;
static GObject *progress_label;
float percentage = 0.0;
GIOStatus status = G_IO_STATUS_NORMAL;
progress_data = (ZenityProgressData *) data;
progress_bar = gtk_builder_get_object (builder, "zenity_progress_bar");
progress_label = gtk_builder_get_object (builder, "zenity_progress_text");
zenity_progress_handle_stdin (
GIOChannel *channel, GIOCondition condition, gpointer data) {
static ZenityProgressData *progress_data;
static GObject *progress_bar;
static GObject *progress_label;
float percentage = 0.0;
GIOStatus status = G_IO_STATUS_NORMAL;
if ((condition & G_IO_IN) != 0) {
GString *string;
GError *error = NULL;
progress_data = (ZenityProgressData *) data;
progress_bar = gtk_builder_get_object (builder, "zenity_progress_bar");
progress_label = gtk_builder_get_object (builder, "zenity_progress_text");
string = g_string_new (NULL);
if ((condition & G_IO_IN) != 0) {
GString *string;
GError *error = NULL;
while (channel->is_readable != TRUE)
;
do {
do {
status = g_io_channel_read_line_string (channel, string, NULL, &error);
string = g_string_new (NULL);
while (gtk_events_pending ())
gtk_main_iteration ();
while (channel->is_readable != TRUE)
;
do {
do {
status = g_io_channel_read_line_string (
channel, string, NULL, &error);
} while (status == G_IO_STATUS_AGAIN);
while (gtk_events_pending ())
gtk_main_iteration ();
if (status != G_IO_STATUS_NORMAL) {
if (error) {
g_warning ("zenity_progress_handle_stdin () : %s", error->message);
g_error_free (error);
error = NULL;
}
continue;
}
} while (status == G_IO_STATUS_AGAIN);
if (!g_ascii_strncasecmp (string->str, "#", 1)) {
gchar *match;
if (status != G_IO_STATUS_NORMAL) {
if (error) {
g_warning (
"zenity_progress_handle_stdin () : %s", error->message);
g_error_free (error);
error = NULL;
}
continue;
}
/* We have a comment, so let's try to change the label */
match = g_strstr_len (string->str, strlen (string->str), "#");
match++;
gtk_label_set_text (GTK_LABEL (progress_label), g_strcompress(g_strchomp (g_strchug (match))));
if (!g_ascii_strncasecmp (string->str, "#", 1)) {
gchar *match;
} else if (g_str_has_prefix (string->str, "pulsate")) {
gchar *colon, *command, *value;
/* We have a comment, so let's try to change the label */
match = g_strstr_len (string->str, strlen (string->str), "#");
match++;
gtk_label_set_text (GTK_LABEL (progress_label),
g_strcompress (g_strchomp (g_strchug (match))));
zenity_util_strip_newline (string->str);
} else if (g_str_has_prefix (string->str, "pulsate")) {
gchar *colon, *command, *value;
colon = strchr(string->str, ':');
if (colon == NULL) {
continue;
}
zenity_util_strip_newline (string->str);
/* split off the command and value */
command = g_strstrip (g_strndup (string->str, colon - string->str));
colon = strchr (string->str, ':');
if (colon == NULL) {
continue;
}
value = colon + 1;
while (*value && g_ascii_isspace (*value)) value++;
/* split off the command and value */
command =
g_strstrip (g_strndup (string->str, colon - string->str));
if (!g_ascii_strcasecmp (value, "false")) {
zenity_progress_pulsate_stop ();
value = colon + 1;
while (*value && g_ascii_isspace (*value))
value++;
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (progress_bar),
progress_data->percentage / 100.0);
} else {
zenity_progress_pulsate_start (progress_bar);
}
if (!g_ascii_strcasecmp (value, "false")) {
zenity_progress_pulsate_stop ();
g_free (command);
} else {
gtk_progress_bar_set_fraction (
GTK_PROGRESS_BAR (progress_bar),
progress_data->percentage / 100.0);
} else {
zenity_progress_pulsate_start (progress_bar);
}
if (!g_ascii_isdigit (*(string->str)))
continue;
g_free (command);
} else {
/* Now try to convert the thing to a number */
percentage = CLAMP(atoi (string->str), 0, 100);
if (!g_ascii_isdigit (*(string->str)))
continue;
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (progress_bar),
percentage / 100.0);
/* Now try to convert the thing to a number */
percentage = CLAMP (atoi (string->str), 0, 100);
progress_data->percentage = percentage;
gtk_progress_bar_set_fraction (
GTK_PROGRESS_BAR (progress_bar), percentage / 100.0);
if (progress_data->time_remaining == TRUE)
zenity_progress_update_time_remaining (progress_data);
progress_data->percentage = percentage;
if (percentage == 100) {
GObject *button;
if (progress_data->time_remaining == TRUE)
zenity_progress_update_time_remaining (progress_data);
button = gtk_builder_get_object(builder, "zenity_progress_ok_button");
gtk_widget_set_sensitive(GTK_WIDGET (button), TRUE);
gtk_widget_grab_focus(GTK_WIDGET (button));
if (percentage == 100) {
GObject *button;
if (progress_data->autoclose) {
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_OK);
gtk_main_quit();
}
}
}
button = gtk_builder_get_object (
builder, "zenity_progress_ok_button");
gtk_widget_set_sensitive (GTK_WIDGET (button), TRUE);
gtk_widget_grab_focus (GTK_WIDGET (button));
} while ((g_io_channel_get_buffer_condition (channel) & G_IO_IN) == G_IO_IN && status != G_IO_STATUS_EOF);
g_string_free (string, TRUE);
}
if (progress_data->autoclose) {
zen_data->exit_code =
zenity_util_return_exit_code (ZENITY_OK);
gtk_main_quit ();
}
}
}
if ((condition & G_IO_IN) != G_IO_IN || status == G_IO_STATUS_EOF) {
/* We assume that we are done, so stop the pulsating and de-sensitize the buttons */
GtkWidget *button;
} while ((g_io_channel_get_buffer_condition (channel) & G_IO_IN) ==
G_IO_IN &&
status != G_IO_STATUS_EOF);
g_string_free (string, TRUE);
}
button = GTK_WIDGET (gtk_builder_get_object (builder,
"zenity_progress_ok_button"));
gtk_widget_set_sensitive (button, TRUE);
gtk_widget_grab_focus (button);
if ((condition & G_IO_IN) != G_IO_IN || status == G_IO_STATUS_EOF) {
/* We assume that we are done, so stop the pulsating and de-sensitize
* the buttons */
GtkWidget *button;
button = GTK_WIDGET (gtk_builder_get_object (builder,
"zenity_progress_cancel_button"));
button = GTK_WIDGET (
gtk_builder_get_object (builder, "zenity_progress_ok_button"));
gtk_widget_set_sensitive (button, TRUE);
gtk_widget_grab_focus (button);
gtk_widget_set_sensitive (button, FALSE);
button = GTK_WIDGET (
gtk_builder_get_object (builder, "zenity_progress_cancel_button"));
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (progress_bar), 1.0);
gtk_widget_set_sensitive (button, FALSE);
zenity_progress_pulsate_stop ();
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (progress_bar), 1.0);
g_object_unref (builder);
zenity_progress_pulsate_stop ();
if (progress_data->autoclose) {
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_OK);
gtk_main_quit();
}
g_object_unref (builder);
g_io_channel_shutdown (channel, TRUE, NULL);
return FALSE;
}
return TRUE;
if (progress_data->autoclose) {
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_OK);
gtk_main_quit ();
}
g_io_channel_shutdown (channel, TRUE, NULL);
return FALSE;
}
return TRUE;
}
static void
zenity_progress_read_info (ZenityProgressData *progress_data)
{
channel = g_io_channel_unix_new (0);
g_io_channel_set_encoding (channel, NULL, NULL);
g_io_channel_set_flags (channel, G_IO_FLAG_NONBLOCK, NULL);
g_io_add_watch (channel, G_IO_IN | G_IO_HUP, zenity_progress_handle_stdin, progress_data);
/* We need to check the pulsate state here, because, the g_io_add_watch
doesn't call the zenity_progress_handle_stdin function if there's no
input. This fix the Bug 567663 */
if (progress_data->pulsate) {
GObject *progress_bar = gtk_builder_get_object (builder, "zenity_progress_bar");
zenity_progress_pulsate_start (progress_bar);
}
zenity_progress_read_info (ZenityProgressData *progress_data) {
channel = g_io_channel_unix_new (0);
g_io_channel_set_encoding (channel, NULL, NULL);
g_io_channel_set_flags (channel, G_IO_FLAG_NONBLOCK, NULL);
g_io_add_watch (channel,
G_IO_IN | G_IO_HUP,
zenity_progress_handle_stdin,
progress_data);
/* We need to check the pulsate state here, because, the g_io_add_watch
doesn't call the zenity_progress_handle_stdin function if there's no
input. This fix the Bug 567663 */
if (progress_data->pulsate) {
GObject *progress_bar =
gtk_builder_get_object (builder, "zenity_progress_bar");
zenity_progress_pulsate_start (progress_bar);
}
}
static void
zenity_text_size_allocate (GtkWidget *widget, GtkAllocation *allocation, gpointer data)
{
gtk_widget_set_size_request (widget, allocation->width/2, -1);
zenity_text_size_allocate (
GtkWidget *widget, GtkAllocation *allocation, gpointer data) {
gtk_widget_set_size_request (widget, allocation->width / 2, -1);
}
void
zenity_progress (ZenityData *data, ZenityProgressData *progress_data)
{
GtkWidget *dialog;
GtkWidget *button;
GObject *text;
GObject *progress_bar;
GObject *cancel_button,*ok_button;
zenity_progress (ZenityData *data, ZenityProgressData *progress_data) {
GtkWidget *dialog;
GtkWidget *button;
GObject *text;
GObject *progress_bar;
GObject *cancel_button, *ok_button;
zen_data = data;
builder = zenity_util_load_ui_file ("zenity_progress_dialog", NULL);
zen_data = data;
builder = zenity_util_load_ui_file ("zenity_progress_dialog", NULL);
if (builder == NULL) {
data->exit_code = zenity_util_return_exit_code (ZENITY_ERROR);
return;
}
if (builder == NULL) {
data->exit_code = zenity_util_return_exit_code (ZENITY_ERROR);
return;
}
gtk_builder_connect_signals (builder, NULL);
gtk_builder_connect_signals (builder, NULL);
text = gtk_builder_get_object (builder, "zenity_progress_text");
text = gtk_builder_get_object (builder, "zenity_progress_text");
dialog = GTK_WIDGET (gtk_builder_get_object (builder,
"zenity_progress_dialog"));
dialog =
GTK_WIDGET (gtk_builder_get_object (builder, "zenity_progress_dialog"));
progress_bar = gtk_builder_get_object (builder, "zenity_progress_bar");
progress_bar = gtk_builder_get_object (builder, "zenity_progress_bar");
g_signal_connect (G_OBJECT (dialog), "response",
G_CALLBACK (zenity_progress_dialog_response), data);
g_signal_connect (G_OBJECT (dialog),
"response",
G_CALLBACK (zenity_progress_dialog_response),
data);
if (data->dialog_title)
gtk_window_set_title (GTK_WINDOW (dialog), data->dialog_title);
if (data->dialog_title)
gtk_window_set_title (GTK_WINDOW (dialog), data->dialog_title);
zenity_util_set_window_icon (dialog, data->window_icon, ZENITY_IMAGE_FULLPATH ("zenity-progress.png"));
zenity_util_set_window_icon (dialog,
data->window_icon,
ZENITY_IMAGE_FULLPATH ("zenity-progress.png"));
if (data->width > -1 || data->height > -1)
gtk_window_set_default_size (GTK_WINDOW (dialog), data->width, data->height);
if (data->width > -1 || data->height > -1)
gtk_window_set_default_size (
GTK_WINDOW (dialog), data->width, data->height);
if (data->width > -1) {
gtk_widget_set_size_request (GTK_WIDGET (text), data->width, -1);
}
else {
g_signal_connect_after (G_OBJECT (text), "size-allocate",
G_CALLBACK (zenity_text_size_allocate), data);
g_signal_connect_after (G_OBJECT (progress_bar), "size-allocate",
G_CALLBACK (zenity_text_size_allocate), data);
}
if (data->width > -1) {
gtk_widget_set_size_request (GTK_WIDGET (text), data->width, -1);
} else {
g_signal_connect_after (G_OBJECT (text),
"size-allocate",
G_CALLBACK (zenity_text_size_allocate),
data);
g_signal_connect_after (G_OBJECT (progress_bar),
"size-allocate",
G_CALLBACK (zenity_text_size_allocate),
data);
}
if (data->modal)
gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
if (data->modal)
gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
if (data->extra_label) {
gint i=0;
while(data->extra_label[i]!=NULL){
gtk_dialog_add_button (GTK_DIALOG (dialog), data->extra_label[i], i);
i++;
}
}
if (data->extra_label) {
gint i = 0;
while (data->extra_label[i] != NULL) {
gtk_dialog_add_button (
GTK_DIALOG (dialog), data->extra_label[i], i);
i++;
}
}
if (data->ok_label) {
button = GTK_WIDGET (gtk_builder_get_object (builder, "zenity_progress_ok_button"));
gtk_button_set_label (GTK_BUTTON (button), data->ok_label);
}
if (data->ok_label) {
button = GTK_WIDGET (
gtk_builder_get_object (builder, "zenity_progress_ok_button"));
gtk_button_set_label (GTK_BUTTON (button), data->ok_label);
}
if (data->cancel_label) {
button = GTK_WIDGET (gtk_builder_get_object (builder, "zenity_progress_cancel_button"));
gtk_button_set_label (GTK_BUTTON (button), data->cancel_label);
}
if (data->cancel_label) {
button = GTK_WIDGET (
gtk_builder_get_object (builder, "zenity_progress_cancel_button"));
gtk_button_set_label (GTK_BUTTON (button), data->cancel_label);
}
if (progress_data->dialog_text)
gtk_label_set_markup (GTK_LABEL (text), g_strcompress (progress_data->dialog_text));
if (progress_data->dialog_text)
gtk_label_set_markup (
GTK_LABEL (text), g_strcompress (progress_data->dialog_text));
if (progress_data->percentage > -1)
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (progress_bar),
progress_data->percentage/100.0);
if (progress_data->percentage > -1)
gtk_progress_bar_set_fraction (
GTK_PROGRESS_BAR (progress_bar), progress_data->percentage / 100.0);
autokill = progress_data->autokill;
autokill = progress_data->autokill;
auto_close = progress_data->autoclose;
ok_button = gtk_builder_get_object (builder, "zenity_progress_ok_button");
auto_close = progress_data->autoclose;
ok_button = gtk_builder_get_object (builder, "zenity_progress_ok_button");
no_cancel = progress_data->no_cancel;
cancel_button = gtk_builder_get_object (builder, "zenity_progress_cancel_button");
no_cancel = progress_data->no_cancel;
cancel_button =
gtk_builder_get_object (builder, "zenity_progress_cancel_button");
if (no_cancel) {
gtk_widget_hide (GTK_WIDGET(cancel_button));
gtk_window_set_deletable (GTK_WINDOW (dialog), FALSE);
}
if (no_cancel) {
gtk_widget_hide (GTK_WIDGET (cancel_button));
gtk_window_set_deletable (GTK_WINDOW (dialog), FALSE);
}
if (no_cancel && auto_close)
gtk_widget_hide(GTK_WIDGET(ok_button));
if (no_cancel && auto_close)
gtk_widget_hide (GTK_WIDGET (ok_button));
zenity_util_show_dialog (dialog, data->attach);
zenity_progress_read_info (progress_data);
zenity_util_show_dialog (dialog, data->attach);
zenity_progress_read_info (progress_data);
if(data->timeout_delay > 0) {
g_timeout_add_seconds (data->timeout_delay, (GSourceFunc) zenity_util_timeout_handle, NULL);
}
if (data->timeout_delay > 0) {
g_timeout_add_seconds (data->timeout_delay,
(GSourceFunc) zenity_util_timeout_handle,
NULL);
}
gtk_main ();
gtk_main ();
}
static void
zenity_progress_dialog_response (GtkWidget *widget, int response, gpointer data)
{
switch (response) {
case GTK_RESPONSE_OK:
zenity_util_exit_code_with_data(ZENITY_OK, zen_data);
break;
zenity_progress_dialog_response (
GtkWidget *widget, int response, gpointer data) {
switch (response) {
case GTK_RESPONSE_OK:
zenity_util_exit_code_with_data (ZENITY_OK, zen_data);
break;
case GTK_RESPONSE_CANCEL:
/* We do not want to kill the parent process, in order to give the user
the ability to choose the action to be taken. See bug #310824.
But we want to give people the option to choose this behavior.
-- Monday 27, March 2006
*/
if (autokill) {
kill (getppid (), 1);
}
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_CANCEL);
break;
case GTK_RESPONSE_CANCEL:
/* We do not want to kill the parent process, in order to give the
user
the ability to choose the action to be taken. See bug #310824.
But we want to give people the option to choose this behavior.
-- Monday 27, March 2006
*/
if (autokill) {
kill (getppid (), 1);
}
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_CANCEL);
break;
case ZENITY_TIMEOUT:
zenity_util_exit_code_with_data (ZENITY_TIMEOUT, zen_data);
break;
default:
if (zen_data->extra_label && response < g_strv_length(zen_data->extra_label))
printf("%s\n",zen_data->extra_label[response]);
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_ESC);
break;
}
gtk_main_quit ();
case ZENITY_TIMEOUT:
zenity_util_exit_code_with_data (ZENITY_TIMEOUT, zen_data);
break;
default:
if (zen_data->extra_label &&
response < g_strv_length (zen_data->extra_label))
printf ("%s\n", zen_data->extra_label[response]);
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_ESC);
break;
}
gtk_main_quit ();
}

213
src/scale.c
View File

@ -23,136 +23,151 @@
#include "config.h"
#include "zenity.h"
#include "util.h"
#include "zenity.h"
static GtkWidget *scale;
static void zenity_scale_value_changed (GtkWidget *widget, gpointer data);
static void zenity_scale_dialog_response (GtkWidget *widget, int response, gpointer data);
static void zenity_scale_dialog_response (
GtkWidget *widget, int response, gpointer data);
void
zenity_scale (ZenityData *data, ZenityScaleData *scale_data)
{
GtkBuilder *builder;
GtkWidget *dialog;
GtkWidget *button;
GObject *text;
void
zenity_scale (ZenityData *data, ZenityScaleData *scale_data) {
GtkBuilder *builder;
GtkWidget *dialog;
GtkWidget *button;
GObject *text;
builder = zenity_util_load_ui_file ("zenity_scale_dialog", "adjustment1", NULL);
builder =
zenity_util_load_ui_file ("zenity_scale_dialog", "adjustment1", NULL);
if (builder == NULL) {
data->exit_code = zenity_util_return_exit_code (ZENITY_ERROR);
return;
}
if (builder == NULL) {
data->exit_code = zenity_util_return_exit_code (ZENITY_ERROR);
return;
}
dialog = GTK_WIDGET (gtk_builder_get_object (builder, "zenity_scale_dialog"));
scale = GTK_WIDGET (gtk_builder_get_object (builder, "zenity_scale_hscale"));
text = gtk_builder_get_object (builder, "zenity_scale_text");
dialog =
GTK_WIDGET (gtk_builder_get_object (builder, "zenity_scale_dialog"));
scale =
GTK_WIDGET (gtk_builder_get_object (builder, "zenity_scale_hscale"));
text = gtk_builder_get_object (builder, "zenity_scale_text");
g_signal_connect (G_OBJECT (dialog), "response",
G_CALLBACK (zenity_scale_dialog_response), data);
if (scale_data->min_value >= scale_data->max_value) {
g_printerr (_("Maximum value must be greater than minimum value.\n"));
data->exit_code = zenity_util_return_exit_code (ZENITY_ERROR);
return;
}
g_signal_connect (G_OBJECT (dialog),
"response",
G_CALLBACK (zenity_scale_dialog_response),
data);
if (scale_data->value < scale_data->min_value ||
scale_data->value > scale_data->max_value) {
g_printerr (_("Value out of range.\n"));
data->exit_code = zenity_util_return_exit_code (ZENITY_ERROR);
return;
}
if (scale_data->min_value >= scale_data->max_value) {
g_printerr (_ ("Maximum value must be greater than minimum value.\n"));
data->exit_code = zenity_util_return_exit_code (ZENITY_ERROR);
return;
}
gtk_builder_connect_signals (builder, NULL);
if (data->dialog_title)
gtk_window_set_title (GTK_WINDOW (dialog), data->dialog_title);
if (scale_data->value < scale_data->min_value ||
scale_data->value > scale_data->max_value) {
g_printerr (_ ("Value out of range.\n"));
data->exit_code = zenity_util_return_exit_code (ZENITY_ERROR);
return;
}
zenity_util_set_window_icon (dialog, data->window_icon, ZENITY_IMAGE_FULLPATH ("zenity-scale.png"));
if (data->width > -1 || data->height > -1)
gtk_window_set_default_size (GTK_WINDOW (dialog), data->width, data->height);
gtk_builder_connect_signals (builder, NULL);
if (data->modal)
gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
if (data->dialog_title)
gtk_window_set_title (GTK_WINDOW (dialog), data->dialog_title);
if (data->extra_label) {
gint i=0;
while(data->extra_label[i]!=NULL){
gtk_dialog_add_button (GTK_DIALOG (dialog), data->extra_label[i], i);
i++;
}
}
zenity_util_set_window_icon (
dialog, data->window_icon, ZENITY_IMAGE_FULLPATH ("zenity-scale.png"));
if (data->ok_label) {
button = GTK_WIDGET (gtk_builder_get_object (builder, "zenity_scale_ok_button"));
gtk_button_set_label (GTK_BUTTON (button), data->ok_label);
}
if (data->width > -1 || data->height > -1)
gtk_window_set_default_size (
GTK_WINDOW (dialog), data->width, data->height);
if (data->cancel_label) {
button = GTK_WIDGET (gtk_builder_get_object (builder, "zenity_scale_cancel_button"));
gtk_button_set_label (GTK_BUTTON (button), data->cancel_label);
}
if (data->modal)
gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
if (scale_data->dialog_text)
gtk_label_set_markup (GTK_LABEL (text), g_strcompress (scale_data->dialog_text));
if (data->extra_label) {
gint i = 0;
while (data->extra_label[i] != NULL) {
gtk_dialog_add_button (
GTK_DIALOG (dialog), data->extra_label[i], i);
i++;
}
}
gtk_range_set_range (GTK_RANGE (scale), scale_data->min_value, scale_data->max_value);
gtk_range_set_value (GTK_RANGE (scale), scale_data->value);
gtk_range_set_increments (GTK_RANGE (scale), scale_data->step, 0);
if (data->ok_label) {
button = GTK_WIDGET (
gtk_builder_get_object (builder, "zenity_scale_ok_button"));
gtk_button_set_label (GTK_BUTTON (button), data->ok_label);
}
if (scale_data->print_partial)
g_signal_connect (G_OBJECT (scale), "value-changed",
G_CALLBACK (zenity_scale_value_changed), data);
if (scale_data->hide_value)
gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);
zenity_util_show_dialog (dialog, data->attach);
if (data->cancel_label) {
button = GTK_WIDGET (
gtk_builder_get_object (builder, "zenity_scale_cancel_button"));
gtk_button_set_label (GTK_BUTTON (button), data->cancel_label);
}
if(data->timeout_delay > 0) {
g_timeout_add_seconds (data->timeout_delay, (GSourceFunc) zenity_util_timeout_handle, dialog);
}
if (scale_data->dialog_text)
gtk_label_set_markup (
GTK_LABEL (text), g_strcompress (scale_data->dialog_text));
g_object_unref (builder);
gtk_range_set_range (
GTK_RANGE (scale), scale_data->min_value, scale_data->max_value);
gtk_range_set_value (GTK_RANGE (scale), scale_data->value);
gtk_range_set_increments (GTK_RANGE (scale), scale_data->step, 0);
gtk_main ();
if (scale_data->print_partial)
g_signal_connect (G_OBJECT (scale),
"value-changed",
G_CALLBACK (zenity_scale_value_changed),
data);
if (scale_data->hide_value)
gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);
zenity_util_show_dialog (dialog, data->attach);
if (data->timeout_delay > 0) {
g_timeout_add_seconds (data->timeout_delay,
(GSourceFunc) zenity_util_timeout_handle,
dialog);
}
g_object_unref (builder);
gtk_main ();
}
static void
zenity_scale_value_changed (GtkWidget *widget, gpointer data)
{
g_print ("%.0f\n", gtk_range_get_value (GTK_RANGE (widget)));
zenity_scale_value_changed (GtkWidget *widget, gpointer data) {
g_print ("%.0f\n", gtk_range_get_value (GTK_RANGE (widget)));
}
static void
zenity_scale_dialog_response (GtkWidget *widget, int response, gpointer data)
{
ZenityData *zen_data = data;
zenity_scale_dialog_response (GtkWidget *widget, int response, gpointer data) {
ZenityData *zen_data = data;
switch (response) {
case GTK_RESPONSE_OK:
zenity_util_exit_code_with_data(ZENITY_OK, zen_data);
g_print ("%.0f\n", gtk_range_get_value (GTK_RANGE (scale)));
break;
switch (response) {
case GTK_RESPONSE_OK:
zenity_util_exit_code_with_data (ZENITY_OK, zen_data);
g_print ("%.0f\n", gtk_range_get_value (GTK_RANGE (scale)));
break;
case GTK_RESPONSE_CANCEL:
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_CANCEL);
break;
case GTK_RESPONSE_CANCEL:
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_CANCEL);
break;
case ZENITY_TIMEOUT:
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_TIMEOUT);
g_print ("%.0f\n", gtk_range_get_value (GTK_RANGE (scale)));
break;
case ZENITY_TIMEOUT:
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_TIMEOUT);
g_print ("%.0f\n", gtk_range_get_value (GTK_RANGE (scale)));
break;
default:
if (zen_data->extra_label && response < g_strv_length(zen_data->extra_label))
printf("%s\n",zen_data->extra_label[response]);
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_ESC);
break;
}
gtk_main_quit ();
default:
if (zen_data->extra_label &&
response < g_strv_length (zen_data->extra_label))
printf ("%s\n", zen_data->extra_label[response]);
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_ESC);
break;
}
gtk_main_quit ();
}

617
src/text.c
View File

@ -23,375 +23,426 @@
#include "config.h"
#include <gio/gio.h>
#include "zenity.h"
#include "util.h"
#include "zenity.h"
#include <gio/gio.h>
#ifdef HAVE_WEBKITGTK
#include <webkit2/webkit2.h>
#endif
static ZenityTextData *zen_text_data;
static ZenityTextData *zen_text_data;
static void zenity_text_dialog_response (GtkWidget *widget, int response, gpointer data);
static void zenity_text_dialog_response (
GtkWidget *widget, int response, gpointer data);
static void zenity_text_toggle_button (GtkToggleButton *button, gpointer data);
#ifdef HAVE_WEBKITGTK
static void
zenity_configure_webkit (WebKitWebView *web_view)
{
WebKitSettings *settings;
settings = webkit_web_view_get_settings(web_view);
g_object_set(G_OBJECT(settings), "auto-load-images", TRUE, NULL);
/*
Stick to the defaults
"cursive-font-family" gchar* : Read / Write / Construct
"default-encoding" gchar* : Read / Write / Construct
"default-font-family" gchar* : Read / Write / Construct
"default-font-size" gint : Read / Write / Construct
"default-monospace-font-size" gint : Read / Write / Construct
"editing-behavior" WebKitEditingBehavior : Read / Write / Construct
*/
g_object_set(G_OBJECT(settings), "enable-caret-browsing", FALSE, NULL);
g_object_set(G_OBJECT(settings), "enable-developer-extras", FALSE, NULL);
g_object_set(G_OBJECT(settings), "enable-fullscreen", FALSE, NULL);
g_object_set(G_OBJECT(settings), "enable-html5-database", FALSE, NULL);
g_object_set(G_OBJECT(settings), "enable-html5-local-storage", FALSE, NULL);
g_object_set(G_OBJECT(settings), "enable-java", FALSE, NULL);
g_object_set(G_OBJECT(settings), "enable-javascript", FALSE, NULL);
g_object_set(G_OBJECT(settings), "enable-offline-web-application-cache", FALSE, NULL);
g_object_set(G_OBJECT(settings), "enable-page-cache", FALSE, NULL);
g_object_set(G_OBJECT(settings), "enable-plugins", FALSE, NULL);
g_object_set(G_OBJECT(settings), "enable-private-browsing", TRUE, NULL);
/*
Stick to defaults
"enforce-96-dpi" gboolean : Read / Write / Construct
"fantasy-font-family" gchar* : Read / Write / Construct
*/
/*
Stick to defaults
"minimum-font-size" gint : Read / Write / Construct
"minimum-logical-font-size" gint : Read / Write / Construct
"monospace-font-family" gchar* : Read / Write / Construct
"print-backgrounds" gboolean : Read / Write / Construct
"resizable-text-areas" gboolean : Read / Write / Construct
"sans-serif-font-family" gchar* : Read / Write / Construct
"serif-font-family" gchar* : Read / Write / Construct
"spell-checking-languages" gchar* : Read / Write / Construct
*/
g_object_set(G_OBJECT(settings), "enable-tabs-to-links", FALSE, NULL);
g_object_set(G_OBJECT(settings), "user-agent",
"Zenity with WebKit (KHTML, like Gecko) support", NULL);
/*
Stick to defaults
"user-stylesheet-uri" gchar* : Read / Write / Construct
"zoom-step" gfloat : Read / Write / Construct
*/
zenity_configure_webkit (WebKitWebView *web_view) {
WebKitSettings *settings;
settings = webkit_web_view_get_settings (web_view);
g_object_set (G_OBJECT (settings), "auto-load-images", TRUE, NULL);
/*
Stick to the defaults
"cursive-font-family" gchar* : Read / Write /
Construct
"default-encoding" gchar* : Read / Write /
Construct
"default-font-family" gchar* : Read / Write /
Construct
"default-font-size" gint : Read / Write /
Construct
"default-monospace-font-size" gint : Read / Write /
Construct
"editing-behavior" WebKitEditingBehavior : Read / Write /
Construct
*/
g_object_set (G_OBJECT (settings), "enable-caret-browsing", FALSE, NULL);
g_object_set (G_OBJECT (settings), "enable-developer-extras", FALSE, NULL);
g_object_set (G_OBJECT (settings), "enable-fullscreen", FALSE, NULL);
g_object_set (G_OBJECT (settings), "enable-html5-database", FALSE, NULL);
g_object_set (
G_OBJECT (settings), "enable-html5-local-storage", FALSE, NULL);
g_object_set (G_OBJECT (settings), "enable-java", FALSE, NULL);
g_object_set (G_OBJECT (settings), "enable-javascript", FALSE, NULL);
g_object_set (G_OBJECT (settings),
"enable-offline-web-application-cache",
FALSE,
NULL);
g_object_set (G_OBJECT (settings), "enable-page-cache", FALSE, NULL);
g_object_set (G_OBJECT (settings), "enable-plugins", FALSE, NULL);
g_object_set (G_OBJECT (settings), "enable-private-browsing", TRUE, NULL);
/*
Stick to defaults
"enforce-96-dpi" gboolean : Read / Write /
Construct
"fantasy-font-family" gchar* : Read / Write /
Construct
*/
/*
Stick to defaults
"minimum-font-size" gint : Read / Write /
Construct
"minimum-logical-font-size" gint : Read / Write /
Construct
"monospace-font-family" gchar* : Read / Write /
Construct
"print-backgrounds" gboolean : Read / Write /
Construct
"resizable-text-areas" gboolean : Read / Write /
Construct
"sans-serif-font-family" gchar* : Read / Write /
Construct
"serif-font-family" gchar* : Read / Write /
Construct
"spell-checking-languages" gchar* : Read / Write /
Construct
*/
g_object_set (G_OBJECT (settings), "enable-tabs-to-links", FALSE, NULL);
g_object_set (G_OBJECT (settings),
"user-agent",
"Zenity with WebKit (KHTML, like Gecko) support",
NULL);
/*
Stick to defaults
"user-stylesheet-uri" gchar* : Read / Write /
Construct
"zoom-step" gfloat : Read / Write /
Construct
*/
}
static gboolean
zenity_text_webview_decision_request (WebKitWebView *web_view,
WebKitPolicyDecision *decision,
WebKitPolicyDecisionType type)
{
if (type == WEBKIT_POLICY_DECISION_TYPE_NAVIGATION_ACTION) {
WebKitNavigationPolicyDecision *navigation_decision = WEBKIT_NAVIGATION_POLICY_DECISION (decision);
WebKitNavigationAction *navigation_action = webkit_navigation_policy_decision_get_navigation_action(navigation_decision);
webkit_policy_decision_ignore (decision);
if (!zen_text_data->no_interaction &&
webkit_navigation_action_get_navigation_type (navigation_action) == WEBKIT_NAVIGATION_TYPE_LINK_CLICKED) {
WebKitURIRequest *request = webkit_navigation_action_get_request(navigation_action);
g_app_info_launch_default_for_uri (webkit_uri_request_get_uri(request), NULL, NULL);
}
}
return TRUE;
WebKitPolicyDecision *decision, WebKitPolicyDecisionType type) {
if (type == WEBKIT_POLICY_DECISION_TYPE_NAVIGATION_ACTION) {
WebKitNavigationPolicyDecision *navigation_decision =
WEBKIT_NAVIGATION_POLICY_DECISION (decision);
WebKitNavigationAction *navigation_action =
webkit_navigation_policy_decision_get_navigation_action (
navigation_decision);
webkit_policy_decision_ignore (decision);
if (!zen_text_data->no_interaction &&
webkit_navigation_action_get_navigation_type (navigation_action) ==
WEBKIT_NAVIGATION_TYPE_LINK_CLICKED) {
WebKitURIRequest *request =
webkit_navigation_action_get_request (navigation_action);
g_app_info_launch_default_for_uri (
webkit_uri_request_get_uri (request), NULL, NULL);
}
}
return TRUE;
}
static void
zenity_text_webview_load_changed (WebKitWebView *webkitwebview,
WebKitLoadEvent event,
gpointer user_data)
{
if (event == WEBKIT_LOAD_FINISHED) {
g_signal_connect (G_OBJECT (webkitwebview), "decide-policy",
G_CALLBACK (zenity_text_webview_decision_request), NULL);
}
zenity_text_webview_load_changed (
WebKitWebView *webkitwebview, WebKitLoadEvent event, gpointer user_data) {
if (event == WEBKIT_LOAD_FINISHED) {
g_signal_connect (G_OBJECT (webkitwebview),
"decide-policy",
G_CALLBACK (zenity_text_webview_decision_request),
NULL);
}
}
#endif
static gboolean
zenity_text_handle_stdin (GIOChannel *channel,
GIOCondition condition,
gpointer data)
{
static GtkTextBuffer *buffer;
static GtkTextView *text_view;
gchar buf[1024];
zenity_text_handle_stdin (
GIOChannel *channel, GIOCondition condition, gpointer data) {
static GtkTextBuffer *buffer;
static GtkTextView *text_view;
gchar buf[1024];
gsize len;
gsize len;
text_view = GTK_TEXT_VIEW (data);
buffer = gtk_text_view_get_buffer (text_view);
text_view = GTK_TEXT_VIEW (data);
buffer = gtk_text_view_get_buffer (text_view);
if ((condition & G_IO_IN) || (condition & (G_IO_IN | G_IO_HUP))) {
GError *error = NULL;
gint status;
if ((condition & G_IO_IN) || (condition & (G_IO_IN | G_IO_HUP))) {
GError *error = NULL;
gint status;
while (channel->is_readable != TRUE)
;
while (channel->is_readable != TRUE)
;
do {
status = g_io_channel_read_chars (channel, buf, 1024, &len, &error);
do {
status = g_io_channel_read_chars (channel, buf, 1024, &len, &error);
while (gtk_events_pending ())
gtk_main_iteration ();
while (gtk_events_pending ())
gtk_main_iteration ();
} while (status == G_IO_STATUS_AGAIN);
} while (status == G_IO_STATUS_AGAIN);
if (status != G_IO_STATUS_NORMAL) {
if (error) {
g_warning ("zenity_text_handle_stdin () : %s", error->message);
g_error_free (error);
error = NULL;
}
return FALSE;
}
if (status != G_IO_STATUS_NORMAL) {
if (error) {
g_warning ("zenity_text_handle_stdin () : %s", error->message);
g_error_free (error);
error = NULL;
}
return FALSE;
}
if (len > 0) {
GtkTextIter end;
gchar *utftext;
gsize localelen;
gsize utflen;
if (len > 0) {
GtkTextIter end;
gchar *utftext;
gsize localelen;
gsize utflen;
gtk_text_buffer_get_end_iter (buffer, &end);
gtk_text_buffer_get_end_iter (buffer, &end);
if (!g_utf8_validate (buf, len, NULL)) {
utftext = g_convert_with_fallback (buf, len, "UTF-8", "ISO-8859-1", NULL, &localelen, &utflen, NULL);
gtk_text_buffer_insert (buffer, &end, utftext, utflen);
g_free (utftext);
} else {
gtk_text_buffer_insert (buffer, &end, buf, len);
}
if (zen_text_data->auto_scroll) {
GtkTextMark *mark = NULL;
mark = gtk_text_buffer_get_insert (buffer);
if (mark != NULL)
gtk_text_view_scroll_to_mark (text_view, mark, 0.0, FALSE, 0, 0);
}
}
}
if (!g_utf8_validate (buf, len, NULL)) {
utftext = g_convert_with_fallback (buf,
len,
"UTF-8",
"ISO-8859-1",
NULL,
&localelen,
&utflen,
NULL);
gtk_text_buffer_insert (buffer, &end, utftext, utflen);
g_free (utftext);
} else {
gtk_text_buffer_insert (buffer, &end, buf, len);
}
if (zen_text_data->auto_scroll) {
GtkTextMark *mark = NULL;
mark = gtk_text_buffer_get_insert (buffer);
if (mark != NULL)
gtk_text_view_scroll_to_mark (
text_view, mark, 0.0, FALSE, 0, 0);
}
}
}
return TRUE;
return TRUE;
}
static void
zenity_text_fill_entries_from_stdin (GtkTextView *text_view)
{
GIOChannel *channel;
zenity_text_fill_entries_from_stdin (GtkTextView *text_view) {
GIOChannel *channel;
channel = g_io_channel_unix_new (0);
g_io_channel_set_encoding (channel, "UTF-8", NULL);
g_io_channel_set_flags (channel, G_IO_FLAG_NONBLOCK, NULL);
g_io_add_watch (channel, G_IO_IN | G_IO_HUP, zenity_text_handle_stdin, text_view);
channel = g_io_channel_unix_new (0);
g_io_channel_set_encoding (channel, "UTF-8", NULL);
g_io_channel_set_flags (channel, G_IO_FLAG_NONBLOCK, NULL);
g_io_add_watch (
channel, G_IO_IN | G_IO_HUP, zenity_text_handle_stdin, text_view);
}
void
zenity_text (ZenityData *data, ZenityTextData *text_data)
{
GtkBuilder *builder;
GtkWidget *dialog;
GtkWidget *ok_button;
GtkWidget *checkbox;
GtkWidget *cancel_button;
zenity_text (ZenityData *data, ZenityTextData *text_data) {
GtkBuilder *builder;
GtkWidget *dialog;
GtkWidget *ok_button;
GtkWidget *checkbox;
GtkWidget *cancel_button;
GObject *text_view;
GtkTextBuffer *text_buffer;
GObject *text_view;
GtkTextBuffer *text_buffer;
#ifdef HAVE_WEBKITGTK
GtkWidget *web_kit;
GtkWidget *scrolled_window;
GtkTextIter start_iter, end_iter;
gchar *content;
GtkWidget *web_kit;
GtkWidget *scrolled_window;
GtkTextIter start_iter, end_iter;
gchar *content;
#endif
zen_text_data = text_data;
builder = zenity_util_load_ui_file ("zenity_text_dialog",
"textbuffer1", NULL);
if (builder == NULL) {
data->exit_code = zenity_util_return_exit_code (ZENITY_ERROR);
return;
}
gtk_builder_connect_signals (builder, NULL);
dialog = GTK_WIDGET (gtk_builder_get_object (builder, "zenity_text_dialog"));
zen_text_data = text_data;
builder =
zenity_util_load_ui_file ("zenity_text_dialog", "textbuffer1", NULL);
ok_button = GTK_WIDGET (gtk_builder_get_object (builder, "zenity_text_close_button"));
cancel_button = GTK_WIDGET (gtk_builder_get_object (builder, "zenity_text_cancel_button"));
checkbox = GTK_WIDGET (gtk_builder_get_object (builder, "zenity_text_checkbox"));
if (builder == NULL) {
data->exit_code = zenity_util_return_exit_code (ZENITY_ERROR);
return;
}
g_signal_connect (G_OBJECT (dialog), "response",
G_CALLBACK (zenity_text_dialog_response), data);
gtk_builder_connect_signals (builder, NULL);
if (data->dialog_title)
gtk_window_set_title (GTK_WINDOW (dialog), data->dialog_title);
dialog =
GTK_WIDGET (gtk_builder_get_object (builder, "zenity_text_dialog"));
zenity_util_set_window_icon (dialog, data->window_icon, ZENITY_IMAGE_FULLPATH ("zenity-text.png"));
ok_button = GTK_WIDGET (
gtk_builder_get_object (builder, "zenity_text_close_button"));
cancel_button = GTK_WIDGET (
gtk_builder_get_object (builder, "zenity_text_cancel_button"));
checkbox =
GTK_WIDGET (gtk_builder_get_object (builder, "zenity_text_checkbox"));
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_CLOSE);
g_signal_connect (G_OBJECT (dialog),
"response",
G_CALLBACK (zenity_text_dialog_response),
data);
text_buffer = gtk_text_buffer_new (NULL);
text_view = gtk_builder_get_object (builder, "zenity_text_view");
gtk_text_view_set_buffer (GTK_TEXT_VIEW (text_view), text_buffer);
gtk_text_view_set_editable (GTK_TEXT_VIEW(text_view), text_data->editable);
if (data->dialog_title)
gtk_window_set_title (GTK_WINDOW (dialog), data->dialog_title);
if (text_data->no_wrap)
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW(text_view), GTK_WRAP_NONE);
zenity_util_set_window_icon (
dialog, data->window_icon, ZENITY_IMAGE_FULLPATH ("zenity-text.png"));
if (text_data->font) {
PangoFontDescription *fontDesc = pango_font_description_from_string (text_data->font);
gtk_widget_override_font (GTK_WIDGET(text_view), fontDesc);
}
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_CLOSE);
if (text_data->uri)
zenity_util_fill_file_buffer (text_buffer, text_data->uri);
else
zenity_text_fill_entries_from_stdin (GTK_TEXT_VIEW(text_view));
text_buffer = gtk_text_buffer_new (NULL);
text_view = gtk_builder_get_object (builder, "zenity_text_view");
gtk_text_view_set_buffer (GTK_TEXT_VIEW (text_view), text_buffer);
gtk_text_view_set_editable (GTK_TEXT_VIEW (text_view), text_data->editable);
if (text_data->editable)
zen_text_data->buffer = text_buffer;
if (text_data->no_wrap)
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (text_view), GTK_WRAP_NONE);
if (data->extra_label) {
gint i=0;
while(data->extra_label[i]!=NULL){
gtk_dialog_add_button (GTK_DIALOG (dialog), data->extra_label[i], i);
i++;
}
}
if (text_data->font) {
PangoFontDescription *fontDesc =
pango_font_description_from_string (text_data->font);
gtk_widget_override_font (GTK_WIDGET (text_view), fontDesc);
}
if (data->ok_label) {
gtk_button_set_label (GTK_BUTTON (ok_button), data->ok_label);
}
if (text_data->uri)
zenity_util_fill_file_buffer (text_buffer, text_data->uri);
else
zenity_text_fill_entries_from_stdin (GTK_TEXT_VIEW (text_view));
if (data->cancel_label) {
gtk_button_set_label (GTK_BUTTON (cancel_button), data->cancel_label);
}
if (text_data->editable)
zen_text_data->buffer = text_buffer;
if (text_data->checkbox) {
gtk_widget_set_visible (GTK_WIDGET (checkbox), TRUE);
gtk_widget_set_sensitive (GTK_WIDGET (ok_button), FALSE);
gtk_button_set_label (GTK_BUTTON (checkbox), text_data->checkbox);
if (data->extra_label) {
gint i = 0;
while (data->extra_label[i] != NULL) {
gtk_dialog_add_button (
GTK_DIALOG (dialog), data->extra_label[i], i);
i++;
}
}
g_signal_connect (G_OBJECT (checkbox), "toggled",
G_CALLBACK (zenity_text_toggle_button), ok_button);
}
if (data->ok_label) {
gtk_button_set_label (GTK_BUTTON (ok_button), data->ok_label);
}
if (data->width > -1 || data->height > -1)
gtk_window_set_default_size (GTK_WINDOW (dialog), data->width, data->height);
else
gtk_window_set_default_size (GTK_WINDOW (dialog), 300, 400);
if (data->cancel_label) {
gtk_button_set_label (GTK_BUTTON (cancel_button), data->cancel_label);
}
if (data->modal)
gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
if (text_data->checkbox) {
gtk_widget_set_visible (GTK_WIDGET (checkbox), TRUE);
gtk_widget_set_sensitive (GTK_WIDGET (ok_button), FALSE);
gtk_button_set_label (GTK_BUTTON (checkbox), text_data->checkbox);
g_signal_connect (G_OBJECT (checkbox),
"toggled",
G_CALLBACK (zenity_text_toggle_button),
ok_button);
}
if (data->width > -1 || data->height > -1)
gtk_window_set_default_size (
GTK_WINDOW (dialog), data->width, data->height);
else
gtk_window_set_default_size (GTK_WINDOW (dialog), 300, 400);
if (data->modal)
gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
#ifdef HAVE_WEBKITGTK
if(text_data->html) {
web_kit = webkit_web_view_new();
scrolled_window = GTK_WIDGET (gtk_builder_get_object (builder, "zenity_text_scrolled_window"));
if (text_data->html) {
web_kit = webkit_web_view_new ();
scrolled_window = GTK_WIDGET (
gtk_builder_get_object (builder, "zenity_text_scrolled_window"));
zenity_configure_webkit (WEBKIT_WEB_VIEW (web_kit));
zenity_configure_webkit (WEBKIT_WEB_VIEW (web_kit));
if (text_data->url)
{
if (!(g_str_has_prefix (text_data->url, "http://") || g_str_has_prefix (text_data->url, "https://")))
text_data->url = g_strdup_printf ("http://%s", text_data->url);
if (text_data->url) {
if (!(g_str_has_prefix (text_data->url, "http://") ||
g_str_has_prefix (text_data->url, "https://")))
text_data->url = g_strdup_printf ("http://%s", text_data->url);
webkit_web_view_load_uri (WEBKIT_WEB_VIEW (web_kit), text_data->url);
}
else
{
gchar *cwd;
gchar *dirname;
gchar *dirname_uri;
dirname = text_data->uri ? g_path_get_dirname (text_data->uri) : g_strdup ("/");
cwd = g_get_current_dir ();
dirname_uri = g_strconcat ("file://", cwd, "/", dirname, "/", NULL);
g_free (cwd);
g_free (dirname);
gtk_text_buffer_get_start_iter (text_buffer, &start_iter);
gtk_text_buffer_get_end_iter (text_buffer, &end_iter);
content = gtk_text_buffer_get_text (text_buffer, &start_iter, &end_iter, TRUE);
webkit_web_view_load_html (WEBKIT_WEB_VIEW(web_kit), content, dirname_uri);
g_free (dirname_uri);
g_free (content);
}
webkit_web_view_load_uri (
WEBKIT_WEB_VIEW (web_kit), text_data->url);
} else {
gchar *cwd;
gchar *dirname;
gchar *dirname_uri;
dirname = text_data->uri ? g_path_get_dirname (text_data->uri)
: g_strdup ("/");
cwd = g_get_current_dir ();
dirname_uri = g_strconcat ("file://", cwd, "/", dirname, "/", NULL);
g_free (cwd);
g_free (dirname);
gtk_text_buffer_get_start_iter (text_buffer, &start_iter);
gtk_text_buffer_get_end_iter (text_buffer, &end_iter);
content = gtk_text_buffer_get_text (
text_buffer, &start_iter, &end_iter, TRUE);
webkit_web_view_load_html (
WEBKIT_WEB_VIEW (web_kit), content, dirname_uri);
g_free (dirname_uri);
g_free (content);
}
// We don't want user to click on links and navigate to another page.
// So, when the page finishes loading, we take handle of the requests.
// We don't want user to click on links and navigate to another page.
// So, when the page finishes loading, we take handle of the requests.
g_signal_connect (G_OBJECT (web_kit), "load-changed",
G_CALLBACK (zenity_text_webview_load_changed), NULL);
g_signal_connect (G_OBJECT (web_kit),
"load-changed",
G_CALLBACK (zenity_text_webview_load_changed),
NULL);
gtk_widget_destroy (GTK_WIDGET (text_view));
gtk_container_add (GTK_CONTAINER(scrolled_window), web_kit);
gtk_widget_show (GTK_WIDGET (web_kit));
}
gtk_widget_destroy (GTK_WIDGET (text_view));
gtk_container_add (GTK_CONTAINER (scrolled_window), web_kit);
gtk_widget_show (GTK_WIDGET (web_kit));
}
#endif
zenity_util_show_dialog (dialog, data->attach);
zenity_util_show_dialog (dialog, data->attach);
g_object_unref (builder);
g_object_unref (builder);
if(data->timeout_delay > 0) {
g_timeout_add_seconds (data->timeout_delay, (GSourceFunc) zenity_util_timeout_handle, dialog);
}
if (data->timeout_delay > 0) {
g_timeout_add_seconds (data->timeout_delay,
(GSourceFunc) zenity_util_timeout_handle,
dialog);
}
gtk_main ();
gtk_main ();
}
static void
zenity_text_toggle_button (GtkToggleButton *button, gpointer data)
{
GtkWidget *ok_button = (GtkWidget *)data;
gtk_widget_set_sensitive (GTK_WIDGET(ok_button), gtk_toggle_button_get_active(button));
zenity_text_toggle_button (GtkToggleButton *button, gpointer data) {
GtkWidget *ok_button = (GtkWidget *) data;
gtk_widget_set_sensitive (
GTK_WIDGET (ok_button), gtk_toggle_button_get_active (button));
}
static void
zenity_text_dialog_output (ZenityData *zen_data)
{
if (zen_text_data->editable) {
GtkTextIter start, end;
gchar *text;
gtk_text_buffer_get_bounds (zen_text_data->buffer, &start, &end);
text = gtk_text_buffer_get_text (zen_text_data->buffer, &start, &end, 0);
g_print ("%s", text);
g_free (text);
}
zenity_text_dialog_output (ZenityData *zen_data) {
if (zen_text_data->editable) {
GtkTextIter start, end;
gchar *text;
gtk_text_buffer_get_bounds (zen_text_data->buffer, &start, &end);
text =
gtk_text_buffer_get_text (zen_text_data->buffer, &start, &end, 0);
g_print ("%s", text);
g_free (text);
}
}
static void
zenity_text_dialog_response (GtkWidget *widget, int response, gpointer data)
{
ZenityData *zen_data = data;
zenity_text_dialog_response (GtkWidget *widget, int response, gpointer data) {
ZenityData *zen_data = data;
switch (response) {
case GTK_RESPONSE_CLOSE:
zenity_text_dialog_output (zen_data);
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_OK);
break;
switch (response) {
case GTK_RESPONSE_CLOSE:
zenity_text_dialog_output (zen_data);
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_OK);
break;
case ZENITY_TIMEOUT:
zenity_text_dialog_output (zen_data);
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_TIMEOUT);
break;
case ZENITY_TIMEOUT:
zenity_text_dialog_output (zen_data);
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_TIMEOUT);
break;
default:
if (zen_data->extra_label && response < g_strv_length(zen_data->extra_label))
printf("%s\n",zen_data->extra_label[response]);
zenity_util_exit_code_with_data(ZENITY_ESC, zen_data);
break;
}
gtk_main_quit ();
default:
if (zen_data->extra_label &&
response < g_strv_length (zen_data->extra_label))
printf ("%s\n", zen_data->extra_label[response]);
zenity_util_exit_code_with_data (ZENITY_ESC, zen_data);
break;
}
gtk_main_quit ();
}

1202
src/tree.c
View File

File diff suppressed because it is too large Load Diff

594
src/util.c
View File

@ -29,340 +29,330 @@
#include "config.h"
#include <stdio.h>
#include <locale.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#include <stdarg.h>
#include "config.h"
#include "util.h"
#include "zenity.h"
#include <errno.h>
#include <locale.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifdef GDK_WINDOWING_X11
#include <gdk/gdkx.h>
#endif
#define ZENITY_OK_DEFAULT 0
#define ZENITY_CANCEL_DEFAULT 1
#define ZENITY_ESC_DEFAULT 1
#define ZENITY_ERROR_DEFAULT -1
#define ZENITY_EXTRA_DEFAULT 127
#define ZENITY_OK_DEFAULT 0
#define ZENITY_CANCEL_DEFAULT 1
#define ZENITY_ESC_DEFAULT 1
#define ZENITY_ERROR_DEFAULT -1
#define ZENITY_EXTRA_DEFAULT 127
GtkBuilder*
zenity_util_load_ui_file (const gchar *root_widget, ...)
{
va_list args;
gchar *arg = NULL;
GPtrArray *ptrarray;
GtkBuilder *builder = gtk_builder_new ();
GError *error = NULL;
gchar **objects;
guint result = 0;
GtkBuilder *
zenity_util_load_ui_file (const gchar *root_widget, ...) {
va_list args;
gchar *arg = NULL;
GPtrArray *ptrarray;
GtkBuilder *builder = gtk_builder_new ();
GError *error = NULL;
gchar **objects;
guint result = 0;
gtk_builder_set_translation_domain (builder, GETTEXT_PACKAGE);
gtk_builder_set_translation_domain (builder, GETTEXT_PACKAGE);
/* We have at least the root_widget and a NULL */
ptrarray = g_ptr_array_sized_new (2);
/* We have at least the root_widget and a NULL */
ptrarray = g_ptr_array_sized_new (2);
g_ptr_array_add (ptrarray, g_strdup (root_widget));
g_ptr_array_add (ptrarray, g_strdup (root_widget));
va_start (args, root_widget);
va_start (args, root_widget);
arg = va_arg (args, gchar*);
arg = va_arg (args, gchar *);
while (arg) {
g_ptr_array_add (ptrarray, g_strdup (arg));
arg = va_arg (args, gchar*);
}
va_end (args);
while (arg) {
g_ptr_array_add (ptrarray, g_strdup (arg));
arg = va_arg (args, gchar *);
}
va_end (args);
/* Enforce terminating NULL */
g_ptr_array_add (ptrarray, NULL);
objects = (gchar**) g_ptr_array_free (ptrarray, FALSE);
if (g_file_test (ZENITY_UI_FILE_RELATIVEPATH, G_FILE_TEST_EXISTS)) {
/* Try current dir, for debugging */
result = gtk_builder_add_objects_from_file (builder,
ZENITY_UI_FILE_RELATIVEPATH,
objects, NULL);
}
/* Enforce terminating NULL */
g_ptr_array_add (ptrarray, NULL);
objects = (gchar **) g_ptr_array_free (ptrarray, FALSE);
if (result == 0)
result = gtk_builder_add_objects_from_file (builder,
ZENITY_UI_FILE_FULLPATH,
objects, &error);
if (g_file_test (ZENITY_UI_FILE_RELATIVEPATH, G_FILE_TEST_EXISTS)) {
/* Try current dir, for debugging */
result = gtk_builder_add_objects_from_file (
builder, ZENITY_UI_FILE_RELATIVEPATH, objects, NULL);
}
g_strfreev (objects);
if (result == 0)
result = gtk_builder_add_objects_from_file (
builder, ZENITY_UI_FILE_FULLPATH, objects, &error);
if (result == 0) {
g_warning ("Could not load ui file %s: %s", ZENITY_UI_FILE_FULLPATH,
error->message);
g_error_free (error);
g_object_unref (builder);
return NULL;
}
g_strfreev (objects);
return builder;
if (result == 0) {
g_warning ("Could not load ui file %s: %s",
ZENITY_UI_FILE_FULLPATH,
error->message);
g_error_free (error);
g_object_unref (builder);
return NULL;
}
return builder;
}
gchar*
zenity_util_strip_newline (gchar *string)
{
gsize len;
g_return_val_if_fail (string != NULL, NULL);
len = strlen (string);
while (len--)
{
if (string[len] == '\n')
string[len] = '\0';
else
break;
}
return string;
gchar *
zenity_util_strip_newline (gchar *string) {
gsize len;
g_return_val_if_fail (string != NULL, NULL);
len = strlen (string);
while (len--) {
if (string[len] == '\n')
string[len] = '\0';
else
break;
}
return string;
}
gboolean
zenity_util_fill_file_buffer (GtkTextBuffer *buffer, const gchar *filename)
{
GtkTextIter iter, end;
FILE *f;
gchar buf[2048];
gint remaining = 0;
zenity_util_fill_file_buffer (GtkTextBuffer *buffer, const gchar *filename) {
GtkTextIter iter, end;
FILE *f;
gchar buf[2048];
gint remaining = 0;
if (filename == NULL)
return FALSE;
if (filename == NULL)
return FALSE;
f = fopen (filename, "r");
f = fopen (filename, "r");
if (f == NULL) {
g_warning ("Cannot open file '%s': %s", filename, g_strerror (errno));
return FALSE;
}
if (f == NULL) {
g_warning ("Cannot open file '%s': %s", filename, g_strerror (errno));
return FALSE;
}
gtk_text_buffer_get_iter_at_offset (buffer, &iter, 0);
gtk_text_buffer_get_iter_at_offset (buffer, &iter, 0);
while (!feof (f)) {
gint count;
const char *leftover;
int to_read = 2047 - remaining;
while (!feof (f)) {
gint count;
const char *leftover;
int to_read = 2047 - remaining;
count = fread (buf + remaining, 1, to_read, f);
buf[count + remaining] = '\0';
count = fread (buf + remaining, 1, to_read, f);
buf[count + remaining] = '\0';
g_utf8_validate (buf, count + remaining, &leftover);
g_utf8_validate (buf, count + remaining, &leftover);
g_assert (g_utf8_validate (buf, leftover - buf, NULL));
gtk_text_buffer_insert (buffer, &iter, buf, leftover - buf);
g_assert (g_utf8_validate (buf, leftover - buf, NULL));
gtk_text_buffer_insert (buffer, &iter, buf, leftover - buf);
remaining = (buf + remaining + count) - leftover;
g_memmove (buf, leftover, remaining);
remaining = (buf + remaining + count) - leftover;
g_memmove (buf, leftover, remaining);
if (remaining > 6 || count < to_read)
break;
}
if (remaining > 6 || count < to_read)
break;
}
if (remaining) {
g_warning ("Invalid UTF-8 data encountered reading file '%s'", filename);
return FALSE;
}
if (remaining) {
g_warning (
"Invalid UTF-8 data encountered reading file '%s'", filename);
return FALSE;
}
/* We had a newline in the buffer to begin with. (The buffer always contains
* a newline, so we delete to the end of the buffer to clean up.
*/
gtk_text_buffer_get_end_iter (buffer, &end);
gtk_text_buffer_delete (buffer, &iter, &end);
/* We had a newline in the buffer to begin with. (The buffer always contains
* a newline, so we delete to the end of the buffer to clean up.
*/
gtk_text_buffer_set_modified (buffer, FALSE);
gtk_text_buffer_get_end_iter (buffer, &end);
gtk_text_buffer_delete (buffer, &iter, &end);
return TRUE;
gtk_text_buffer_set_modified (buffer, FALSE);
return TRUE;
}
const gchar *
zenity_util_icon_name_from_filename (const gchar *filename)
{
if (!filename || !filename[0])
return "dialog-warning"; /* default */
zenity_util_icon_name_from_filename (const gchar *filename) {
if (!filename || !filename[0])
return "dialog-warning"; /* default */
if (!g_ascii_strcasecmp (filename, "warning"))
return "dialog-warning";
if (!g_ascii_strcasecmp (filename, "info"))
return "dialog-information";
if (!g_ascii_strcasecmp (filename, "question"))
return "dialog-question";
if (!g_ascii_strcasecmp (filename, "error"))
return "dialog-error";
return NULL;
if (!g_ascii_strcasecmp (filename, "warning"))
return "dialog-warning";
if (!g_ascii_strcasecmp (filename, "info"))
return "dialog-information";
if (!g_ascii_strcasecmp (filename, "question"))
return "dialog-question";
if (!g_ascii_strcasecmp (filename, "error"))
return "dialog-error";
return NULL;
}
void
zenity_util_set_window_icon_from_file (GtkWidget *widget, const gchar *filename)
{
GdkPixbuf *pixbuf;
const gchar *icon_name;
zenity_util_set_window_icon_from_file (
GtkWidget *widget, const gchar *filename) {
GdkPixbuf *pixbuf;
const gchar *icon_name;
icon_name = zenity_util_icon_name_from_filename (filename);
if (icon_name) {
gtk_window_set_icon_name (GTK_WINDOW (widget), icon_name);
} else {
pixbuf = gdk_pixbuf_new_from_file (filename, NULL);
gtk_window_set_icon (GTK_WINDOW (widget), pixbuf);
g_object_unref (pixbuf);
}
icon_name = zenity_util_icon_name_from_filename (filename);
if (icon_name) {
gtk_window_set_icon_name (GTK_WINDOW (widget), icon_name);
} else {
pixbuf = gdk_pixbuf_new_from_file (filename, NULL);
gtk_window_set_icon (GTK_WINDOW (widget), pixbuf);
g_object_unref (pixbuf);
}
}
void
zenity_util_set_window_icon (GtkWidget *widget, const gchar *filename, const gchar *default_file)
{
GdkPixbuf *pixbuf;
zenity_util_set_window_icon (
GtkWidget *widget, const gchar *filename, const gchar *default_file) {
GdkPixbuf *pixbuf;
if (filename != NULL) {
zenity_util_set_window_icon_from_file (widget, filename);
} else {
pixbuf = gdk_pixbuf_new_from_file (default_file, NULL);
if (pixbuf != NULL) {
gtk_window_set_icon (GTK_WINDOW (widget), pixbuf);
g_object_unref (pixbuf);
}
}
if (filename != NULL) {
zenity_util_set_window_icon_from_file (widget, filename);
} else {
pixbuf = gdk_pixbuf_new_from_file (default_file, NULL);
if (pixbuf != NULL) {
gtk_window_set_icon (GTK_WINDOW (widget), pixbuf);
g_object_unref (pixbuf);
}
}
}
void
zenity_util_set_window_icon_from_icon_name (GtkWidget *widget, const gchar *filename, const gchar *default_icon_name)
{
if (filename != NULL)
zenity_util_set_window_icon_from_file (widget, filename);
else
gtk_window_set_icon_name (GTK_WINDOW (widget), default_icon_name);
zenity_util_set_window_icon_from_icon_name (
GtkWidget *widget, const gchar *filename, const gchar *default_icon_name) {
if (filename != NULL)
zenity_util_set_window_icon_from_file (widget, filename);
else
gtk_window_set_icon_name (GTK_WINDOW (widget), default_icon_name);
}
void
zenity_util_show_help (GError **error)
{
gchar *tmp;
tmp = g_find_program_in_path ("yelp");
zenity_util_show_help (GError **error) {
gchar *tmp;
tmp = g_find_program_in_path ("yelp");
if (tmp) {
g_free (tmp);
g_spawn_command_line_async ("yelp help:zenity", error);
}
if (tmp) {
g_free (tmp);
g_spawn_command_line_async ("yelp help:zenity", error);
}
}
gint
zenity_util_return_exit_code ( ZenityExitCode value )
{
gint
zenity_util_return_exit_code (ZenityExitCode value) {
const gchar *env_var = NULL;
gint retval;
const gchar *env_var = NULL;
gint retval;
switch (value) {
case ZENITY_OK:
env_var = g_getenv("ZENITY_OK");
if (! env_var)
env_var = g_getenv("DIALOG_OK");
if (! env_var)
retval = ZENITY_OK_DEFAULT;
break;
case ZENITY_CANCEL:
env_var = g_getenv("ZENITY_CANCEL");
if (! env_var)
env_var = g_getenv("DIALOG_CANCEL");
if (! env_var)
retval = ZENITY_CANCEL_DEFAULT;
break;
case ZENITY_ESC:
env_var = g_getenv("ZENITY_ESC");
if (! env_var)
env_var = g_getenv("DIALOG_ESC");
if (! env_var)
retval = ZENITY_ESC_DEFAULT;
break;
case ZENITY_EXTRA:
env_var = g_getenv("ZENITY_EXTRA");
if (! env_var)
env_var = g_getenv("DIALOG_EXTRA");
if (! env_var)
retval = ZENITY_EXTRA_DEFAULT;
break;
case ZENITY_ERROR:
env_var = g_getenv("ZENITY_ERROR");
if (! env_var)
env_var = g_getenv("DIALOG_ERROR");
if (! env_var)
retval = ZENITY_ERROR_DEFAULT;
break;
case ZENITY_TIMEOUT:
env_var = g_getenv("ZENITY_TIMEOUT");
if (! env_var)
env_var = g_getenv("DIALOG_TIMEOUT");
if (! env_var)
retval = ZENITY_TIMEOUT;
break;
default:
retval = 1;
}
if (env_var)
retval = atoi (env_var);
return retval;
switch (value) {
case ZENITY_OK:
env_var = g_getenv ("ZENITY_OK");
if (!env_var)
env_var = g_getenv ("DIALOG_OK");
if (!env_var)
retval = ZENITY_OK_DEFAULT;
break;
case ZENITY_CANCEL:
env_var = g_getenv ("ZENITY_CANCEL");
if (!env_var)
env_var = g_getenv ("DIALOG_CANCEL");
if (!env_var)
retval = ZENITY_CANCEL_DEFAULT;
break;
case ZENITY_ESC:
env_var = g_getenv ("ZENITY_ESC");
if (!env_var)
env_var = g_getenv ("DIALOG_ESC");
if (!env_var)
retval = ZENITY_ESC_DEFAULT;
break;
case ZENITY_EXTRA:
env_var = g_getenv ("ZENITY_EXTRA");
if (!env_var)
env_var = g_getenv ("DIALOG_EXTRA");
if (!env_var)
retval = ZENITY_EXTRA_DEFAULT;
break;
case ZENITY_ERROR:
env_var = g_getenv ("ZENITY_ERROR");
if (!env_var)
env_var = g_getenv ("DIALOG_ERROR");
if (!env_var)
retval = ZENITY_ERROR_DEFAULT;
break;
case ZENITY_TIMEOUT:
env_var = g_getenv ("ZENITY_TIMEOUT");
if (!env_var)
env_var = g_getenv ("DIALOG_TIMEOUT");
if (!env_var)
retval = ZENITY_TIMEOUT;
break;
default:
retval = 1;
}
if (env_var)
retval = atoi (env_var);
return retval;
}
void
zenity_util_exit_code_with_data(ZenityExitCode value, ZenityData *zen_data)
{
zen_data->exit_code = zenity_util_return_exit_code (value);
zenity_util_exit_code_with_data (ZenityExitCode value, ZenityData *zen_data) {
zen_data->exit_code = zenity_util_return_exit_code (value);
}
#ifdef GDK_WINDOWING_X11
static Window
transient_get_xterm (void)
{
const char *wid_str = g_getenv ("WINDOWID");
if (wid_str) {
char *wid_str_end;
int ret;
Window wid = strtoul (wid_str, &wid_str_end, 10);
if (*wid_str != '\0' && *wid_str_end == '\0' && wid != 0) {
XWindowAttributes attrs;
gdk_error_trap_push ();
ret = XGetWindowAttributes (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), wid, &attrs);
gdk_flush();
if (gdk_error_trap_pop () != 0 || ret == 0) {
return None;
}
return wid;
}
}
return None;
transient_get_xterm (void) {
const char *wid_str = g_getenv ("WINDOWID");
if (wid_str) {
char *wid_str_end;
int ret;
Window wid = strtoul (wid_str, &wid_str_end, 10);
if (*wid_str != '\0' && *wid_str_end == '\0' && wid != 0) {
XWindowAttributes attrs;
gdk_error_trap_push ();
ret = XGetWindowAttributes (
GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), wid, &attrs);
gdk_flush ();
if (gdk_error_trap_pop () != 0 || ret == 0) {
return None;
}
return wid;
}
}
return None;
}
static void
transient_x_free (void *ptr)
{
if (ptr)
XFree (ptr);
transient_x_free (void *ptr) {
if (ptr)
XFree (ptr);
}
static gboolean
transient_is_toplevel (Window wid)
{
XTextProperty prop;
Display *dpy = GDK_DISPLAY_XDISPLAY (gdk_display_get_default ());
if (!XGetWMName (dpy, wid, &prop))
return FALSE;
transient_x_free (prop.value);
return !!prop.value;
transient_is_toplevel (Window wid) {
XTextProperty prop;
Display *dpy = GDK_DISPLAY_XDISPLAY (gdk_display_get_default ());
if (!XGetWMName (dpy, wid, &prop))
return FALSE;
transient_x_free (prop.value);
return !!prop.value;
}
/*
@ -372,62 +362,56 @@ transient_is_toplevel (Window wid)
*/
static Window
transient_get_xterm_toplevel (void)
{
Window xterm = transient_get_xterm ();
Display *dpy = GDK_DISPLAY_XDISPLAY (gdk_display_get_default ());
while (xterm != None && !transient_is_toplevel (xterm))
{
Window root, parent, *children;
unsigned nchildren;
XQueryTree (dpy, xterm,
&root, &parent,
&children, &nchildren);
transient_x_free (children);
if (parent == root)
xterm = None;
else
xterm = parent;
}
return xterm;
transient_get_xterm_toplevel (void) {
Window xterm = transient_get_xterm ();
Display *dpy = GDK_DISPLAY_XDISPLAY (gdk_display_get_default ());
while (xterm != None && !transient_is_toplevel (xterm)) {
Window root, parent, *children;
unsigned nchildren;
XQueryTree (dpy, xterm, &root, &parent, &children, &nchildren);
transient_x_free (children);
if (parent == root)
xterm = None;
else
xterm = parent;
}
return xterm;
}
static void
zenity_util_make_transient (GdkWindow *window, Window parent)
{
Window parent_window = parent;
if (parent_window == 0)
parent_window = transient_get_xterm_toplevel ();
if (parent_window != None) {
XSetTransientForHint (GDK_DISPLAY_XDISPLAY(gdk_display_get_default()), GDK_WINDOW_XID(window), parent_window);
}
zenity_util_make_transient (GdkWindow *window, Window parent) {
Window parent_window = parent;
if (parent_window == 0)
parent_window = transient_get_xterm_toplevel ();
if (parent_window != None) {
XSetTransientForHint (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()),
GDK_WINDOW_XID (window),
parent_window);
}
}
#endif /* GDK_WINDOWING_X11 */
void
zenity_util_show_dialog (GtkWidget *dialog, guintptr parent)
{
gtk_widget_realize (dialog);
zenity_util_show_dialog (GtkWidget *dialog, guintptr parent) {
gtk_widget_realize (dialog);
#ifdef GDK_WINDOWING_X11
if (GDK_IS_X11_DISPLAY (gdk_display_get_default ()))
{
g_assert (gtk_widget_get_window(dialog));
zenity_util_make_transient (gtk_widget_get_window(dialog), parent);
}
if (GDK_IS_X11_DISPLAY (gdk_display_get_default ())) {
g_assert (gtk_widget_get_window (dialog));
zenity_util_make_transient (gtk_widget_get_window (dialog), parent);
}
#endif
gtk_widget_show (dialog);
gtk_widget_show (dialog);
}
gboolean
zenity_util_timeout_handle (gpointer data)
{
GtkDialog *dialog = GTK_DIALOG(data);
if(dialog != NULL)
gtk_dialog_response(dialog, ZENITY_TIMEOUT);
else {
gtk_main_quit();
exit(ZENITY_TIMEOUT);
}
return FALSE;
gboolean
zenity_util_timeout_handle (gpointer data) {
GtkDialog *dialog = GTK_DIALOG (data);
if (dialog != NULL)
gtk_dialog_response (dialog, ZENITY_TIMEOUT);
else {
gtk_main_quit ();
exit (ZENITY_TIMEOUT);
}
return FALSE;
}

47
src/util.h
View File

@ -1,37 +1,34 @@
#ifndef UTIL_H
#ifndef UTIL_H
#define UTIL_H
#include <gtk/gtk.h>
#include "zenity.h"
#include <gtk/gtk.h>
G_BEGIN_DECLS
#define ZENITY_UI_FILE_FULLPATH ZENITY_DATADIR "/zenity.ui"
#define ZENITY_UI_FILE_RELATIVEPATH "./zenity.ui"
#define ZENITY_UI_FILE_FULLPATH ZENITY_DATADIR "/zenity.ui"
#define ZENITY_UI_FILE_RELATIVEPATH "./zenity.ui"
#define ZENITY_IMAGE_FULLPATH(filename) (ZENITY_DATADIR "/" filename)
#define ZENITY_IMAGE_FULLPATH(filename) (ZENITY_DATADIR "/" filename)
GtkBuilder* zenity_util_load_ui_file (const gchar *widget_root, ...) G_GNUC_NULL_TERMINATED;
gchar * zenity_util_strip_newline (gchar *string);
gboolean zenity_util_fill_file_buffer (GtkTextBuffer *buffer,
const gchar *filename);
const gchar * zenity_util_icon_name_from_filename (const gchar *filename);
void zenity_util_set_window_icon (GtkWidget *widget,
const gchar *filename,
const gchar *default_file);
void zenity_util_set_window_icon_from_icon_name(GtkWidget *widget,
const gchar *filename,
const gchar *default_icon_name);
void zenity_util_set_window_icon_from_file (GtkWidget *widget,
const gchar *filename);
void zenity_util_show_help (GError **error);
gint zenity_util_return_exit_code (ZenityExitCode value);
void zenity_util_exit_code_with_data (ZenityExitCode value,
ZenityData *data);
void zenity_util_show_dialog (GtkWidget *widget, guintptr parent);
GtkBuilder *zenity_util_load_ui_file (
const gchar *widget_root, ...) G_GNUC_NULL_TERMINATED;
gchar *zenity_util_strip_newline (gchar *string);
gboolean zenity_util_fill_file_buffer (
GtkTextBuffer *buffer, const gchar *filename);
const gchar *zenity_util_icon_name_from_filename (const gchar *filename);
void zenity_util_set_window_icon (
GtkWidget *widget, const gchar *filename, const gchar *default_file);
void zenity_util_set_window_icon_from_icon_name (
GtkWidget *widget, const gchar *filename, const gchar *default_icon_name);
void zenity_util_set_window_icon_from_file (
GtkWidget *widget, const gchar *filename);
void zenity_util_show_help (GError **error);
gint zenity_util_return_exit_code (ZenityExitCode value);
void zenity_util_exit_code_with_data (ZenityExitCode value, ZenityData *data);
void zenity_util_show_dialog (GtkWidget *widget, guintptr parent);
gboolean zenity_util_timeout_handle (gpointer data);
gboolean zenity_util_timeout_handle (gpointer data);
G_END_DECLS

271
src/zenity.h
View File

@ -7,9 +7,9 @@ G_BEGIN_DECLS
#ifdef ENABLE_NLS
#include <libintl.h>
#define _(String) dgettext(GETTEXT_PACKAGE,String)
#define _(String) dgettext (GETTEXT_PACKAGE, String)
#ifdef gettext_noop
#define N_(String) gettext_noop(String)
#define N_(String) gettext_noop (String)
#else
#define N_(String) (String)
#endif
@ -18,205 +18,196 @@ G_BEGIN_DECLS
#define N_(String) (String)
#define textdomain(String) (String)
#define gettext(String) (String)
#define dgettext(Domain,String) (String)
#define dcgettext(Domain,String,Type) (String)
#define bindtextdomain(Domain,Directory) (Domain)
#define dgettext(Domain, String) (String)
#define dcgettext(Domain, String, Type) (String)
#define bindtextdomain(Domain, Directory) (Domain)
#endif
typedef struct {
gchar *dialog_title;
gchar *window_icon;
gchar *ok_label;
gchar *cancel_label;
gchar **extra_label;
gint width;
gint height;
gint exit_code;
gint timeout_delay;
gboolean modal;
guintptr attach;
gchar *dialog_title;
gchar *window_icon;
gchar *ok_label;
gchar *cancel_label;
gchar **extra_label;
gint width;
gint height;
gint exit_code;
gint timeout_delay;
gboolean modal;
guintptr attach;
} ZenityData;
typedef enum {
ZENITY_OK,
ZENITY_CANCEL,
ZENITY_ESC,
ZENITY_ERROR,
ZENITY_EXTRA,
ZENITY_TIMEOUT
ZENITY_OK,
ZENITY_CANCEL,
ZENITY_ESC,
ZENITY_ERROR,
ZENITY_EXTRA,
ZENITY_TIMEOUT
} ZenityExitCode;
typedef struct {
gchar *dialog_text;
gint day;
gint month;
gint year;
gchar *date_format;
gchar *dialog_text;
gint day;
gint month;
gint year;
gchar *date_format;
} ZenityCalendarData;
typedef enum {
ZENITY_MSG_WARNING,
ZENITY_MSG_QUESTION,
ZENITY_MSG_SWITCH,
ZENITY_MSG_ERROR,
ZENITY_MSG_INFO
ZENITY_MSG_WARNING,
ZENITY_MSG_QUESTION,
ZENITY_MSG_SWITCH,
ZENITY_MSG_ERROR,
ZENITY_MSG_INFO
} MsgMode;
typedef struct {
gchar *dialog_text;
gchar *dialog_icon;
MsgMode mode;
gboolean no_wrap;
gboolean no_markup;
gboolean default_cancel;
gboolean ellipsize;
gchar *dialog_text;
gchar *dialog_icon;
MsgMode mode;
gboolean no_wrap;
gboolean no_markup;
gboolean default_cancel;
gboolean ellipsize;
} ZenityMsgData;
typedef struct {
gchar *dialog_text;
gint value;
gint min_value;
gint max_value;
gint step;
gboolean print_partial;
gboolean hide_value;
gchar *dialog_text;
gint value;
gint min_value;
gint max_value;
gint step;
gboolean print_partial;
gboolean hide_value;
} ZenityScaleData;
typedef struct {
gchar *uri;
gboolean multi;
gboolean directory;
gboolean save;
gboolean confirm_overwrite;
gchar *separator;
gchar **filter;
gchar *uri;
gboolean multi;
gboolean directory;
gboolean save;
gboolean confirm_overwrite;
gchar *separator;
gchar **filter;
} ZenityFileData;
typedef struct {
gchar *dialog_text;
gchar *entry_text;
gboolean hide_text;
const gchar **data;
gchar *dialog_text;
gchar *entry_text;
gboolean hide_text;
const gchar **data;
} ZenityEntryData;
typedef struct {
gchar *dialog_text;
gchar *entry_text;
gboolean pulsate;
gboolean autoclose;
gboolean autokill;
gdouble percentage;
gboolean no_cancel;
gboolean time_remaining;
gchar *dialog_text;
gchar *entry_text;
gboolean pulsate;
gboolean autoclose;
gboolean autokill;
gdouble percentage;
gboolean no_cancel;
gboolean time_remaining;
} ZenityProgressData;
typedef struct {
gchar *uri;
gboolean editable;
gboolean no_wrap;
gboolean auto_scroll;
gchar *font;
GtkTextBuffer *buffer;
gchar *checkbox;
gchar *uri;
gboolean editable;
gboolean no_wrap;
gboolean auto_scroll;
gchar *font;
GtkTextBuffer *buffer;
gchar *checkbox;
#ifdef HAVE_WEBKITGTK
gboolean html;
gboolean no_interaction;
gchar *url;
gboolean html;
gboolean no_interaction;
gchar *url;
#endif
} ZenityTextData;
typedef struct {
gchar *dialog_text;
GSList *columns;
gboolean checkbox;
gboolean radiobox;
gboolean hide_header;
gboolean imagebox;
gchar *separator;
gboolean multi;
gboolean editable;
gboolean mid_search;
gchar *print_column;
gchar *hide_column;
const gchar **data;
gchar *dialog_text;
GSList *columns;
gboolean checkbox;
gboolean radiobox;
gboolean hide_header;
gboolean imagebox;
gchar *separator;
gboolean multi;
gboolean editable;
gboolean mid_search;
gchar *print_column;
gchar *hide_column;
const gchar **data;
} ZenityTreeData;
#ifdef HAVE_LIBNOTIFY
typedef struct {
gchar *notification_text;
gboolean listen;
gchar **notification_hints;
gchar *notification_text;
gboolean listen;
gchar **notification_hints;
} ZenityNotificationData;
#endif
typedef struct {
gchar *color;
gboolean show_palette;
gchar *color;
gboolean show_palette;
} ZenityColorData;
typedef struct {
GSList *list;
GSList *list_widgets;
GSList *list_values;
GSList *column_values;
GSList *combo_values;
gchar *dialog_text;
gchar *separator;
gchar *date_format;
// gchar *hide_column;
gboolean show_header;
GSList *list;
GSList *list_widgets;
GSList *list_values;
GSList *column_values;
GSList *combo_values;
gchar *dialog_text;
gchar *separator;
gchar *date_format;
// gchar *hide_column;
gboolean show_header;
} ZenityFormsData;
typedef enum {
ZENITY_FORMS_ENTRY,
ZENITY_FORMS_PASSWORD,
ZENITY_FORMS_CALENDAR,
ZENITY_FORMS_LIST,
ZENITY_FORMS_COMBO
ZENITY_FORMS_ENTRY,
ZENITY_FORMS_PASSWORD,
ZENITY_FORMS_CALENDAR,
ZENITY_FORMS_LIST,
ZENITY_FORMS_COMBO
} ZenityFormsType;
typedef struct {
gchar *option_value;
ZenityFormsType type;
GtkWidget *forms_widget;
gchar *option_value;
ZenityFormsType type;
GtkWidget *forms_widget;
} ZenityFormsValue;
typedef struct {
gboolean username;
gchar *password;
GtkWidget *entry_username;
GtkWidget *entry_password;
gboolean username;
gchar *password;
GtkWidget *entry_username;
GtkWidget *entry_password;
} ZenityPasswordData;
void zenity_calendar (ZenityData *data,
ZenityCalendarData *calendar_data);
void zenity_msg (ZenityData *data,
ZenityMsgData *msg_data);
void zenity_fileselection (ZenityData *data,
ZenityFileData *file_data);
void zenity_entry (ZenityData *data,
ZenityEntryData *entry_data);
void zenity_progress (ZenityData *data,
ZenityProgressData *progress_data);
void zenity_text (ZenityData *data,
ZenityTextData *text_data);
void zenity_tree (ZenityData *data,
ZenityTreeData *tree_data);
void zenity_calendar (ZenityData *data, ZenityCalendarData *calendar_data);
void zenity_msg (ZenityData *data, ZenityMsgData *msg_data);
void zenity_fileselection (ZenityData *data, ZenityFileData *file_data);
void zenity_entry (ZenityData *data, ZenityEntryData *entry_data);
void zenity_progress (ZenityData *data, ZenityProgressData *progress_data);
void zenity_text (ZenityData *data, ZenityTextData *text_data);
void zenity_tree (ZenityData *data, ZenityTreeData *tree_data);
#ifdef HAVE_LIBNOTIFY
void zenity_notification (ZenityData *data,
ZenityNotificationData *notification_data);
void zenity_notification (
ZenityData *data, ZenityNotificationData *notification_data);
#endif
void zenity_colorselection (ZenityData *data,
ZenityColorData *notification_data);
void zenity_scale (ZenityData *data,
ZenityScaleData *scale_data);
void zenity_about (ZenityData *data);
void zenity_colorselection (
ZenityData *data, ZenityColorData *notification_data);
void zenity_scale (ZenityData *data, ZenityScaleData *scale_data);
void zenity_about (ZenityData *data);
void zenity_password_dialog (ZenityData *data,
ZenityPasswordData *password_data);
void zenity_forms_dialog (ZenityData *data,
ZenityFormsData *forms_data);
void zenity_password_dialog (
ZenityData *data, ZenityPasswordData *password_data);
void zenity_forms_dialog (ZenityData *data, ZenityFormsData *forms_data);
G_END_DECLS
#endif /* ZENITY_H */