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 <vector>
 
#include "gui/backend/gtk_widgets/gtk_wrapper.h"
 
class Color;

 
#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"), nullptr, 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) \
  { .red = static_cast<float> (r), \
    .green = static_cast<float> (g), \
    .blue = static_cast<float> (b), \
    .alpha = static_cast<float> (a) }
 
#define Z_GDK_RECTANGLE_INIT(_x, _y, _w, _h) \
  { .x = _x, .y = _y, .width = _w, .height = _h }
 
#define Z_GDK_RECTANGLE_INIT_UNIT(_x, _y) \
  { .x = _x, .y = _y, .width = 1, .height = 1 }
 
#define Z_GRAPHENE_RECT_INIT(_x, _y, _w, _h) \
  { \
    .origin = { .x = (_x), .y = (_y) }, .size = { \
      .width = (_w), \
      .height = (_h) \
    } \
  }
 
#define Z_GRAPHENE_POINT_INIT(_x, _y) \
  { .x = static_cast<float> (_x), .y = static_cast<float> (_y) }
 
#define Z_GRAPHENE_SIZE_INIT(_w, _h) \
  { .width = static_cast<float> (_w), .height = static_cast<float> (_h) }

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_columns (GtkColumnView * column_view);
 
GListStore *
z_gtk_column_view_get_list_store (GtkColumnView * column_view);

void
z_gtk_list_store_splice (GListStore * store, auto &items)
{
  static_assert (
    std::is_pointer_v<typename std::decay_t<decltype (items)>::value_type>,
    "items must be a vector of pointers");
  std::vector<gpointer> additions (items.begin (), items.end ());
  g_list_store_splice (
    store, 0, g_list_model_get_n_items (G_LIST_MODEL (store)),
    additions.data (), additions.size ());
}
 
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, nullptr);
}
 
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, nullptr);
}

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),
    nullptr, nullptr, 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);
 
#if 0
GtkSourceLanguageManager *
z_gtk_source_language_manager_get (void);
#endif

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);
 
#if HAVE_X11
Window
z_gtk_window_get_x11_xid (GtkWindow * window);
#endif
 
#ifdef _WIN32
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_string_array (
  const char ** 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);
 
const char *
z_gtk_get_enum_nick (GType type, gint value);
 
void
z_gtk_snapshot_append_color (
  GtkSnapshot *           snapshot,
  Color                   color,
  const graphene_rect_t * rect);

#endif