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

Fix style

Browse Source 
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

91
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>",
static const gchar *const authors[] = {"Glynn Foster <glynn foster sun com>",
"Lucas Rocha <lucasr gnome org>",
"Mike Newman <mikegtn gnome org>",
NULL
};
NULL};
static const char *documenters[] = {
"Glynn Foster <glynn.foster@sun.com>",
static const char *documenters[] = {"Glynn Foster <glynn.foster@sun.com>",
"Lucas Rocha <lucasr@gnome.org>",
"Java Desktop System Documentation Team",
"GNOME Documentation Project",
NULL
};
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 "
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, "
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 "
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.")
};
"Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA "
"02110-1301, USA.")};
#if 0
static gint
@ -254,40 +253,53 @@ zenity_zen_wisdom (GtkDialog *dialog, GdkEventKey *event, gpointer user_data)
#endif
void
zenity_about (ZenityData *data)
{
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 ();
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,
"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"));
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);
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",
@ -299,8 +311,7 @@ zenity_about (ZenityData *data)
}
static void
zenity_about_dialog_response (GtkWidget *widget, int response, gpointer data)
{
zenity_about_dialog_response (GtkWidget *widget, int response, gpointer data) {
ZenityData *zen_data = data;
switch (response) {

72
src/calendar.c
View File

@ -23,20 +23,19 @@
#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)
{
zenity_calendar (ZenityData *data, ZenityCalendarData *cal_data) {
GtkBuilder *builder;
GtkWidget *dialog;
GtkWidget *button;
@ -53,19 +52,24 @@ zenity_calendar (ZenityData *data, ZenityCalendarData *cal_data)
gtk_builder_connect_signals (builder, NULL);
dialog = GTK_WIDGET (gtk_builder_get_object (builder,
"zenity_calendar_dialog"));
dialog =
GTK_WIDGET (gtk_builder_get_object (builder, "zenity_calendar_dialog"));
g_signal_connect (G_OBJECT (dialog), "response",
G_CALLBACK (zenity_calendar_dialog_response), data);
g_signal_connect (G_OBJECT (dialog),
"response",
G_CALLBACK (zenity_calendar_dialog_response),
data);
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-calendar.png"));
zenity_util_set_window_icon (dialog,
data->window_icon,
ZENITY_IMAGE_FULLPATH ("zenity-calendar.png"));
if (data->width > -1 || data->height > -1)
gtk_window_set_default_size (GTK_WINDOW (dialog), data->width, data->height);
gtk_window_set_default_size (
GTK_WINDOW (dialog), data->width, data->height);
if (data->modal)
gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
@ -73,40 +77,49 @@ zenity_calendar (ZenityData *data, ZenityCalendarData *cal_data)
text = gtk_builder_get_object (builder, "zenity_calendar_text");
if (cal_data->dialog_text)
gtk_label_set_markup (GTK_LABEL (text), g_strcompress (cal_data->dialog_text));
gtk_label_set_markup (
GTK_LABEL (text), g_strcompress (cal_data->dialog_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);
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);
g_signal_connect (calendar, "day-selected-double-click",
G_CALLBACK (zenity_calendar_double_click), data);
g_signal_connect (calendar,
"day-selected-double-click",
G_CALLBACK (zenity_calendar_double_click),
data);
gtk_label_set_mnemonic_widget (GTK_LABEL (text), calendar);
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_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);
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"));
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"));
button = GTK_WIDGET (
gtk_builder_get_object (builder, "zenity_calendar_cancel_button"));
gtk_button_set_label (GTK_BUTTON (button), data->cancel_label);
}
@ -115,8 +128,7 @@ zenity_calendar (ZenityData *data, ZenityCalendarData *cal_data)
gtk_main ();
}
static void
zenity_calendar_dialog_output (void)
{
zenity_calendar_dialog_output (void) {
guint day, month, year;
gchar time_string[128];
GDate *date = NULL;
@ -131,8 +143,8 @@ zenity_calendar_dialog_output (void)
}
static void
zenity_calendar_dialog_response (GtkWidget *widget, int response, gpointer data)
{
zenity_calendar_dialog_response (
GtkWidget *widget, int response, gpointer data) {
ZenityData *zen_data;
zen_data = data;
@ -153,8 +165,9 @@ zenity_calendar_dialog_response (GtkWidget *widget, int response, gpointer data)
break;
default:
if (zen_data->extra_label && response < g_strv_length(zen_data->extra_label))
printf("%s\n",zen_data->extra_label[response]);
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;
}
@ -162,7 +175,6 @@ zenity_calendar_dialog_response (GtkWidget *widget, int response, gpointer data)
}
static void
zenity_calendar_double_click (GtkCalendar *cal, gpointer data)
{
zenity_calendar_double_click (GtkCalendar *cal, gpointer data) {
zenity_calendar_dialog_response (NULL, GTK_RESPONSE_OK, data);
}

34
src/color.c
View File

@ -23,16 +23,17 @@
#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)
{
void
zenity_colorselection (ZenityData *data, ZenityColorData *color_data) {
GtkWidget *dialog;
GtkWidget *button;
GdkRGBA color;
@ -41,7 +42,8 @@ void zenity_colorselection (ZenityData *data, ZenityColorData *color_data)
dialog = gtk_color_chooser_dialog_new (data->dialog_title, NULL);
g_signal_connect (G_OBJECT (dialog), "response",
g_signal_connect (G_OBJECT (dialog),
"response",
G_CALLBACK (zenity_colorselection_dialog_response),
color_data);
@ -52,9 +54,10 @@ void zenity_colorselection (ZenityData *data, ZenityColorData *color_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);
gint i = 0;
while (data->extra_label[i] != NULL) {
gtk_dialog_add_button (
GTK_DIALOG (dialog), data->extra_label[i], i);
i++;
}
}
@ -84,17 +87,17 @@ void zenity_colorselection (ZenityData *data, ZenityColorData *color_data)
dialog);
}
gtk_main();
gtk_main ();
}
static void
zenity_colorselection_dialog_response (GtkWidget *widget, int response, gpointer data)
{
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);
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;
@ -104,8 +107,9 @@ zenity_colorselection_dialog_response (GtkWidget *widget, int response, gpointer
break;
default:
if (zen_data->extra_label && response < g_strv_length(zen_data->extra_label))
printf("%s\n",zen_data->extra_label[response]);
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;
}

78
src/entry.c
View File

@ -23,17 +23,17 @@
#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)
{
zenity_entry_fill_entries (GSList **entries, const gchar **args) {
gint i = 0;
while (args[i] != NULL) {
@ -43,14 +43,12 @@ zenity_entry_fill_entries (GSList **entries, const gchar **args)
}
static void
zenity_entry_combo_activate_default (GtkEntry *entry, gpointer 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)
{
zenity_entry (ZenityData *data, ZenityEntryData *entry_data) {
GtkBuilder *builder = NULL;
GtkWidget *dialog;
GtkWidget *button;
@ -68,48 +66,57 @@ zenity_entry (ZenityData *data, ZenityEntryData *entry_data)
gtk_builder_connect_signals (builder, NULL);
dialog = GTK_WIDGET (gtk_builder_get_object (builder, "zenity_entry_dialog"));
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);
g_signal_connect (G_OBJECT (dialog),
"response",
G_CALLBACK (zenity_entry_dialog_response),
data);
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"));
zenity_util_set_window_icon (
dialog, data->window_icon, ZENITY_IMAGE_FULLPATH ("zenity-entry.png"));
if (data->width > -1 || data->height > -1)
gtk_window_set_default_size (GTK_WINDOW (dialog), data->width, data->height);
gtk_window_set_default_size (
GTK_WINDOW (dialog), data->width, data->height);
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);
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_entry_ok_button"));
button = GTK_WIDGET (
gtk_builder_get_object (builder, "zenity_entry_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_entry_cancel_button"));
button = GTK_WIDGET (
gtk_builder_get_object (builder, "zenity_entry_cancel_button"));
gtk_button_set_label (GTK_BUTTON (button), data->cancel_label);
}
text = gtk_builder_get_object (builder, "zenity_entry_text");
if (entry_data->dialog_text)
gtk_label_set_text_with_mnemonic (GTK_LABEL (text), g_strcompress (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);
zenity_entry_fill_entries (&entries, entry_data->data);
n_entries = g_slist_length (entries);
@ -117,19 +124,22 @@ zenity_entry (ZenityData *data, ZenityEntryData *entry_data)
entry = gtk_combo_box_text_new_with_entry ();
for (tmp = entries; tmp; tmp = tmp->next) {
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (entry), tmp->data);
gtk_combo_box_text_append_text (
GTK_COMBO_BOX_TEXT (entry), tmp->data);
}
if (entry_data->entry_text) {
gtk_combo_box_text_prepend_text (GTK_COMBO_BOX_TEXT (entry), 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);
}
g_signal_connect (gtk_bin_get_child (GTK_BIN (entry)), "activate",
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();
entry = gtk_entry_new ();
gtk_entry_set_activates_default (GTK_ENTRY (entry), TRUE);
@ -150,16 +160,17 @@ zenity_entry (ZenityData *data, ZenityEntryData *entry_data)
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 ();
}
static void
zenity_entry_dialog_output (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));
@ -168,18 +179,16 @@ zenity_entry_dialog_output (void)
if (text != NULL)
g_print ("%s\n", text);
}
static void
zenity_entry_dialog_response (GtkWidget *widget, int response, gpointer 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);
zenity_util_exit_code_with_data (ZENITY_OK, zen_data);
break;
case GTK_RESPONSE_CANCEL:
@ -192,8 +201,9 @@ zenity_entry_dialog_response (GtkWidget *widget, int response, gpointer data)
break;
default:
if (zen_data->extra_label && response < g_strv_length(zen_data->extra_label))
printf("%s\n",zen_data->extra_label[response]);
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;
}

90
src/fileselection.c
View File

@ -23,16 +23,17 @@
#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_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)
{
void
zenity_fileselection (ZenityData *data, ZenityFileData *file_data) {
GtkWidget *dialog;
gchar *dir;
gchar *basename;
@ -50,22 +51,28 @@ void zenity_fileselection (ZenityData *data, ZenityFileData *file_data)
action = GTK_FILE_CHOOSER_ACTION_SAVE;
}
dialog = gtk_file_chooser_dialog_new (NULL, NULL,
dialog = gtk_file_chooser_dialog_new (NULL,
NULL,
action,
_("_Cancel"), GTK_RESPONSE_CANCEL,
_("_OK"), GTK_RESPONSE_OK,
_ ("_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);
gint i = 0;
while (data->extra_label[i] != NULL) {
gtk_dialog_add_button (
GTK_DIALOG (dialog), data->extra_label[i], i);
i++;
}
}
@ -73,7 +80,8 @@ void zenity_fileselection (ZenityData *data, ZenityFileData *file_data)
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"));
zenity_util_set_window_icon (
dialog, data->window_icon, ZENITY_IMAGE_FULLPATH ("zenity-file.png"));
if (data->modal)
gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
@ -82,14 +90,17 @@ void zenity_fileselection (ZenityData *data, ZenityFileData *file_data)
dir = g_path_get_dirname (file_data->uri);
if (g_path_is_absolute (file_data->uri) == TRUE)
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), dir);
gtk_file_chooser_set_current_folder (
GTK_FILE_CHOOSER (dialog), dir);
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);
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);
(void) gtk_file_chooser_set_filename (
GTK_FILE_CHOOSER (dialog), file_data->uri);
g_free (basename);
}
g_free (dir);
@ -102,9 +113,9 @@ void zenity_fileselection (ZenityData *data, ZenityFileData *file_data)
/* Filter format: Executables | *.exe *.bat *.com */
gint filter_i;
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];
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;
@ -123,7 +134,8 @@ void zenity_fileselection (ZenityData *data, ZenityFileData *file_data)
gtk_file_filter_set_name (filter, name);
/* Point i to the right position for split */
for (++i; filter_str[i] == ' '; i++);
for (++i; filter_str[i] == ' '; i++)
;
} else {
gtk_file_filter_set_name (filter, filter_str);
i = 0;
@ -146,37 +158,40 @@ void zenity_fileselection (ZenityData *data, ZenityFileData *file_data)
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 ();
}
static void
zenity_fileselection_dialog_output (GtkWidget *widget, ZenityFileData *file_data)
{
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));
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 ("%s", file_data->separator);
}
g_print("\n");
g_slist_free(selections);
g_print ("\n");
g_slist_free (selections);
}
static void
zenity_fileselection_dialog_response (GtkWidget *widget, int response, gpointer data)
{
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);
zenity_util_exit_code_with_data (ZENITY_OK, zen_data);
break;
case GTK_RESPONSE_CANCEL:
@ -189,8 +204,9 @@ zenity_fileselection_dialog_response (GtkWidget *widget, int response, gpointer
break;
default:
if (zen_data->extra_label && response < g_strv_length(zen_data->extra_label))
printf("%s\n",zen_data->extra_label[response]);
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;
}

