FR: cut/copy/paste interface for GTK

DarkTrick · August 8, 2021, 10:07am

Has there been any consideration for an interface to make it easier for the developer to run cut/copy/paste clipboard actions on widget (needed for the implementation of a copy/paste menu).

Why is this needed?
Currently, you can

if (GTK_IS_LABEL (widget) || GTK_IS_ENTRY (widget) || GTK_IS_TEXT_VIEW (widget)) || GTK_IS_EDITABLE (widget) || ...
Or guint signal = g_signal_lookup ("copy-clipboard", G_OBJECT_TYPE (widget));
to figure out, if a widget supports cut/copy/paste signals or methods. Unfortunately, both ways are only fragile options.

ebassi · August 8, 2021, 10:29am

And once you get an interface, what are you going to do? You cannot use the same API between Label, Entry, and TextView anyway in order to get the contents of the clipboard and add them to the widget; nor you can use the same API to get the contents of the widget and put them into the clipboard. Labels aren’t even going to support copying their contents into the clipboard, unless they are selectable, and if something is determined at run time then it cannot be used as a type.

Use different callbacks for each widget that can operate on the clipboard in your application.

matthiasc · August 9, 2021, 4:59am

GTK’s text widgets (label, entry, textview) support the clipboard out of the box. For adding clipbord support to custom widgets, the interface to use is GdkClipboard.

DarkTrick · August 10, 2021, 11:13am

I don’t understand that statement. This is the current situation of signals and functions. They are all consistent: signals have a widget and user data,

GtkLabel has
- a copy-clipboard signal
  (void cb (GtkLabel *label, gpointer user_data))
GtkEntry has
- a copy-clipboard signal
  (void cb (GtkEntry *entry, gpointer user_data))
- a cut-clipboard signal
  (void cb (GtkEntry *entry, gpointer user_data))
- a paste-clipboard signal
  (void cb (GtkEntry *entry, gpointer user_data))
- gtk_editable_copy_clipboard
  (void gtk_editable_copy_clipboard (GtkEditable *editable))
- gtk_editable_cut_clipboard
  (void gtk_editable_cut_clipboard (GtkEditable *editable))
- gtk_editable_paste_clipboard
  (void gtk_editable_paste_clipboard (GtkEditable *editable))
GtkTextView has
- copy-clipboard
  (void cb (GtkTextView *text_view, gpointer user_data))
- cut-clipboard
  (void cb (GtkTextView *text_view, gpointer user_data))
- paste-clipboard
  (void cb (GtkTextView *text_view, gpointer user_data))

Indeed GtkTextBuffer’s API looks different:

void gtk_text_buffer_copy_clipboard (GtkTextBuffer *buffer, GtkClipboard *clipboard)
void gtk_text_buffer_cut_clipboard (GtkTextBuffer *buffer, GtkClipboard *clipboard, gboolean default_editable);
gtk_text_buffer_paste_clipboard (...)

In this case it would be discussable how and if to handle an interface.

DarkTrick · August 10, 2021, 11:19am

Yes, they do. But they don’t share a common interface class. That means, the programmer always has to care about which widget they are working with, even though all functions/signals do the very same: copy text / cut text / paste text.
A common interface for these actions would allow the programmer to not care about the specific widget anymore.

matthiasc · August 12, 2021, 7:33pm

I don’t understand why you have to care about the clipboard. It just works

DarkTrick · August 16, 2021, 10:47am

It “just works” only as long as you use the accelerators or right-click menu. But there are many applications with menus like this:

In these cases the app devs must take good care, to check any possible case.

A quick search on Github revealed that quite some fork their flow according to the type of widget. That’s error prone because future development might introduce not yet considered widgets.

Here Thunar checks for the type to determine copy-ability.

This code is error-prone for future development, because it won’t respond to GtkTextViews or GtkLabels, that might be introduced by future programmers or add-on developers.

Here DevHelp ifs for various types:

github.com

