Exemple #1
0
// Fuse & encfs must be installed, the user must be in group 'fuse'.
void check_requirements ()
{
	FILE *f = fopen ("/dev/fuse", "rw");
	if (f==NULL) {
		GtkWidget *dialog = 
			gtk_message_dialog_new_with_markup (NULL,
					GTK_DIALOG_MODAL,
					GTK_MESSAGE_ERROR,
					GTK_BUTTONS_OK,
					"<span weight=\"bold\" size=\"larger\">%s</span>\n\n%s",
					_("Cryptkeeper cannot access fuse and so cannot start"),
					_("Check that fuse is installed and that you are a member of the fuse group."));
		gtk_dialog_run (GTK_DIALOG (dialog));
		gtk_widget_destroy (dialog);
		exit (0);
	}
	fclose (f);

	struct stat blah;
	if ((stat ("/usr/bin/encfs", &blah) == -1) &&
	    (stat ("/usr/local/bin/encfs", &blah) == -1)) {
		GtkWidget *dialog = 
			gtk_message_dialog_new_with_markup (NULL,
					GTK_DIALOG_MODAL,
					GTK_MESSAGE_ERROR,
					GTK_BUTTONS_OK,
					"<span weight=\"bold\" size=\"larger\">%s</span>\n\n%s",
					_("Cryptkeeper cannot find EncFS"),
					_("Check that EncFS is installed and try again."));
		gtk_dialog_run (GTK_DIALOG (dialog));
		gtk_widget_destroy (dialog);
		exit (0);
	}
}
Exemple #2
0
void cb_clicked_mail_generate(GtkWidget *button, gpointer data)
{
    gint error = 0;
    gchar *mail_data = NULL;
    gchar *mail_data_message = NULL;
    GtkTextIter start_iter;
    GtkTextIter end_iter;

    UNUSED(button);
    UNUSED(data);

    gtk_text_buffer_get_start_iter(gtk_mail_text_buffer, &start_iter);
    gtk_text_buffer_get_end_iter(gtk_mail_text_buffer, &end_iter);
    mail_data_message = gtk_text_buffer_get_text(gtk_mail_text_buffer, &start_iter, &end_iter, TRUE);

    mail_data = g_strdup_printf("MATMSG:TO:%s;SUB:%s;BODY:%s;;", (gchar *)gtk_entry_get_text(GTK_ENTRY(gtk_mail_entry_to)), (gchar *)gtk_entry_get_text(GTK_ENTRY(gtk_mail_entry_subject)), mail_data_message);

    error = qr_render(mail_data);

    g_free(mail_data_message);
    g_free(mail_data);

    switch(error)
    {
    case ERR_NO_ERROR:
    {
        gtk_set_output();

        break;
    }
    case ERR_INVALID_INPUT:
    {
        GtkWidget *dialog = gtk_message_dialog_new_with_markup(GTK_WINDOW(window), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "<span size=\"x-large\">Error</span>\n\nFailed to generate QR code: Invalid input.\n\nTry to type something into the input.");
        gtk_dialog_run(GTK_DIALOG(dialog));
        gtk_widget_destroy(dialog);
        break;
    }
    case ERR_NO_MEMORY:
    {
        GtkWidget *dialog = gtk_message_dialog_new_with_markup(GTK_WINDOW(window), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "<span size=\"x-large\">Error</span>\n\nFailed to generate QR code: Failed to allocate memory for input.\n\nThis means that your systems tells this program that no more memory is available. Try to close some programs.");
        gtk_dialog_run(GTK_DIALOG(dialog));
        gtk_widget_destroy(dialog);
        break;
    }
    case ERR_RANGE:
    {
        GtkWidget *dialog = gtk_message_dialog_new_with_markup(GTK_WINDOW(window), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "<span size=\"x-large\">Error</span>\n\nFailed to generate QR code: Input data is too large.\n\nQR codes have a maximum size of input data. Try to shorten your input data.");
        gtk_dialog_run(GTK_DIALOG(dialog));
        gtk_widget_destroy(dialog);
        break;
    }
    }
}
static void
activation_error (void)
{
	char const *vendor;
	GtkWidget *dialog;

	vendor =
	    ServerVendor (GDK_DISPLAY_XDISPLAY
			  (gdk_display_get_default ()));

	/* VNC viewers will not work, do not barrage them with warnings */
	if (NULL != vendor && NULL != strstr (vendor, "VNC"))
		return;

	dialog = gtk_message_dialog_new_with_markup (NULL,
						     0,
						     GTK_MESSAGE_ERROR,
						     GTK_BUTTONS_CLOSE,
						     _
						     ("Error activating XKB configuration.\n"
						      "There can be various reasons for that.\n\n"
						      "If you report this situation as a bug, include the results of\n"
						      " • <b>%s</b>\n"
						      " • <b>%s</b>\n"
						      " • <b>%s</b>\n"
						      " • <b>%s</b>"),
						     "xprop -root | grep XKB",
						     "gsettings get org.gnome.libgnomekbd.keyboard model",
						     "gsettings get org.gnome.libgnomekbd.keyboard layouts",
						     "gsettings get org.gnome.libgnomekbd.keyboard options");
	g_signal_connect (dialog, "response",
			  G_CALLBACK (gtk_widget_destroy), NULL);
	csd_delayed_show_dialog (dialog);
}
void geanypg_check_sig(encrypt_data * ed, gpgme_signature_t sig)
{
    GtkWidget * dialog;
    gpgme_sigsum_t summary;
    char buffer[512];
    strncpy(buffer, sig->fpr, 40);
    buffer[40] = 0;
    geanypg_get_keys_with_fp(ed, buffer);
    summary = sig->summary;
    char * result = geanypg_result(sig);

    dialog = gtk_message_dialog_new_with_markup(GTK_WINDOW(geany->main_widgets->window),
                                                GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
                                                GTK_MESSAGE_INFO,
                                                GTK_BUTTONS_OK,
                                                "%s %s\n<tt>%s</tt>",
                                                _("Found a signature from"),
                                                buffer,
                                                result);
    gtk_window_set_title(GTK_WINDOW(dialog), _("Signature"));

    gtk_dialog_run(GTK_DIALOG(dialog));
    free(result);
    gtk_widget_destroy(dialog);
}
Exemple #5
0
static void
show_dialog (
    TpSimpleApprover *self,
    TpChannelDispatchOperation *cdo,
    TpContact *target)
{
    GFile *avatar_file = tp_contact_get_avatar_file (target);
    GtkWidget *dialog = gtk_message_dialog_new_with_markup (NULL,
        0, /* flags */
        GTK_MESSAGE_QUESTION,
        GTK_BUTTONS_NONE,
        "<b>%s</b> (<i>%s</i>) would like to edit a spreadsheet in LibreOffice "
        "with you.",
        tp_contact_get_alias (target),
        tp_contact_get_identifier (target));

    if (avatar_file != NULL)
    {
        GtkWidget *avatar = gtk_image_new_from_file (g_file_get_path (avatar_file));

        gtk_message_dialog_set_image (GTK_MESSAGE_DIALOG (dialog), avatar);
    }

    gtk_dialog_add_buttons (GTK_DIALOG (dialog),
        "_Reject", GTK_RESPONSE_REJECT,
        "_Accept", GTK_RESPONSE_ACCEPT,
        NULL);

    g_object_set_data_full (G_OBJECT (dialog), "client", g_object_ref (self), g_object_unref);
    g_signal_connect (dialog, "response", G_CALLBACK (dialog_response_cb), g_object_ref (cdo));

    gtk_window_set_skip_taskbar_hint (GTK_WINDOW (dialog), FALSE);

    gtk_widget_show_all (dialog);
}
Exemple #6
0
/**
 * fm_askv
 * @parent: toplevel parent widget
 * @title: title for the window with question
 * @question: the question to show to the user
 * @options: a NULL terminated list of button labels
 *
 * Ask the user a question with several options provided.
 *
 * Before 0.1.16 this call had different arguments.
 *
 * Return value: the index of selected button, or -1 if the dialog is closed.
 *
 * Since: 0.1.0
 */
