gtk.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: © 2018-2024 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#ifndef __UTILS_GTK_H__
#define __UTILS_GTK_H__
 
#include "zrythm-config.h"
 
#include <stdbool.h>
 
#include <gtk/gtk.h>
#ifdef HAVE_X11
#  include <gdk/x11/gdkx.h>
#endif
 
#ifdef _WOE32
#  include <gdk/win32/gdkwin32.h>
#endif
 
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#include <gtksourceview/gtksource.h>
#pragma GCC diagnostic pop
 
#include <cyaml/cyaml.h>
 
#define DEFAULT_CLIPBOARD gdk_display_get_clipboard (gdk_display_get_default ())
 
#define CREATE_MIDI_LEARN_MENU_ITEM(action) \
  z_gtk_create_menu_item (_ ("MIDI learn"), "signal-midi", action)
 
#define CREATE_CUT_MENU_ITEM(action) \
  z_gtk_create_menu_item (_ ("Cu_t"), "edit-cut", action)
 
#define CREATE_COPY_MENU_ITEM(action) \
  z_gtk_create_menu_item (_ ("_Copy"), "edit-copy", action)
 
#define CREATE_PASTE_MENU_ITEM(action) \
  z_gtk_create_menu_item (_ ("_Paste"), "edit-paste", action)
 
#define CREATE_DELETE_MENU_ITEM(action) \
  z_gtk_create_menu_item (_ ("_Delete"), "edit-delete", action)
 
#define CREATE_CLEAR_SELECTION_MENU_ITEM(action) \
  z_gtk_create_menu_item (/* TRANSLATORS: deselects everything */ \
                          _ ("Cle_ar Selection"), "edit-clear", action)
 
#define CREATE_SELECT_ALL_MENU_ITEM(action) \
  z_gtk_create_menu_item (_ ("Select A_ll"), "edit-select-all", action)
 
#define CREATE_DUPLICATE_MENU_ITEM(action) \
  z_gtk_create_menu_item (_ ("Duplicate"), "edit-duplicate", action)
 
#define CREATE_MUTE_MENU_ITEM(action) \
  z_gtk_create_menu_item (_ ("Mute"), "mute", action)
 
#define CREATE_UNMUTE_MENU_ITEM(action) \
  z_gtk_create_menu_item (_ ("Unmute"), NULL, action)
 
#define z_gtk_assistant_set_current_page_complete(assistant, complete) \
  gtk_assistant_set_page_complete ( \
    GTK_ASSISTANT (assistant), \
    gtk_assistant_get_nth_page ( \
      GTK_ASSISTANT (assistant), \
      gtk_assistant_get_current_page (GTK_ASSISTANT (assistant))), \
    complete);
 
#define Z_GDK_RGBA_INIT(r, g, b, a) \
  (GdkRGBA) \
  { \
    .red = (float) (r), .green = (float) (g), .blue = (float) (b), \
    .alpha = (float) (a) \
  }
 
#define Z_GDK_RECTANGLE_INIT(_x, _y, _w, _h) \
  (GdkRectangle) \
  { \
    .x = _x, .y = _y, .width = _w, .height = _h \
  }
 
#define Z_GDK_RECTANGLE_INIT_UNIT(_x, _y) \
  (GdkRectangle) \
  { \
    .x = _x, .y = _y, .width = 1, .height = 1 \
  }
 
typedef enum IconType IconType;
 
typedef struct _ZGObjectImpl
{
  GTypeInstance g_type_instance;
 
  /*< private >*/
  guint   ref_count; /* (atomic) */
  GData * qdata;
} ZGObjectImpl;
 
enum ZGtkResize
{
  Z_GTK_NO_RESIZE,
  Z_GTK_RESIZE
};
 
enum ZGtkShrink
{
  Z_GTK_NO_SHRINK,
  Z_GTK_SHRINK
};
 
static inline GtkWidget *
z_gtk_notebook_get_current_page_widget (GtkNotebook * notebook)
{
  return gtk_notebook_get_nth_page (
    notebook, gtk_notebook_get_current_page (notebook));
}
 
static inline GtkWidget *
z_gtk_notebook_get_current_tab_label_widget (GtkNotebook * notebook)
{
  return gtk_notebook_get_tab_label (
    notebook, z_gtk_notebook_get_current_page_widget (notebook));
}
 
GdkMonitor *
z_gtk_get_primary_monitor (void);
 
int
z_gtk_get_primary_monitor_scale_factor (void);
 
int
z_gtk_get_primary_monitor_refresh_rate (void);
 
bool
z_gtk_is_wayland (void);
 
void
z_gtk_tree_view_remove_all_columns (GtkTreeView * treeview);
 
void
z_gtk_column_view_remove_all_columnes (GtkColumnView * column_view);
 
GListStore *
z_gtk_column_view_get_list_store (GtkColumnView * column_view);
 
