PIKApp/app/widgets/pikacriticaldialog.c

638 lines
22 KiB
C

/* PIKA - Photo and Image Kooker Application
* a rebranding of The GNU Image Manipulation Program (created with heckimp)
* A derived work which may be trivial. However, any changes may be (C)2023 by Aldercone Studio
*
* Original copyright, applying to most contents (license remains unchanged):
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* pikacriticaldialog.c
* Copyright (C) 2018 Jehan <jehan@gimp.org>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
/*
* This widget is particular that I want to be able to use it
* internally but also from an alternate tool (pika-debug-tool). It
* means that the implementation must stay as generic glib/GTK+ as
* possible.
*/
#include "config.h"
#include <string.h>
#include <gtk/gtk.h>
#include <gegl.h>
#ifdef PLATFORM_OSX
#import <Cocoa/Cocoa.h>
#endif
#ifdef G_OS_WIN32
#undef DATADIR
#include <windows.h>
#endif
#include "pikacriticaldialog.h"
#include "pika-intl.h"
#include "pika-version.h"
#define PIKA_CRITICAL_RESPONSE_CLIPBOARD 1
#define PIKA_CRITICAL_RESPONSE_URL 2
#define PIKA_CRITICAL_RESPONSE_RESTART 3
#define PIKA_CRITICAL_RESPONSE_DOWNLOAD 4
#define BUTTON1_TEXT _("Copy Bug Information")
#define BUTTON2_TEXT _("Open Bug Tracker")
enum
{
PROP_0,
PROP_LAST_VERSION,
PROP_RELEASE_DATE
};
static void pika_critical_dialog_constructed (GObject *object);
static void pika_critical_dialog_finalize (GObject *object);
static void pika_critical_dialog_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec);
static void pika_critical_dialog_response (GtkDialog *dialog,
gint response_id);
static void pika_critical_dialog_copy_info (PikaCriticalDialog *dialog);
static gboolean browser_open_url (GtkWindow *window,
const gchar *url,
GError **error);
G_DEFINE_TYPE (PikaCriticalDialog, pika_critical_dialog, GTK_TYPE_DIALOG)
#define parent_class pika_critical_dialog_parent_class
static void
pika_critical_dialog_class_init (PikaCriticalDialogClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GtkDialogClass *dialog_class = GTK_DIALOG_CLASS (klass);
object_class->constructed = pika_critical_dialog_constructed;
object_class->finalize = pika_critical_dialog_finalize;
object_class->set_property = pika_critical_dialog_set_property;
dialog_class->response = pika_critical_dialog_response;
g_object_class_install_property (object_class, PROP_LAST_VERSION,
g_param_spec_string ("last-version",
NULL, NULL, NULL,
G_PARAM_WRITABLE |
G_PARAM_CONSTRUCT_ONLY));
g_object_class_install_property (object_class, PROP_RELEASE_DATE,
g_param_spec_string ("release-date",
NULL, NULL, NULL,
G_PARAM_WRITABLE |
G_PARAM_CONSTRUCT_ONLY));
}
static void
pika_critical_dialog_init (PikaCriticalDialog *dialog)
{
PangoAttrList *attrs;
PangoAttribute *attr;
gtk_window_set_role (GTK_WINDOW (dialog), "pika-critical");
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_CLOSE);
gtk_window_set_resizable (GTK_WINDOW (dialog), TRUE);
dialog->main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_container_set_border_width (GTK_CONTAINER (dialog->main_vbox), 6);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
dialog->main_vbox, TRUE, TRUE, 0);
gtk_widget_show (dialog->main_vbox);
/* The error label. */
dialog->top_label = gtk_label_new (NULL);
gtk_widget_set_halign (dialog->top_label, GTK_ALIGN_START);
gtk_label_set_ellipsize (GTK_LABEL (dialog->top_label), PANGO_ELLIPSIZE_END);
gtk_label_set_selectable (GTK_LABEL (dialog->top_label), TRUE);
gtk_box_pack_start (GTK_BOX (dialog->main_vbox), dialog->top_label,
FALSE, FALSE, 0);
attrs = pango_attr_list_new ();
attr = pango_attr_weight_new (PANGO_WEIGHT_SEMIBOLD);
pango_attr_list_insert (attrs, attr);
gtk_label_set_attributes (GTK_LABEL (dialog->top_label), attrs);
pango_attr_list_unref (attrs);
gtk_widget_show (dialog->top_label);
dialog->center_label = gtk_label_new (NULL);
gtk_widget_set_halign (dialog->center_label, GTK_ALIGN_START);
gtk_label_set_selectable (GTK_LABEL (dialog->center_label), TRUE);
gtk_box_pack_start (GTK_BOX (dialog->main_vbox), dialog->center_label,
FALSE, FALSE, 0);
gtk_widget_show (dialog->center_label);
dialog->bottom_label = gtk_label_new (NULL);
gtk_widget_set_halign (dialog->bottom_label, GTK_ALIGN_START);
gtk_box_pack_start (GTK_BOX (dialog->main_vbox), dialog->bottom_label, FALSE, FALSE, 0);
attrs = pango_attr_list_new ();
attr = pango_attr_style_new (PANGO_STYLE_ITALIC);
pango_attr_list_insert (attrs, attr);
gtk_label_set_attributes (GTK_LABEL (dialog->bottom_label), attrs);
pango_attr_list_unref (attrs);
gtk_widget_show (dialog->bottom_label);
dialog->pid = 0;
dialog->program = NULL;
}
static void
pika_critical_dialog_constructed (GObject *object)
{
PikaCriticalDialog *dialog = PIKA_CRITICAL_DIALOG (object);
GtkWidget *scrolled;
GtkTextBuffer *buffer;
gchar *version;
gchar *text;
/* Bug details for developers. */
scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled),
GTK_SHADOW_IN);
gtk_widget_set_size_request (scrolled, -1, 200);
if (dialog->last_version)
{
GtkWidget *expander;
GtkWidget *vbox;
GtkWidget *button;
expander = gtk_expander_new (_("See bug details"));
gtk_box_pack_start (GTK_BOX (dialog->main_vbox), expander, TRUE, TRUE, 0);
gtk_widget_show (expander);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 4);
gtk_container_add (GTK_CONTAINER (expander), vbox);
gtk_widget_show (vbox);
gtk_box_pack_start (GTK_BOX (vbox), scrolled, TRUE, TRUE, 0);
gtk_widget_show (scrolled);
button = gtk_button_new_with_label (BUTTON1_TEXT);
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (pika_critical_dialog_copy_info),
dialog);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
gtk_dialog_add_buttons (GTK_DIALOG (dialog),
_("Go to _Download page"), PIKA_CRITICAL_RESPONSE_DOWNLOAD,
_("_Close"), GTK_RESPONSE_CLOSE,
NULL);
/* Recommend an update. */
text = g_strdup_printf (_("A new version of PIKA (%s) was released on %s.\n"
"It is recommended to update."),
dialog->last_version, dialog->release_date);
gtk_label_set_text (GTK_LABEL (dialog->center_label), text);
g_free (text);
text = _("You are running an unsupported version!");
gtk_label_set_text (GTK_LABEL (dialog->bottom_label), text);
}
else
{
/* Pack directly (and well visible) the bug details. */
gtk_box_pack_start (GTK_BOX (dialog->main_vbox), scrolled, TRUE, TRUE, 0);
gtk_widget_show (scrolled);
gtk_dialog_add_buttons (GTK_DIALOG (dialog),
BUTTON1_TEXT, PIKA_CRITICAL_RESPONSE_CLIPBOARD,
BUTTON2_TEXT, PIKA_CRITICAL_RESPONSE_URL,
_("_Close"), GTK_RESPONSE_CLOSE,
NULL);
/* Generic "report a bug" instructions. */
text = g_strdup_printf ("%s\n"
" \xe2\x80\xa2 %s %s\n"
" \xe2\x80\xa2 %s %s\n"
" \xe2\x80\xa2 %s\n"
" \xe2\x80\xa2 %s\n"
" \xe2\x80\xa2 %s\n"
" \xe2\x80\xa2 %s",
_("To help us improve PIKA, you can report the bug with "
"these simple steps:"),
_("Copy the bug information to the clipboard by clicking: "),
BUTTON1_TEXT,
_("Open our bug tracker in the browser by clicking: "),
BUTTON2_TEXT,
_("Create a login if you don't have one yet."),
_("Paste the clipboard text in a new bug report."),
_("Add relevant information in English in the bug report "
"explaining what you were doing when this error occurred."),
_("This error may have left PIKA in an inconsistent state. "
"It is advised to save your work and restart PIKA."));
gtk_label_set_text (GTK_LABEL (dialog->center_label), text);
g_free (text);
text = _("You can also close the dialog directly but "
"reporting bugs is the best way to make your "
"software awesome.");
gtk_label_set_text (GTK_LABEL (dialog->bottom_label), text);
}
buffer = gtk_text_buffer_new (NULL);
version = pika_version (TRUE, FALSE);
text = g_strdup_printf ("<!-- %s -->\n\n\n```\n%s\n```",
_("Copy-paste this whole debug data to report to developers"),
version);
gtk_text_buffer_set_text (buffer, text, -1);
g_free (version);
g_free (text);
dialog->details = gtk_text_view_new_with_buffer (buffer);
g_object_unref (buffer);
gtk_text_view_set_editable (GTK_TEXT_VIEW (dialog->details), FALSE);
gtk_widget_show (dialog->details);
gtk_container_add (GTK_CONTAINER (scrolled), dialog->details);
}
static void
pika_critical_dialog_finalize (GObject *object)
{
PikaCriticalDialog *dialog = PIKA_CRITICAL_DIALOG (object);
if (dialog->program)
g_free (dialog->program);
if (dialog->last_version)
g_free (dialog->last_version);
if (dialog->release_date)
g_free (dialog->release_date);
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
pika_critical_dialog_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
PikaCriticalDialog *dialog = PIKA_CRITICAL_DIALOG (object);
switch (property_id)
{
case PROP_LAST_VERSION:
dialog->last_version = g_value_dup_string (value);
break;
case PROP_RELEASE_DATE:
dialog->release_date = g_value_dup_string (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
pika_critical_dialog_copy_info (PikaCriticalDialog *dialog)
{
GtkClipboard *clipboard;
clipboard = gtk_clipboard_get_for_display (gdk_display_get_default (),
GDK_SELECTION_CLIPBOARD);
if (clipboard)
{
GtkTextBuffer *buffer;
gchar *text;
GtkTextIter start;
GtkTextIter end;
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (dialog->details));
gtk_text_buffer_get_iter_at_offset (buffer, &start, 0);
gtk_text_buffer_get_iter_at_offset (buffer, &end, -1);
text = gtk_text_buffer_get_text (buffer, &start, &end, FALSE);
gtk_clipboard_set_text (clipboard, text, -1);
g_free (text);
}
}
/* XXX This is taken straight from plug-ins/common/web-browser.c
*
* This really sucks but this class also needs to be called by
* tools/pika-debug-tool.c as a separate process and therefore cannot
* make use of the PDB. Anyway shouldn't we just move this as a utils
* function? Why does such basic feature as opening a URL in a
* cross-platform way need to be a plug-in?
*/
static gboolean
browser_open_url (GtkWindow *window,
const gchar *url,
GError **error)
{
#ifdef G_OS_WIN32
HINSTANCE hinst = ShellExecute (GetDesktopWindow(),
"open", url, NULL, NULL, SW_SHOW);
if ((intptr_t) hinst <= 32)
{
const gchar *err;
switch ((intptr_t) hinst)
{
case 0 :
err = _("The operating system is out of memory or resources.");
break;
case ERROR_FILE_NOT_FOUND :
err = _("The specified file was not found.");
break;
case ERROR_PATH_NOT_FOUND :
err = _("The specified path was not found.");
break;
case ERROR_BAD_FORMAT :
err = _("The .exe file is invalid (non-Microsoft Win32 .exe or error in .exe image).");
break;
case SE_ERR_ACCESSDENIED :
err = _("The operating system denied access to the specified file.");
break;
case SE_ERR_ASSOCINCOMPLETE :
err = _("The file name association is incomplete or invalid.");
break;
case SE_ERR_DDEBUSY :
err = _("DDE transaction busy");
break;
case SE_ERR_DDEFAIL :
err = _("The DDE transaction failed.");
break;
case SE_ERR_DDETIMEOUT :
err = _("The DDE transaction timed out.");
break;
case SE_ERR_DLLNOTFOUND :
err = _("The specified DLL was not found.");
break;
case SE_ERR_NOASSOC :
err = _("There is no application associated with the given file name extension.");
break;
case SE_ERR_OOM :
err = _("There was not enough memory to complete the operation.");
break;
case SE_ERR_SHARE:
err = _("A sharing violation occurred.");
break;
default :
err = _("Unknown Microsoft Windows error.");
}
g_set_error (error, 0, 0, _("Failed to open '%s': %s"), url, err);
return FALSE;
}
return TRUE;
#elif defined(PLATFORM_OSX)
NSURL *ns_url;
gboolean retval;
@autoreleasepool
{
ns_url = [NSURL URLWithString: [NSString stringWithUTF8String: url]];
retval = [[NSWorkspace sharedWorkspace] openURL: ns_url];
}
return retval;
#else
return gtk_show_uri_on_window (window,
url,
GDK_CURRENT_TIME,
error);
#endif
}
static void
pika_critical_dialog_response (GtkDialog *dialog,
gint response_id)
{
PikaCriticalDialog *critical = PIKA_CRITICAL_DIALOG (dialog);
const gchar *url = NULL;
switch (response_id)
{
case PIKA_CRITICAL_RESPONSE_CLIPBOARD:
pika_critical_dialog_copy_info (critical);
break;
case PIKA_CRITICAL_RESPONSE_DOWNLOAD:
#ifdef PIKA_UNSTABLE
url = "https://heckin.technology/AlderconeStudio/PIKApp/downloads/devel/";
#else
url = "https://heckin.technology/AlderconeStudio/PIKApp/downloads/";
#endif
case PIKA_CRITICAL_RESPONSE_URL:
if (url == NULL)
{
gchar *temp = g_ascii_strdown (BUG_REPORT_URL, -1);
/* Only accept custom web links. */
if (g_str_has_prefix (temp, "http://") ||
g_str_has_prefix (temp, "https://"))
url = BUG_REPORT_URL;
else
/* XXX Ideally I'd find a way to prefill the bug report
* through the URL or with POST data. But I could not find
* any. Anyway since we may soon ditch bugzilla to follow
* GNOME infrastructure changes, I don't want to waste too
* much time digging into it.
*/
url = PACKAGE_BUGREPORT;
g_free (temp);
}
browser_open_url (GTK_WINDOW (dialog), url, NULL);
break;
case PIKA_CRITICAL_RESPONSE_RESTART:
{
gchar *args[2] = { critical->program , NULL };
#ifndef G_OS_WIN32
/* It is unneeded to kill the process on Win32. This was run
* as an async call and the main process should already be
* dead by now.
*/
if (critical->pid > 0)
kill ((pid_t ) critical->pid, SIGINT);
#endif
if (critical->program)
g_spawn_async (NULL, args, NULL, G_SPAWN_DEFAULT,
NULL, NULL, NULL, NULL);
}
/* Fall through. */
case GTK_RESPONSE_DELETE_EVENT:
case GTK_RESPONSE_CLOSE:
default:
gtk_widget_destroy (GTK_WIDGET (dialog));
break;
}
}
/* public functions */
GtkWidget *
pika_critical_dialog_new (const gchar *title,
const gchar *last_version,
gint64 release_timestamp)
{
GtkWidget *dialog;
gchar *date = NULL;
g_return_val_if_fail (title != NULL, NULL);
if (release_timestamp > 0)
{
GDateTime *datetime;
datetime = g_date_time_new_from_unix_local (release_timestamp);
date = g_date_time_format (datetime, "%x");
g_date_time_unref (datetime);
}
dialog = g_object_new (PIKA_TYPE_CRITICAL_DIALOG,
"title", title,
"last-version", last_version,
"release-date", date,
NULL);
g_free (date);
return dialog;
}
void
pika_critical_dialog_add (GtkWidget *dialog,
const gchar *message,
const gchar *trace,
gboolean is_fatal,
const gchar *program,
gint pid)
{
PikaCriticalDialog *critical;
GtkTextBuffer *buffer;
GtkTextIter end;
gchar *text;
if (! PIKA_IS_CRITICAL_DIALOG (dialog) || ! message)
{
/* This is a bit hackish. We usually should use
* g_return_if_fail(). But I don't want to end up in a critical
* recursing loop if our code had bugs. We would crash PIKA with
* a CRITICAL which would otherwise not have necessarily ended up
* in a crash.
*/
return;
}
critical = PIKA_CRITICAL_DIALOG (dialog);
/* The user text, which should be localized. */
if (is_fatal)
{
text = g_strdup_printf (_("PIKA crashed with a fatal error: %s"),
message);
}
else if (! gtk_label_get_text (GTK_LABEL (critical->top_label)) ||
strlen (gtk_label_get_text (GTK_LABEL (critical->top_label))) == 0)
{
/* First error. Let's just display it. */
text = g_strdup_printf (_("PIKA encountered an error: %s"),
message);
}
else
{
/* Let's not display all errors. They will be in the bug report
* part anyway.
*/
text = g_strdup_printf (_("PIKA encountered several critical errors!"));
}
gtk_label_set_text (GTK_LABEL (critical->top_label),
text);
g_free (text);
if (is_fatal && ! critical->last_version)
{
/* Same text as before except that we don't need the last point
* about saving and restarting since anyway we are crashing and
* manual saving is not possible anymore (or even advisable since
* if it fails, one may corrupt files).
*/
text = g_strdup_printf ("%s\n"
" \xe2\x80\xa2 %s \"%s\"\n"
" \xe2\x80\xa2 %s \"%s\"\n"
" \xe2\x80\xa2 %s\n"
" \xe2\x80\xa2 %s\n"
" \xe2\x80\xa2 %s",
_("To help us improve PIKA, you can report the bug with "
"these simple steps:"),
_("Copy the bug information to the clipboard by clicking: "),
BUTTON1_TEXT,
_("Open our bug tracker in the browser by clicking: "),
BUTTON2_TEXT,
_("Create a login if you don't have one yet."),
_("Paste the clipboard text in a new bug report."),
_("Add relevant information in English in the bug report "
"explaining what you were doing when this error occurred."));
gtk_label_set_text (GTK_LABEL (critical->center_label), text);
g_free (text);
}
/* The details text is untranslated on purpose. This is the message
* meant to go to clipboard for the bug report. It has to be in
* English.
*/
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (critical->details));
gtk_text_buffer_get_iter_at_offset (buffer, &end, -1);
if (trace)
text = g_strdup_printf ("\n> %s\n\nStack trace:\n```\n%s\n```", message, trace);
else
text = g_strdup_printf ("\n> %s\n", message);
gtk_text_buffer_insert (buffer, &end, text, -1);
g_free (text);
/* Finally when encountering a fatal message, propose one more button
* to restart PIKA.
*/
if (is_fatal)
{
gtk_dialog_add_buttons (GTK_DIALOG (dialog),
_("_Restart PIKA"), PIKA_CRITICAL_RESPONSE_RESTART,
NULL);
critical->program = g_strdup (program);
critical->pid = pid;
}
}