GNOME/devhelp/blob/0bae3449eeae67b5d0a1c9b4e40cd8da684c5b98/src/dh-window.c#L249


      
                  /* FIXME: the code here closes the current *tab*, but in help-overlay.ui
                   * it is documented as "Close the current window". Look for example at
                   * what gedit does, or other GNOME apps with a GtkNotebook plus Ctrl+W
                   * shortcut, and do the same.
                   */
                  page_num = gtk_notebook_get_current_page (GTK_NOTEBOOK (priv->notebook));
                  gtk_notebook_remove_page (GTK_NOTEBOOK (priv->notebook), page_num);
          }
          
          static void
          copy_cb (GSimpleAction *action,
                   GVariant      *parameter,
                   gpointer       user_data)
          {
                  DhWindow *window = DH_WINDOW (user_data);
                  DhWindowPrivate *priv = dh_window_get_instance_private (window);
                  GtkWidget *widget;
          
                  widget = gtk_window_get_focus (GTK_WINDOW (window));
          
                  if (GTK_IS_EDITABLE (widget)) {

Here evolution ifs for various types:

github.com

GNOME/evolution/blob/9debad14e2af1768d543e796b10090511a56d4d7/src/e-util/e-focus-tracker.c#L1169


      
          		is_editable = gtk_text_view_get_editable (text_view);
          
          		gtk_text_buffer_cut_clipboard (buffer, clipboard, is_editable);
          
          	} else if (E_IS_CONTENT_EDITOR (focus)) {
          		e_content_editor_cut (E_CONTENT_EDITOR (focus));
          	}
          }
          
          void
          e_focus_tracker_copy_clipboard (EFocusTracker *focus_tracker)
          {
          	GtkWidget *focus;
          
          	g_return_if_fail (E_IS_FOCUS_TRACKER (focus_tracker));
          
          	focus = e_focus_tracker_get_focus (focus_tracker);
          
          	if (E_IS_SELECTABLE (focus)) {
          		e_selectable_copy_clipboard (E_SELECTABLE (focus));

Here Recipes ifs for various types:

github.com

GNOME/recipes/blob/305de4769cee28feaa2da073b326d233f51f8842/src/gr-window.c#L1040


      
                  gtk_widget_class_bind_template_callback (widget_class, close_export_done);
          }
          
          static GtkClipboard *
          get_clipboard (GtkWidget *widget)
          {
                  return gtk_widget_get_clipboard (widget, gdk_atom_intern_static_string ("CLIPBOARD"));
          }
          
          static void
          copy_activated (GSimpleAction *action,
                          GVariant      *parameter,
                          gpointer       user_data)
          {
                  GtkWindow *window = GTK_WINDOW (user_data);
                  GtkWidget *focus;
          
                  focus = gtk_window_get_focus (window);
                  if (GTK_IS_TEXT_VIEW (focus))
                          gtk_text_buffer_copy_clipboard (gtk_text_view_get_buffer (GTK_TEXT_VIEW (focus)),
                                                          get_clipboard (focus));

Here [whatever this app is] ifs for different types:

github.com

zakkudo/gwaei/blob/12e5ffc44aafb32d70eb07cc70e006a329894438/src/gwaei/searchwindow.c#L980


      
          {
              //Sanity check
              g_assert (window != NULL && widget != NULL); 
          
              //Declarations
              GtkClipboard *clipboard;
              GtkTextBuffer *buffer;
          
              if (GTK_IS_ENTRY (widget))
              {
                gtk_editable_copy_clipboard (GTK_EDITABLE (widget));
              }
              else if (GTK_IS_TEXT_VIEW (widget))
              {
                buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (widget));
                clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
                gtk_text_buffer_copy_clipboard (buffer, clipboard);
              }
              else
              {
                g_warning ("Unsupported widget type for gw_searchwindow_copy_text()\n");

Here …

github.com

mate-desktop/mate-utils/blob/a39e540dbdff8ba90e5aaa7d50332f8108006dc5/mate-dictionary/src/gdict-window.c#L1025


      
              gtk_widget_destroy (GTK_WIDGET (window));
          }
          
          static void
          gdict_window_cmd_edit_copy (GtkAction   *action,
          			    GdictWindow *window)
          {
            g_assert (GDICT_IS_WINDOW (window));
          
            if (gtk_widget_has_focus (window->entry))
              gtk_editable_copy_clipboard (GTK_EDITABLE (window->entry));
            else
              gdict_defbox_copy_to_clipboard (GDICT_DEFBOX (window->defbox),
                                              gtk_clipboard_get (GDK_SELECTION_CLIPBOARD));
          }
          
          static void
          gdict_window_cmd_edit_select_all (GtkAction   *action,
          				  GdictWindow *window)
          {
            g_assert (GDICT_IS_WINDOW (window));

Here …

github.com

v1cont/yam/blob/e6dc0e6bb3140317dff508bf3a417dcb9752cc8e/src/compose.c#L7597


      
                  }
              }
          }
          
          static void
          compose_copy_cb (Compose * compose)
          {
            if (compose->focused_editable && gtk_widget_has_focus (compose->focused_editable))
              {
                if (GTK_IS_EDITABLE (compose->focused_editable))
                  gtk_editable_copy_clipboard (GTK_EDITABLE (compose->focused_editable));
                else if (GTK_IS_TEXT_VIEW (compose->focused_editable))
                  {
                    GtkTextView *text = GTK_TEXT_VIEW (compose->text);
                    GtkTextBuffer *buffer;
                    GtkClipboard *clipboard;
          
                    buffer = gtk_text_view_get_buffer (text);
                    clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
          
                    gtk_text_buffer_copy_clipboard (buffer, clipboard);

Here …

github.com

Gnucash/gnucash/blob/c3dc34330d88bf0d20de0304e7f15ff19c9214cc/gnucash/gnome-utils/gnc-main-window.c#L4395


      
              }
          }
          
          static void
          gnc_main_window_cmd_edit_copy (GtkAction *action, GncMainWindow *window)
          {
              GtkWidget *widget = gtk_window_get_focus (GTK_WINDOW(window));
          
              if (GTK_IS_EDITABLE(widget))
              {
                  gtk_editable_copy_clipboard (GTK_EDITABLE(widget));
              }
              else if (GTK_IS_TEXT_VIEW(widget))
              {
                  GtkTextBuffer *text_buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW(widget));
                  GtkClipboard *clipboard = gtk_widget_get_clipboard (GTK_WIDGET(widget),
                                                                      GDK_SELECTION_CLIPBOARD);
                  if (clipboard)
                      gtk_text_buffer_copy_clipboard (text_buffer, clipboard);
              }
          }