void
z_gtk_list_store_splice (GListStore * store, GPtrArray * ptr_array);
 
void
z_gtk_widget_remove_all_children (GtkWidget * widget);
 
void
z_gtk_widget_destroy_all_children (GtkWidget * widget);
 
void
z_gtk_widget_remove_children_of_type (GtkWidget * widget, GType type);
 
void
z_gtk_overlay_add_if_not_exists (GtkOverlay * overlay, GtkWidget * widget);
 
void
z_gtk_button_set_icon_name_and_text (
  GtkButton *    btn,
  const char *   name,
  const char *   text,
  bool           icon_first,
  GtkOrientation orientation,
  int            spacing);
 
GtkToggleButton *
z_gtk_toggle_button_new_with_icon (const char * name);
 
GtkToggleButton *
z_gtk_toggle_button_new_with_icon_and_text (
  const char *   name,
  const char *   text,
  bool           icon_first,
  GtkOrientation orientation,
  int            spacing);
 
GtkButton *
z_gtk_button_new_with_icon_and_text (
  const char *   name,
  const char *   text,
  bool           icon_first,
  GtkOrientation orientation,
  int            spacing);
 
#define z_gtk_create_menu_item(lbl_name, icn_name, action_name) \
  z_gtk_create_menu_item_full (lbl_name, icn_name, action_name)
 
GMenuItem *
z_gtk_create_menu_item_full (
  const gchar * label_name,
  const gchar * icon_name,
  const char *  detailed_action);
 
char *
z_gtk_get_tooltip_for_action (const char * detailed_action, const char * tooltip);
 
void
z_gtk_widget_set_tooltip_for_action (
  GtkWidget *  widget,
  const char * detailed_action,
  const char * tooltip);
 
void
z_gtk_set_tooltip_for_actionable (
  GtkActionable * actionable,
  const char *    tooltip);
 
#if 0
void
z_gtk_tool_button_set_icon_size (
  GtkToolButton * toolbutton,
  GtkIconSize     icon_size);
#endif
 
static inline GdkDevice *
z_gtk_widget_get_device (GtkWidget * widget)
{
  return (gdk_seat_get_pointer (
    gdk_display_get_default_seat (gtk_widget_get_display (widget))));
}
 
#if 0
static inline GdkWindow *
z_gtk_widget_get_root_gdk_window (
  GtkWidget * widget)
{
  GdkScreen * screen =
    z_gtk_widget_get_screen (widget);
  return
    gdk_screen_get_root_window (screen);
}
#endif
 
#if 0
static inline void
z_gtk_widget_get_global_coordinates (
  GtkWidget * widget,
  int *       x,
  int *       y)
{
  GdkDevice * dev =
    z_gtk_widget_get_device (widget);
  GdkWindow * win =
    z_gtk_widget_get_root_gdk_window (widget);
  gdk_window_get_device_position (
    win, dev, x, y, NULL);
}
 
static inline void
z_gtk_widget_get_global_coordinates_double (
  GtkWidget * widget,
  double *    x,
  double *    y)
{
  GdkDevice * dev =
    z_gtk_widget_get_device (widget);
  GdkWindow * win =
    z_gtk_widget_get_root_gdk_window (widget);
  gdk_window_get_device_position_double (
    win, dev, x, y, NULL);
}
 
static inline void
z_gtk_warp_cursor_to (
  GtkWidget * widget, int x, int y)
{
  GdkDevice * dev =
    z_gtk_widget_get_device (widget);
  GdkScreen * screen =
    z_gtk_widget_get_screen (widget);
  gdk_device_warp (dev, screen, x, y);
}
#endif
 
static inline GdkSurface *
z_gtk_widget_get_surface (GtkWidget * widget)
{
  GtkNative * native = gtk_widget_get_native (widget);
  return gtk_native_get_surface (native);
}
 
static inline void
z_gtk_widget_get_mask (GtkWidget * widget, GdkModifierType * mask)
{
  gdk_surface_get_device_position (
    z_gtk_widget_get_surface (widget), z_gtk_widget_get_device (widget), NULL,
    NULL, mask);
}
 
static inline int
z_gtk_keyval_is_alt (const guint keyval)
{
  return keyval == GDK_KEY_Alt_L || keyval == GDK_KEY_Alt_R
         || keyval == GDK_KEY_Meta_L || keyval == GDK_KEY_Meta_R;
}
 
static inline int
z_gtk_keyval_is_ctrl (const guint keyval)
{
  return keyval == GDK_KEY_Control_L || keyval == GDK_KEY_Control_R;
}
 
static inline int
z_gtk_keyval_is_arrow (const guint keyval)
{
  return keyval == GDK_KEY_Left || keyval == GDK_KEY_Right
         || keyval == GDK_KEY_Down || keyval == GDK_KEY_Up;
}
 