182
src/forms.c
View File

@ -22,19 +22,23 @@
*/
#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)
{
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, };
GValue value = {
0,
};
n_columns = gtk_tree_model_get_n_columns (model);
for (i = 0; i < n_columns; i++) {
@ -45,8 +49,8 @@ static void zenity_forms_dialog_get_selected (GtkTreeModel *model, GtkTreePath *
}
static GtkWidget *
zenity_forms_create_and_fill_combo (ZenityFormsData *forms_data, int combo_number)
{
zenity_forms_create_and_fill_combo (
ZenityFormsData *forms_data, int combo_number) {
GtkListStore *list_store;
GtkWidget *combo_box;
GtkCellRenderer *renderer;
@ -55,7 +59,8 @@ zenity_forms_create_and_fill_combo (ZenityFormsData *forms_data, int combo_numbe
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);
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) {
@ -79,15 +84,15 @@ zenity_forms_create_and_fill_combo (ZenityFormsData *forms_data, int combo_numbe
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);
gtk_cell_layout_set_attributes (
GTK_CELL_LAYOUT (combo_box), renderer, "text", 0, NULL);
return combo_box;
}
static GtkWidget *
zenity_forms_create_and_fill_list (ZenityFormsData *forms_data,
int list_number, gchar *header)
{
zenity_forms_create_and_fill_list (
ZenityFormsData *forms_data, int list_number, gchar *header) {
GtkListStore *list_store;
GtkWidget *tree_view;
GtkWidget *scrolled_window;
@ -105,7 +110,8 @@ zenity_forms_create_and_fill_list (ZenityFormsData *forms_data,
tree_view = gtk_tree_view_new ();
if (forms_data->column_values) {
column_values = g_slist_nth_data (forms_data->column_values, list_number);
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) {
@ -117,11 +123,10 @@ zenity_forms_create_and_fill_list (ZenityFormsData *forms_data,
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 = 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++;
}
}
@ -157,20 +162,23 @@ zenity_forms_create_and_fill_list (ZenityFormsData *forms_data,
}
}
gtk_tree_view_set_model (GTK_TREE_VIEW (tree_view), GTK_TREE_MODEL (list_store));
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_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);
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)
{
void
zenity_forms_dialog (ZenityData *data, ZenityFormsData *forms_data) {
GtkBuilder *builder = NULL;
GtkWidget *dialog;
GtkWidget *grid;
@ -185,48 +193,56 @@ void zenity_forms_dialog (ZenityData *data, ZenityFormsData *forms_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;
}
gtk_builder_connect_signals(builder, NULL);
gtk_builder_connect_signals (builder, NULL);
dialog = GTK_WIDGET (gtk_builder_get_object (builder, "zenity_forms_dialog"));
dialog =
GTK_WIDGET (gtk_builder_get_object (builder, "zenity_forms_dialog"));
g_signal_connect (G_OBJECT(dialog), "response",
G_CALLBACK (zenity_forms_dialog_response), forms_data);
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);
if (data->width > -1 || data->height > -1)
gtk_window_set_default_size (GTK_WINDOW (dialog), data->width, data->height);
gtk_window_set_default_size (
GTK_WINDOW (dialog), data->width, data->height);
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);
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_forms_ok_button"));
button = GTK_WIDGET (
gtk_builder_get_object (builder, "zenity_forms_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_forms_cancel_button"));
button = GTK_WIDGET (
gtk_builder_get_object (builder, "zenity_forms_cancel_button"));
gtk_button_set_label (GTK_BUTTON (button), data->cancel_label);
}
text = GTK_WIDGET (gtk_builder_get_object (builder, "zenity_forms_text"));
if (forms_data->dialog_text)
gtk_label_set_markup (GTK_LABEL (text), g_strcompress (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"));
@ -234,37 +250,35 @@ void zenity_forms_dialog (ZenityData *data, ZenityFormsData *forms_data)
ZenityFormsValue *zenity_value = (ZenityFormsValue *) tmp->data;
GtkWidget *label;
label = gtk_label_new(zenity_value->option_value);
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);
gtk_grid_attach (GTK_GRID (grid), label, 0, i, 1, 1);
switch(zenity_value->type)
{
switch (zenity_value->type) {
case ZENITY_FORMS_ENTRY:
zenity_value->forms_widget = gtk_entry_new();
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);
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();
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);
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);
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();
zenity_value->forms_widget = gtk_entry_new ();
break;
}
@ -272,7 +286,8 @@ void zenity_forms_dialog (ZenityData *data, ZenityFormsData *forms_data)
GTK_WIDGET (zenity_value->forms_widget),
label,
GTK_POS_RIGHT,
1, 1);
1,
1);
i++;
}
@ -282,15 +297,16 @@ void zenity_forms_dialog (ZenityData *data, ZenityFormsData *forms_data)
g_object_unref (builder);
if (data->timeout_delay > 0) {
g_timeout_add_seconds (data->timeout_delay, (GSourceFunc) zenity_util_timeout_handle, dialog);
g_timeout_add_seconds (data->timeout_delay,
(GSourceFunc) zenity_util_timeout_handle,
dialog);
}
gtk_main();
gtk_main ();
}
static void
zenity_forms_dialog_output (ZenityFormsData *forms_data)
{
zenity_forms_dialog_output (ZenityFormsData *forms_data) {
GSList *tmp, *tmp2;
guint day, year, month;
GDate *date = NULL;
@ -305,19 +321,23 @@ zenity_forms_dialog_output (ZenityFormsData *forms_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)));
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))));
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))));
(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
} else
g_print ("%s", (gchar *) tmp2->data);
}
@ -326,15 +346,26 @@ zenity_forms_dialog_output (ZenityFormsData *forms_data)
break;
case ZENITY_FORMS_CALENDAR:
gtk_calendar_get_date (GTK_CALENDAR (zenity_value->forms_widget), &day, &month, &year);
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_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);
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);
@ -342,23 +373,21 @@ zenity_forms_dialog_output (ZenityFormsData *forms_data)
} else
g_print (" ");
break;
}
if (tmp->next != NULL)
g_print("%s", forms_data->separator);
g_print ("%s", forms_data->separator);
}
g_print("\n");
g_print ("\n");
}
static void
zenity_forms_dialog_response (GtkWidget *widget, int response, gpointer 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);
zenity_util_exit_code_with_data (ZENITY_OK, zen_data);
break;
case GTK_RESPONSE_CANCEL:
@ -371,8 +400,9 @@ zenity_forms_dialog_response (GtkWidget *widget, int response, gpointer data)
break;
default:
if (zen_data->extra_label && response < g_strv_length(zen_data->extra_label))
printf("%s\n",zen_data->extra_label[response]);
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;
}

15
src/main.c
View File