Here …

github.com

geany/geany/blob/b524a58e12e85c94a32f64fb72615978b2628af1/src/callbacks.c#L261


      
          		gtk_text_buffer_cut_clipboard(buffer, gtk_clipboard_get(GDK_NONE), TRUE);
          	}
          }
          
          
          void on_copy1_activate(GtkMenuItem *menuitem, gpointer user_data)
          {
          	GtkWidget *focusw = gtk_window_get_focus(GTK_WINDOW(main_widgets.window));
          
          	if (GTK_IS_EDITABLE(focusw))
          		gtk_editable_copy_clipboard(GTK_EDITABLE(focusw));
          	else if (IS_SCINTILLA(focusw))
          		sci_copy(SCINTILLA(focusw));
          	else if (GTK_IS_TEXT_VIEW(focusw))
          	{
          		GtkTextBuffer *buffer = gtk_text_view_get_buffer(
          			GTK_TEXT_VIEW(focusw));
          		gtk_text_buffer_copy_clipboard(buffer, gtk_clipboard_get(GDK_NONE));
          	}
          }

Here …

github.com

semjacko/bachelor_thesis/blob/49a26aad12d2c71c1d034ec9c2580272f0183ee9/modules/iup/src/gtk/iupgtk_text.c#L1058


      
          ih->data->disable_callbacks = 1;
          if (iupStrEqualNoCase(value, "COPY"))
          {
            if (ih->data->is_multiline)
            {
              GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(ih->handle));
              GtkClipboard *clipboard = gtk_clipboard_get(gdk_atom_intern("CLIPBOARD", FALSE));
              gtk_text_buffer_copy_clipboard(buffer, clipboard);
            }
            else
              gtk_editable_copy_clipboard(GTK_EDITABLE(ih->handle));
          }
          else if (iupStrEqualNoCase(value, "CUT"))
          {
            if (ih->data->is_multiline)
            {
              GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(ih->handle));
              GtkClipboard *clipboard = gtk_clipboard_get(gdk_atom_intern("CLIPBOARD", FALSE));
              gtk_text_buffer_cut_clipboard(buffer, clipboard, TRUE);
            }
            else

