summaryrefslogtreecommitdiffstats
path: root/subprojects/libhandy/src/hdy-stackable-box-private.h
blob: d72c75a79337e87942522a1b83bd564c844a8d48 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
/*
 * Copyright (C) 2018 Purism SPC
 *
 * SPDX-License-Identifier: LGPL-2.1+
 */

#pragma once

#if !defined(_HANDY_INSIDE) && !defined(HANDY_COMPILATION)
#error "Only <handy.h> can be included directly."
#endif

#include <gtk/gtk.h>
#include "hdy-navigation-direction.h"
#include "hdy-swipe-tracker.h"

G_BEGIN_DECLS

#define HDY_TYPE_STACKABLE_BOX (hdy_stackable_box_get_type())

G_DECLARE_FINAL_TYPE (HdyStackableBox, hdy_stackable_box, HDY, STACKABLE_BOX, GObject)

typedef enum {
  HDY_STACKABLE_BOX_TRANSITION_TYPE_OVER,
  HDY_STACKABLE_BOX_TRANSITION_TYPE_UNDER,
  HDY_STACKABLE_BOX_TRANSITION_TYPE_SLIDE,
} HdyStackableBoxTransitionType;

HdyStackableBox *hdy_stackable_box_new (GtkContainer      *container,
                                        GtkContainerClass *klass,
                                        gboolean           can_unfold);
gboolean         hdy_stackable_box_get_folded (HdyStackableBox *self);
GtkWidget       *hdy_stackable_box_get_visible_child (HdyStackableBox *self);
void             hdy_stackable_box_set_visible_child (HdyStackableBox *self,
                                                      GtkWidget       *visible_child);
const gchar     *hdy_stackable_box_get_visible_child_name (HdyStackableBox *self);
void             hdy_stackable_box_set_visible_child_name (HdyStackableBox *self,
                                                           const gchar     *name);
gboolean         hdy_stackable_box_get_homogeneous (HdyStackableBox *self,
                                                    gboolean         folded,
                                                    GtkOrientation   orientation);
void             hdy_stackable_box_set_homogeneous (HdyStackableBox *self,
                                                    gboolean         folded,
                                                    GtkOrientation   orientation,
                                                    gboolean         homogeneous);
HdyStackableBoxTransitionType hdy_stackable_box_get_transition_type (HdyStackableBox *self);
void             hdy_stackable_box_set_transition_type (HdyStackableBox               *self,
                                                        HdyStackableBoxTransitionType  transition);

guint            hdy_stackable_box_get_mode_transition_duration (HdyStackableBox *self);
void             hdy_stackable_box_set_mode_transition_duration (HdyStackableBox *self,
                                                                 guint            duration);

guint            hdy_stackable_box_get_child_transition_duration (HdyStackableBox *self);
void             hdy_stackable_box_set_child_transition_duration (HdyStackableBox *self,
                                                                  guint            duration);
gboolean         hdy_stackable_box_get_child_transition_running (HdyStackableBox *self);
gboolean         hdy_stackable_box_get_interpolate_size (HdyStackableBox *self);
void             hdy_stackable_box_set_interpolate_size (HdyStackableBox *self,
                                                         gboolean         interpolate_size);
gboolean         hdy_stackable_box_get_can_swipe_back (HdyStackableBox *self);
void             hdy_stackable_box_set_can_swipe_back (HdyStackableBox *self,
                                                       gboolean         can_swipe_back);
gboolean         hdy_stackable_box_get_can_swipe_forward (HdyStackableBox *self);
void             hdy_stackable_box_set_can_swipe_forward (HdyStackableBox *self,
                                                          gboolean         can_swipe_forward);

GtkWidget       *hdy_stackable_box_get_adjacent_child (HdyStackableBox        *self,
                                                       HdyNavigationDirection  direction);
gboolean         hdy_stackable_box_navigate (HdyStackableBox        *self,
                                             HdyNavigationDirection  direction);

GtkWidget       *hdy_stackable_box_get_child_by_name (HdyStackableBox *self,
                                                      const gchar     *name);

GtkOrientation   hdy_stackable_box_get_orientation (HdyStackableBox *self);
void             hdy_stackable_box_set_orientation (HdyStackableBox *self,
                                                    GtkOrientation   orientation);

const gchar     *hdy_stackable_box_get_child_name (HdyStackableBox *self,
                                                   GtkWidget       *widget);
void             hdy_stackable_box_set_child_name (HdyStackableBox *self,
                                                   GtkWidget       *widget,
                                                   const gchar     *name);
gboolean         hdy_stackable_box_get_child_navigatable (HdyStackableBox *self,
                                                          GtkWidget       *widget);
void             hdy_stackable_box_set_child_navigatable (HdyStackableBox *self,
                                                          GtkWidget       *widget,
                                                          gboolean         navigatable);

void             hdy_stackable_box_switch_child (HdyStackableBox *self,
                                                 guint            index,
                                                 gint64           duration);

HdySwipeTracker *hdy_stackable_box_get_swipe_tracker (HdyStackableBox *self);
gdouble          hdy_stackable_box_get_distance (HdyStackableBox *self);
gdouble         *hdy_stackable_box_get_snap_points (HdyStackableBox *self,
                                                    gint            *n_snap_points);
gdouble          hdy_stackable_box_get_progress (HdyStackableBox *self);
gdouble          hdy_stackable_box_get_cancel_progress (HdyStackableBox *self);
void             hdy_stackable_box_get_swipe_area (HdyStackableBox        *self,
                                                   HdyNavigationDirection  navigation_direction,
                                                   gboolean                is_drag,
                                                   GdkRectangle           *rect);

void             hdy_stackable_box_add (HdyStackableBox *self,
                                        GtkWidget       *widget);
void             hdy_stackable_box_remove (HdyStackableBox *self,
                                           GtkWidget       *widget);
void             hdy_stackable_box_forall (HdyStackableBox *self,
                                           gboolean         include_internals,
                                           GtkCallback      callback,
                                           gpointer         callback_data);

void             hdy_stackable_box_measure (HdyStackableBox *self,
                                            GtkOrientation   orientation,
                                            int              for_size,
                                            int             *minimum,
                                            int             *natural,
                                            int             *minimum_baseline,
                                            int             *natural_baseline);
void             hdy_stackable_box_size_allocate (HdyStackableBox *self,
                                                  GtkAllocation   *allocation);
gboolean         hdy_stackable_box_draw (HdyStackableBox *self,
                                         cairo_t         *cr);
void             hdy_stackable_box_realize (HdyStackableBox *self);
void             hdy_stackable_box_unrealize (HdyStackableBox *self);
void             hdy_stackable_box_map (HdyStackableBox *self);
void             hdy_stackable_box_unmap (HdyStackableBox *self);
void             hdy_stackable_box_direction_changed (HdyStackableBox  *self,
                                                      GtkTextDirection  previous_direction);

G_END_DECLS