@ -23,13 +23,13 @@
#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
@ -40,12 +40,12 @@ main (gint argc, gchar **argv) {
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);
@ -102,7 +102,8 @@ main (gint argc, gchar **argv) {
g_print ("%s\n", VERSION);
break;
case MODE_LAST:
g_printerr (_("You must specify a dialog type. See 'zenity --help' for details\n"));
g_printerr (_ ("You must specify a dialog type. See 'zenity "
"--help' for details\n"));
zenity_option_free ();
exit (-1);
default:

113
src/msg.c
View File

@ -23,21 +23,24 @@
#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;
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);
@ -46,13 +49,10 @@ zenity_msg_construct_question_dialog (GtkWidget *dialog, ZenityMsgData *msg_data
if (data->ok_label) {
gtk_button_set_label (GTK_BUTTON (ok_button), data->ok_label);
}
}
static void
zenity_label_widget_clipboard_selection(GtkWidget *widget)
{
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
@ -69,15 +69,14 @@ zenity_label_widget_clipboard_selection(GtkWidget *widget)
<property name="selectable">True</property>
.
*/
g_object_set(gtk_widget_get_settings (widget),
g_object_set (gtk_widget_get_settings (widget),
"gtk-label-select-on-focus",
FALSE,
NULL);
}
void
zenity_msg (ZenityData *data, ZenityMsgData *msg_data)
{
zenity_msg (ZenityData *data, ZenityMsgData *msg_data) {
GtkBuilder *builder;
GtkWidget *dialog;
GtkWidget *ok_button;
@ -87,16 +86,19 @@ zenity_msg (ZenityData *data, ZenityMsgData *msg_data)
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"));
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"));
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"));
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;
@ -104,18 +106,22 @@ zenity_msg (ZenityData *data, ZenityMsgData *msg_data)
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"));
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"));
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"));
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"));
ok_button = GTK_WIDGET (
gtk_builder_get_object (builder, "zenity_info_ok_button"));
break;
default:
@ -129,9 +135,10 @@ zenity_msg (ZenityData *data, ZenityMsgData *msg_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);
gint i = 0;
while (data->extra_label[i] != NULL) {
gtk_dialog_add_button (
GTK_DIALOG (dialog), data->extra_label[i], i);
i++;
}
}
@ -141,8 +148,10 @@ zenity_msg (ZenityData *data, ZenityMsgData *msg_data)
return;
}
g_signal_connect (G_OBJECT (dialog), "response",
G_CALLBACK (zenity_msg_dialog_response), data);
g_signal_connect (G_OBJECT (dialog),
"response",
G_CALLBACK (zenity_msg_dialog_response),
data);
gtk_builder_connect_signals (builder, NULL);
@ -157,24 +166,29 @@ zenity_msg (ZenityData *data, ZenityMsgData *msg_data)
switch (msg_data->mode) {
case ZENITY_MSG_WARNING:
zenity_util_set_window_icon_from_icon_name (dialog, data->window_icon, "dialog-warning");
zenity_util_set_window_icon_from_icon_name (
dialog, data->window_icon, "dialog-warning");
break;
case ZENITY_MSG_QUESTION:
zenity_util_set_window_icon_from_icon_name (dialog, data->window_icon, "dialog-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");
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");
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");
zenity_util_set_window_icon_from_icon_name (
dialog, data->window_icon, "dialog-information");
break;
default:
@ -182,14 +196,15 @@ zenity_msg (ZenityData *data, ZenityMsgData *msg_data)
}
if (data->width > -1 || data->height > -1)
gtk_window_set_default_size (GTK_WINDOW (dialog), data->width, data->height);
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
if (!msg_data->ellipsize && !msg_data->no_wrap) {
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,
// 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);
@ -202,23 +217,27 @@ zenity_msg (ZenityData *data, ZenityMsgData *msg_data)
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));
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);
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);
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);
if (data->timeout_delay > 0) {
g_timeout_add_seconds (data->timeout_delay,
(GSourceFunc) zenity_util_timeout_handle,
NULL);
}
g_object_unref (builder);
@ -227,13 +246,12 @@ zenity_msg (ZenityData *data, ZenityMsgData *msg_data)
}
static void
zenity_msg_dialog_response (GtkWidget *widget, int response, gpointer 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);
zenity_util_exit_code_with_data (ZENITY_OK, zen_data);
break;
case GTK_RESPONSE_CANCEL:
@ -241,8 +259,9 @@ zenity_msg_dialog_response (GtkWidget *widget, int response, gpointer data)
break;
default:
if (zen_data->extra_label && response < g_strv_length(zen_data->extra_label))
printf("%s\n",zen_data->extra_label[response]);
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;
}

140
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,14 +41,13 @@ static char *icon_file;
static GHashTable *notification_hints;
static NotifyNotification *
zenity_notification_new(gchar *message, gchar *icon_file)
{
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"));
g_printerr (_ ("Could not parse message\n"));
return NULL;
}
@ -60,13 +59,11 @@ zenity_notification_new(gchar *message, gchar *icon_file)
}
static void
on_notification_default_action (NotifyNotification *n,
const char *action,
void *user_data)
{
on_notification_default_action (
NotifyNotification *n, const char *action, void *user_data) {
ZenityData *zen_data;
zen_data = (ZenityData *)user_data;
zen_data = (ZenityData *) user_data;
notify_notification_close (n, NULL);
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_OK);
@ -75,18 +72,14 @@ on_notification_default_action (NotifyNotification *n,
}
static GHashTable *
zenity_notification_parse_hints_array (gchar **hints)
{
zenity_notification_parse_hints_array (gchar **hints) {
GHashTable *result;
gchar** pair;
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++) {
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);
@ -100,10 +93,9 @@ zenity_notification_parse_hints_array (gchar **hints)
}
static GHashTable *
zenity_notification_parse_hints (gchar *hints)
{
zenity_notification_parse_hints (gchar *hints) {
GHashTable *result;
gchar** hint_array;
gchar **hint_array;
hint_array = g_strsplit (g_strcompress (hints), "\n", MAX_HINTS);
result = zenity_notification_parse_hints_array (hint_array);
@ -112,8 +104,8 @@ zenity_notification_parse_hints (gchar *hints)
}
static void
zenity_notification_set_hint(gpointer key, gpointer value, gpointer user_data)
{
zenity_notification_set_hint (
gpointer key, gpointer value, gpointer user_data) {
NotifyNotification *notification;
gchar *hint_name;
GVariant *hint_value;
@ -127,36 +119,37 @@ zenity_notification_set_hint(gpointer key, gpointer value, gpointer user_data)
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)) {
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"));
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)) {
} 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)) {
} 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"));
g_printerr (_ ("Unsupported hint. Skipping.\n"));
return;
} else if ((g_ascii_strcasecmp ("x", hint_name) == 0)
|| (g_ascii_strcasecmp ("y", hint_name) == 0)) {
} else if ((g_ascii_strcasecmp ("x", hint_name) == 0) ||
(g_ascii_strcasecmp ("y", hint_name) == 0)) {
/* int hints */
if (string_value == NULL)
string_value = "";
@ -170,18 +163,16 @@ zenity_notification_set_hint(gpointer key, gpointer value, gpointer user_data)
hint_value = g_variant_new_byte (byte_value);
} else {
/* unknown hints */
g_printerr (_("Unknown hint name. Skipping.\n"));
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)
{
zenity_notification_set_hints (
NotifyNotification *notification, GHashTable *hints) {
if (hints == NULL) {
return;
}
@ -190,10 +181,8 @@ zenity_notification_set_hints (NotifyNotification *notification, GHashTable *hin
}
static gboolean
zenity_notification_handle_stdin (GIOChannel *channel,
GIOCondition condition,
gpointer user_data)
{
zenity_notification_handle_stdin (
GIOChannel *channel, GIOCondition condition, gpointer user_data) {
if ((condition & G_IO_IN) != 0) {
GString *string;
GError *error = NULL;
@ -206,7 +195,8 @@ zenity_notification_handle_stdin (GIOChannel *channel,
gchar *command, *value, *colon;
do {
status = g_io_channel_read_line_string (channel, string, NULL, &error);
status = g_io_channel_read_line_string (
channel, string, NULL, &error);
while (gdk_events_pending ())
gtk_main_iteration ();
@ -223,16 +213,17 @@ zenity_notification_handle_stdin (GIOChannel *channel,
}
zenity_util_strip_newline (string->str);
colon = strchr(string->str, ':');
colon = strchr (string->str, ':');
if (colon == NULL) {
g_printerr (_("Could not parse command from stdin\n"));
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++;
while (*value && g_ascii_isspace (*value))
value++;
if (!g_ascii_strcasecmp (command, "icon")) {
g_free (icon_file);
@ -258,7 +249,8 @@ zenity_notification_handle_stdin (GIOChannel *channel,
notify_notification_show (notif, &error);
if (error) {
g_warning ("Error showing notification: %s", error->message);
g_warning (
"Error showing notification: %s", error->message);
g_error_free (error);
error = NULL;
}
@ -278,7 +270,8 @@ zenity_notification_handle_stdin (GIOChannel *channel,
notify_notification_show (notif, &error);
if (error) {
g_warning ("Error showing notification: %s", error->message);
g_warning (
"Error showing notification: %s", error->message);
g_error_free (error);
error = NULL;
}
@ -303,39 +296,38 @@ zenity_notification_handle_stdin (GIOChannel *channel,
}
static void
zenity_notification_listen_on_stdin (ZenityData *data)
{
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);
g_io_add_watch (
channel, G_IO_IN | G_IO_HUP, zenity_notification_handle_stdin, data);
}
void
zenity_notification (ZenityData *data, ZenityNotificationData *notification_data)
{
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"));
notify_init (_ ("Zenity notification"));
}
if (notification_data->listen) {
zenity_notification_listen_on_stdin (data);
gtk_main();
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);
@ -351,8 +343,9 @@ zenity_notification (ZenityData *data, ZenityNotificationData *notification_data
/* 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);
notification_hints = zenity_notification_parse_hints_array (
notification_data->notification_hints);
zenity_notification_set_hints (notification, notification_hints);
g_hash_table_unref (notification_hints);
}
@ -365,12 +358,13 @@ zenity_notification (ZenityData *data, ZenityNotificationData *notification_data
}
exit (1);
}
}
if (data->timeout_delay > 0) {
g_timeout_add_seconds (data->timeout_delay, (GSourceFunc) zenity_util_timeout_handle, NULL);
gtk_main();
g_timeout_add_seconds (data->timeout_delay,
(GSourceFunc) zenity_util_timeout_handle,
NULL);
gtk_main ();
}
}

1782
src/option.c
View File

File diff suppressed because it is too large Load Diff

6
src/option.h
View File

@ -80,11 +80,9 @@ typedef struct {
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);

146
src/password.c
View File

@ -22,16 +22,17 @@
*/
#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)
{
void
zenity_password_dialog (ZenityData *data, ZenityPasswordData *password_data) {
GtkWidget *dialog;
GtkWidget *image;
GtkWidget *hbox;
@ -44,102 +45,76 @@ void zenity_password_dialog (ZenityData *data, ZenityPasswordData *password_data
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);
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_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_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);
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);
/* Checks if username has been passed as a parameter */
gchar *title_text = N_("Type your password");
gchar *title_text = N_ ("Type your password");
if(password_data->username)
title_text = N_("Type your username and password");
if (password_data->username)
title_text = N_ ("Type your username and password");
label = gtk_label_new(title_text);
label = gtk_label_new (title_text);
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))),
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);
vbox_labels = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
vbox_entries = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))),
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),
vbox_labels,
FALSE,
TRUE,
12);
gtk_box_pack_start(GTK_BOX(hbox),
vbox_entries,
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(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),
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);
}
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);
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);
if (data->dialog_title)
gtk_window_set_title (GTK_WINDOW (dialog), data->dialog_title);
@ -147,10 +122,12 @@ void zenity_password_dialog (ZenityData *data, ZenityPasswordData *password_data
if (data->modal)
gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
g_signal_connect (G_OBJECT (dialog), "response",
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))));
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) {
@ -158,20 +135,26 @@ void zenity_password_dialog (ZenityData *data, ZenityPasswordData *password_data
(GSourceFunc) zenity_util_timeout_handle,
dialog);
}
gtk_main();
gtk_main ();
}
static void
zenity_password_dialog_response (GtkWidget *widget, int response, gpointer data)
{
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);
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)));
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)));
g_print ("%s\n",
gtk_entry_get_text (
GTK_ENTRY (password_data->entry_password)));
break;
case GTK_RESPONSE_CANCEL:
@ -179,8 +162,9 @@ zenity_password_dialog_response (GtkWidget *widget, int response, gpointer data)
break;
default:
if (zen_data->extra_label && response < g_strv_length(zen_data->extra_label))
printf("%s\n",zen_data->extra_label[response]);
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;
}