Here …

github.com

mmuman/NetSurf/blob/a11ad57bf64ae4e701e049ced1233cc4c7b22054/frontends/gtk/toolbar.c#L2484


      
          
          
          /**
           * handler for copy tool bar item clicked signal
           *
           * \param widget The widget the signal is being delivered to.
           * \param data The toolbar context passed when the signal was connected
           * \return TRUE
           */
          static gboolean
          copy_button_clicked_cb(GtkWidget *widget, gpointer data)
          {
          	struct nsgtk_toolbar *tb = (struct nsgtk_toolbar *)data;
          	struct browser_window *bw;
          	GtkWidget *focused;
          	GtkWidget *toplevel;
          
          	toplevel = gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW);
          
          	focused = gtk_window_get_focus(GTK_WINDOW(toplevel));

And thing’s get even more difficult, if you want to disable menu items, if there is no selected text.

A common interface for this common task would IMO strengthen and improve app structure and reduce code complexity. It would also suggest people to implement the interface themselves.

I don’t understand why you have to care about the clipboard. It just works

The point I’m trying to make is, it does not “just work”. You actually have to take a well-thought effort to ensure your app is working consistently.

matthiasc · August 17, 2021, 3:04pm

It is still not clear what you want, and what is missing.

DarkTrick · September 6, 2021, 6:31am

sorry for the late reply.

It is still not clear what you want,

A unified interface for cut/copy/paste actions of widgets.

and what is missing.

A unified interface for cut/copy/paste actions of widgets.

Example:

Interface function to check clipboard usability:
- gtk_clipboardable_can_copy ()
- gtk_clipboardable_can_paste ()
Interface functions to actually use the clipboard:
- gtk_clipboardable_copy ()
- gtk_clipboardable_paste ()
- gtk_clipboardable_cut ()

These functions would provide a clear unified interface for copy/paste/cut action into/from clipboard.

This would not only benefit GTK itself, but also third party widgets/apps, because it encourages to actually implement the interface instead of falling for a manual approach.

jfrancis · September 6, 2021, 3:45pm

Have you tried to use the clipboard.copy, clipboard.cut and clipboard.paste actions? I believe that does most of what you are asking for. These should be supported/documented on the respective text widgets. Perhaps those apps should be wanting to change their menu items to use these actions, to reduce code?

DarkTrick · September 7, 2021, 12:33am

Have you tried to use the clipboard.copy, clipboard.cut and clipboard.paste actions?

I didn’t know they exist. Do you have a link to some documentation?

jfrancis · September 7, 2021, 1:02am

Hmm, they are missing on the individual widgets, but they are mentioned here: Gtk – 4.0: Overview of actions in GTK

DarkTrick · September 9, 2021, 1:39am

Clipboard operations on entries, text view and labels, typically used in the context menu

Looks like it’s difficult to hook into that in case you want your own custom copy/paste actions for your custom widgets. (Couldn’t test it, as it seems not available on Gtk3)

jfrancis · September 9, 2021, 3:09am

It should be possible to implement the same actions on custom widgets using the normal way to implement actions, or pass them through to an internal GtkEntry or similar.

DarkTrick · September 13, 2021, 11:58am

As I’m not using GTK4 I can’t verify at the moment, but I guess it’s the answer to this thread Thank you?

jfrancis · September 14, 2021, 9:24pm

I think one thing missing is that there is no way to check whether a widget responds to this action or whether the action is enabled, so maybe that would be covered by these issues:

https://gitlab.gnome.org/GNOME/gtk/-/issues/4161

https://gitlab.gnome.org/GNOME/gtk/-/issues/4162

system · October 14, 2021, 9:24pm

This topic was automatically closed 30 days after the last reply. New replies are no longer allowed.