303 lines
8.6 KiB
C
303 lines
8.6 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
|
|
*
|
|
* 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/>.
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include <string.h>
|
|
|
|
#include <gegl.h>
|
|
#include <gtk/gtk.h>
|
|
|
|
#include "libpikabase/pikabase.h"
|
|
|
|
#include "actions-types.h"
|
|
|
|
#include "core/pika.h"
|
|
#include "core/pika-utils.h"
|
|
#include "core/pikacontext.h"
|
|
#include "core/pikaimage.h"
|
|
#include "core/pikaprojectable.h"
|
|
#include "core/pikaprojection.h"
|
|
|
|
#include "gegl/pika-gegl-utils.h"
|
|
|
|
#include "widgets/pikaaction.h"
|
|
#include "widgets/pikaactiongroup.h"
|
|
#include "widgets/pikamenufactory.h"
|
|
#include "widgets/pikauimanager.h"
|
|
|
|
#include "display/pikadisplay.h"
|
|
#include "display/pikadisplayshell.h"
|
|
#include "display/pikaimagewindow.h"
|
|
|
|
#include "menus/menus.h"
|
|
|
|
#include "actions.h"
|
|
#include "debug-commands.h"
|
|
|
|
|
|
/* local function prototypes */
|
|
|
|
static gboolean debug_benchmark_projection (PikaDisplay *display);
|
|
static gboolean debug_show_image_graph (PikaImage *source_image);
|
|
|
|
static void debug_print_qdata (PikaObject *object);
|
|
static void debug_print_qdata_foreach (GQuark key_id,
|
|
gpointer data,
|
|
gpointer user_data);
|
|
|
|
|
|
/* public functions */
|
|
|
|
void
|
|
debug_gtk_inspector_cmd_callback (PikaAction *action,
|
|
GVariant *value,
|
|
gpointer data)
|
|
{
|
|
gtk_window_set_interactive_debugging (TRUE);
|
|
}
|
|
|
|
void
|
|
debug_mem_profile_cmd_callback (PikaAction *action,
|
|
GVariant *value,
|
|
gpointer data)
|
|
{
|
|
extern gboolean pika_debug_memsize;
|
|
Pika *pika;
|
|
return_if_no_pika (pika, data);
|
|
|
|
pika_debug_memsize = TRUE;
|
|
|
|
pika_object_get_memsize (PIKA_OBJECT (pika), NULL);
|
|
|
|
pika_debug_memsize = FALSE;
|
|
}
|
|
|
|
void
|
|
debug_benchmark_projection_cmd_callback (PikaAction *action,
|
|
GVariant *value,
|
|
gpointer data)
|
|
{
|
|
PikaDisplay *display;
|
|
return_if_no_display (display, data);
|
|
|
|
g_idle_add ((GSourceFunc) debug_benchmark_projection, g_object_ref (display));
|
|
}
|
|
|
|
void
|
|
debug_show_image_graph_cmd_callback (PikaAction *action,
|
|
GVariant *value,
|
|
gpointer data)
|
|
{
|
|
PikaImage *source_image = NULL;
|
|
return_if_no_image (source_image, data);
|
|
|
|
g_idle_add ((GSourceFunc) debug_show_image_graph, g_object_ref (source_image));
|
|
}
|
|
|
|
void
|
|
debug_dump_keyboard_shortcuts_cmd_callback (PikaAction *action,
|
|
GVariant *value,
|
|
gpointer data)
|
|
{
|
|
PikaDisplay *display;
|
|
PikaUIManager *manager;
|
|
GList *group_it;
|
|
GList *strings = NULL;
|
|
|
|
return_if_no_display (display, data);
|
|
|
|
manager = menus_get_image_manager_singleton (display->pika);
|
|
|
|
/* Gather formatted strings of keyboard shortcuts */
|
|
for (group_it = pika_ui_manager_get_action_groups (manager);
|
|
group_it;
|
|
group_it = g_list_next (group_it))
|
|
{
|
|
PikaActionGroup *group = group_it->data;
|
|
GList *actions = NULL;
|
|
GList *action_it = NULL;
|
|
|
|
actions = pika_action_group_list_actions (group);
|
|
actions = g_list_sort (actions, (GCompareFunc) pika_action_name_compare);
|
|
|
|
for (action_it = actions; action_it; action_it = g_list_next (action_it))
|
|
{
|
|
gchar **accels;
|
|
PikaAction *action = action_it->data;
|
|
const gchar *name = pika_action_get_name (action);
|
|
|
|
if (name[0] == '<')
|
|
continue;
|
|
|
|
accels = pika_action_get_display_accels (action);
|
|
|
|
if (accels && accels[0])
|
|
{
|
|
const gchar *label_tmp;
|
|
gchar *label;
|
|
|
|
label_tmp = pika_action_get_label (action);
|
|
label = pika_strip_uline (label_tmp);
|
|
|
|
strings = g_list_prepend (strings,
|
|
g_strdup_printf ("%-20s %s",
|
|
accels[0], label));
|
|
|
|
g_free (label);
|
|
|
|
for (gint i = 1; accels[i] != NULL; i++)
|
|
strings = g_list_prepend (strings, g_strdup (accels[i]));
|
|
}
|
|
|
|
g_strfreev (accels);
|
|
}
|
|
|
|
g_list_free (actions);
|
|
}
|
|
|
|
/* Sort and prints the strings */
|
|
{
|
|
GList *string_it = NULL;
|
|
|
|
strings = g_list_sort (strings, (GCompareFunc) strcmp);
|
|
|
|
for (string_it = strings; string_it; string_it = g_list_next (string_it))
|
|
{
|
|
g_print ("%s\n", (gchar *) string_it->data);
|
|
g_free (string_it->data);
|
|
}
|
|
|
|
g_list_free (strings);
|
|
}
|
|
}
|
|
|
|
void
|
|
debug_dump_attached_data_cmd_callback (PikaAction *action,
|
|
GVariant *value,
|
|
gpointer data)
|
|
{
|
|
Pika *pika = action_data_get_pika (data);
|
|
PikaContext *user_context = pika_get_user_context (pika);
|
|
|
|
debug_print_qdata (PIKA_OBJECT (pika));
|
|
debug_print_qdata (PIKA_OBJECT (user_context));
|
|
}
|
|
|
|
|
|
/* private functions */
|
|
|
|
static gboolean
|
|
debug_benchmark_projection (PikaDisplay *display)
|
|
{
|
|
PikaImage *image = pika_display_get_image (display);
|
|
|
|
if (image)
|
|
{
|
|
PikaProjection *projection = pika_image_get_projection (image);
|
|
|
|
pika_projection_stop_rendering (projection);
|
|
|
|
PIKA_TIMER_START ();
|
|
|
|
pika_image_invalidate_all (image);
|
|
pika_projection_flush_now (projection, TRUE);
|
|
|
|
PIKA_TIMER_END ("Validation of the entire projection");
|
|
|
|
g_object_unref (display);
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static gboolean
|
|
debug_show_image_graph (PikaImage *source_image)
|
|
{
|
|
GeglNode *image_graph;
|
|
GeglNode *output_node;
|
|
PikaImage *new_image;
|
|
GeglNode *introspect;
|
|
GeglNode *sink;
|
|
GeglBuffer *buffer = NULL;
|
|
|
|
image_graph = pika_projectable_get_graph (PIKA_PROJECTABLE (source_image));
|
|
|
|
output_node = gegl_node_get_output_proxy (image_graph, "output");
|
|
|
|
introspect = gegl_node_new_child (NULL,
|
|
"operation", "gegl:introspect",
|
|
"node", output_node,
|
|
NULL);
|
|
sink = gegl_node_new_child (NULL,
|
|
"operation", "gegl:buffer-sink",
|
|
"buffer", &buffer,
|
|
NULL);
|
|
|
|
gegl_node_link_many (introspect, sink, NULL);
|
|
gegl_node_process (sink);
|
|
|
|
if (buffer)
|
|
{
|
|
gchar *new_name;
|
|
|
|
/* This should not happen but "gegl:introspect" is a bit fickle as
|
|
* it uses an external binary `dot`. Prevent useless crashes.
|
|
* I don't output a warning when buffer is NULL because anyway
|
|
* GEGL will output one itself.
|
|
*/
|
|
new_name = g_strdup_printf ("%s GEGL graph",
|
|
pika_image_get_display_name (source_image));
|
|
|
|
new_image = pika_create_image_from_buffer (source_image->pika,
|
|
buffer, new_name);
|
|
pika_image_set_file (new_image, g_file_new_for_uri (new_name));
|
|
|
|
g_free (new_name);
|
|
g_object_unref (buffer);
|
|
}
|
|
|
|
g_object_unref (sink);
|
|
g_object_unref (introspect);
|
|
|
|
g_object_unref (source_image);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static void
|
|
debug_print_qdata (PikaObject *object)
|
|
{
|
|
g_print ("\nData attached to '%s':\n\n", pika_object_get_name (object));
|
|
g_datalist_foreach (&G_OBJECT (object)->qdata,
|
|
debug_print_qdata_foreach,
|
|
NULL);
|
|
g_print ("\n");
|
|
}
|
|
|
|
static void
|
|
debug_print_qdata_foreach (GQuark key_id,
|
|
gpointer data,
|
|
gpointer user_data)
|
|
{
|
|
g_print ("%s: %p\n", g_quark_to_string (key_id), data);
|
|
}
|