219
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,18 +45,17 @@ 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)
{
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)
{
zenity_progress_pulsate_stop (void) {
if (pulsate_timeout > 0) {
g_source_remove (pulsate_timeout);
pulsate_timeout = -1;
@ -64,53 +63,51 @@ zenity_progress_pulsate_stop (void)
}
static void
zenity_progress_pulsate_start (GObject *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);
pulsate_timeout = g_timeout_add (
100, zenity_progress_pulsate_progress_bar, progress_bar);
}
}
static void
zenity_progress_update_time_remaining (ZenityProgressData *progress_data)
{
zenity_progress_update_time_remaining (ZenityProgressData *progress_data) {
static GObject *progress_time = NULL;
static time_t start_time = (time_t)(-1);
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);
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 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);
seconds = (gulong) (remaining_time % 60);
remaining_time /= 60;
minutes = (gulong) (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);
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)
{
zenity_progress_handle_stdin (
GIOChannel *channel, GIOCondition condition, gpointer data) {
static ZenityProgressData *progress_data;
static GObject *progress_bar;
static GObject *progress_label;
@ -131,7 +128,8 @@ zenity_progress_handle_stdin (GIOChannel *channel,
;
do {
do {
status = g_io_channel_read_line_string (channel, string, NULL, &error);
status = g_io_channel_read_line_string (
channel, string, NULL, &error);
while (gtk_events_pending ())
gtk_main_iteration ();
@ -140,7 +138,8 @@ zenity_progress_handle_stdin (GIOChannel *channel,
if (status != G_IO_STATUS_NORMAL) {
if (error) {
g_warning ("zenity_progress_handle_stdin () : %s", error->message);
g_warning (
"zenity_progress_handle_stdin () : %s", error->message);
g_error_free (error);
error = NULL;
}
@ -153,28 +152,32 @@ zenity_progress_handle_stdin (GIOChannel *channel,
/* 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))));
gtk_label_set_text (GTK_LABEL (progress_label),
g_strcompress (g_strchomp (g_strchug (match))));
} else if (g_str_has_prefix (string->str, "pulsate")) {
gchar *colon, *command, *value;
zenity_util_strip_newline (string->str);
colon = strchr(string->str, ':');
colon = strchr (string->str, ':');
if (colon == NULL) {
continue;
}
/* split off the command and value */
command = g_strstrip (g_strndup (string->str, colon - string->str));
command =
g_strstrip (g_strndup (string->str, colon - string->str));
value = colon + 1;
while (*value && g_ascii_isspace (*value)) value++;
while (*value && g_ascii_isspace (*value))
value++;
if (!g_ascii_strcasecmp (value, "false")) {
zenity_progress_pulsate_stop ();
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (progress_bar),
gtk_progress_bar_set_fraction (
GTK_PROGRESS_BAR (progress_bar),
progress_data->percentage / 100.0);
} else {
zenity_progress_pulsate_start (progress_bar);
@ -187,10 +190,10 @@ zenity_progress_handle_stdin (GIOChannel *channel,
continue;
/* Now try to convert the thing to a number */
percentage = CLAMP(atoi (string->str), 0, 100);
percentage = CLAMP (atoi (string->str), 0, 100);
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (progress_bar),
percentage / 100.0);
gtk_progress_bar_set_fraction (
GTK_PROGRESS_BAR (progress_bar), percentage / 100.0);
progress_data->percentage = percentage;
@ -200,32 +203,37 @@ zenity_progress_handle_stdin (GIOChannel *channel,
if (percentage == 100) {
GObject *button;
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));
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 (progress_data->autoclose) {
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_OK);
gtk_main_quit();
zen_data->exit_code =
zenity_util_return_exit_code (ZENITY_OK);
gtk_main_quit ();
}
}
}
} while ((g_io_channel_get_buffer_condition (channel) & G_IO_IN) == G_IO_IN && status != G_IO_STATUS_EOF);
} 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 ((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 */
/* 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_ok_button"));
button = GTK_WIDGET (
gtk_builder_get_object (builder, "zenity_progress_ok_button"));
gtk_widget_set_sensitive (button, TRUE);
gtk_widget_grab_focus (button);
button = GTK_WIDGET (gtk_builder_get_object (builder,
"zenity_progress_cancel_button"));
button = GTK_WIDGET (
gtk_builder_get_object (builder, "zenity_progress_cancel_button"));
gtk_widget_set_sensitive (button, FALSE);
@ -237,7 +245,7 @@ zenity_progress_handle_stdin (GIOChannel *channel,
if (progress_data->autoclose) {
zen_data->exit_code = zenity_util_return_exit_code (ZENITY_OK);
gtk_main_quit();
gtk_main_quit ();
}
g_io_channel_shutdown (channel, TRUE, NULL);
@ -247,35 +255,37 @@ zenity_progress_handle_stdin (GIOChannel *channel,
}
static void
zenity_progress_read_info (ZenityProgressData *progress_data)
{
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);
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");
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)
{
zenity_progress (ZenityData *data, ZenityProgressData *progress_data) {
GtkWidget *dialog;
GtkWidget *button;
GObject *text;
GObject *progress_bar;
GObject *cancel_button,*ok_button;
GObject *cancel_button, *ok_button;
zen_data = data;
builder = zenity_util_load_ui_file ("zenity_progress_dialog", NULL);
@ -289,59 +299,71 @@ zenity_progress (ZenityData *data, ZenityProgressData *progress_data)
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");
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);
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);
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);
} 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->extra_label) {
gint i=0;
while(data->extra_label[i]!=NULL){
gtk_dialog_add_button (GTK_DIALOG (dialog), data->extra_label[i], i);
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"));
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"));
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));
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);
gtk_progress_bar_set_fraction (
GTK_PROGRESS_BAR (progress_bar), progress_data->percentage / 100.0);
autokill = progress_data->autokill;
@ -349,36 +371,40 @@ zenity_progress (ZenityData *data, ZenityProgressData *progress_data)
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");
cancel_button =
gtk_builder_get_object (builder, "zenity_progress_cancel_button");
if (no_cancel) {
gtk_widget_hide (GTK_WIDGET(cancel_button));
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));
gtk_widget_hide (GTK_WIDGET (ok_button));
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 ();
}
static void
zenity_progress_dialog_response (GtkWidget *widget, int response, gpointer data)
{
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);
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
/* 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
@ -393,8 +419,9 @@ zenity_progress_dialog_response (GtkWidget *widget, int response, gpointer data)
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]);
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;
}

77
src/scale.c
View File

@ -23,45 +23,50 @@
#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)
{
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;
}
dialog = GTK_WIDGET (gtk_builder_get_object (builder, "zenity_scale_dialog"));
scale = GTK_WIDGET (gtk_builder_get_object (builder, "zenity_scale_hscale"));
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);
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"));
g_printerr (_ ("Maximum value must be greater than minimum value.\n"));
data->exit_code = zenity_util_return_exit_code (ZENITY_ERROR);
return;
}
if (scale_data->value < scale_data->min_value ||
scale_data->value > scale_data->max_value) {
g_printerr (_("Value out of range.\n"));
g_printerr (_ ("Value out of range.\n"));
data->exit_code = zenity_util_return_exit_code (ZENITY_ERROR);
return;
}
@ -71,50 +76,61 @@ zenity_scale (ZenityData *data, ZenityScaleData *scale_data)
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-scale.png"));
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_window_set_default_size (
GTK_WINDOW (dialog), data->width, data->height);
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);
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_scale_ok_button"));
button = GTK_WIDGET (
gtk_builder_get_object (builder, "zenity_scale_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_scale_cancel_button"));
button = GTK_WIDGET (
gtk_builder_get_object (builder, "zenity_scale_cancel_button"));
gtk_button_set_label (GTK_BUTTON (button), data->cancel_label);
}
if (scale_data->dialog_text)
gtk_label_set_markup (GTK_LABEL (text), g_strcompress (scale_data->dialog_text));
gtk_label_set_markup (
GTK_LABEL (text), g_strcompress (scale_data->dialog_text));
gtk_range_set_range (GTK_RANGE (scale), scale_data->min_value, scale_data->max_value);
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 (scale_data->print_partial)
g_signal_connect (G_OBJECT (scale), "value-changed",
G_CALLBACK (zenity_scale_value_changed), data);
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);
if (data->timeout_delay > 0) {
g_timeout_add_seconds (data->timeout_delay,
(GSourceFunc) zenity_util_timeout_handle,
dialog);
}
g_object_unref (builder);
@ -123,19 +139,17 @@ zenity_scale (ZenityData *data, ZenityScaleData *scale_data)
}
static void
zenity_scale_value_changed (GtkWidget *widget, gpointer data)
{
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)
{
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);
zenity_util_exit_code_with_data (ZENITY_OK, zen_data);
g_print ("%.0f\n", gtk_range_get_value (GTK_RANGE (scale)));
break;
@ -149,8 +163,9 @@ zenity_scale_dialog_response (GtkWidget *widget, int response, gpointer data)
break;
default:
if (zen_data->extra_label && response < g_strv_length(zen_data->extra_label))
printf("%s\n",zen_data->extra_label[response]);
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;
}

281
src/text.c
View File

@ -23,9 +23,9 @@
#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>
@ -33,98 +33,124 @@
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)
{
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);
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
"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);
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
"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
"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);
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
"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)
{
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);
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);
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)
{
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);
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)
{
zenity_text_handle_stdin (
GIOChannel *channel, GIOCondition condition, gpointer data) {
static GtkTextBuffer *buffer;
static GtkTextView *text_view;
gchar buf[1024];
@ -167,7 +193,14 @@ zenity_text_handle_stdin (GIOChannel *channel,
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);
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 {
@ -177,7 +210,8 @@ zenity_text_handle_stdin (GIOChannel *channel,
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);
gtk_text_view_scroll_to_mark (
text_view, mark, 0.0, FALSE, 0, 0);
}
}
}
@ -186,19 +220,18 @@ zenity_text_handle_stdin (GIOChannel *channel,
}
static void
zenity_text_fill_entries_from_stdin (GtkTextView *text_view)
{
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);
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)
{
zenity_text (ZenityData *data, ZenityTextData *text_data) {
GtkBuilder *builder;
GtkWidget *dialog;
GtkWidget *ok_button;
@ -215,8 +248,8 @@ zenity_text (ZenityData *data, ZenityTextData *text_data)
gchar *content;
#endif
zen_text_data = text_data;
builder = zenity_util_load_ui_file ("zenity_text_dialog",
"textbuffer1", NULL);
builder =
zenity_util_load_ui_file ("zenity_text_dialog", "textbuffer1", NULL);
if (builder == NULL) {
data->exit_code = zenity_util_return_exit_code (ZENITY_ERROR);
@ -225,47 +258,56 @@ zenity_text (ZenityData *data, ZenityTextData *text_data)
gtk_builder_connect_signals (builder, NULL);
dialog = GTK_WIDGET (gtk_builder_get_object (builder, "zenity_text_dialog"));
dialog =
GTK_WIDGET (gtk_builder_get_object (builder, "zenity_text_dialog"));
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"));
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"));
g_signal_connect (G_OBJECT (dialog), "response",
G_CALLBACK (zenity_text_dialog_response), data);
g_signal_connect (G_OBJECT (dialog),
"response",
G_CALLBACK (zenity_text_dialog_response),
data);
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-text.png"));
zenity_util_set_window_icon (
dialog, data->window_icon, ZENITY_IMAGE_FULLPATH ("zenity-text.png"));
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_CLOSE);
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);
gtk_text_view_set_editable (GTK_TEXT_VIEW (text_view), text_data->editable);
if (text_data->no_wrap)
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW(text_view), GTK_WRAP_NONE);
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (text_view), GTK_WRAP_NONE);
if (text_data->font) {
PangoFontDescription *fontDesc = pango_font_description_from_string (text_data->font);
gtk_widget_override_font (GTK_WIDGET(text_view), fontDesc);
PangoFontDescription *fontDesc =
pango_font_description_from_string (text_data->font);
gtk_widget_override_font (GTK_WIDGET (text_view), fontDesc);
}
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));
zenity_text_fill_entries_from_stdin (GTK_TEXT_VIEW (text_view));
if (text_data->editable)
zen_text_data->buffer = text_buffer;
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);
gint i = 0;
while (data->extra_label[i] != NULL) {
gtk_dialog_add_button (
GTK_DIALOG (dialog), data->extra_label[i], i);
i++;
}
}
@ -283,12 +325,15 @@ zenity_text (ZenityData *data, ZenityTextData *text_data)
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);
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);
gtk_window_set_default_size (
GTK_WINDOW (dialog), data->width, data->height);
else
gtk_window_set_default_size (GTK_WINDOW (dialog), 300, 400);
@ -296,34 +341,36 @@ zenity_text (ZenityData *data, ZenityTextData *text_data)
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));
if (text_data->url)
{
if (!(g_str_has_prefix (text_data->url, "http://") || g_str_has_prefix (text_data->url, "https://")))
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
{
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 ("/");
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);
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);
}
@ -331,11 +378,13 @@ zenity_text (ZenityData *data, ZenityTextData *text_data)
// 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_container_add (GTK_CONTAINER (scrolled_window), web_kit);
gtk_widget_show (GTK_WIDGET (web_kit));
}
#endif
@ -344,36 +393,37 @@ zenity_text (ZenityData *data, ZenityTextData *text_data)
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 ();
}
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)
{
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);
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)
{
zenity_text_dialog_response (GtkWidget *widget, int response, gpointer data) {
ZenityData *zen_data = data;
switch (response) {
@ -388,9 +438,10 @@ zenity_text_dialog_response (GtkWidget *widget, int response, gpointer data)
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);
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 ();

436
src/tree.c
View File

@ -25,10 +25,10 @@
#include "config.h"
#include <string.h>
#include <stdlib.h>
#include "zenity.h"
#include "util.h"
#include "zenity.h"
#include <stdlib.h>
#include <string.h>
#define MAX_ELEMENTS_BEFORE_SCROLLING 5
#define PRINT_HIDE_COLUMN_SEPARATOR ","
@ -43,14 +43,17 @@ static GIOChannel *channel;
static int *zenity_tree_extract_column_indexes (char *indexes, gint n_columns);
static gboolean zenity_tree_column_is_hidden (gint column_index);
static void zenity_tree_dialog_response (GtkWidget *widget, int response, gpointer data);
static void zenity_tree_row_activated (GtkTreeView *tree_view, GtkTreePath *tree_path,
GtkTreeViewColumn *tree_col, gpointer data);
static void zenity_tree_dialog_response (
GtkWidget *widget, int response, gpointer data);
static void zenity_tree_row_activated (GtkTreeView *tree_view,
GtkTreePath *tree_path, GtkTreeViewColumn *tree_col, gpointer data);
static gboolean
zenity_tree_dialog_untoggle (GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data)
{
GValue toggle_value = {0, };
zenity_tree_dialog_untoggle (
GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data) {
GValue toggle_value = {
0,
};
gtk_tree_model_get_value (model, iter, 0, &toggle_value);
@ -60,8 +63,8 @@ zenity_tree_dialog_untoggle (GtkTreeModel *model, GtkTreePath *path, GtkTreeIter
}
static void
zenity_tree_toggled_callback (GtkCellRendererToggle *cell, gchar *path_string, gpointer data)
{
zenity_tree_toggled_callback (
GtkCellRendererToggle *cell, gchar *path_string, gpointer data) {
GtkTreeModel *model;
GtkTreeIter iter;
GtkTreePath *path;
@ -69,7 +72,8 @@ zenity_tree_toggled_callback (GtkCellRendererToggle *cell, gchar *path_string, g
model = GTK_TREE_MODEL (data);
/* Because this is a radio list, we should untoggle the previous toggle so that
/* Because this is a radio list, we should untoggle the previous toggle so
* that
* we only have one selection at any given time
*/
@ -88,12 +92,8 @@ zenity_tree_toggled_callback (GtkCellRendererToggle *cell, gchar *path_string, g
}
static void
zenity_load_pixbuf (GtkTreeViewColumn *tree_column,
GtkCellRenderer *cell,
GtkTreeModel *tree_model,
GtkTreeIter *iter,
gpointer data)
{
zenity_load_pixbuf (GtkTreeViewColumn *tree_column, GtkCellRenderer *cell,
GtkTreeModel *tree_model, GtkTreeIter *iter, gpointer data) {
static GHashTable *pixbuf_cache = NULL;
GError *error = NULL;
GdkPixbuf *pixbuf;
@ -106,7 +106,7 @@ zenity_load_pixbuf (GtkTreeViewColumn *tree_column,
if (!pixbuf_cache) {
pixbuf_cache = g_hash_table_new (g_str_hash, g_str_equal);
g_assert(pixbuf_cache);
g_assert (pixbuf_cache);
}
pixbuf = g_hash_table_lookup (pixbuf_cache, str);
@ -126,10 +126,8 @@ zenity_load_pixbuf (GtkTreeViewColumn *tree_column,
}
static gboolean
zenity_tree_handle_stdin (GIOChannel *channel,
GIOCondition condition,
gpointer data)
{
zenity_tree_handle_stdin (
GIOChannel *channel, GIOCondition condition, gpointer data) {
static GtkTreeView *tree_view;
GtkTreeModel *model;
static GtkTreeIter iter;
@ -142,9 +140,12 @@ zenity_tree_handle_stdin (GIOChannel *channel,
GIOStatus status = G_IO_STATUS_NORMAL;
tree_view = GTK_TREE_VIEW (data);
n_columns = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (tree_view), "n_columns"));
editable = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (tree_view), "editable"));
toggles = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (tree_view), "toggles"));
n_columns =
GPOINTER_TO_INT (g_object_get_data (G_OBJECT (tree_view), "n_columns"));
editable =
GPOINTER_TO_INT (g_object_get_data (G_OBJECT (tree_view), "editable"));
toggles =
GPOINTER_TO_INT (g_object_get_data (G_OBJECT (tree_view), "toggles"));
model = gtk_tree_view_get_model (tree_view);
@ -159,12 +160,14 @@ zenity_tree_handle_stdin (GIOChannel *channel,
string = g_string_new (NULL);
while ((g_io_channel_get_flags(channel) & G_IO_FLAG_IS_READABLE) != G_IO_FLAG_IS_READABLE)
while ((g_io_channel_get_flags (channel) & G_IO_FLAG_IS_READABLE) !=
G_IO_FLAG_IS_READABLE)
;
do {
do {
if (g_io_channel_get_flags(channel) & G_IO_FLAG_IS_READABLE)
status = g_io_channel_read_line_string (channel, string, NULL, &error);
if (g_io_channel_get_flags (channel) & G_IO_FLAG_IS_READABLE)
status = g_io_channel_read_line_string (
channel, string, NULL, &error);
else
return FALSE;
@ -172,13 +175,14 @@ zenity_tree_handle_stdin (GIOChannel *channel,
gtk_main_iteration ();
// TODO: Find a better way to avoid 100% cpu utilization
g_usleep(10000);
g_usleep (10000);
} while (status == G_IO_STATUS_AGAIN);
if (status != G_IO_STATUS_NORMAL) {
if (error) {
g_warning ("zenity_tree_handle_stdin () : %s", error->message);
g_warning (
"zenity_tree_handle_stdin () : %s", error->message);
g_error_free (error);
error = NULL;
}
@ -193,34 +197,48 @@ zenity_tree_handle_stdin (GIOChannel *channel,
}
if (toggles && column_count == 0) {
if (strcmp (g_ascii_strdown (zenity_util_strip_newline (string->str), -1), "true") == 0)
gtk_list_store_set (GTK_LIST_STORE (model), &iter, column_count, TRUE, -1);
if (strcmp (g_ascii_strdown (
zenity_util_strip_newline (string->str), -1),
"true") == 0)
gtk_list_store_set (
GTK_LIST_STORE (model), &iter, column_count, TRUE, -1);
else
gtk_list_store_set (GTK_LIST_STORE (model), &iter, column_count, FALSE, -1);
}
else {
gtk_list_store_set (GTK_LIST_STORE (model), &iter, column_count, zenity_util_strip_newline (string->str), -1);
gtk_list_store_set (
GTK_LIST_STORE (model), &iter, column_count, FALSE, -1);
} else {
gtk_list_store_set (GTK_LIST_STORE (model),
&iter,
column_count,
zenity_util_strip_newline (string->str),
-1);
}
if (editable) {
gtk_list_store_set (GTK_LIST_STORE (model), &iter, n_columns, TRUE, -1);
gtk_list_store_set (
GTK_LIST_STORE (model), &iter, n_columns, TRUE, -1);
}
if (row_count == MAX_ELEMENTS_BEFORE_SCROLLING) {
GtkWidget *scrolled_window;
GtkRequisition rectangle;
gtk_widget_get_preferred_size (GTK_WIDGET (tree_view), &rectangle, NULL);
scrolled_window = GTK_WIDGET (gtk_builder_get_object (builder,
"zenity_tree_window"));
gtk_widget_set_size_request (scrolled_window, -1, rectangle.height);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_widget_get_preferred_size (
GTK_WIDGET (tree_view), &rectangle, NULL);
scrolled_window = GTK_WIDGET (
gtk_builder_get_object (builder, "zenity_tree_window"));
gtk_widget_set_size_request (
scrolled_window, -1, rectangle.height);
gtk_scrolled_window_set_policy (
GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
}
column_count++;
} while ((g_io_channel_get_buffer_condition (channel) & G_IO_IN) == G_IO_IN && status != G_IO_STATUS_EOF);
} while ((g_io_channel_get_buffer_condition (channel) & G_IO_IN) ==
G_IO_IN &&
status != G_IO_STATUS_EOF);
g_string_free (string, TRUE);
}
@ -232,35 +250,33 @@ zenity_tree_handle_stdin (GIOChannel *channel,
}
static void
zenity_tree_fill_entries_from_stdin (GtkTreeView *tree_view,
gint n_columns,
gboolean toggles,
gboolean editable)
{
g_object_set_data (G_OBJECT (tree_view), "n_columns", GINT_TO_POINTER (n_columns));
g_object_set_data (G_OBJECT (tree_view), "toggles", GINT_TO_POINTER (toggles));
g_object_set_data (G_OBJECT (tree_view), "editable", GINT_TO_POINTER (editable));
zenity_tree_fill_entries_from_stdin (GtkTreeView *tree_view, gint n_columns,
gboolean toggles, gboolean editable) {
g_object_set_data (
G_OBJECT (tree_view), "n_columns", GINT_TO_POINTER (n_columns));
g_object_set_data (
G_OBJECT (tree_view), "toggles", GINT_TO_POINTER (toggles));
g_object_set_data (
G_OBJECT (tree_view), "editable", GINT_TO_POINTER (editable));
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_tree_handle_stdin, tree_view);
g_io_add_watch (
channel, G_IO_IN | G_IO_HUP, zenity_tree_handle_stdin, tree_view);
}
static void
zenity_tree_fill_entries (GtkTreeView *tree_view,
const gchar **args,
gint n_columns,
gboolean toggles,
gboolean editable)
{
zenity_tree_fill_entries (GtkTreeView *tree_view, const gchar **args,
gint n_columns, gboolean toggles, gboolean editable) {
GtkTreeModel *model;
GtkTreeIter iter;
gint i = 0;
model = gtk_tree_view_get_model (tree_view);
g_object_set_data (G_OBJECT (tree_view), "n_columns", GINT_TO_POINTER (n_columns));
g_object_set_data (
G_OBJECT (tree_view), "n_columns", GINT_TO_POINTER (n_columns));
while (args[i] != NULL) {
gint j;
@ -270,28 +286,35 @@ zenity_tree_fill_entries (GtkTreeView *tree_view,
for (j = 0; j < n_columns; j++) {
if (toggles && j == 0) {
if (strcmp (g_ascii_strdown ((gchar *) args[i+j], -1), "true") == 0)
gtk_list_store_set (GTK_LIST_STORE (model), &iter, j, TRUE, -1);
if (strcmp (g_ascii_strdown ((gchar *) args[i + j], -1),
"true") == 0)
gtk_list_store_set (
GTK_LIST_STORE (model), &iter, j, TRUE, -1);
else
gtk_list_store_set (GTK_LIST_STORE (model), &iter, j, FALSE, -1);
}
else
gtk_list_store_set (GTK_LIST_STORE (model), &iter, j, args[i+j], -1);
gtk_list_store_set (
GTK_LIST_STORE (model), &iter, j, FALSE, -1);
} else
gtk_list_store_set (
GTK_LIST_STORE (model), &iter, j, args[i + j], -1);
}
if (editable)
gtk_list_store_set (GTK_LIST_STORE (model), &iter, n_columns, TRUE, -1);
gtk_list_store_set (
GTK_LIST_STORE (model), &iter, n_columns, TRUE, -1);
if (i == MAX_ELEMENTS_BEFORE_SCROLLING) {
GtkWidget *scrolled_window;
GtkRequisition rectangle;
gtk_widget_get_preferred_size (GTK_WIDGET (tree_view), &rectangle, NULL);
scrolled_window = GTK_WIDGET (gtk_builder_get_object (builder,
"zenity_tree_window"));
gtk_widget_get_preferred_size (
GTK_WIDGET (tree_view), &rectangle, NULL);
scrolled_window = GTK_WIDGET (
gtk_builder_get_object (builder, "zenity_tree_window"));
gtk_widget_set_size_request (scrolled_window, -1, rectangle.height);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_policy (
GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
}
i += n_columns;
@ -299,23 +322,17 @@ zenity_tree_fill_entries (GtkTreeView *tree_view,
}
static gboolean
zenity_mid_search_func (GtkTreeModel *model, gint column,
const gchar *key, GtkTreeIter *iter,
gpointer search_data)
{
zenity_mid_search_func (GtkTreeModel *model, gint column, const gchar *key,
GtkTreeIter *iter, gpointer search_data) {
gchar *iter_string = NULL;
gtk_tree_model_get (model, iter, column, &iter_string, -1);
return ! (g_strrstr (g_utf8_strdown(iter_string, -1),
g_utf8_strdown(key, -1)) != NULL);
return !(g_strrstr (g_utf8_strdown (iter_string, -1),
g_utf8_strdown (key, -1)) != NULL);
}
static void
zenity_cell_edited_callback (GtkCellRendererText *cell,
const gchar *path_string,
const gchar *new_text,
gpointer data)
{
const gchar *path_string, const gchar *new_text, gpointer data) {
GtkTreeModel *model;
GtkTreePath *path;
GtkTreeIter iter;
@ -333,8 +350,7 @@ zenity_cell_edited_callback (GtkCellRendererText *cell,
}
void
zenity_tree (ZenityData *data, ZenityTreeData *tree_data)
{
zenity_tree (ZenityData *data, ZenityTreeData *tree_data) {
GtkWidget *dialog;
GtkWidget *button;
GObject *tree_view;
@ -361,35 +377,39 @@ zenity_tree (ZenityData *data, ZenityTreeData *tree_data)
if (strcmp (g_ascii_strdown (tree_data->print_column, -1), "all") == 0)
print_all_columns = TRUE;
else
print_columns = zenity_tree_extract_column_indexes (tree_data->print_column, n_columns);
}
else {
print_columns = zenity_tree_extract_column_indexes (
tree_data->print_column, n_columns);
} else {
print_columns = g_new (gint, 2);
print_columns[0] = (tree_data->radiobox || tree_data->checkbox ? 2 : 1);
print_columns[1] = 0;
}
if (tree_data->hide_column)
hide_columns = zenity_tree_extract_column_indexes (tree_data->hide_column, n_columns);
hide_columns = zenity_tree_extract_column_indexes (
tree_data->hide_column, n_columns);
if (n_columns == 0) {
g_printerr (_("No column titles specified for List dialog.\n"));
g_printerr (_ ("No column titles specified for List dialog.\n"));
data->exit_code = zenity_util_return_exit_code (ZENITY_ERROR);
return;
}
if (tree_data->checkbox + tree_data->radiobox + tree_data->imagebox > 1) {
g_printerr (_("You should use only one List dialog type.\n"));
g_printerr (_ ("You should use only one List dialog type.\n"));
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_tree_dialog"));
dialog =
GTK_WIDGET (gtk_builder_get_object (builder, "zenity_tree_dialog"));
g_signal_connect (G_OBJECT (dialog), "response",
G_CALLBACK (zenity_tree_dialog_response), data);
g_signal_connect (G_OBJECT (dialog),
"response",
G_CALLBACK (zenity_tree_dialog_response),
data);
if (data->dialog_title)
gtk_window_set_title (GTK_WINDOW (dialog), data->dialog_title);
@ -398,38 +418,46 @@ zenity_tree (ZenityData *data, ZenityTreeData *tree_data)
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);
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_tree_ok_button"));
button = GTK_WIDGET (
gtk_builder_get_object (builder, "zenity_tree_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_tree_cancel_button"));
button = GTK_WIDGET (
gtk_builder_get_object (builder, "zenity_tree_cancel_button"));
gtk_button_set_label (GTK_BUTTON (button), data->cancel_label);
}
text = gtk_builder_get_object (builder, "zenity_tree_text");
if (tree_data->dialog_text)
gtk_label_set_markup (GTK_LABEL (text), g_strcompress (tree_data->dialog_text));
gtk_label_set_markup (
GTK_LABEL (text), g_strcompress (tree_data->dialog_text));
zenity_util_set_window_icon (dialog, data->window_icon, ZENITY_IMAGE_FULLPATH ("zenity-list.png"));
zenity_util_set_window_icon (
dialog, data->window_icon, ZENITY_IMAGE_FULLPATH ("zenity-list.png"));
if (data->width > -1 || data->height > -1)
gtk_window_set_default_size (GTK_WINDOW (dialog), data->width, data->height);
gtk_window_set_default_size (
GTK_WINDOW (dialog), data->width, data->height);
tree_view = gtk_builder_get_object (builder, "zenity_tree_view");
if (!(tree_data->radiobox || tree_data->checkbox))
g_signal_connect (tree_view, "row-activated",
G_CALLBACK (zenity_tree_row_activated), data);
g_signal_connect (tree_view,
"row-activated",
G_CALLBACK (zenity_tree_row_activated),
data);
/* Create an empty list store */
model = g_object_new (GTK_TYPE_LIST_STORE, NULL);
@ -440,7 +468,8 @@ zenity_tree (ZenityData *data, ZenityTreeData *tree_data)
column_types = g_new (GType, n_columns);
for (i = 0; i < n_columns; i++) {
/* Have the limitation that the radioboxes and checkboxes are in the first column */
/* Have the limitation that the radioboxes and checkboxes are in the
* first column */
if (i == 0 && (tree_data->checkbox || tree_data->radiobox))
column_types[i] = G_TYPE_BOOLEAN;
else
@ -459,14 +488,16 @@ zenity_tree (ZenityData *data, ZenityTreeData *tree_data)
if (!(tree_data->radiobox || tree_data->checkbox)) {
if (tree_data->multi)
gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)),
gtk_tree_selection_set_mode (
gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)),
GTK_SELECTION_MULTIPLE);
else
gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)),
gtk_tree_selection_set_mode (
gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)),
GTK_SELECTION_SINGLE);
}
else
gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)),
} else
gtk_tree_selection_set_mode (
gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)),
GTK_SELECTION_NONE);
column_index = 0;
@ -479,43 +510,53 @@ zenity_tree (ZenityData *data, ZenityTreeData *tree_data)
cell_renderer = gtk_cell_renderer_toggle_new ();
if (tree_data->radiobox) {
g_object_set (G_OBJECT (cell_renderer), "radio", TRUE, NULL);
g_object_set_data (G_OBJECT (model), "radio", GINT_TO_POINTER (1));
g_object_set (
G_OBJECT (cell_renderer), "radio", TRUE, NULL);
g_object_set_data (
G_OBJECT (model), "radio", GINT_TO_POINTER (1));
}
g_signal_connect (cell_renderer, "toggled",
G_CALLBACK (zenity_tree_toggled_callback), model);
g_signal_connect (cell_renderer,
"toggled",
G_CALLBACK (zenity_tree_toggled_callback),
model);
column = gtk_tree_view_column_new_with_attributes (tmp->data,
cell_renderer,
"active", column_index, NULL);
column = gtk_tree_view_column_new_with_attributes (
tmp->data, cell_renderer, "active", column_index, NULL);
} else if (tree_data->imagebox) {
GtkCellRenderer *cell_renderer = gtk_cell_renderer_pixbuf_new ();
column = gtk_tree_view_column_new_with_attributes (tmp->data,
cell_renderer, NULL);
gtk_tree_view_column_set_cell_data_func (column, cell_renderer,
zenity_load_pixbuf, NULL, NULL);
}
else {
GtkCellRenderer *cell_renderer =
gtk_cell_renderer_pixbuf_new ();
column = gtk_tree_view_column_new_with_attributes (
tmp->data, cell_renderer, NULL);
gtk_tree_view_column_set_cell_data_func (
column, cell_renderer, zenity_load_pixbuf, NULL, NULL);
} else {
if (tree_data->editable) {
GtkCellRenderer *cell_renderer;
cell_renderer = gtk_cell_renderer_text_new ();
g_signal_connect (G_OBJECT (cell_renderer), "edited",
g_signal_connect (G_OBJECT (cell_renderer),
"edited",
G_CALLBACK (zenity_cell_edited_callback),
gtk_tree_view_get_model (GTK_TREE_VIEW (tree_view)));
g_object_set_data (G_OBJECT (cell_renderer), "column", GINT_TO_POINTER (column_index));
g_object_set_data (G_OBJECT (cell_renderer),
"column",
GINT_TO_POINTER (column_index));
column = gtk_tree_view_column_new_with_attributes (tmp->data,
column =
gtk_tree_view_column_new_with_attributes (tmp->data,
cell_renderer,
"text", column_index,
"editable", n_columns,
"text",
column_index,
"editable",
n_columns,
NULL);
}
else {
column = gtk_tree_view_column_new_with_attributes (tmp->data,
} else {
column =
gtk_tree_view_column_new_with_attributes (tmp->data,
gtk_cell_renderer_text_new (),
"text", column_index,
"text",
column_index,
NULL);
}
@ -526,27 +567,32 @@ zenity_tree (ZenityData *data, ZenityTreeData *tree_data)
gtk_tree_view_column_set_visible (column, FALSE);
first_column = TRUE;
}
else {
} else {
if (tree_data->editable) {
GtkCellRenderer *cell_renderer;
cell_renderer = gtk_cell_renderer_text_new ();
g_signal_connect (G_OBJECT (cell_renderer), "edited",
g_signal_connect (G_OBJECT (cell_renderer),
"edited",
G_CALLBACK (zenity_cell_edited_callback),
gtk_tree_view_get_model (GTK_TREE_VIEW (tree_view)));
g_object_set_data (G_OBJECT (cell_renderer), "column", GINT_TO_POINTER (column_index));
g_object_set_data (G_OBJECT (cell_renderer),
"column",
GINT_TO_POINTER (column_index));
column = gtk_tree_view_column_new_with_attributes (tmp->data,
cell_renderer,
"text", column_index,
"editable", n_columns,
"text",
column_index,
"editable",
n_columns,
NULL);
}
else {
} else {
column = gtk_tree_view_column_new_with_attributes (tmp->data,
gtk_cell_renderer_text_new (),
"text", column_index, NULL);
"text",
column_index,
NULL);
}
gtk_tree_view_column_set_sort_column_id (column, column_index);
@ -565,24 +611,42 @@ zenity_tree (ZenityData *data, ZenityTreeData *tree_data)
if (tree_data->radiobox || tree_data->checkbox) {
if (tree_data->data && *tree_data->data)
zenity_tree_fill_entries (GTK_TREE_VIEW (tree_view), tree_data->data, n_columns, TRUE, tree_data->editable);
zenity_tree_fill_entries (GTK_TREE_VIEW (tree_view),
tree_data->data,
n_columns,
TRUE,
tree_data->editable);
else
zenity_tree_fill_entries_from_stdin (GTK_TREE_VIEW (tree_view), n_columns, TRUE, tree_data->editable);
}
else {
zenity_tree_fill_entries_from_stdin (GTK_TREE_VIEW (tree_view),
n_columns,
TRUE,
tree_data->editable);
} else {
if (tree_data->data && *tree_data->data)
zenity_tree_fill_entries (GTK_TREE_VIEW (tree_view), tree_data->data, n_columns, FALSE, tree_data->editable);
zenity_tree_fill_entries (GTK_TREE_VIEW (tree_view),
tree_data->data,
n_columns,
FALSE,
tree_data->editable);
else
zenity_tree_fill_entries_from_stdin (GTK_TREE_VIEW (tree_view), n_columns, FALSE, tree_data->editable);
zenity_tree_fill_entries_from_stdin (GTK_TREE_VIEW (tree_view),
n_columns,
FALSE,
tree_data->editable);
}
zenity_util_show_dialog (dialog, data->attach);
if (tree_data->mid_search)
gtk_tree_view_set_search_equal_func(GTK_TREE_VIEW(tree_view), (GtkTreeViewSearchEqualFunc) zenity_mid_search_func, model, NULL);
gtk_tree_view_set_search_equal_func (GTK_TREE_VIEW (tree_view),
(GtkTreeViewSearchEqualFunc) zenity_mid_search_func,
model,
NULL);
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 ();
@ -591,12 +655,15 @@ zenity_tree (ZenityData *data, ZenityTreeData *tree_data)
}
static void
zenity_tree_dialog_get_selected (GtkTreeModel *model, GtkTreePath *path_buf, GtkTreeIter *iter, GtkTreeView *tree_view)
{
GValue value = {0, };
zenity_tree_dialog_get_selected (GtkTreeModel *model, GtkTreePath *path_buf,
GtkTreeIter *iter, GtkTreeView *tree_view) {
GValue value = {
0,
};
gint n_columns, i;
n_columns = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (tree_view), "n_columns"));
n_columns =
GPOINTER_TO_INT (g_object_get_data (G_OBJECT (tree_view), "n_columns"));
if (print_all_columns) {
for (i = 0; i < n_columns; i++) {
@ -617,23 +684,29 @@ zenity_tree_dialog_get_selected (GtkTreeModel *model, GtkTreePath *path_buf, Gtk
}
static gboolean
zenity_tree_dialog_toggle_get_selected (GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, GtkTreeView *tree_view)
{
GValue toggle_value = {0, };
zenity_tree_dialog_toggle_get_selected (GtkTreeModel *model, GtkTreePath *path,
GtkTreeIter *iter, GtkTreeView *tree_view) {
GValue toggle_value = {
0,
};
gint n_columns, i;
n_columns = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (tree_view), "n_columns"));
n_columns =
GPOINTER_TO_INT (g_object_get_data (G_OBJECT (tree_view), "n_columns"));
gtk_tree_model_get_value (model, iter, 0, &toggle_value);
if (g_value_get_boolean (&toggle_value)) {
GValue value = {0, };
GValue value = {
0,
};
if (print_all_columns) {
for (i = 1; i < n_columns; i++) {
gtk_tree_model_get_value (model, iter, i, &value);
selected = g_slist_append (selected, g_value_dup_string (&value));
selected =
g_slist_append (selected, g_value_dup_string (&value));
g_value_unset (&value);
}
g_value_unset (&toggle_value);
@ -641,7 +714,8 @@ zenity_tree_dialog_toggle_get_selected (GtkTreeModel *model, GtkTreePath *path,
}
for (i = 0; print_columns[i] != 0; i++) {
gtk_tree_model_get_value (model, iter, print_columns[i] - 1, &value);
gtk_tree_model_get_value (
model, iter, print_columns[i] - 1, &value);
selected = g_slist_append (selected, g_value_dup_string (&value));
g_value_unset (&value);
@ -654,9 +728,8 @@ zenity_tree_dialog_toggle_get_selected (GtkTreeModel *model, GtkTreePath *path,
}
static void
zenity_tree_dialog_output (void)
{
GObject *tree_view;
zenity_tree_dialog_output (void) {
GObject *tree_view;
GtkTreeSelection *selection;
GtkTreeModel *model;
@ -664,7 +737,8 @@ GObject *tree_view;
model = gtk_tree_view_get_model (GTK_TREE_VIEW (tree_view));
if (gtk_tree_model_get_column_type (model, 0) == G_TYPE_BOOLEAN)
gtk_tree_model_foreach (model, (GtkTreeModelForeachFunc) zenity_tree_dialog_toggle_get_selected,
gtk_tree_model_foreach (model,
(GtkTreeModelForeachFunc) zenity_tree_dialog_toggle_get_selected,
GTK_TREE_VIEW (tree_view));
else {
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view));
@ -678,8 +752,7 @@ GObject *tree_view;
for (tmp = selected; tmp; tmp = tmp->next) {
if (tmp->next != NULL) {
g_print ("%s%s", (gchar *) tmp->data, separator);
}
else
} else
g_print ("%s\n", (gchar *) tmp->data);
}
@ -691,14 +764,13 @@ GObject *tree_view;
}
static void
zenity_tree_dialog_response (GtkWidget *widget, int response, gpointer data)
{
zenity_tree_dialog_response (GtkWidget *widget, int response, gpointer data) {
ZenityData *zen_data = data;
switch (response) {
case GTK_RESPONSE_OK:
zenity_tree_dialog_output ();
zenity_util_exit_code_with_data(ZENITY_OK, zen_data);
zenity_util_exit_code_with_data (ZENITY_OK, zen_data);
break;
case GTK_RESPONSE_CANCEL:
@ -711,12 +783,14 @@ zenity_tree_dialog_response (GtkWidget *widget, int response, gpointer data)
break;
default:
if (zen_data->extra_label && response < g_strv_length(zen_data->extra_label))
printf("%s\n",zen_data->extra_label[response]);
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;
}
if (channel != NULL && g_io_channel_get_flags (channel) & G_IO_FLAG_IS_READABLE)
if (channel != NULL &&
g_io_channel_get_flags (channel) & G_IO_FLAG_IS_READABLE)
g_io_channel_shutdown (channel, TRUE, NULL);
gtk_main_quit ();
@ -724,8 +798,7 @@ zenity_tree_dialog_response (GtkWidget *widget, int response, gpointer data)
static void
zenity_tree_row_activated (GtkTreeView *tree_view, GtkTreePath *tree_path,
GtkTreeViewColumn *tree_col, gpointer data)
{
GtkTreeViewColumn *tree_col, gpointer data) {
ZenityData *zen_data = data;
zenity_tree_dialog_output ();
@ -734,8 +807,7 @@ zenity_tree_row_activated (GtkTreeView *tree_view, GtkTreePath *tree_path,
}
static gboolean
zenity_tree_column_is_hidden (gint column_index)
{
zenity_tree_column_is_hidden (gint column_index) {
gint i;
if (hide_columns != NULL)
@ -747,14 +819,12 @@ zenity_tree_column_is_hidden (gint column_index)
}
static gint *
zenity_tree_extract_column_indexes (char *indexes, int n_columns)
{
zenity_tree_extract_column_indexes (char *indexes, int n_columns) {
char **tmp;
gint *result;
gint i, j, index;
tmp = g_strsplit (indexes,
PRINT_HIDE_COLUMN_SEPARATOR, 0);
tmp = g_strsplit (indexes, PRINT_HIDE_COLUMN_SEPARATOR, 0);
result = g_new (gint, 1);

176
src/util.c
View File

@ -29,15 +29,15 @@
#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>
@ -49,9 +49,8 @@
#define ZENITY_ERROR_DEFAULT -1
#define ZENITY_EXTRA_DEFAULT 127
GtkBuilder*
zenity_util_load_ui_file (const gchar *root_widget, ...)
{
GtkBuilder *
zenity_util_load_ui_file (const gchar *root_widget, ...) {
va_list args;
gchar *arg = NULL;
GPtrArray *ptrarray;
@ -69,34 +68,33 @@ zenity_util_load_ui_file (const gchar *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*);
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);
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);
result = gtk_builder_add_objects_from_file (
builder, ZENITY_UI_FILE_RELATIVEPATH, objects, NULL);
}
if (result == 0)
result = gtk_builder_add_objects_from_file (builder,
ZENITY_UI_FILE_FULLPATH,
objects, &error);
result = gtk_builder_add_objects_from_file (
builder, ZENITY_UI_FILE_FULLPATH, objects, &error);
g_strfreev (objects);
if (result == 0) {
g_warning ("Could not load ui file %s: %s", ZENITY_UI_FILE_FULLPATH,
g_warning ("Could not load ui file %s: %s",
ZENITY_UI_FILE_FULLPATH,
error->message);
g_error_free (error);
g_object_unref (builder);
@ -105,16 +103,14 @@ zenity_util_load_ui_file (const gchar *root_widget, ...)
return builder;
}
gchar*
zenity_util_strip_newline (gchar *string)
{
gchar *
zenity_util_strip_newline (gchar *string) {
gsize len;
g_return_val_if_fail (string != NULL, NULL);
len = strlen (string);
while (len--)
{
while (len--) {
if (string[len] == '\n')
string[len] = '\0';
else
@ -125,8 +121,7 @@ zenity_util_strip_newline (gchar *string)
}
gboolean
zenity_util_fill_file_buffer (GtkTextBuffer *buffer, const gchar *filename)
{
zenity_util_fill_file_buffer (GtkTextBuffer *buffer, const gchar *filename) {
GtkTextIter iter, end;
FILE *f;
gchar buf[2048];
@ -165,7 +160,8 @@ zenity_util_fill_file_buffer (GtkTextBuffer *buffer, const gchar *filename)
}
if (remaining) {
g_warning ("Invalid UTF-8 data encountered reading file '%s'", filename);
g_warning (
"Invalid UTF-8 data encountered reading file '%s'", filename);
return FALSE;
}
@ -182,8 +178,7 @@ zenity_util_fill_file_buffer (GtkTextBuffer *buffer, const gchar *filename)
}
const gchar *
zenity_util_icon_name_from_filename (const gchar *filename)
{
zenity_util_icon_name_from_filename (const gchar *filename) {
if (!filename || !filename[0])
return "dialog-warning"; /* default */
@ -199,8 +194,8 @@ zenity_util_icon_name_from_filename (const gchar *filename)
}
void
zenity_util_set_window_icon_from_file (GtkWidget *widget, const gchar *filename)
{
zenity_util_set_window_icon_from_file (
GtkWidget *widget, const gchar *filename) {
GdkPixbuf *pixbuf;
const gchar *icon_name;
@ -215,8 +210,8 @@ zenity_util_set_window_icon_from_file (GtkWidget *widget, const gchar *filename)
}
void
zenity_util_set_window_icon (GtkWidget *widget, const gchar *filename, const gchar *default_file)
{
zenity_util_set_window_icon (
GtkWidget *widget, const gchar *filename, const gchar *default_file) {
GdkPixbuf *pixbuf;
if (filename != NULL) {
@ -231,8 +226,8 @@ zenity_util_set_window_icon (GtkWidget *widget, const gchar *filename, const gch
}
void
zenity_util_set_window_icon_from_icon_name (GtkWidget *widget, const gchar *filename, const gchar *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
@ -240,8 +235,7 @@ zenity_util_set_window_icon_from_icon_name (GtkWidget *widget, const gchar *file
}
void
zenity_util_show_help (GError **error)
{
zenity_util_show_help (GError **error) {
gchar *tmp;
tmp = g_find_program_in_path ("yelp");
@ -252,8 +246,7 @@ zenity_util_show_help (GError **error)
}
gint
zenity_util_return_exit_code ( ZenityExitCode value )
{
zenity_util_return_exit_code (ZenityExitCode value) {
const gchar *env_var = NULL;
gint retval;
@ -261,50 +254,50 @@ zenity_util_return_exit_code ( ZenityExitCode value )
switch (value) {
case ZENITY_OK:
env_var = g_getenv("ZENITY_OK");
if (! env_var)
env_var = g_getenv("DIALOG_OK");
if (! env_var)
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)
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)
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)
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)
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)
env_var = g_getenv ("ZENITY_TIMEOUT");
if (!env_var)
env_var = g_getenv ("DIALOG_TIMEOUT");
if (!env_var)
retval = ZENITY_TIMEOUT;
break;
@ -318,16 +311,14 @@ zenity_util_return_exit_code ( ZenityExitCode value )
}
void
zenity_util_exit_code_with_data(ZenityExitCode value, ZenityData *zen_data)
{
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)
{
transient_get_xterm (void) {
const char *wid_str = g_getenv ("WINDOWID");
if (wid_str) {
char *wid_str_end;
@ -336,8 +327,9 @@ transient_get_xterm (void)
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();
ret = XGetWindowAttributes (
GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), wid, &attrs);
gdk_flush ();
if (gdk_error_trap_pop () != 0 || ret == 0) {
return None;
}
@ -348,15 +340,13 @@ transient_get_xterm (void)
}
static void
transient_x_free (void *ptr)
{
transient_x_free (void *ptr) {
if (ptr)
XFree (ptr);
}
static gboolean
transient_is_toplevel (Window wid)
{
transient_is_toplevel (Window wid) {
XTextProperty prop;
Display *dpy = GDK_DISPLAY_XDISPLAY (gdk_display_get_default ());
if (!XGetWMName (dpy, wid, &prop))
@ -372,17 +362,13 @@ transient_is_toplevel (Window wid)
*/
static Window
transient_get_xterm_toplevel (void)
{
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))
{
while (xterm != None && !transient_is_toplevel (xterm)) {
Window root, parent, *children;
unsigned nchildren;
XQueryTree (dpy, xterm,
&root, &parent,
&children, &nchildren);
XQueryTree (dpy, xterm, &root, &parent, &children, &nchildren);
transient_x_free (children);
if (parent == root)
xterm = None;
@ -393,41 +379,39 @@ transient_get_xterm_toplevel (void)
}
static void
zenity_util_make_transient (GdkWindow *window, Window parent)
{
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);
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)
{
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);
}
gboolean
zenity_util_timeout_handle (gpointer data)
{
GtkDialog *dialog = GTK_DIALOG(data);
if(dialog != NULL)
gtk_dialog_response(dialog, ZENITY_TIMEOUT);
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);
gtk_main_quit ();
exit (ZENITY_TIMEOUT);
}
return FALSE;
}

31
src/util.h
View File

@ -1,9 +1,8 @@
#ifndef UTIL_H
#define UTIL_H
#include <gtk/gtk.h>
#include "zenity.h"
#include <gtk/gtk.h>
G_BEGIN_DECLS
@ -12,23 +11,21 @@ G_BEGIN_DECLS
#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);
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_exit_code_with_data (ZenityExitCode value, ZenityData *data);
void zenity_util_show_dialog (GtkWidget *widget, guintptr parent);
gboolean zenity_util_timeout_handle (gpointer data);

51
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,9 +18,9 @@ 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 {
@ -163,7 +163,7 @@ typedef struct {
gchar *dialog_text;
gchar *separator;
gchar *date_format;
// gchar *hide_column;
// gchar *hide_column;
gboolean show_header;
} ZenityFormsData;
@ -188,35 +188,26 @@ typedef struct {
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_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 */