AlderconeStudio/PIKApp
AlderconeStudio
/
PIKApp
0
0
Fork 0
Code Issues 1 Pull Requests Packages Projects Releases 1 Wiki Activity
PIKApp/app/widgets/pikadeviceeditor.c

589 lines
21 KiB
C
Raw Permalink Blame History

/* 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
*
* pikadeviceeditor.c
* Copyright (C) 2010 Michael Natterer <mitch@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/>.
*/
#include "config.h"
#include <gegl.h>
#include <gtk/gtk.h>
#include "libpikabase/pikabase.h"
#include "libpikawidgets/pikawidgets.h"
#include "widgets-types.h"
#include "core/pika.h"
#include "core/pikacontext.h"
#include "core/pikafilteredcontainer.h"
#include "core/pikalist.h"
#include "pikacontainerview.h"
#include "pikacontainertreestore.h"
#include "pikacontainertreeview.h"
#include "pikadeviceeditor.h"
#include "pikadeviceinfo.h"
#include "pikadeviceinfoeditor.h"
#include "pikadevicemanager.h"
#include "pikadevices.h"
#include "pikamessagebox.h"
#include "pikamessagedialog.h"
#include "pikaviewrenderer.h"
#include "pika-intl.h"
enum
{
PROP_0,
PROP_PIKA
};
typedef struct _PikaDeviceEditorPrivate PikaDeviceEditorPrivate;
struct _PikaDeviceEditorPrivate
{
Pika *pika;
GQuark name_changed_handler;
GtkWidget *treeview;
GtkWidget *delete_button;
GtkWidget *label;
GtkWidget *image;
GtkWidget *stack;
};
#define PIKA_DEVICE_EDITOR_GET_PRIVATE(editor) \
((PikaDeviceEditorPrivate *) pika_device_editor_get_instance_private ((PikaDeviceEditor *) (editor)))
static void pika_device_editor_constructed (GObject *object);
static void pika_device_editor_dispose (GObject *object);
static void pika_device_editor_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec);
static void pika_device_editor_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec);
static void pika_device_editor_add_device (PikaContainer *container,
PikaDeviceInfo *info,
PikaDeviceEditor *editor);
static void pika_device_editor_remove_device (PikaContainer *container,
PikaDeviceInfo *info,
PikaDeviceEditor *editor);
static void pika_device_editor_device_changed (PikaDeviceInfo *info,
PikaDeviceEditor *editor);
static gboolean pika_device_editor_select_device (PikaContainerView *view,
GList *viewables,
GList *paths,
PikaDeviceEditor *editor);
static void pika_device_editor_delete_clicked (GtkWidget *button,
PikaDeviceEditor *editor);
G_DEFINE_TYPE_WITH_PRIVATE (PikaDeviceEditor, pika_device_editor,
GTK_TYPE_PANED)
#define parent_class pika_device_editor_parent_class
static void
pika_device_editor_class_init (PikaDeviceEditorClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->constructed = pika_device_editor_constructed;
object_class->dispose = pika_device_editor_dispose;
object_class->set_property = pika_device_editor_set_property;
object_class->get_property = pika_device_editor_get_property;
g_object_class_install_property (object_class, PROP_PIKA,
g_param_spec_object ("pika",
NULL, NULL,
PIKA_TYPE_PIKA,
PIKA_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY));
}
static void
pika_device_editor_init (PikaDeviceEditor *editor)
{
PikaDeviceEditorPrivate *private = PIKA_DEVICE_EDITOR_GET_PRIVATE (editor);
GtkWidget *vbox;
GtkWidget *ebox;
GtkWidget *hbox;
gint icon_width;
gint icon_height;
gtk_orientable_set_orientation (GTK_ORIENTABLE (editor),
GTK_ORIENTATION_HORIZONTAL);
gtk_paned_set_wide_handle (GTK_PANED (editor), TRUE);
gtk_icon_size_lookup (GTK_ICON_SIZE_BUTTON, &icon_width, &icon_height);
private->treeview = pika_container_tree_view_new (NULL, NULL, icon_height, 0);
gtk_widget_set_size_request (private->treeview, 300, -1);
gtk_paned_pack1 (GTK_PANED (editor), private->treeview, TRUE, FALSE);
gtk_widget_show (private->treeview);
g_signal_connect_object (private->treeview, "select-items",
G_CALLBACK (pika_device_editor_select_device),
G_OBJECT (editor), 0);
private->delete_button =
pika_editor_add_button (PIKA_EDITOR (private->treeview),
PIKA_ICON_EDIT_DELETE,
_("Delete the selected device"),
NULL,
G_CALLBACK (pika_device_editor_delete_clicked),
NULL,
G_OBJECT (editor));
gtk_widget_set_sensitive (private->delete_button, FALSE);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_paned_pack2 (GTK_PANED (editor), vbox, TRUE, FALSE);
gtk_widget_show (vbox);
ebox = gtk_event_box_new ();
gtk_widget_set_state_flags (ebox, GTK_STATE_FLAG_SELECTED, TRUE);
gtk_style_context_add_class (gtk_widget_get_style_context (ebox),
GTK_STYLE_CLASS_VIEW);
gtk_box_pack_start (GTK_BOX (vbox), ebox, FALSE, FALSE, 0);
gtk_widget_show (ebox);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 6);
gtk_container_add (GTK_CONTAINER (ebox), hbox);
gtk_widget_show (hbox);
private->label = gtk_label_new (NULL);
gtk_widget_set_state_flags (private->label, GTK_STATE_FLAG_SELECTED, TRUE);
gtk_label_set_xalign (GTK_LABEL (private->label), 0.0);
gtk_label_set_ellipsize (GTK_LABEL (private->label), PANGO_ELLIPSIZE_END);
pika_label_set_attributes (GTK_LABEL (private->label),
PANGO_ATTR_WEIGHT, PANGO_WEIGHT_BOLD,
-1);
gtk_box_pack_start (GTK_BOX (hbox), private->label, TRUE, TRUE, 0);
gtk_widget_show (private->label);
private->image = gtk_image_new ();
gtk_widget_set_state_flags (private->image, GTK_STATE_FLAG_SELECTED, TRUE);
gtk_widget_set_size_request (private->image, -1, 24);
gtk_box_pack_end (GTK_BOX (hbox), private->image, FALSE, FALSE, 0);
gtk_widget_show (private->image);
private->stack = gtk_stack_new ();
gtk_container_set_border_width (GTK_CONTAINER (private->stack), 12);
gtk_stack_set_transition_type (GTK_STACK (private->stack),
GTK_STACK_TRANSITION_TYPE_SLIDE_UP_DOWN);
gtk_box_pack_start (GTK_BOX (vbox), private->stack, TRUE, TRUE, 0);
gtk_widget_show (private->stack);
}
static gboolean
pika_device_editor_filter (PikaObject *object,
gpointer user_data)
{
PikaDeviceInfo *info = PIKA_DEVICE_INFO (object);
GdkDevice *device = pika_device_info_get_device (info, NULL);
/* In the device editor, we filter out virtual devices (useless from a
* configuration standpoint) as well as the xtest API device.
* They only leave you wondering what you should do with them and
* should be ignored.
* We show device info with no actual associated device. These will
* simply be shown as grayed out and represent older physical devices
* which may simply be unplugged right now (but it's nice to show it
* in the list and can be manually deleted).
*/
return ((! device || gdk_device_get_device_type (device) != GDK_DEVICE_TYPE_MASTER) &&
/* Technically only a useful check on X11 but I could also
* imagine for instance a devicerc used on X11 then Wayland
* and it would be useless to show there the now absent XTEST
* device. So we run this name comparison all the time (the
* name is so specific that no real device ever would have
* this name; and this is the only way available to recognize
* this XTEST device which is meant to look like any other
* device).
*/
g_strcmp0 (pika_object_get_name (info), "Virtual core XTEST pointer") != 0);
}
static void
pika_device_editor_constructed (GObject *object)
{
PikaDeviceEditor *editor = PIKA_DEVICE_EDITOR (object);
PikaDeviceEditorPrivate *private = PIKA_DEVICE_EDITOR_GET_PRIVATE (editor);
PikaContainer *devices;
PikaContainer *filtered;
PikaContext *context;
GList *list;
G_OBJECT_CLASS (parent_class)->constructed (object);
pika_assert (PIKA_IS_PIKA (private->pika));
devices = PIKA_CONTAINER (pika_devices_get_manager (private->pika));
filtered = pika_filtered_container_new (devices, pika_device_editor_filter, NULL);
/* connect to "remove" before the container view does so we can get
* the stack child stored in its model
*/
g_signal_connect (devices, "remove",
G_CALLBACK (pika_device_editor_remove_device),
editor);
pika_container_view_set_container (PIKA_CONTAINER_VIEW (private->treeview),
filtered);
context = pika_context_new (private->pika, "device-editor-list", NULL);
pika_container_view_set_context (PIKA_CONTAINER_VIEW (private->treeview),
context);
g_object_unref (context);
g_signal_connect (devices, "add",
G_CALLBACK (pika_device_editor_add_device),
editor);
private->name_changed_handler =
pika_container_add_handler (devices, "name-changed",
G_CALLBACK (pika_device_editor_device_changed),
editor);
for (list = PIKA_LIST (devices)->queue->head;
list;
list = g_list_next (list))
{
pika_device_editor_add_device (devices, list->data, editor);
}
g_object_unref (devices);
}
static void
pika_device_editor_dispose (GObject *object)
{
PikaDeviceEditorPrivate *private = PIKA_DEVICE_EDITOR_GET_PRIVATE (object);
PikaContainer *devices;
devices = PIKA_CONTAINER (pika_devices_get_manager (private->pika));
g_signal_handlers_disconnect_by_func (devices,
pika_device_editor_add_device,
object);
g_signal_handlers_disconnect_by_func (devices,
pika_device_editor_remove_device,
object);
if (private->name_changed_handler)
{
pika_container_remove_handler (devices, private->name_changed_handler);
private->name_changed_handler = 0;
}
G_OBJECT_CLASS (parent_class)->dispose (object);
}
static void
pika_device_editor_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
PikaDeviceEditorPrivate *private = PIKA_DEVICE_EDITOR_GET_PRIVATE (object);
switch (property_id)
{
case PROP_PIKA:
private->pika = g_value_get_object (value); /* don't ref */
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
pika_device_editor_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
PikaDeviceEditorPrivate *private = PIKA_DEVICE_EDITOR_GET_PRIVATE (object);
switch (property_id)
{
case PROP_PIKA:
g_value_set_object (value, private->pika);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
pika_device_editor_add_device (PikaContainer *container,
PikaDeviceInfo *info,
PikaDeviceEditor *editor)
{
PikaDeviceEditorPrivate *private = PIKA_DEVICE_EDITOR_GET_PRIVATE (editor);
GtkWidget *widget;
GtkTreeIter *iter;
widget = pika_device_info_editor_new (info);
gtk_stack_add_named (GTK_STACK (private->stack), widget,
pika_object_get_name (info));
gtk_widget_show (widget);
iter = pika_container_view_lookup (PIKA_CONTAINER_VIEW (private->treeview),
PIKA_VIEWABLE (info));
if (iter)
{
PikaContainerTreeView *treeview;
treeview = PIKA_CONTAINER_TREE_VIEW (private->treeview);
gtk_tree_store_set (GTK_TREE_STORE (treeview->model), iter,
PIKA_CONTAINER_TREE_STORE_COLUMN_USER_DATA, widget,
PIKA_CONTAINER_TREE_STORE_COLUMN_NAME_SENSITIVE,
pika_device_info_get_device (info, NULL) != NULL,
-1);
}
}
static void
pika_device_editor_remove_device (PikaContainer *container,
PikaDeviceInfo *info,
PikaDeviceEditor *editor)
{
PikaDeviceEditorPrivate *private = PIKA_DEVICE_EDITOR_GET_PRIVATE (editor);
GtkTreeIter *iter;
iter = pika_container_view_lookup (PIKA_CONTAINER_VIEW (private->treeview),
PIKA_VIEWABLE (info));
if (iter)
{
PikaContainerTreeView *treeview;
GtkWidget *widget;
treeview = PIKA_CONTAINER_TREE_VIEW (private->treeview);
gtk_tree_model_get (treeview->model, iter,
PIKA_CONTAINER_TREE_STORE_COLUMN_USER_DATA, &widget,
-1);
if (widget)
gtk_widget_destroy (widget);
}
}
static void
pika_device_editor_device_changed (PikaDeviceInfo *info,
PikaDeviceEditor *editor)
{
PikaDeviceEditorPrivate *private = PIKA_DEVICE_EDITOR_GET_PRIVATE (editor);
GtkTreeIter *iter;
iter = pika_container_view_lookup (PIKA_CONTAINER_VIEW (private->treeview),
PIKA_VIEWABLE (info));
if (iter)
{
PikaContainerTreeView *treeview;
treeview = PIKA_CONTAINER_TREE_VIEW (private->treeview);
gtk_tree_store_set (GTK_TREE_STORE (treeview->model), iter,
PIKA_CONTAINER_TREE_STORE_COLUMN_NAME_SENSITIVE,
pika_device_info_get_device (info, NULL) != NULL,
-1);
}
}
static gboolean
pika_device_editor_select_device (PikaContainerView *view,
GList *viewables,
GList *paths,
PikaDeviceEditor *editor)
{
PikaDeviceEditorPrivate *private = PIKA_DEVICE_EDITOR_GET_PRIVATE (editor);
g_return_val_if_fail (g_list_length (viewables) < 2, FALSE);
if (viewables)
{
PikaContainerTreeView *treeview;
GtkWidget *widget;
GtkTreeIter iter;
gboolean iter_valid;
treeview = PIKA_CONTAINER_TREE_VIEW (private->treeview);
for (iter_valid = gtk_tree_model_get_iter_first (treeview->model, &iter);
iter_valid;
iter_valid = gtk_tree_model_iter_next (treeview->model, &iter))
{
PikaViewRenderer *renderer;
gtk_tree_model_get (treeview->model, &iter,
PIKA_CONTAINER_TREE_STORE_COLUMN_USER_DATA, &widget,
PIKA_CONTAINER_TREE_STORE_COLUMN_RENDERER, &renderer,
-1);
if (renderer->viewable == viewables->data && widget)
{
PikaDeviceInfo *info;
gboolean delete_sensitive = FALSE;
gtk_stack_set_visible_child (GTK_STACK (private->stack), widget);
g_object_get (widget ,"info", &info, NULL);
gtk_label_set_text (GTK_LABEL (private->label),
pika_object_get_name (info));
gtk_image_set_from_icon_name (GTK_IMAGE (private->image),
pika_viewable_get_icon_name (PIKA_VIEWABLE (info)),
GTK_ICON_SIZE_BUTTON);
if (! pika_device_info_get_device (info, NULL))
delete_sensitive = TRUE;
gtk_widget_set_sensitive (private->delete_button, delete_sensitive);
g_object_unref (info);
g_object_unref (renderer);
break;
}
g_object_unref (renderer);
}
}
return TRUE;
}
static void
pika_device_editor_delete_response (GtkWidget *dialog,
gint response_id,
PikaDeviceEditor *editor)
{
PikaDeviceEditorPrivate *private = PIKA_DEVICE_EDITOR_GET_PRIVATE (editor);
gtk_widget_destroy (dialog);
if (response_id == GTK_RESPONSE_OK)
{
GList *selected;
if (pika_container_view_get_selected (PIKA_CONTAINER_VIEW (private->treeview),
&selected, NULL))
{
PikaContainer *devices;
devices = PIKA_CONTAINER (pika_devices_get_manager (private->pika));
pika_container_remove (devices, selected->data);
g_list_free (selected);
}
}
gtk_widget_set_sensitive (GTK_WIDGET (editor), TRUE);
}
static void
pika_device_editor_delete_clicked (GtkWidget *button,
PikaDeviceEditor *editor)
{
PikaDeviceEditorPrivate *private = PIKA_DEVICE_EDITOR_GET_PRIVATE (editor);
GtkWidget *dialog;
GList *selected;
if (! pika_container_view_get_selected (PIKA_CONTAINER_VIEW (private->treeview),
&selected, NULL))
return;
dialog = pika_message_dialog_new (_("Delete Device Settings"),
PIKA_ICON_DIALOG_QUESTION,
gtk_widget_get_toplevel (GTK_WIDGET (editor)),
GTK_DIALOG_DESTROY_WITH_PARENT,
pika_standard_help_func, NULL,
_("_Cancel"), GTK_RESPONSE_CANCEL,
_("_Delete"), GTK_RESPONSE_OK,
NULL);
pika_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
g_signal_connect (dialog, "response",
G_CALLBACK (pika_device_editor_delete_response),
editor);
pika_message_box_set_primary_text (PIKA_MESSAGE_DIALOG (dialog)->box,
_("Delete \"%s\"?"),
pika_object_get_name (selected->data));
pika_message_box_set_text (PIKA_MESSAGE_DIALOG (dialog)->box,
_("You are about to delete this device's "
"stored settings.\n"
"The next time this device is plugged, "
"default settings will be used."));
g_list_free (selected);
gtk_widget_set_sensitive (GTK_WIDGET (editor), FALSE);
gtk_widget_show (dialog);
}
/* public functions */
GtkWidget *
pika_device_editor_new (Pika *pika)
{
g_return_val_if_fail (PIKA_IS_PIKA (pika), NULL);
return g_object_new (PIKA_TYPE_DEVICE_EDITOR,
"pika", pika,
NULL);
}
Reference in New Issue View Git Blame Copy Permalink