int fm_askv(GtkWindow* parent, const char* title, const char* question, char* const* options)
{
    int ret;
    guint id = 1;
    GtkDialog* dlg = GTK_DIALOG(gtk_message_dialog_new_with_markup(parent, 0,
                                                        GTK_MESSAGE_QUESTION, 0,
                                                        "%s", question));
    gtk_window_set_title(GTK_WINDOW(dlg), title ? title : _("Question"));
    /* FIXME: need to handle defualt button and alternative button
     * order problems. */
    while(*options)
    {
        /* FIXME: handle button image and stock buttons */
        /*GtkWidget* btn =*/
        gtk_dialog_add_button(dlg, *options, id);
        ++options;
        ++id;
    }
    ret = gtk_dialog_run(dlg);
    if(ret >= 1)
        ret -= 1;
    else
        ret = -1;
    gtk_widget_destroy((GtkWidget*)dlg);
    return ret;
}
static void 
action_message_cb (GtkAction *action,
		   GtkWindow *window)
{
  GtkMessageDialog *dialog = NULL;
  //gboolean ret_val = FALSE;
  gchar *message = NULL;

  message = g_strdup_printf (_("The function is not implemente yet. Help?"));
  
  dialog = (GtkMessageDialog *) gtk_message_dialog_new_with_markup 
    (
     (GtkWindow *) gtk_widget_get_toplevel ( GTK_WIDGET(window)), 
     GTK_DIALOG_MODAL,
     GTK_MESSAGE_QUESTION, 
     GTK_BUTTONS_OK_CANCEL, "<b>%s</b>", 
     message);
  
  g_free (message);

  //ret_val = (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK);
  gtk_dialog_run (GTK_DIALOG (dialog));

  gtk_widget_destroy ((GtkWidget *) dialog);
}
Exemple #8
0
static void
handle_error (GtkPrintOperation *operation)
{
	GtkWidget *dialog;
	GError *error = NULL;

	dialog = gtk_message_dialog_new_with_markup (
		NULL, 0, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
		"<span weight=\"bold\" size=\"larger\">%s</span>",
		_("An error occurred while printing"));

	gtk_print_operation_get_error (operation, &error);

	if (error != NULL && error->message != NULL)
		gtk_message_dialog_format_secondary_text (
			GTK_MESSAGE_DIALOG (dialog), "%s\n\n%s",
			_("The printing system reported the "
			"following details about the error:"),
			error->message);
	else
		gtk_message_dialog_format_secondary_text (
			GTK_MESSAGE_DIALOG (dialog), "%s",
			_("The printing system did not report "
			"any additional details about the error."));

	if (error != NULL)
		g_error_free (error);

	gtk_dialog_run (GTK_DIALOG (dialog));

	gtk_widget_destroy (dialog);
}
Exemple #9
0
GtkBuilder*
create_builder_or_die(const gchar * name)
{
	guint res = 0;
	GValue *gval;
	GError *error = NULL;
	const gchar *ghb_ui;

    const gchar *markup =
        N_("<b><big>Unable to create %s.</big></b>\n"
        "\n"
        "Internal error. Could not parse UI description.\n"
		"%s");
	g_debug("create_builder_or_die ()\n");
	GtkBuilder *xml = gtk_builder_new();
	gval = ghb_resource_get("ghb-ui");
	ghb_ui = g_value_get_string(gval);
	if (xml != NULL)
		res = gtk_builder_add_from_string(xml, ghb_ui, -1, &error);
    if (!xml || !res) 
	{
        GtkWidget *dialog = gtk_message_dialog_new_with_markup(NULL,
            GTK_DIALOG_MODAL,
            GTK_MESSAGE_ERROR,
            GTK_BUTTONS_CLOSE,
            _(markup),
            name, error->message);
        gtk_dialog_run(GTK_DIALOG(dialog));
        gtk_widget_destroy(dialog);
        exit(EXIT_FAILURE);
    }
    return xml;
}
Exemple #10
0
static void
log_handler(const gchar * log_domain,
	    GLogLevelFlags log_level,
	    const gchar * message, gpointer user_data)
{
    if (!params.gui_running) {
	/* No GUI running: spit the message to the terminal */
	g_print("\n\n*** %s: %s\n\n",
		(log_level & G_LOG_FLAG_FATAL) ? _("Error") : _("Warning"),
		message);
    } else {
	/* Hooray! We have a GUI running! */
	GtkWidget *dialog;

	dialog = gtk_message_dialog_new_with_markup(NULL, GTK_DIALOG_MODAL,
						    (log_level &
						     G_LOG_FLAG_FATAL) ?
						    GTK_MESSAGE_ERROR :
						    GTK_MESSAGE_WARNING,
						    GTK_BUTTONS_CLOSE,
						    "<big><b>%s</b></big>\n\n%s",
						    (log_level &
						     G_LOG_FLAG_FATAL) ?
						    _("Fatal Error") :
						    _("Warning"), message);

	gtk_dialog_run(GTK_DIALOG(dialog));
	gtk_widget_destroy(dialog);
    }
}
Exemple #11
0
static int
ui_gtk_print_import_result(char *buf)
{
	GtkDialog *diag = 0;
	char *str = 0, *tmp = 0;
	
	gdk_threads_enter();
	ASSERT_TRUE(tmp = ship_pangoify(buf), err);
	ASSERT_TRUE(str = mallocz(strlen(tmp) + 64), err);
	sprintf(str, "<big>Import complete!</big>\n\n%s", tmp);
	ASSERT_TRUE(diag = (GtkDialog*)gtk_message_dialog_new_with_markup(NULL,
									  GTK_DIALOG_MODAL,
									  GTK_MESSAGE_INFO,
									  GTK_BUTTONS_OK,
									  str,
									  NULL), err);
	gtk_dialog_run(diag);
	gtk_widget_destroy((GtkWidget*)diag);
 err:
	gdk_threads_leave();

	freez(str);
	freez(tmp);
	return 0;
}
Exemple #12
0
gboolean
rookie_misc_run_confirm_dialog (const gchar * title,
								const gchar * message,
								const gchar * ok_button,
								GtkWindow * modal)
{
	GtkWidget * dialog = gtk_message_dialog_new_with_markup (
								modal,
								GTK_DIALOG_MODAL,
								GTK_MESSAGE_QUESTION,
								GTK_BUTTONS_NONE,
								"<b>%s</b>\n\n%s",
								title,
								message);

	gtk_dialog_add_buttons (GTK_DIALOG(dialog),
							GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
							ok_button, GTK_RESPONSE_OK, NULL);
	gtk_window_set_geometry_hints (GTK_WINDOW (dialog),
								   dialog, NULL,
								   GDK_HINT_USER_SIZE | GDK_HINT_USER_POS);

	gtk_widget_set_size_request (dialog, 400, 40);
	int response = gtk_dialog_run (GTK_DIALOG(dialog));
	gtk_widget_destroy (dialog);

	return response == GTK_RESPONSE_OK;
}
Exemple #13
0
void
oregano_error_with_title (gchar *title, gchar *desc)
{
	GtkWidget *dialog;
	gint result;

	GString* span_msg;

	span_msg = g_string_new("<span weight=\"bold\" size=\"large\">");
	span_msg = g_string_append(span_msg, title);
	span_msg = g_string_append(span_msg,"</span>");

	if (desc && desc[0] != '\0') {
		span_msg = g_string_append(span_msg,"\n\n");
		span_msg = g_string_append(span_msg, desc);
	}

	dialog = gtk_message_dialog_new_with_markup (
		NULL,
		GTK_DIALOG_MODAL,
		GTK_MESSAGE_ERROR,
		GTK_BUTTONS_OK,
		span_msg->str);

	gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);

	result = gtk_dialog_run (GTK_DIALOG (dialog));

	g_string_free(span_msg, TRUE);
	gtk_widget_destroy (dialog);
}
Exemple #14
0
gint
oregano_question (gchar *msg)
{
	GtkWidget *dialog;
	gint ans;

	dialog = gtk_message_dialog_new_with_markup (
		NULL,
		GTK_MESSAGE_QUESTION,
		GTK_BUTTONS_OK,
		GTK_BUTTONS_CANCEL,
		msg);

	gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_CANCEL);

	ans = gtk_dialog_run (GTK_DIALOG (dialog));

	switch (ans) {
		case GTK_RESPONSE_ACCEPT:
			return TRUE;
		default:
			return FALSE;
	}

	gtk_widget_destroy (dialog);
}
Exemple #15
0
void
authorg_util_message (GtkWidget *parent, const gchar *message, const gchar *secondary)
{
	GtkWidget *dialog;
	gchar *tmp;

	if (secondary == NULL)
	{
		dialog = gtk_message_dialog_new_with_markup (GTK_WINDOW (parent),
				GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
				GTK_MESSAGE_INFO,
				GTK_BUTTONS_OK,
                "%s",
				tmp = g_strdup_printf ("<b>%s</b>", message));
		g_free (tmp);
	}
	else
	{
		dialog = gtk_message_dialog_new (GTK_WINDOW (parent),
				GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
				GTK_MESSAGE_INFO,
				GTK_BUTTONS_OK,
				"%s", message);

		gtk_message_dialog_format_secondary_text (
				GTK_MESSAGE_DIALOG (dialog),
				"%s", secondary);
	}

	gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
	gtk_dialog_run (GTK_DIALOG (dialog));

	gtk_widget_destroy (dialog);
}
Exemple #16
0
// NOTE: this is used from 'mscorlib.dll' System.IO.IsolatedStorage/MoonIsolatedStorageFile.cs
// NOTE: we let the caller supply the string so i18n can occur in managed land only
gboolean
isolated_storage_increase_quota_to (const char *primary_text, const char* secondary_text)
{
#if PAL_GTK_WINDOWING
	// the dialog is displayed only if the action leading to this call was initiated directly from the user
	if (!Deployment::GetCurrent ()->GetSurface ()->IsUserInitiatedEvent ())
		return false;

	Surface *surface = Deployment::GetCurrent ()->GetSurface ();

	GtkWidget *widget = gtk_message_dialog_new_with_markup (NULL,
						GTK_DIALOG_MODAL,
						GTK_MESSAGE_QUESTION,
						GTK_BUTTONS_YES_NO,
						primary_text);

	gtk_window_set_title (GTK_WINDOW (widget), PACKAGE_STRING);
	gtk_message_dialog_format_secondary_markup (GTK_MESSAGE_DIALOG (widget), secondary_text);

	gboolean result = (gtk_dialog_run (GTK_DIALOG (widget)) == GTK_RESPONSE_YES);
	surface->SetCurrentDeployment ();
	gtk_widget_destroy (widget);
	return result;
#else
	return TRUE;
#endif
}
Exemple #17
0
static void
engine_aborted_cb (OreganoEngine *engine, Simulation *s)
{
	GtkWidget *dialog;
	int answer;

	if (s->progress_timeout_id != 0) {
		g_source_remove (s->progress_timeout_id);
		s->progress_timeout_id = 0;
	}

	gtk_widget_destroy (GTK_WIDGET (s->dialog));
	s->dialog = NULL;

	if (!schematic_view_log_window_exists (s->sv)) {
		dialog = gtk_message_dialog_new_with_markup (
			GTK_WINDOW (s->sv->toplevel),
			GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
			GTK_MESSAGE_ERROR,
			GTK_BUTTONS_YES_NO,
			_("<span weight=\"bold\" size=\"large\">The simulation was aborted due to an error.</span>\n\n"
				"Would you like to view the error log?"));

		answer = gtk_dialog_run (GTK_DIALOG (dialog));
		gtk_widget_destroy (dialog);

		if (answer == GTK_RESPONSE_YES) {
			schematic_view_log_show (s->sv, TRUE);
		}
	} else {
		oregano_error (_("The simulation was aborted due to an error"));

		schematic_view_log_show (s->sv, FALSE);
	}
}
Exemple #18
0
G_MODULE_EXPORT
void
on_version_realize                     (GtkWidget       *widget,
gpointer         user_data)
{
  const char *latest = checkupdates();

  gtk_label_set_text(GTK_LABEL(widget), getpackageversion());

  if(latest)
  {
    if(strcmp(latest, getpackageversion()) != 0)
    {
      static GtkWidget *dialog = NULL;

      if(!GTK_IS_WIDGET(dialog))
      {
        dialog = gtk_message_dialog_new_with_markup (GTK_WINDOW(mainwindow),
                                  GTK_DIALOG_DESTROY_WITH_PARENT,
                                  GTK_MESSAGE_INFO,
                                  GTK_BUTTONS_CLOSE,
                                  "The latest version is <tt>%s</tt>.\n\nYou can visit <span foreground=\"blue\"><u>http://www.ezix.org/</u></span> for more information.",
                                  latest);

        gtk_window_set_title(GTK_WINDOW(dialog), "Update available");
        /* Destroy the dialog when the user responds to it (e.g. clicks a button) */
        g_signal_connect_swapped (dialog, "response",
                           G_CALLBACK (gtk_widget_destroy),
                           dialog);
      }

      gtk_widget_show(dialog);
    }
  }
}
static gint
play_back_confirm_deletion (void)
{
        GtkWidget *dialog;
        gint response;

        dialog = gtk_message_dialog_new_with_markup (
                GTK_WINDOW (GVA_WIDGET_PLAY_BACK_WINDOW),
                GTK_DIALOG_DESTROY_WITH_PARENT,
                GTK_MESSAGE_WARNING, GTK_BUTTONS_NONE,
                "<big><b>%s</b></big>",
                _("Delete selected game recordings?"));

        gtk_message_dialog_format_secondary_text (
                GTK_MESSAGE_DIALOG (dialog), "%s",
                _("This operation will permanently erase the recorded games "
                  "you have selected.  Are you sure you want to proceed?"));

        gtk_dialog_add_button (
                GTK_DIALOG (dialog), _("Do Not Delete"), GTK_RESPONSE_REJECT);

        gtk_dialog_add_button (
                GTK_DIALOG (dialog), GTK_STOCK_DELETE, GTK_RESPONSE_ACCEPT);

        response = gtk_dialog_run (GTK_DIALOG (dialog));

        gtk_widget_destroy (dialog);

        return response;
}
Exemple #20
0
static int
ui_gtk_popup(char *buf)
{
#ifdef CONFIG_MAEMOUI_ENABLED
	GtkWidget *w = NULL;
	
	gdk_threads_enter();
	w = hildon_banner_show_information(NULL /* GTK_WIDGET(window) */, NULL, buf);
	gtk_widget_show_all(w);
	gdk_flush();
	gdk_threads_leave();

 	USER_PRINT("We should print: %s\n", buf);
#else

#ifndef HAVE_LIBNOTIFY
	GtkDialog *diag = 0;
	char *str = 0, *tmp = 0;
	
	gdk_threads_enter();
	ASSERT_TRUE(tmp = ship_pangoify(buf), err);
	ASSERT_TRUE(str = mallocz(strlen(tmp) + 64), err);
	sprintf(str, "<big>%s</big>", tmp);
	ASSERT_TRUE(diag = (GtkDialog*)gtk_message_dialog_new_with_markup(NULL,
									  /* GTK_DIALOG_MODAL */0,
									  GTK_MESSAGE_INFO,
									  GTK_BUTTONS_OK,
									  str), err);
	gtk_dialog_run(diag);
	gtk_widget_destroy((GtkWidget*)diag);
 err:
	gdk_threads_leave();
	freez(str);
	freez(tmp);
#else
	/* new, libnotify-based notifications */
	// thanks zenity; http://svn.gnome.org/viewvc/zenity/trunk/src/notification.c?view=markup

	NotifyNotification *notif;

	gdk_threads_enter();

	/* this has changed with version 0.7xx */
#ifdef HAVE_LIBNOTIFY_NEW
	notif = notify_notification_new("p2pship", buf,
					GTK_STOCK_DIALOG_WARNING);
#else
	notif = notify_notification_new("p2pship", buf,
					GTK_STOCK_DIALOG_WARNING,
					//GTK_STOCK_DIALOG_INFO, 
					NULL);
#endif
	notify_notification_show(notif, NULL);
	g_object_unref(notif);
	gdk_threads_leave();
#endif

#endif
	return 0;
}
Exemple #21
0
static void boot_jumper_prompt()
{
	GtkWidget *dialog = NULL;
		dialog = gtk_message_dialog_new_with_markup(GTK_WINDOW(DATA_GET(global_data,"main_window")),GTK_DIALOG_MODAL,GTK_MESSAGE_WARNING,GTK_BUTTONS_OK,"\nPlease jumper the boot jumper on\nthe ECU and power cycle it\nand click OK when done");
	gtk_dialog_run(GTK_DIALOG(dialog));
	gtk_widget_destroy(dialog);
}
Exemple #22
0
static void
show_error (const gchar *format, ...)
{
  va_list var_args;
  gchar *s;

  va_start (var_args, format);

  s = g_strdup_vprintf (format, var_args);

  if (have_gtk)
    {
      GtkWidget *dialog;
      dialog = gtk_message_dialog_new_with_markup (NULL,
                                                   GTK_DIALOG_MODAL,
                                                   GTK_MESSAGE_ERROR,
                                                   GTK_BUTTONS_CLOSE,
                                                   "<big><b>%s</b></big>",
                                                   _("An error occurred"));
      gtk_message_dialog_format_secondary_markup (GTK_MESSAGE_DIALOG (dialog), "%s", s);
      gtk_window_set_title (GTK_WINDOW (dialog), _("Disk Image Mounter"));
      gtk_dialog_run (GTK_DIALOG (dialog));
      gtk_widget_destroy (dialog);
    }
  else
    {
      g_printerr ("%s\n", s);
    }

  g_free (s);
  va_end (var_args);
}
Exemple #23
0
void
gtkhtml_editor_show_uri (GtkWindow *parent,
                         const gchar *uri)
{
	GtkWidget *dialog;
	GdkScreen *screen = NULL;
	GError *error = NULL;
	guint32 timestamp;

	g_return_if_fail (uri != NULL);

	timestamp = gtk_get_current_event_time ();

	if (parent != NULL)
		screen = gtk_widget_get_screen (GTK_WIDGET (parent));

	if (gtk_show_uri (screen, uri, timestamp, &error))
		return;

	dialog = gtk_message_dialog_new_with_markup (
		parent, GTK_DIALOG_DESTROY_WITH_PARENT,
		GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
		"<big><b>%s</b></big>",
		_("Could not open the link."));

	gtk_message_dialog_format_secondary_text (
		GTK_MESSAGE_DIALOG (dialog), "%s", error->message);

	gtk_dialog_run (GTK_DIALOG (dialog));

	gtk_widget_destroy (dialog);
	g_error_free (error);
}
Exemple #24
0
int
load_theme (EyesApplet *eyes_applet, const gchar *theme_dir)
{
	GtkWidget *dialog;

	FILE* theme_file;
        gchar *file_name;

        eyes_applet->theme_dir = g_strdup_printf ("%s/", theme_dir);

        file_name = g_strdup_printf("%s%s",theme_dir,"/config");
        theme_file = fopen (file_name, "r");
        if (theme_file == NULL) {
        	g_free (eyes_applet->theme_dir);
        	eyes_applet->theme_dir = g_strdup_printf (GEYES_THEMES_DIR "Default-tiny/");
        	g_free (file_name);
                file_name = g_strdup (GEYES_THEMES_DIR "Default-tiny/config");
                theme_file = fopen (file_name, "r");
        }

	/* if it's still NULL we've got a major problem */
	if (theme_file == NULL) {
		dialog = gtk_message_dialog_new_with_markup (NULL,
				GTK_DIALOG_DESTROY_WITH_PARENT,
				GTK_MESSAGE_ERROR,
				GTK_BUTTONS_OK,
				"<b>%s</b>\n\n%s",
				_("Can not launch the eyes applet."),
				_("There was a fatal error while trying to load the theme."));

		gtk_dialog_run (GTK_DIALOG (dialog));
		gtk_widget_destroy (dialog);

		gtk_widget_destroy (GTK_WIDGET (eyes_applet->applet));

		return FALSE;
	}

        parse_theme_file (eyes_applet, theme_file);
        fclose (theme_file);

        eyes_applet->theme_name = g_strdup (theme_dir);
       
        if (eyes_applet->eye_image)
        	g_object_unref (eyes_applet->eye_image);
        eyes_applet->eye_image = gdk_pixbuf_new_from_file (eyes_applet->eye_filename, NULL);
        if (eyes_applet->pupil_image)
        	g_object_unref (eyes_applet->pupil_image);
        eyes_applet->pupil_image = gdk_pixbuf_new_from_file (eyes_applet->pupil_filename, NULL);

	eyes_applet->eye_height = gdk_pixbuf_get_height (eyes_applet->eye_image);
        eyes_applet->eye_width = gdk_pixbuf_get_width (eyes_applet->eye_image);
        eyes_applet->pupil_height = gdk_pixbuf_get_height (eyes_applet->pupil_image);
        eyes_applet->pupil_width = gdk_pixbuf_get_width (eyes_applet->pupil_image);
        
        g_free (file_name);
   
	return TRUE;
}
bool PasswordChangeDialog::Apply ()
{
	const char *old_pass = gtk_entry_get_text (GTK_ENTRY (m_oldPass));
	const char *new_pass1 = gtk_entry_get_text (GTK_ENTRY (m_newPass1));
	const char *new_pass2 = gtk_entry_get_text (GTK_ENTRY (m_newPass2));

	if (strcmp (new_pass1, new_pass2) != 0) {
		GtkWidget *dialog = 
			gtk_message_dialog_new_with_markup (GTK_WINDOW (m_window),
					GTK_DIALOG_MODAL,
					GTK_MESSAGE_ERROR,
					GTK_BUTTONS_OK,
					"<span weight=\"bold\" size=\"larger\">%s</span>",
					_("The new passwords do not match"));
		gtk_dialog_run (GTK_DIALOG (dialog));
		gtk_widget_destroy (dialog);
		return false;
	}

	char *output;
	int status = encfs_stash_change_password (m_cryptDir, old_pass, new_pass1, &output);
	if (status) {
		GtkWidget *dialog = gtk_message_dialog_new_with_markup (NULL,
				GTK_DIALOG_MODAL,
				GTK_MESSAGE_ERROR,
				GTK_BUTTONS_CANCEL,
				"<span weight=\"bold\" size=\"larger\">%s</span>\n%s",
				_("Error setting password:"******"<span weight=\"bold\" size=\"larger\">%s</span>",
				_("Password changed"));
		gtk_dialog_run (GTK_DIALOG (dialog));
		gtk_widget_destroy (dialog);
		free (output);
		return true;
	}
}
Exemple #26
0
void ptk_show_error(GtkWindow* parent, const char* title, const char* message )
{
  GtkWidget* dlg = gtk_message_dialog_new_with_markup(parent, GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, message, NULL);
  if( title )
    gtk_window_set_title( (GtkWindow*)dlg, title );
  gtk_dialog_run( GTK_DIALOG(dlg) );
  gtk_widget_destroy( dlg );
}
Exemple #27
0
static void explorer_init(Explorer *self) {

    if (g_file_test (FYRE_DATADIR "/explorer.glade", G_FILE_TEST_EXISTS))
        self->xml = glade_xml_new (FYRE_DATADIR "/explorer.glade", NULL, NULL);
    if (!self->xml)
	self->xml = glade_xml_new(BR_DATADIR("/fyre/explorer.glade"), NULL, NULL);
    if (!self->xml) {
	GtkWidget *dialog;
	dialog = gtk_message_dialog_new_with_markup(NULL, 0, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
						    "<b>Fyre can't find its data files.</b>\n\n"
						    "The main glade file could not be located.\n"
						    "We tried looking for it in the following places:\n"
						    "\n"
						    "    %s\n"
						    "    %s",
						    FYRE_DATADIR "/explorer.glade",
						    BR_DATADIR("/fyre/explorer.glade"));
	gtk_dialog_run(GTK_DIALOG(dialog));
	exit(0);
    }

    self->window = glade_xml_get_widget(self->xml, "explorer_window");
    fyre_set_icon_later(self->window);
    fyre_set_icon_later(glade_xml_get_widget(self->xml, "animation_window"));
    fyre_set_icon_later(glade_xml_get_widget(self->xml, "interactive_prefs"));
    fyre_set_icon_later(glade_xml_get_widget(self->xml, "cluster_window"));
    fyre_set_icon_later(glade_xml_get_widget(self->xml, "about_window"));
    fyre_set_icon_later(glade_xml_get_widget(self->xml, "error dialog"));

    /* Connect signal handlers */
    glade_xml_signal_connect_data(self->xml, "on_randomize",                    G_CALLBACK(on_randomize),                    self);
    glade_xml_signal_connect_data(self->xml, "on_load_defaults",                G_CALLBACK(on_load_defaults),                self);
    glade_xml_signal_connect_data(self->xml, "on_save",                         G_CALLBACK(on_save),                         self);
    glade_xml_signal_connect_data(self->xml, "on_save_exr",                     G_CALLBACK(on_save_exr),                     self);
    glade_xml_signal_connect_data(self->xml, "on_quit",                         G_CALLBACK(on_quit),                         self);
    glade_xml_signal_connect_data(self->xml, "on_pause_rendering_toggle",       G_CALLBACK(on_pause_rendering_toggle),       self);
    glade_xml_signal_connect_data(self->xml, "on_load_from_image",              G_CALLBACK(on_load_from_image),              self);
    glade_xml_signal_connect_data(self->xml, "on_widget_toggle",                G_CALLBACK(on_widget_toggle),                self);
    glade_xml_signal_connect_data(self->xml, "on_zoom_reset",                   G_CALLBACK(on_zoom_reset),                   self);
    glade_xml_signal_connect_data(self->xml, "on_zoom_in",                      G_CALLBACK(on_zoom_in),                      self);
    glade_xml_signal_connect_data(self->xml, "on_zoom_out",                     G_CALLBACK(on_zoom_out),                     self);
    glade_xml_signal_connect_data(self->xml, "on_render_time_changed",          G_CALLBACK(on_render_time_changed),          self);
    glade_xml_signal_connect_data(self->xml, "on_interactive_prefs_delete",     G_CALLBACK(on_interactive_prefs_delete),     self);

#ifndef HAVE_EXR
    /* If we don't have OpenEXR support, gray out the menu item
     * so it sits there taunting the user and not breaking HIG
     */
    gtk_widget_set_sensitive(glade_xml_get_widget(self->xml, "save_image_as_exr"), FALSE);
#endif

    /* Set up the statusbar */
    self->statusbar = GTK_STATUSBAR(glade_xml_get_widget(self->xml, "statusbar"));
    self->render_status_context = gtk_statusbar_get_context_id(self->statusbar, "Rendering status");
    self->speed_timer = g_timer_new();
    self->auto_update_rate_timer = g_timer_new();
    self->status_update_rate_timer = g_timer_new();
}
Exemple #28
0
static void
info_dialog_show_error (const char *err)
{
	GtkWidget *dialog;

	dialog = gtk_message_dialog_new_with_markup (NULL, 0, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
			"<span weight=\"bold\" size=\"larger\">%s</span>\n\n%s", _("Error displaying connection information:"), err);
	gtk_window_present (GTK_WINDOW (dialog));
	g_signal_connect_swapped (dialog, "response", G_CALLBACK (gtk_widget_destroy), dialog);
}
Exemple #29
0
gboolean on_click_delete_stash (GtkMenuItem *mi, gpointer data)
{
	int idx = GPOINTER_TO_INT (data);

	GtkWidget *dialog = gtk_message_dialog_new_with_markup (NULL,
			GTK_DIALOG_MODAL,
			GTK_MESSAGE_QUESTION,
			GTK_BUTTONS_OK_CANCEL,
			"<span weight=\"bold\" size=\"larger\">%s\n\n%s</span>",
			_("Are you sure you want to remove the encrypted folder:"),
			cryptPoints[idx].GetMountDir ());
	int result = gtk_dialog_run (GTK_DIALOG (dialog));
	gtk_widget_destroy (dialog);
	if (result != GTK_RESPONSE_OK) return FALSE;
	
	if (!unmount_cryptpoint (idx)) {
		// f**k. can't unmount
		moan_cant_unmount (cryptPoints[idx].GetMountDir());
	} else {
		GtkWidget *dialog = gtk_message_dialog_new_with_markup (NULL,
				GTK_DIALOG_MODAL,
				GTK_MESSAGE_WARNING,
				GTK_BUTTONS_YES_NO,
				"<span weight=\"bold\" size=\"larger\">%s\n\n%s</span>",
				_("Do you want to permanently erase the encrypted data:"),
				cryptPoints[idx].GetCryptDir ());
		int result = gtk_dialog_run (GTK_DIALOG (dialog));
		gtk_widget_destroy (dialog);

		if (result != GTK_RESPONSE_YES) {
			cryptPoints.erase (cryptPoints.begin () + idx);
		} else {
			// recursive delete is tedious to implement ;)
			char buf[1024];
			snprintf (buf, sizeof (buf), "rm -rf \"%s\"", cryptPoints[idx].GetCryptDir ());
			system (buf);
			cryptPoints.erase (cryptPoints.begin () + idx);
		}
		write_config ();
	}
	
	return FALSE;
}
Exemple #30
0
static int
ui_gtk_query_import_contacts(ship_list_t *list)
{
	GtkDialog *diag = 0;
	int ret = 0;
	char *str = 0, *tmp = 0;
	int len = 0, size = 0, i;
	char *tmp2 = 0;

	gdk_threads_enter();
	ASSERT_TRUE(str = append_str("<big>Add Contacts?</big>\n\nDo you want to add the following people to your addressbook?\n", str, &size, &len), err);
	
	for (i=0; i < 4 && i < ship_list_length(list); i++) {
		contact_t *c = ship_list_get(list, i);
		
		ASSERT_TRUE((tmp = append_str("   ", str, &size, &len)) && (str = tmp), err);
		ASSERT_TRUE(tmp2 = ship_pangoify(c->name), err);
		ASSERT_TRUE((tmp = append_str(tmp2, str, &size, &len)) && (str = tmp), err);
		freez(tmp2);
		
		ASSERT_TRUE((tmp = append_str(" <i>(", str, &size, &len)) && (str = tmp), err);

		ASSERT_TRUE(tmp2 = ship_pangoify(c->sip_aor), err);
		ASSERT_TRUE((tmp = append_str(tmp2, str, &size, &len)) && (str = tmp), err);
		freez(tmp2);

		ASSERT_TRUE((tmp = append_str(")</i>\n", str, &size, &len)) && (str = tmp), err);
	}
	
	if (i < ship_list_length(list)) {
		ASSERT_TRUE(tmp2 = mallocz(64), err);
		sprintf(tmp2, ".. and <b>%d</b> others\n", ship_list_length(list) - i);
		ASSERT_TRUE((tmp = append_str(tmp2, str, &size, &len)) && (str = tmp), err);
		freez(tmp2);
	}

	ASSERT_TRUE(diag = (GtkDialog*)gtk_message_dialog_new_with_markup(NULL,
									  GTK_DIALOG_MODAL,
									  GTK_MESSAGE_QUESTION,
									  GTK_BUTTONS_YES_NO,
									  str,
									  NULL), err);

	ret = gtk_dialog_run(diag);
	gtk_widget_destroy((GtkWidget*)diag);
	if (ret == -8)
		ret = 1;
	else
		ret = 0;
 err:
	gdk_threads_leave();
	freez(str);
	freez(tmp2);
	return ret;
}