static inline int
z_gtk_keyval_is_shift (const guint keyval)
{
  return keyval == GDK_KEY_Shift_L || keyval == GDK_KEY_Shift_R;
}
 
static inline int
z_gtk_keyval_is_menu (const guint keyval)
{
  return keyval == GDK_KEY_Menu;
}
 
GtkWidget *
z_gtk_widget_get_nth_child (GtkWidget * widget, int index);
 
void
z_gtk_button_set_emblem (GtkButton * btn, const char * emblem_icon);
 
void
z_gtk_setup_foldable_notebook (GtkNotebook * notebook);
 
void
z_gtk_widget_set_margin (GtkWidget * widget, int margin);
 
GtkFlowBoxChild *
z_gtk_flow_box_get_selected_child (GtkFlowBox * self);
 
bool
z_gtk_activate_dir_link_func (GtkLabel * label, char * uri, void * data);
 
GtkSourceLanguageManager *
z_gtk_source_language_manager_get (void);
 
void
z_gtk_notebook_make_detachable (
  GtkNotebook * notebook,
  GtkWindow *   parent_window);
 
char *
z_gtk_text_buffer_get_full_text (GtkTextBuffer * buffer);
 
void
z_gtk_generate_screenshot_image (
  GtkWidget *  widget,
  const char * type,
  char **      option_keys,
  char **      option_values,
  char **      ret_dir,
  char **      ret_path,
  bool         accept_fallback);
 
void
z_gtk_actionable_set_action_from_setting (
  GtkActionable * actionable,
  GSettings *     settings,
  const char *    key);
 
bool
z_gtk_is_event_button (GdkEvent * ev);
 
void
z_gtk_scrolled_window_get_visible_rect (
  GtkScrolledWindow * scroll,
  graphene_rect_t *   rect);
 
void
z_gtk_graphene_rect_t_to_gdk_rectangle (
  GdkRectangle *    rect,
  graphene_rect_t * grect);
 
void
z_gdk_rectangle_to_graphene_rect_t (graphene_rect_t * grect, GdkRectangle * rect);
 
void
z_gdk_rectangle_print (const GdkRectangle * rect);
 
int
z_gtk_dialog_run (GtkDialog * dialog, bool destroy_on_close);
 
void
z_gtk_show_context_menu_from_g_menu (
  GtkPopoverMenu * popover_menu,
  double           x,
  double           y,
  GMenu *          menu);
 
GdkDragAction
z_gtk_drop_target_get_selected_action (GtkDropTarget * drop_target);
 
GtkIconTheme *
z_gtk_icon_theme_get_default (void);
 
char *
z_gdk_clipboard_get_text (GdkClipboard * clipboard);
 
#ifdef HAVE_X11
Window
z_gtk_window_get_x11_xid (GtkWindow * window);
#endif
 
#ifdef _WOE32
HWND
z_gtk_window_get_windows_hwnd (GtkWindow * window);
#endif
 
#ifdef __APPLE__
void *
z_gtk_window_get_nsview (GtkWindow * window);
#endif
 
GdkPixbuf *
z_gdk_pixbuf_new_from_icon_name (
  const char * icon_name,
  int          width,
  int          height,
  int          scale,
  GError **    error);
 
GdkTexture *
z_gdk_texture_new_from_icon_name (
  const char * icon_name,
  int          width,
  int          height,
  int          scale);
 
void
z_gtk_print_graphene_rect (graphene_rect_t * rect);
 
void
z_gtk_widget_print_hierarchy (GtkWidget * widget);
 
const char *
z_gtk_get_gsk_renderer_type (void);
 
gboolean
z_gtk_simple_action_shortcut_func (
  GtkWidget * widget,
  GVariant *  args,
  gpointer    user_data);
 
GtkWidget *
z_gtk_widget_find_child_of_type (GtkWidget * widget, GType type);
 
void
z_gtk_list_box_remove_all_children (GtkListBox * list_box);
 
void
z_graphene_rect_print (const graphene_rect_t * rect);
 
GtkStringList *
z_gtk_string_list_new_from_cyaml_strvals (
  const cyaml_strval_t * strvals,
  size_t                 num_vals,
  bool                   localized);
 
GtkWidget *
z_gtk_get_first_focusable_child (GtkWidget * parent);
 
bool
z_gtk_descendant_has_focus (GtkWidget * parent);
 
void
z_gtk_window_make_escapable (GtkWindow * self);
 
void
z_gtk_drop_down_list_item_header_setup_common (
  GtkSignalListItemFactory * factory,
  GObject *                  list_item,
  gpointer                   user_data);
 
void
z_gtk_drop_down_factory_setup_common (
  GtkSignalListItemFactory * factory,
  GObject *                  list_item,
  gpointer                   user_data);
 
void
z_gtk_drop_down_factory_setup_common_ellipsized (
  GtkSignalListItemFactory * factory,
  GObject *                  list_item,
  gpointer                   user_data);
 
#endif