ctkpathbar.c

Bug Summary

File:	ctk/ctkpathbar.c
Warning:	line 1103, column 28 Access to field 'data' results in a dereference of a null pointer (loaded from variable 'up_button')
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name ctkpathbar.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=all -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/rootdir/ctk -fcoverage-compilation-dir=/rootdir/ctk -resource-dir /usr/lib/llvm-19/lib/clang/19 -D HAVE_CONFIG_H -I . -I .. -D G_LOG_DOMAIN="Ctk" -D G_LOG_USE_STRUCTURED=1 -D CTK_VERSION="3.25.5" -D CTK_BINARY_VERSION="3.0.0" -D CTK_COMPILATION -D CTK_PRINT_BACKEND_ENABLE_UNSUPPORTED -D CTK_LIBDIR="/usr/lib" -D CTK_LOCALEDIR="/usr/share/locale" -D CTK_DATADIR="/usr/share" -D CTK_DATA_PREFIX="/usr" -D CTK_SYSCONFDIR="/usr/etc" -D CTK_HOST="x86_64-pc-linux-gnu" -D CTK_PRINT_BACKENDS="file,cups" -D X11_DATA_PREFIX="/usr" -D ISO_CODES_PREFIX="" -I .. -I ../ctk -I .. -I ../cdk -I /usr/include/glib-2.0 -I /usr/lib/x86_64-linux-gnu/glib-2.0/include -I /usr/include/sysprof-6 -D G_ENABLE_DEBUG -D G_ENABLE_CONSISTENCY_CHECKS -D GLIB_MIN_REQUIRED_VERSION=GLIB_VERSION_2_66 -D GLIB_MAX_ALLOWED_VERSION=GLIB_VERSION_2_66 -I /usr/include/pango-1.0 -I /usr/include/glib-2.0 -I /usr/lib/x86_64-linux-gnu/glib-2.0/include -I /usr/include/sysprof-6 -I /usr/include/harfbuzz -I /usr/include/freetype2 -I /usr/include/libpng16 -I /usr/include/libmount -I /usr/include/blkid -I /usr/include/fribidi -I /usr/include/cairo -I /usr/include/pixman-1 -I /usr/include/atk-1.0 -I /usr/include/gdk-pixbuf-2.0 -I /usr/include/x86_64-linux-gnu -I /usr/include/webp -I /usr/include/at-spi2-atk/2.0 -I /usr/include/at-spi-2.0 -I /usr/include/dbus-1.0 -I /usr/lib/x86_64-linux-gnu/dbus-1.0/include -I /usr/include/gio-unix-2.0 -I /usr/include/harfbuzz -I /usr/include/freetype2 -I /usr/include/libpng16 -I /usr/include/glib-2.0 -I /usr/lib/x86_64-linux-gnu/glib-2.0/include -I /usr/include/sysprof-6 -I /usr/include/pango-1.0 -I /usr/include/libmount -I /usr/include/blkid -I /usr/include/fribidi -I /usr/include/cairo -I /usr/include/pixman-1 -D PIC -internal-isystem /usr/lib/llvm-19/lib/clang/19/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -ferror-limit 19 -fvisibility=hidden -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -analyzer-checker deadcode.DeadStores -analyzer-checker alpha.deadcode.UnreachableCode -analyzer-checker alpha.core.CastSize -analyzer-checker alpha.core.CastToStruct -analyzer-checker alpha.core.IdenticalExpr -analyzer-checker alpha.security.ArrayBoundV2 -analyzer-checker alpha.security.MallocOverflow -analyzer-checker alpha.security.ReturnPtrRange -analyzer-checker alpha.unix.SimpleStream -analyzer-checker alpha.unix.cstring.BufferOverlap -analyzer-checker alpha.unix.cstring.NotNullTerminated -analyzer-checker alpha.unix.cstring.OutOfBounds -analyzer-checker alpha.core.FixedAddr -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /rootdir/html-report/2024-12-19-111339-43635-1 -x c ctkpathbar.c
1/* -*- Mode: C; c-file-style: "gnu"; tab-width: 8 -*- */
2/* ctkpathbar.c
* Copyright (C) 2004  Red Hat, Inc.,  Jonathan Blandford <jrb@gnome.org>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/

19#include "config.h"

21#include "ctkpathbar.h"

23#include <string.h>

25#include "ctkbox.h"
26#include "ctkcssnodeprivate.h"
27#include "ctkdnd.h"
28#include "ctkdragsource.h"
29#include "ctkicontheme.h"
30#include "ctkimage.h"
31#include "ctkintl.h"
32#include "ctklabel.h"
33#include "ctkmain.h"
34#include "ctkmarshalers.h"
35#include "ctksettings.h"
36#include "ctktogglebutton.h"
37#include "ctkwidgetpath.h"
38#include "ctkwidgetprivate.h"

40struct _CtkPathBarPrivate
41{
CtkFileSystem *file_system;
GFile *root_file;
GFile *home_file;
GFile *desktop_file;

/* List of running GCancellable.  When we cancel one, we remove it from this list.
 * The pathbar cancels all outstanding cancellables when it is disposed.
 *
 * In code that queues async I/O operations:
 *
 *   - Obtain a cancellable from the async I/O APIs, and call add_cancellable().
 *
 * To cancel a cancellable:
 *
 *   - Call cancel_cancellable().
 *
 * In async I/O callbacks:
 *
 *   - Check right away if g_cancellable_is_cancelled():  if true, just
 *     g_object_unref() the cancellable and return early (also free your
 *     closure data if you have one).
 *
 *   - If it was not cancelled, call cancellable_async_done().  This will
 *     unref the cancellable and unqueue it from the pathbar's outstanding
 *     cancellables.  Do your normal work to process the async result and free
 *     your closure data if you have one.
 */
GList *cancellables;

GCancellable *get_info_cancellable;

GIcon *root_icon;
GIcon *home_icon;
GIcon *desktop_icon;

CdkWindow *event_window;

GList *button_list;
GList *first_scrolled_button;
GList *fake_root;
CtkWidget *up_slider_button;
CtkWidget *down_slider_button;
guint settings_signal_id;
gint16 slider_width;
gint16 button_offset;
guint timer;
guint slider_visible : 1;
guint need_timer     : 1;
guint ignore_click   : 1;
guint scrolling_up   : 1;
guint scrolling_down : 1;
93};

95enum {
PATH_CLICKED,
LAST_SIGNAL
98};

100typedef enum {
NORMAL_BUTTON,
ROOT_BUTTON,
HOME_BUTTON,
DESKTOP_BUTTON
105} ButtonType;

107#define BUTTON_DATA(x)((ButtonData *)(x)) ((ButtonData *)(x))

109#define SCROLL_DELAY_FACTOR5 5
110#define TIMEOUT_INITIAL500     500
111#define TIMEOUT_REPEAT50      50

113static guint path_bar_signals [LAST_SIGNAL] = { 0 };

115/* Icon size for if we can't get it from the theme */
116#define FALLBACK_ICON_SIZE16 16

118typedef struct _ButtonData ButtonData;

120struct _ButtonData
121{
CtkWidget *button;
ButtonType type;
char *dir_name;
GFile *file;
CtkWidget *image;
CtkWidget *label;
GCancellable *cancellable;
guint ignore_changes : 1;
guint file_is_hidden : 1;
131};
132/* This macro is used to check if a button can be used as a fake root.
* All buttons in front of a fake root are automatically hidden when in a
* directory below a fake root and replaced with the "<" arrow button.
*/
136#define BUTTON_IS_FAKE_ROOT(button)((button)->type == HOME_BUTTON) ((button)->type == HOME_BUTTON)

138G_DEFINE_TYPE_WITH_PRIVATE (CtkPathBar, ctk_path_bar, CTK_TYPE_CONTAINER)static void ctk_path_bar_init (CtkPathBar *self); static void
 ctk_path_bar_class_init (CtkPathBarClass *klass); static GType
 ctk_path_bar_get_type_once (void); static gpointer ctk_path_bar_parent_class
 = ((void*)0); static gint CtkPathBar_private_offset; static void
 ctk_path_bar_class_intern_init (gpointer klass) { ctk_path_bar_parent_class
 = g_type_class_peek_parent (klass); if (CtkPathBar_private_offset
 != 0) g_type_class_adjust_private_offset (klass, &CtkPathBar_private_offset
); ctk_path_bar_class_init ((CtkPathBarClass*) klass); } __attribute__
 ((__unused__)) static inline gpointer ctk_path_bar_get_instance_private
 (CtkPathBar *self) { return (((gpointer) ((guint8*) (self) +
 (glong) (CtkPathBar_private_offset)))); } GType ctk_path_bar_get_type
 (void) { static GType static_g_define_type_id = 0; if ((__extension__
 ({ _Static_assert (sizeof *(&static_g_define_type_id) ==
 sizeof (gpointer), "Expression evaluates to false"); (void) (
? (gpointer) * (&static_g_define_type_id) : ((void*)0))
; (!(__extension__ ({ _Static_assert (sizeof *(&static_g_define_type_id
) == sizeof (gpointer), "Expression evaluates to false"); __typeof__
 (*(&static_g_define_type_id)) gapg_temp_newval; __typeof__
 ((&static_g_define_type_id)) gapg_temp_atomic = (&static_g_define_type_id
); __atomic_load (gapg_temp_atomic, &gapg_temp_newval, 5)
; gapg_temp_newval; })) && g_once_init_enter_pointer (
&static_g_define_type_id)); })) ) { GType g_define_type_id
 = ctk_path_bar_get_type_once (); (__extension__ ({ _Static_assert
 (sizeof *(&static_g_define_type_id) == sizeof (gpointer)
, "Expression evaluates to false"); 0 ? (void) (*(&static_g_define_type_id
) = (g_define_type_id)) : (void) 0; g_once_init_leave_pointer
 ((&static_g_define_type_id), (gpointer) (guintptr) (g_define_type_id
)); })) ; } return static_g_define_type_id; } __attribute__ (
(__noinline__)) static GType ctk_path_bar_get_type_once (void
) { GType g_define_type_id = g_type_register_static_simple ((
ctk_container_get_type ()), g_intern_static_string ("CtkPathBar"
), sizeof (CtkPathBarClass), (GClassInitFunc)(void (*)(void))
 ctk_path_bar_class_intern_init, sizeof (CtkPathBar), (GInstanceInitFunc
)(void (*)(void)) ctk_path_bar_init, (GTypeFlags) 0); { {{ CtkPathBar_private_offset
 = g_type_add_instance_private (g_define_type_id, sizeof (CtkPathBarPrivate
)); };} } return g_define_type_id; }

140static void ctk_path_bar_finalize                 (GObject          *object);
141static void ctk_path_bar_dispose                  (GObject          *object);
142static void ctk_path_bar_realize                  (CtkWidget        *widget);
143static void ctk_path_bar_unrealize                (CtkWidget        *widget);
144static void ctk_path_bar_get_preferred_width      (CtkWidget        *widget,
                                                 gint             *minimum,
                                                 gint             *natural);
147static void ctk_path_bar_get_preferred_height     (CtkWidget        *widget,
                                                 gint             *minimum,
                                                 gint             *natural);
150static void ctk_path_bar_map                      (CtkWidget        *widget);
151static void ctk_path_bar_unmap                    (CtkWidget        *widget);
152static void ctk_path_bar_size_allocate            (CtkWidget        *widget,
				   CtkAllocation    *allocation);
154static void ctk_path_bar_add                      (CtkContainer     *container,
				   CtkWidget        *widget);
156static void ctk_path_bar_remove                   (CtkContainer     *container,
				   CtkWidget        *widget);
158static void ctk_path_bar_forall                   (CtkContainer     *container,
				   gboolean          include_internals,
				   CtkCallback       callback,
				   gpointer          callback_data);
162static gboolean ctk_path_bar_scroll               (CtkWidget        *widget,
				   CdkEventScroll   *event);
164static void ctk_path_bar_scroll_up                (CtkPathBar       *path_bar);
165static void ctk_path_bar_scroll_down              (CtkPathBar       *path_bar);
166static void ctk_path_bar_stop_scrolling           (CtkPathBar       *path_bar);
167static gboolean ctk_path_bar_slider_up_defocus    (CtkWidget        *widget,
				   CdkEventButton   *event,
				   CtkPathBar       *path_bar);
170static gboolean ctk_path_bar_slider_down_defocus  (CtkWidget        *widget,
				   CdkEventButton   *event,
				   CtkPathBar       *path_bar);
173static gboolean ctk_path_bar_slider_button_press  (CtkWidget        *widget,
				   CdkEventButton   *event,
				   CtkPathBar       *path_bar);
176static gboolean ctk_path_bar_slider_button_release(CtkWidget        *widget,
				   CdkEventButton   *event,
				   CtkPathBar       *path_bar);
179static void ctk_path_bar_grab_notify              (CtkWidget        *widget,
				   gboolean          was_grabbed);
181static void ctk_path_bar_state_changed            (CtkWidget        *widget,
				   CtkStateType      previous_state);
183static void ctk_path_bar_style_updated            (CtkWidget        *widget);
184static void ctk_path_bar_screen_changed           (CtkWidget        *widget,
				   CdkScreen        *previous_screen);
186static void ctk_path_bar_check_icon_theme         (CtkPathBar       *path_bar);
187static void ctk_path_bar_update_button_appearance (CtkPathBar       *path_bar,
				   ButtonData       *button_data,
				   gboolean          current_dir);

191static void
192add_cancellable (CtkPathBar   *path_bar,
 GCancellable *cancellable)
194{
g_assert (g_list_find (path_bar->priv->cancellables, cancellable) == NULL)do { if (g_list_find (path_bar->priv->cancellables, cancellable
) == ((void*)0)) ; else g_assertion_message_expr ("Ctk", "ctkpathbar.c"
, 195, ((const char*) (__func__)), "g_list_find (path_bar->priv->cancellables, cancellable) == NULL"
); } while (0);
path_bar->priv->cancellables = g_list_prepend (path_bar->priv->cancellables, cancellable);
197}

199static void
200drop_node_for_cancellable (CtkPathBar *path_bar,
	   GCancellable *cancellable)
202{
GList *node;

node = g_list_find (path_bar->priv->cancellables, cancellable);
g_assert (node != NULL)do { if (node != ((void*)0)) ; else g_assertion_message_expr (
"Ctk", "ctkpathbar.c", 206, ((const char*) (__func__)), "node != NULL"
); } while (0);
node->data = NULL((void*)0);
path_bar->priv->cancellables = g_list_delete_link (path_bar->priv->cancellables, node);
209}

211static void
212cancel_cancellable (CtkPathBar   *path_bar,
    GCancellable *cancellable)
214{
drop_node_for_cancellable (path_bar, cancellable);
g_cancellable_cancel (cancellable);
217}

219static void
220cancellable_async_done (CtkPathBar   *path_bar,
	GCancellable *cancellable)
222{
drop_node_for_cancellable (path_bar, cancellable);
g_object_unref (cancellable);
225}

227static void
228cancel_all_cancellables (CtkPathBar *path_bar)
229{
while (path_bar->priv->cancellables)
  {
    GCancellable *cancellable = path_bar->priv->cancellables->data;
    cancel_cancellable (path_bar, cancellable);
  }
235}

237static void
238on_slider_unmap (CtkWidget  *widget,
 CtkPathBar *path_bar)
240{
if (path_bar->priv->timer &&
    ((widget == path_bar->priv->up_slider_button && path_bar->priv->scrolling_up) ||
     (widget == path_bar->priv->down_slider_button && path_bar->priv->scrolling_down)))
  ctk_path_bar_stop_scrolling (path_bar);
245}

247static void
248ctk_path_bar_init (CtkPathBar *path_bar)
249{
CtkStyleContext *context;

path_bar->priv = ctk_path_bar_get_instance_private (path_bar);

ctk_widget_init_template (CTK_WIDGET (path_bar)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((path_bar)), ((ctk_widget_get_type ())))))));

/* Add the children manually because CtkPathBar derives from an abstract class,
 * Glade cannot edit a <template> in ctkpathbar.ui if it's only a CtkContainer.
 */
ctk_container_add (CTK_CONTAINER (path_bar)((((CtkContainer*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((path_bar)), ((ctk_container_get_type ())))))), path_bar->priv->up_slider_button);
ctk_container_add (CTK_CONTAINER (path_bar)((((CtkContainer*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((path_bar)), ((ctk_container_get_type ())))))), path_bar->priv->down_slider_button);

/* CtkBuilder wont let us connect 'swapped' without specifying the signal's
 * user data in the .ui file
 */
g_signal_connect_swapped (path_bar->priv->up_slider_button, "clicked",g_signal_connect_data ((path_bar->priv->up_slider_button
), ("clicked"), (((GCallback) (ctk_path_bar_scroll_up))), (path_bar
), ((void*)0), G_CONNECT_SWAPPED)
	    G_CALLBACK (ctk_path_bar_scroll_up), path_bar)g_signal_connect_data ((path_bar->priv->up_slider_button
), ("clicked"), (((GCallback) (ctk_path_bar_scroll_up))), (path_bar
), ((void*)0), G_CONNECT_SWAPPED);
g_signal_connect_swapped (path_bar->priv->down_slider_button, "clicked",g_signal_connect_data ((path_bar->priv->down_slider_button
), ("clicked"), (((GCallback) (ctk_path_bar_scroll_down))), (
path_bar), ((void*)0), G_CONNECT_SWAPPED)
	    G_CALLBACK (ctk_path_bar_scroll_down), path_bar)g_signal_connect_data ((path_bar->priv->down_slider_button
), ("clicked"), (((GCallback) (ctk_path_bar_scroll_down))), (
path_bar), ((void*)0), G_CONNECT_SWAPPED);

ctk_widget_set_has_window (CTK_WIDGET (path_bar)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((path_bar)), ((ctk_widget_get_type ())))))), FALSE(0));

context = ctk_widget_get_style_context (CTK_WIDGET (path_bar)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((path_bar)), ((ctk_widget_get_type ())))))));
ctk_style_context_add_class (context, "path-bar");
ctk_style_context_add_class (context, CTK_STYLE_CLASS_LINKED"linked");

path_bar->priv->get_info_cancellable = NULL((void*)0);
path_bar->priv->cancellables = NULL((void*)0);
278}

280static void
281ctk_path_bar_class_init (CtkPathBarClass *path_bar_class)
282{
GObjectClass *gobject_class;
CtkWidgetClass *widget_class;
CtkContainerClass *container_class;

gobject_class = (GObjectClass *) path_bar_class;
widget_class = (CtkWidgetClass *) path_bar_class;
container_class = (CtkContainerClass *) path_bar_class;

gobject_class->finalize = ctk_path_bar_finalize;
gobject_class->dispose = ctk_path_bar_dispose;

widget_class->get_preferred_width = ctk_path_bar_get_preferred_width;
widget_class->get_preferred_height = ctk_path_bar_get_preferred_height;
widget_class->realize = ctk_path_bar_realize;
widget_class->unrealize = ctk_path_bar_unrealize;
widget_class->map = ctk_path_bar_map;
widget_class->unmap = ctk_path_bar_unmap;
widget_class->size_allocate = ctk_path_bar_size_allocate;
widget_class->style_updated = ctk_path_bar_style_updated;
widget_class->screen_changed = ctk_path_bar_screen_changed;
widget_class->grab_notify = ctk_path_bar_grab_notify;
widget_class->state_changed = ctk_path_bar_state_changed;
widget_class->scroll_event = ctk_path_bar_scroll;

container_class->add = ctk_path_bar_add;
container_class->forall = ctk_path_bar_forall;
container_class->remove = ctk_path_bar_remove;
ctk_container_class_handle_border_width (container_class);
/* FIXME: */
/*  container_class->child_type = ctk_path_bar_child_type;*/

path_bar_signals [PATH_CLICKED] =
  g_signal_new (I_("path-clicked")g_intern_static_string ("path-clicked"),
  G_OBJECT_CLASS_TYPE (gobject_class)((((GTypeClass*) (gobject_class))->g_type)),
  G_SIGNAL_RUN_FIRST,
  G_STRUCT_OFFSET (CtkPathBarClass, path_clicked)((glong) __builtin_offsetof(CtkPathBarClass, path_clicked)),
  NULL((void*)0), NULL((void*)0),
  _ctk_marshal_VOID__POINTER_POINTER_BOOLEAN,
  G_TYPE_NONE((GType) ((1) << (2))), 3,
  G_TYPE_POINTER((GType) ((17) << (2))),
  G_TYPE_POINTER((GType) ((17) << (2))),
  G_TYPE_BOOLEAN((GType) ((5) << (2))));

/* Bind class to template
 */
ctk_widget_class_set_template_from_resource (widget_class,
			       "/org/ctk/libctk/ui/ctkpathbar.ui");

ctk_widget_class_bind_template_child_private (widget_class, CtkPathBar, up_slider_button)ctk_widget_class_bind_template_child_full (widget_class, "up_slider_button"
, (0), (CtkPathBar_private_offset + (((glong) __builtin_offsetof
(CtkPathBarPrivate, up_slider_button)))));
ctk_widget_class_bind_template_child_private (widget_class, CtkPathBar, down_slider_button)ctk_widget_class_bind_template_child_full (widget_class, "down_slider_button"
, (0), (CtkPathBar_private_offset + (((glong) __builtin_offsetof
(CtkPathBarPrivate, down_slider_button)))));

ctk_widget_class_bind_template_callback (widget_class, ctk_path_bar_slider_button_press)ctk_widget_class_bind_template_callback_full (((((CtkWidgetClass
*) (void *) g_type_check_class_cast ((GTypeClass*) ((widget_class
)), ((ctk_widget_get_type ())))))), "ctk_path_bar_slider_button_press"
, ((GCallback) (ctk_path_bar_slider_button_press)));
ctk_widget_class_bind_template_callback (widget_class, ctk_path_bar_slider_button_release)ctk_widget_class_bind_template_callback_full (((((CtkWidgetClass
*) (void *) g_type_check_class_cast ((GTypeClass*) ((widget_class
)), ((ctk_widget_get_type ())))))), "ctk_path_bar_slider_button_release"
, ((GCallback) (ctk_path_bar_slider_button_release)));
ctk_widget_class_bind_template_callback (widget_class, ctk_path_bar_slider_up_defocus)ctk_widget_class_bind_template_callback_full (((((CtkWidgetClass
*) (void *) g_type_check_class_cast ((GTypeClass*) ((widget_class
)), ((ctk_widget_get_type ())))))), "ctk_path_bar_slider_up_defocus"
, ((GCallback) (ctk_path_bar_slider_up_defocus)));
ctk_widget_class_bind_template_callback (widget_class, ctk_path_bar_slider_down_defocus)ctk_widget_class_bind_template_callback_full (((((CtkWidgetClass
*) (void *) g_type_check_class_cast ((GTypeClass*) ((widget_class
)), ((ctk_widget_get_type ())))))), "ctk_path_bar_slider_down_defocus"
, ((GCallback) (ctk_path_bar_slider_down_defocus)));
ctk_widget_class_bind_template_callback (widget_class, ctk_path_bar_scroll_up)ctk_widget_class_bind_template_callback_full (((((CtkWidgetClass
*) (void *) g_type_check_class_cast ((GTypeClass*) ((widget_class
)), ((ctk_widget_get_type ())))))), "ctk_path_bar_scroll_up",
 ((GCallback) (ctk_path_bar_scroll_up)));
ctk_widget_class_bind_template_callback (widget_class, ctk_path_bar_scroll_down)ctk_widget_class_bind_template_callback_full (((((CtkWidgetClass
*) (void *) g_type_check_class_cast ((GTypeClass*) ((widget_class
)), ((ctk_widget_get_type ())))))), "ctk_path_bar_scroll_down"
, ((GCallback) (ctk_path_bar_scroll_down)));
ctk_widget_class_bind_template_callback (widget_class, on_slider_unmap)ctk_widget_class_bind_template_callback_full (((((CtkWidgetClass
*) (void *) g_type_check_class_cast ((GTypeClass*) ((widget_class
)), ((ctk_widget_get_type ())))))), "on_slider_unmap", ((GCallback
) (on_slider_unmap)));
341}


344static void
345ctk_path_bar_finalize (GObject *object)
346{
CtkPathBar *path_bar;

path_bar = CTK_PATH_BAR (object)((((CtkPathBar*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((object)), ((ctk_path_bar_get_type ()))))));

cancel_all_cancellables (path_bar);
ctk_path_bar_stop_scrolling (path_bar);

g_list_free (path_bar->priv->button_list);
g_clear_object (&path_bar->priv->root_file)do { _Static_assert (sizeof *((&path_bar->priv->root_file
)) == sizeof (gpointer), "Expression evaluates to false"); __typeof__
 (((&path_bar->priv->root_file))) _pp = ((&path_bar
->priv->root_file)); __typeof__ (*((&path_bar->priv
->root_file))) _ptr = *_pp; *_pp = ((void*)0); if (_ptr) (
g_object_unref) (_ptr); } while (0);
g_clear_object (&path_bar->priv->home_file)do { _Static_assert (sizeof *((&path_bar->priv->home_file
)) == sizeof (gpointer), "Expression evaluates to false"); __typeof__
 (((&path_bar->priv->home_file))) _pp = ((&path_bar
->priv->home_file)); __typeof__ (*((&path_bar->priv
->home_file))) _ptr = *_pp; *_pp = ((void*)0); if (_ptr) (
g_object_unref) (_ptr); } while (0);
g_clear_object (&path_bar->priv->desktop_file)do { _Static_assert (sizeof *((&path_bar->priv->desktop_file
)) == sizeof (gpointer), "Expression evaluates to false"); __typeof__
 (((&path_bar->priv->desktop_file))) _pp = ((&path_bar
->priv->desktop_file)); __typeof__ (*((&path_bar->
priv->desktop_file))) _ptr = *_pp; *_pp = ((void*)0); if (
_ptr) (g_object_unref) (_ptr); } while (0);

g_clear_object (&path_bar->priv->root_icon)do { _Static_assert (sizeof *((&path_bar->priv->root_icon
)) == sizeof (gpointer), "Expression evaluates to false"); __typeof__
 (((&path_bar->priv->root_icon))) _pp = ((&path_bar
->priv->root_icon)); __typeof__ (*((&path_bar->priv
->root_icon))) _ptr = *_pp; *_pp = ((void*)0); if (_ptr) (
g_object_unref) (_ptr); } while (0);
g_clear_object (&path_bar->priv->home_icon)do { _Static_assert (sizeof *((&path_bar->priv->home_icon
)) == sizeof (gpointer), "Expression evaluates to false"); __typeof__
 (((&path_bar->priv->home_icon))) _pp = ((&path_bar
->priv->home_icon)); __typeof__ (*((&path_bar->priv
->home_icon))) _ptr = *_pp; *_pp = ((void*)0); if (_ptr) (
g_object_unref) (_ptr); } while (0);
g_clear_object (&path_bar->priv->desktop_icon)do { _Static_assert (sizeof *((&path_bar->priv->desktop_icon
)) == sizeof (gpointer), "Expression evaluates to false"); __typeof__
 (((&path_bar->priv->desktop_icon))) _pp = ((&path_bar
->priv->desktop_icon)); __typeof__ (*((&path_bar->
priv->desktop_icon))) _ptr = *_pp; *_pp = ((void*)0); if (
_ptr) (g_object_unref) (_ptr); } while (0);

g_clear_object (&path_bar->priv->file_system)do { _Static_assert (sizeof *((&path_bar->priv->file_system
)) == sizeof (gpointer), "Expression evaluates to false"); __typeof__
 (((&path_bar->priv->file_system))) _pp = ((&path_bar
->priv->file_system)); __typeof__ (*((&path_bar->
priv->file_system))) _ptr = *_pp; *_pp = ((void*)0); if (_ptr
) (g_object_unref) (_ptr); } while (0);

G_OBJECT_CLASS (ctk_path_bar_parent_class)((((GObjectClass*) (void *) g_type_check_class_cast ((GTypeClass
*) ((ctk_path_bar_parent_class)), (((GType) ((20) << (2
))))))))->finalize (object);
366}

368/* Removes the settings signal handler.  It's safe to call multiple times */
369static void
370remove_settings_signal (CtkPathBar *path_bar,
	CdkScreen  *screen)
372{
if (path_bar->priv->settings_signal_id)
  {
    CtkSettings *settings;

    settings = ctk_settings_get_for_screen (screen);
    g_signal_handler_disconnect (settings,
		   path_bar->priv->settings_signal_id);
    path_bar->priv->settings_signal_id = 0;
  }
382}

384static void
385ctk_path_bar_dispose (GObject *object)
386{
CtkPathBar *path_bar = CTK_PATH_BAR (object)((((CtkPathBar*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((object)), ((ctk_path_bar_get_type ()))))));

remove_settings_signal (path_bar, ctk_widget_get_screen (CTK_WIDGET (object)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((object)), ((ctk_widget_get_type ()))))))));

path_bar->priv->get_info_cancellable = NULL((void*)0);
cancel_all_cancellables (path_bar);

G_OBJECT_CLASS (ctk_path_bar_parent_class)((((GObjectClass*) (void *) g_type_check_class_cast ((GTypeClass
*) ((ctk_path_bar_parent_class)), (((GType) ((20) << (2
))))))))->dispose (object);
395}

397/* Size requisition:
* 
* Ideally, our size is determined by another widget, and we are just filling
* available space.
*/
402static void
403ctk_path_bar_get_preferred_width (CtkWidget *widget,
                                gint      *minimum,
                                gint      *natural)
406{
ButtonData *button_data;
CtkPathBar *path_bar;
GList *list;
gint child_height;
gint height;
gint child_min, child_nat;

path_bar = CTK_PATH_BAR (widget)((((CtkPathBar*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((ctk_path_bar_get_type ()))))));

*minimum = *natural = 0;
height = 0;

for (list = path_bar->priv->button_list; list; list = list->next)
  {
    button_data = BUTTON_DATA (list->data)((ButtonData *)(list->data));
    ctk_widget_get_preferred_width (button_data->button, &child_min, &child_nat);
    ctk_widget_get_preferred_height (button_data->button, &child_height, NULL((void*)0));
    height = MAX (height, child_height)(((height) > (child_height)) ? (height) : (child_height));

    if (button_data->type == NORMAL_BUTTON)
      {
        /* Use 2*Height as button width because of ellipsized label.  */
        child_min = MAX (child_min, child_height * 2)(((child_min) > (child_height * 2)) ? (child_min) : (child_height
 * 2));
        child_nat = MAX (child_min, child_height * 2)(((child_min) > (child_height * 2)) ? (child_min) : (child_height
 * 2));
      }

    *minimum = MAX (*minimum, child_min)(((*minimum) > (child_min)) ? (*minimum) : (child_min));
    *natural = *natural + child_nat;
  }

/* Add space for slider, if we have more than one path */
/* Theoretically, the slider could be bigger than the other button.  But we're
 * not going to worry about that now.
 */
path_bar->priv->slider_width = 0;

ctk_widget_get_preferred_width (path_bar->priv->up_slider_button, &child_min, &child_nat);
if (path_bar->priv->button_list && path_bar->priv->button_list->next != NULL((void*)0))
  {
    *minimum += child_min;
    *natural += child_nat;
  }
path_bar->priv->slider_width = MAX (path_bar->priv->slider_width, child_min)(((path_bar->priv->slider_width) > (child_min)) ? (path_bar
->priv->slider_width) : (child_min));

ctk_widget_get_preferred_width (path_bar->priv->down_slider_button, &child_min, &child_nat);
if (path_bar->priv->button_list && path_bar->priv->button_list->next != NULL((void*)0))
  {
    *minimum += child_min;
    *natural += child_nat;
  }
path_bar->priv->slider_width = MAX (path_bar->priv->slider_width, child_min)(((path_bar->priv->slider_width) > (child_min)) ? (path_bar
->priv->slider_width) : (child_min));
458}

460static void
461ctk_path_bar_get_preferred_height (CtkWidget *widget,
                                 gint      *minimum,
                                 gint      *natural)
464{
ButtonData *button_data;
CtkPathBar *path_bar;
GList *list;
gint child_min, child_nat;

path_bar = CTK_PATH_BAR (widget)((((CtkPathBar*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((ctk_path_bar_get_type ()))))));

*minimum = *natural = 0;

for (list = path_bar->priv->button_list; list; list = list->next)
  {
    button_data = BUTTON_DATA (list->data)((ButtonData *)(list->data));
    ctk_widget_get_preferred_height (button_data->button, &child_min, &child_nat);

    *minimum = MAX (*minimum, child_min)(((*minimum) > (child_min)) ? (*minimum) : (child_min));
    *natural = MAX (*natural, child_nat)(((*natural) > (child_nat)) ? (*natural) : (child_nat));
  }

ctk_widget_get_preferred_height (path_bar->priv->up_slider_button, &child_min, &child_nat);
*minimum = MAX (*minimum, child_min)(((*minimum) > (child_min)) ? (*minimum) : (child_min));
*natural = MAX (*natural, child_nat)(((*natural) > (child_nat)) ? (*natural) : (child_nat));

ctk_widget_get_preferred_height (path_bar->priv->down_slider_button, &child_min, &child_nat);
*minimum = MAX (*minimum, child_min)(((*minimum) > (child_min)) ? (*minimum) : (child_min));
*natural = MAX (*natural, child_nat)(((*natural) > (child_nat)) ? (*natural) : (child_nat));
490}

492static void
493ctk_path_bar_update_slider_buttons (CtkPathBar *path_bar)
494{
if (path_bar->priv->button_list)
  {
    CtkWidget *button;

    button = BUTTON_DATA (path_bar->priv->button_list->data)((ButtonData *)(path_bar->priv->button_list->data))->button;
    if (ctk_widget_get_child_visible (button))
{
 ctk_path_bar_stop_scrolling (path_bar);
 ctk_widget_set_sensitive (path_bar->priv->down_slider_button, FALSE(0));
}
    else
ctk_widget_set_sensitive (path_bar->priv->down_slider_button, TRUE(!(0)));

    button = BUTTON_DATA (g_list_last (path_bar->priv->button_list)->data)((ButtonData *)(g_list_last (path_bar->priv->button_list
)->data))->button;
    if (ctk_widget_get_child_visible (button))
{
 ctk_path_bar_stop_scrolling (path_bar);
 ctk_widget_set_sensitive (path_bar->priv->up_slider_button, FALSE(0));
}
    else
ctk_widget_set_sensitive (path_bar->priv->up_slider_button, TRUE(!(0)));
  }
517}

519static void
520ctk_path_bar_map (CtkWidget *widget)
521{
cdk_window_show (CTK_PATH_BAR (widget)((((CtkPathBar*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((ctk_path_bar_get_type ()))))))->priv->event_window);

CTK_WIDGET_CLASS (ctk_path_bar_parent_class)((((CtkWidgetClass*) (void *) g_type_check_class_cast ((GTypeClass
*) ((ctk_path_bar_parent_class)), ((ctk_widget_get_type ())))
)))->map (widget);
525}

527static void
528ctk_path_bar_unmap (CtkWidget *widget)
529{
ctk_path_bar_stop_scrolling (CTK_PATH_BAR (widget)((((CtkPathBar*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((ctk_path_bar_get_type ())))))));
cdk_window_hide (CTK_PATH_BAR (widget)((((CtkPathBar*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((ctk_path_bar_get_type ()))))))->priv->event_window);

CTK_WIDGET_CLASS (ctk_path_bar_parent_class)((((CtkWidgetClass*) (void *) g_type_check_class_cast ((GTypeClass
*) ((ctk_path_bar_parent_class)), ((ctk_widget_get_type ())))
)))->unmap (widget);
534}

536static void
537ctk_path_bar_realize (CtkWidget *widget)
538{
CtkPathBar *path_bar;
CtkAllocation allocation;
CdkWindow *window;
CdkWindowAttr attributes;
gint attributes_mask;

ctk_widget_set_realized (widget, TRUE(!(0)));

path_bar = CTK_PATH_BAR (widget)((((CtkPathBar*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((ctk_path_bar_get_type ()))))));
window = ctk_widget_get_parent_window (widget);
ctk_widget_set_window (widget, window);
g_object_ref (window)((__typeof__ (window)) (g_object_ref) (window));

ctk_widget_get_allocation (widget, &allocation);

attributes.window_type = CDK_WINDOW_CHILD;
attributes.x = allocation.x;
attributes.y = allocation.y;
attributes.width = allocation.width;
attributes.height = allocation.height;
attributes.wclass = CDK_INPUT_ONLY;
attributes.event_mask = ctk_widget_get_events (widget);
attributes.event_mask |= CDK_SCROLL_MASK;
attributes_mask = CDK_WA_X | CDK_WA_Y;

path_bar->priv->event_window = cdk_window_new (ctk_widget_get_parent_window (widget),
                                         &attributes, attributes_mask);
ctk_widget_register_window (widget, path_bar->priv->event_window);
567}

569static void
570ctk_path_bar_unrealize (CtkWidget *widget)
571{
CtkPathBar *path_bar;

path_bar = CTK_PATH_BAR (widget)((((CtkPathBar*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((ctk_path_bar_get_type ()))))));

ctk_widget_unregister_window (widget, path_bar->priv->event_window);
cdk_window_destroy (path_bar->priv->event_window);
path_bar->priv->event_window = NULL((void*)0);

CTK_WIDGET_CLASS (ctk_path_bar_parent_class)((((CtkWidgetClass*) (void *) g_type_check_class_cast ((GTypeClass
*) ((ctk_path_bar_parent_class)), ((ctk_widget_get_type ())))
)))->unrealize (widget);
581}

583/* This is a tad complicated
*/
585static void
586ctk_path_bar_size_allocate (CtkWidget     *widget,
	    CtkAllocation *allocation)
588{
CtkWidget *child;
CtkPathBar *path_bar = CTK_PATH_BAR (widget)((((CtkPathBar*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((ctk_path_bar_get_type ()))))));
CtkTextDirection direction;
CtkAllocation child_allocation;
GList *list, *first_button;
gint width;
gint allocation_width;
gboolean need_sliders = TRUE(!(0));
gint up_slider_offset = 0;
gint down_slider_offset = 0;
CtkRequisition child_requisition;

ctk_widget_set_allocation (widget, allocation);

if (ctk_widget_get_realized (widget))
  cdk_window_move_resize (path_bar->priv->event_window,
	    allocation->x, allocation->y,
	    allocation->width, allocation->height);

/* No path is set; we don't have to allocate anything. */
if (path_bar->priv->button_list == NULL((void*)0))
  {
    _ctk_widget_set_simple_clip (widget, NULL((void*)0));

    return;
  }

direction = ctk_widget_get_direction (widget);
allocation_width = allocation->width;

/* First, we check to see if we need the scrollbars. */
if (path_bar->priv->fake_root)
  width = path_bar->priv->slider_width;
else
  width = 0;

for (list = path_bar->priv->button_list; list; list = list->next)
  {
    child = BUTTON_DATA (list->data)((ButtonData *)(list->data))->button;

    ctk_widget_get_preferred_size (child, &child_requisition, NULL((void*)0));

    width += child_requisition.width;
    if (list == path_bar->priv->fake_root)
break;
  }

if (width <= allocation_width)
  {
    if (path_bar->priv->fake_root)
first_button = path_bar->priv->fake_root;
    else
first_button = g_list_last (path_bar->priv->button_list);
  }
else
  {
    gboolean reached_end = FALSE(0);
    gint slider_space = 2 * path_bar->priv->slider_width;

    if (path_bar->priv->first_scrolled_button)
first_button = path_bar->priv->first_scrolled_button;
    else
first_button = path_bar->priv->button_list;
    need_sliders = TRUE(!(0));

    /* To see how much space we have, and how many buttons we can display.
     * We start at the first button, count forward until hit the new
     * button, then count backwards.
     */
    /* Count down the path chain towards the end. */
    ctk_widget_get_preferred_size (BUTTON_DATA (first_button->data)((ButtonData *)(first_button->data))->button,
                                   &child_requisition, NULL((void*)0));

    width = child_requisition.width;
    list = first_button->prev;
    while (list && !reached_end)
{
 child = BUTTON_DATA (list->data)((ButtonData *)(list->data))->button;

        ctk_widget_get_preferred_size (child, &child_requisition, NULL((void*)0));

 if (width + child_requisition.width + slider_space > allocation_width)
   reached_end = TRUE(!(0));
 else if (list == path_bar->priv->fake_root)
   break;
 else
   width += child_requisition.width;

 list = list->prev;
}

    /* Finally, we walk up, seeing how many of the previous buttons we can
     * add */
    while (first_button->next && !reached_end)
{
 child = BUTTON_DATA (first_button->next->data)((ButtonData *)(first_button->next->data))->button;

        ctk_widget_get_preferred_size (child, &child_requisition, NULL((void*)0));

 if (width + child_requisition.width + slider_space > allocation_width)
   {
     reached_end = TRUE(!(0));
   }
 else
   {
     width += child_requisition.width;
     if (first_button == path_bar->priv->fake_root)
break;
     first_button = first_button->next;
   }
}
  }

/* Now, we allocate space to the buttons */
child_allocation.y = allocation->y;
child_allocation.height = allocation->height;

if (direction == CTK_TEXT_DIR_RTL)
  {
    child_allocation.x = allocation->x + allocation->width;
    if (need_sliders || path_bar->priv->fake_root)
{
 child_allocation.x -= path_bar->priv->slider_width;
 up_slider_offset = allocation->width - path_bar->priv->slider_width;
}
  }
else
  {
    child_allocation.x = allocation->x;
    if (need_sliders || path_bar->priv->fake_root)
{
 up_slider_offset = 0;
 child_allocation.x += path_bar->priv->slider_width;
}
  }

for (list = first_button; list; list = list->prev)
  {
    CtkAllocation widget_allocation;
    ButtonData *button_data;

    button_data = BUTTON_DATA (list->data)((ButtonData *)(list->data));
    child = button_data->button;

    ctk_widget_get_preferred_size (child, &child_requisition, NULL((void*)0));

    child_allocation.width = MIN (child_requisition.width,(((child_requisition.width) < (allocation_width - 2 * path_bar
->priv->slider_width)) ? (child_requisition.width) : (allocation_width
 - 2 * path_bar->priv->slider_width))
		    allocation_width - 2 * path_bar->priv->slider_width)(((child_requisition.width) < (allocation_width - 2 * path_bar
->priv->slider_width)) ? (child_requisition.width) : (allocation_width
 - 2 * path_bar->priv->slider_width));

    if (direction == CTK_TEXT_DIR_RTL)
child_allocation.x -= child_allocation.width;

    /* Check to see if we've don't have any more space to allocate buttons */
    if (need_sliders && direction == CTK_TEXT_DIR_RTL)
{
        ctk_widget_get_allocation (widget, &widget_allocation);
 if (child_allocation.x - path_bar->priv->slider_width < widget_allocation.x)
   break;
}
    else if (need_sliders && direction == CTK_TEXT_DIR_LTR)
{
        ctk_widget_get_allocation (widget, &widget_allocation);
 if (child_allocation.x + child_allocation.width + path_bar->priv->slider_width >
     widget_allocation.x + allocation_width)
   break;
}

    if (child_allocation.width < child_requisition.width)
{
 if (!ctk_widget_get_has_tooltip (child))
   ctk_widget_set_tooltip_text (child, button_data->dir_name);
}
    else if (ctk_widget_get_has_tooltip (child))
ctk_widget_set_tooltip_text (child, NULL((void*)0));
    
    ctk_widget_set_child_visible (child, TRUE(!(0)));
    ctk_widget_size_allocate (child, &child_allocation);

    if (direction == CTK_TEXT_DIR_RTL)
      {
        down_slider_offset = child_allocation.x - allocation->x - path_bar->priv->slider_width;
      }
    else
      {
        down_slider_offset += child_allocation.width;
        child_allocation.x += child_allocation.width;
      }
  }
/* Now we go hide all the widgets that don't fit */
while (list)
  {
    child = BUTTON_DATA (list->data)((ButtonData *)(list->data))->button;
    ctk_widget_set_child_visible (child, FALSE(0));
    list = list->prev;
  }
for (list = first_button->next; list; list = list->next)
  {
    child = BUTTON_DATA (list->data)((ButtonData *)(list->data))->button;
    ctk_widget_set_child_visible (child, FALSE(0));
  }

if (need_sliders || path_bar->priv->fake_root)
  {
    child_allocation.width = path_bar->priv->slider_width;
    child_allocation.x = up_slider_offset + allocation->x;
    ctk_widget_size_allocate (path_bar->priv->up_slider_button, &child_allocation);

    ctk_widget_set_child_visible (path_bar->priv->up_slider_button, TRUE(!(0)));
    ctk_widget_show_all (path_bar->priv->up_slider_button);

    if (direction == CTK_TEXT_DIR_LTR)
      down_slider_offset += path_bar->priv->slider_width;
  }
else
  {
    ctk_widget_set_child_visible (path_bar->priv->up_slider_button, FALSE(0));
  }

if (need_sliders)
  {
    child_allocation.width = path_bar->priv->slider_width;
    child_allocation.x = down_slider_offset + allocation->x;
    
    ctk_widget_size_allocate (path_bar->priv->down_slider_button, &child_allocation);

    ctk_widget_set_child_visible (path_bar->priv->down_slider_button, TRUE(!(0)));
    ctk_widget_show_all (path_bar->priv->down_slider_button);
    ctk_path_bar_update_slider_buttons (path_bar);
  }
else
  {
    ctk_widget_set_child_visible (path_bar->priv->down_slider_button, FALSE(0));
  }

_ctk_widget_set_simple_clip (widget, NULL((void*)0));
824}

826static void
827ctk_path_bar_style_updated (CtkWidget *widget)
828{
CTK_WIDGET_CLASS (ctk_path_bar_parent_class)((((CtkWidgetClass*) (void *) g_type_check_class_cast ((GTypeClass
*) ((ctk_path_bar_parent_class)), ((ctk_widget_get_type ())))
)))->style_updated (widget);

ctk_path_bar_check_icon_theme (CTK_PATH_BAR (widget)((((CtkPathBar*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((ctk_path_bar_get_type ())))))));
832}

834static void
835ctk_path_bar_screen_changed (CtkWidget *widget,
	     CdkScreen *previous_screen)
837{
if (CTK_WIDGET_CLASS (ctk_path_bar_parent_class)((((CtkWidgetClass*) (void *) g_type_check_class_cast ((GTypeClass
*) ((ctk_path_bar_parent_class)), ((ctk_widget_get_type ())))
)))->screen_changed)
  CTK_WIDGET_CLASS (ctk_path_bar_parent_class)((((CtkWidgetClass*) (void *) g_type_check_class_cast ((GTypeClass
*) ((ctk_path_bar_parent_class)), ((ctk_widget_get_type ())))
)))->screen_changed (widget, previous_screen);

/* We might nave a new settings, so we remove the old one */
if (previous_screen)
  remove_settings_signal (CTK_PATH_BAR (widget)((((CtkPathBar*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((ctk_path_bar_get_type ())))))), previous_screen);

ctk_path_bar_check_icon_theme (CTK_PATH_BAR (widget)((((CtkPathBar*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((ctk_path_bar_get_type ())))))));
846}

848static gboolean
849ctk_path_bar_scroll (CtkWidget      *widget,
     CdkEventScroll *event)
851{
switch (event->direction)
  {
  case CDK_SCROLL_RIGHT:
  case CDK_SCROLL_DOWN:
    ctk_path_bar_scroll_down (CTK_PATH_BAR (widget)((((CtkPathBar*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((ctk_path_bar_get_type ())))))));
    break;
  case CDK_SCROLL_LEFT:
  case CDK_SCROLL_UP:
    ctk_path_bar_scroll_up (CTK_PATH_BAR (widget)((((CtkPathBar*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((ctk_path_bar_get_type ())))))));
    break;
  case CDK_SCROLL_SMOOTH:
    break;
  }

return TRUE(!(0));
867}

869static void
870ctk_path_bar_add (CtkContainer *container,
  CtkWidget    *widget)

873{
ctk_widget_set_parent (widget, CTK_WIDGET (container)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((container)), ((ctk_widget_get_type ())))))));
875}

877static void
878ctk_path_bar_remove_1 (CtkContainer *container,
       CtkWidget    *widget)
880{
gboolean was_visible = ctk_widget_get_visible (widget);
ctk_widget_unparent (widget);
if (was_visible)
  ctk_widget_queue_resize (CTK_WIDGET (container)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((container)), ((ctk_widget_get_type ())))))));
885}

887static void
888ctk_path_bar_remove (CtkContainer *container,
     CtkWidget    *widget)
890{
CtkPathBar *path_bar;
GList *children;

path_bar = CTK_PATH_BAR (container)((((CtkPathBar*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((container)), ((ctk_path_bar_get_type ()))))));

if (widget == path_bar->priv->up_slider_button)
  {
    ctk_path_bar_remove_1 (container, widget);
    path_bar->priv->up_slider_button = NULL((void*)0);
    return;
  }

if (widget == path_bar->priv->down_slider_button)
  {
    ctk_path_bar_remove_1 (container, widget);
    path_bar->priv->down_slider_button = NULL((void*)0);
    return;
  }

children = path_bar->priv->button_list;
while (children)
  {
    if (widget == BUTTON_DATA (children->data)((ButtonData *)(children->data))->button)
{
 ctk_path_bar_remove_1 (container, widget);
 path_bar->priv->button_list = g_list_remove_link (path_bar->priv->button_list, children);
 g_list_free (children);
 return;
}
    
    children = children->next;
  }
923}

925static void
926ctk_path_bar_forall (CtkContainer *container,
     gboolean      include_internals G_GNUC_UNUSED__attribute__ ((__unused__)),
     CtkCallback   callback,
     gpointer      callback_data)
930{
CtkPathBar *path_bar;
GList *children;

g_return_if_fail (callback != NULL)do { if ((callback != ((void*)0))) { } else { g_return_if_fail_warning
 ("Ctk", ((const char*) (__func__)), "callback != NULL"); return
; } } while (0);
path_bar = CTK_PATH_BAR (container)((((CtkPathBar*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((container)), ((ctk_path_bar_get_type ()))))));

children = path_bar->priv->button_list;
while (children)
  {
    CtkWidget *child;
    child = BUTTON_DATA (children->data)((ButtonData *)(children->data))->button;
    children = children->next;

    (* callback) (child, callback_data);
  }

if (path_bar->priv->up_slider_button)
  (* callback) (path_bar->priv->up_slider_button, callback_data);

if (path_bar->priv->down_slider_button)
  (* callback) (path_bar->priv->down_slider_button, callback_data);
952}

954static void
955ctk_path_bar_scroll_down (CtkPathBar *path_bar)
956{
CtkAllocation allocation, button_allocation;
GList *list;
GList *down_button = NULL((void*)0);
gint space_available;

if (path_bar->priv->ignore_click)
  {
    path_bar->priv->ignore_click = FALSE(0);
    return;   
  }

if (ctk_widget_get_child_visible (BUTTON_DATA (path_bar->priv->button_list->data)((ButtonData *)(path_bar->priv->button_list->data))->button))
  {
    /* Return if the last button is already visible */
    return;
  }

ctk_widget_queue_resize (CTK_WIDGET (path_bar)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((path_bar)), ((ctk_widget_get_type ())))))));

/* We find the button at the 'down' end that we have to make
 * visible */
for (list = path_bar->priv->button_list; list; list = list->next)
  {
    if (list->next && ctk_widget_get_child_visible (BUTTON_DATA (list->next->data)((ButtonData *)(list->next->data))->button))
{
 down_button = list;
 break;
}
  }

ctk_widget_get_allocation (CTK_WIDGET (path_bar)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((path_bar)), ((ctk_widget_get_type ())))))), &allocation);
ctk_widget_get_allocation (BUTTON_DATA (down_button->data)((ButtonData *)(down_button->data))->button, &button_allocation);

space_available = (allocation.width
     - 2 * path_bar->priv->slider_width
                   - button_allocation.width);
path_bar->priv->first_scrolled_button = down_button;

/* We have space_available free space that's not being used.  
 * So we walk down from the end, adding buttons until we use all free space.
 */
while (space_available > 0)
  {
    path_bar->priv->first_scrolled_button = down_button;
    down_button = down_button->next;
    if (!down_button)
break;
    space_available -= button_allocation.width;
  }
1006}

1008static void
1009ctk_path_bar_scroll_up (CtkPathBar *path_bar)
1010{
GList *list;

if (path_bar->priv->ignore_click)
  {
    path_bar->priv->ignore_click = FALSE(0);
    return;   
  }

list = g_list_last (path_bar->priv->button_list);

if (ctk_widget_get_child_visible (BUTTON_DATA (list->data)((ButtonData *)(list->data))->button))
  {
    /* Return if the first button is already visible */
    return;
  }

ctk_widget_queue_resize (CTK_WIDGET (path_bar)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((path_bar)), ((ctk_widget_get_type ())))))));

for ( ; list; list = list->prev)
  {
    if (list->prev && ctk_widget_get_child_visible (BUTTON_DATA (list->prev->data)((ButtonData *)(list->prev->data))->button))
{
 if (list->prev == path_bar->priv->fake_root)
   path_bar->priv->fake_root = NULL((void*)0);
 path_bar->priv->first_scrolled_button = list;
 return;
}
  }
1039}

1041static gboolean
1042ctk_path_bar_scroll_timeout (CtkPathBar *path_bar)
1043{
gboolean retval = FALSE(0);

if (path_bar->priv->timer)
  {
    if (path_bar->priv->scrolling_up)
ctk_path_bar_scroll_up (path_bar);
    else if (path_bar->priv->scrolling_down)
ctk_path_bar_scroll_down (path_bar);

    if (path_bar->priv->need_timer) 
{
 path_bar->priv->need_timer = FALSE(0);

 path_bar->priv->timer = cdk_threads_add_timeout (TIMEOUT_REPEAT50 * SCROLL_DELAY_FACTOR5,
			   (GSourceFunc)ctk_path_bar_scroll_timeout,
			   path_bar);
        g_source_set_name_by_id (path_bar->priv->timer, "[ctk+] ctk_path_bar_scroll_timeout");
}
    else
retval = TRUE(!(0));
  }

return retval;
1067}

1069static void 
1070ctk_path_bar_stop_scrolling (CtkPathBar *path_bar)
1071{
if (path_bar->priv->timer)
  {
    g_source_remove (path_bar->priv->timer);
    path_bar->priv->timer = 0;
    path_bar->priv->need_timer = FALSE(0);
  }
1078}

1080static gboolean
1081ctk_path_bar_slider_up_defocus (CtkWidget      *widget G_GNUC_UNUSED__attribute__ ((__unused__)),
                              CdkEventButton *event,
                              CtkPathBar     *path_bar)
1084{
GList *list;
GList *up_button = NULL((void*)0);
1
'up_button' initialized to a null pointer value→

if (event->type != CDK_FOCUS_CHANGE)
2
←
Assuming field 'type' is equal to CDK_FOCUS_CHANGE→
3
←
Taking false branch→
  return FALSE(0);

for (list = g_list_last (path_bar->priv->button_list); list; list = list->prev)
  {
    if (ctk_widget_get_child_visible (BUTTON_DATA (list->data)((ButtonData *)(list->data))->button))
      {
        up_button = list;
        break;
      }
  }

/* don't let the focus vanish */
if ((!ctk_widget_is_sensitive (path_bar->priv->up_slider_button)) ||
4
←
Assuming the condition is true→
    (!ctk_widget_get_child_visible (path_bar->priv->up_slider_button)))
  ctk_widget_grab_focus (BUTTON_DATA (up_button->data)((ButtonData *)(up_button->data))->button);
5
←
Access to field 'data' results in a dereference of a null pointer (loaded from variable 'up_button')

return FALSE(0);
1106}

1108static gboolean
1109ctk_path_bar_slider_down_defocus (CtkWidget      *widget G_GNUC_UNUSED__attribute__ ((__unused__)),
                                CdkEventButton *event,
                                CtkPathBar     *path_bar)
1112{
GList *list;
GList *down_button = NULL((void*)0);

if (event->type != CDK_FOCUS_CHANGE)
  return FALSE(0);

for (list = path_bar->priv->button_list; list; list = list->next)
  {
    if (ctk_widget_get_child_visible (BUTTON_DATA (list->data)((ButtonData *)(list->data))->button))
      {
        down_button = list;
        break;
      }
  }

/* don't let the focus vanish */
if ((!ctk_widget_is_sensitive (path_bar->priv->down_slider_button)) ||
    (!ctk_widget_get_child_visible (path_bar->priv->down_slider_button)))
  ctk_widget_grab_focus (BUTTON_DATA (down_button->data)((ButtonData *)(down_button->data))->button);

return FALSE(0);
1134}

1136static gboolean
1137ctk_path_bar_slider_button_press (CtkWidget      *widget, 
		  CdkEventButton *event,
		  CtkPathBar     *path_bar)
1140{
if (event->type != CDK_BUTTON_PRESS || event->button != CDK_BUTTON_PRIMARY(1))
  return FALSE(0);

path_bar->priv->ignore_click = FALSE(0);

if (widget == path_bar->priv->up_slider_button)
  {
    path_bar->priv->scrolling_down = FALSE(0);
    path_bar->priv->scrolling_up = TRUE(!(0));
    ctk_path_bar_scroll_up (path_bar);
  }
else if (widget == path_bar->priv->down_slider_button)
  {
    path_bar->priv->scrolling_up = FALSE(0);
    path_bar->priv->scrolling_down = TRUE(!(0));
    ctk_path_bar_scroll_down (path_bar);
  }

if (!path_bar->priv->timer)
  {
    path_bar->priv->need_timer = TRUE(!(0));
    path_bar->priv->timer = cdk_threads_add_timeout (TIMEOUT_INITIAL500,
		       (GSourceFunc)ctk_path_bar_scroll_timeout,
		       path_bar);
    g_source_set_name_by_id (path_bar->priv->timer, "[ctk+] ctk_path_bar_scroll_timeout");
  }

return FALSE(0);
1169}

1171static gboolean
1172ctk_path_bar_slider_button_release (CtkWidget      *widget G_GNUC_UNUSED__attribute__ ((__unused__)),
		    CdkEventButton *event,
		    CtkPathBar     *path_bar)
1175{
if (event->type != CDK_BUTTON_RELEASE)
  return FALSE(0);

path_bar->priv->ignore_click = TRUE(!(0));
ctk_path_bar_stop_scrolling (path_bar);

return FALSE(0);
1183}

1185static void
1186ctk_path_bar_grab_notify (CtkWidget *widget,
	  gboolean   was_grabbed)
1188{
if (!was_grabbed)
  ctk_path_bar_stop_scrolling (CTK_PATH_BAR (widget)((((CtkPathBar*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((ctk_path_bar_get_type ())))))));
1191}

1193static void
1194ctk_path_bar_state_changed (CtkWidget    *widget,
	    CtkStateType  previous_state G_GNUC_UNUSED__attribute__ ((__unused__)))
1196{
if (!ctk_widget_is_sensitive (widget))
  ctk_path_bar_stop_scrolling (CTK_PATH_BAR (widget)((((CtkPathBar*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((ctk_path_bar_get_type ())))))));
1199}


1202/* Changes the icons wherever it is needed */
1203static void
1204reload_icons (CtkPathBar *path_bar)
1205{
GList *list;

g_clear_object (&path_bar->priv->root_icon)do { _Static_assert (sizeof *((&path_bar->priv->root_icon
)) == sizeof (gpointer), "Expression evaluates to false"); __typeof__
 (((&path_bar->priv->root_icon))) _pp = ((&path_bar
->priv->root_icon)); __typeof__ (*((&path_bar->priv
->root_icon))) _ptr = *_pp; *_pp = ((void*)0); if (_ptr) (
g_object_unref) (_ptr); } while (0);
g_clear_object (&path_bar->priv->home_icon)do { _Static_assert (sizeof *((&path_bar->priv->home_icon
)) == sizeof (gpointer), "Expression evaluates to false"); __typeof__
 (((&path_bar->priv->home_icon))) _pp = ((&path_bar
->priv->home_icon)); __typeof__ (*((&path_bar->priv
->home_icon))) _ptr = *_pp; *_pp = ((void*)0); if (_ptr) (
g_object_unref) (_ptr); } while (0);
g_clear_object (&path_bar->priv->desktop_icon)do { _Static_assert (sizeof *((&path_bar->priv->desktop_icon
)) == sizeof (gpointer), "Expression evaluates to false"); __typeof__
 (((&path_bar->priv->desktop_icon))) _pp = ((&path_bar
->priv->desktop_icon)); __typeof__ (*((&path_bar->
priv->desktop_icon))) _ptr = *_pp; *_pp = ((void*)0); if (
_ptr) (g_object_unref) (_ptr); } while (0);

for (list = path_bar->priv->button_list; list; list = list->next)
  {
    ButtonData *button_data;
    gboolean current_dir;

    button_data = BUTTON_DATA (list->data)((ButtonData *)(list->data));
    if (button_data->type != NORMAL_BUTTON)
{
 current_dir = ctk_toggle_button_get_active (CTK_TOGGLE_BUTTON (button_data->button)((((CtkToggleButton*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((button_data->button)), ((ctk_toggle_button_get_type (
))))))));
 ctk_path_bar_update_button_appearance (path_bar, button_data, current_dir);
}
  }
1224}

1226static void
1227change_icon_theme (CtkPathBar *path_bar)
1228{
reload_icons (path_bar);
1230}

1232/* Callback used when a CtkSettings value changes */
1233static void
1234settings_notify_cb (GObject    *object G_GNUC_UNUSED__attribute__ ((__unused__)),
    GParamSpec *pspec,
    CtkPathBar *path_bar)
1237{
const char *name;

name = g_param_spec_get_name (pspec);

if (strcmp (name, "ctk-icon-theme-name") == 0)
  change_icon_theme (path_bar);
1244}

1246static void
1247ctk_path_bar_check_icon_theme (CtkPathBar *path_bar)
1248{
if (path_bar->priv->settings_signal_id == 0)
  {
    CtkSettings *settings;

    settings = ctk_settings_get_for_screen (ctk_widget_get_screen (CTK_WIDGET (path_bar)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((path_bar)), ((ctk_widget_get_type ()))))))));
    path_bar->priv->settings_signal_id = g_signal_connect (settings, "notify",g_signal_connect_data ((settings), ("notify"), (((GCallback) (
settings_notify_cb))), (path_bar), ((void*)0), (GConnectFlags
) 0)
                                                           G_CALLBACK (settings_notify_cb), path_bar)g_signal_connect_data ((settings), ("notify"), (((GCallback) (
settings_notify_cb))), (path_bar), ((void*)0), (GConnectFlags
) 0);
  }

change_icon_theme (path_bar);
1259}

1261/* Public functions and their helpers */
1262static void
1263ctk_path_bar_clear_buttons (CtkPathBar *path_bar)
1264{
while (path_bar->priv->button_list != NULL((void*)0))
  {
    ctk_container_remove (CTK_CONTAINER (path_bar)((((CtkContainer*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((path_bar)), ((ctk_container_get_type ())))))), BUTTON_DATA (path_bar->priv->button_list->data)((ButtonData *)(path_bar->priv->button_list->data))->button);
  }
path_bar->priv->first_scrolled_button = NULL((void*)0);
path_bar->priv->fake_root = NULL((void*)0);
1271}

1273static void
1274button_clicked_cb (CtkWidget *button,
   gpointer   data)
1276{
ButtonData *button_data;
CtkPathBar *path_bar;
GList *button_list;
gboolean child_is_hidden;
GFile *child_file;

button_data = BUTTON_DATA (data)((ButtonData *)(data));
if (button_data->ignore_changes)
  return;

path_bar = CTK_PATH_BAR (ctk_widget_get_parent (button))((((CtkPathBar*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((ctk_widget_get_parent (button))), ((ctk_path_bar_get_type
 ()))))));

button_list = g_list_find (path_bar->priv->button_list, button_data);
g_assert (button_list != NULL)do { if (button_list != ((void*)0)) ; else g_assertion_message_expr
 ("Ctk", "ctkpathbar.c", 1290, ((const char*) (__func__)), "button_list != NULL"
); } while (0);

g_signal_handlers_block_by_func (button,g_signal_handlers_block_matched ((button), (GSignalMatchType)
 (G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA), 0, 0, ((void*)0
), (((GCallback) (button_clicked_cb))), (data))
		   G_CALLBACK (button_clicked_cb), data)g_signal_handlers_block_matched ((button), (GSignalMatchType)
 (G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA), 0, 0, ((void*)0
), (((GCallback) (button_clicked_cb))), (data));
ctk_toggle_button_set_active (CTK_TOGGLE_BUTTON (button)((((CtkToggleButton*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((button)), ((ctk_toggle_button_get_type ())))))), TRUE(!(0)));
g_signal_handlers_unblock_by_func (button,g_signal_handlers_unblock_matched ((button), (GSignalMatchType
) (G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA), 0, 0, ((void*)
0), (((GCallback) (button_clicked_cb))), (data))
		     G_CALLBACK (button_clicked_cb), data)g_signal_handlers_unblock_matched ((button), (GSignalMatchType
) (G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA), 0, 0, ((void*)
0), (((GCallback) (button_clicked_cb))), (data));

if (button_list->prev)
  {
    ButtonData *child_data;

    child_data = BUTTON_DATA (button_list->prev->data)((ButtonData *)(button_list->prev->data));
    child_file = child_data->file;
    child_is_hidden = child_data->file_is_hidden;
  }
else
  {
    child_file = NULL((void*)0);
    child_is_hidden = FALSE(0);
  }

g_signal_emit (path_bar, path_bar_signals [PATH_CLICKED], 0,
 button_data->file, child_file, child_is_hidden);
1314}

1316struct SetButtonImageData
1317{
CtkPathBar *path_bar;
ButtonData *button_data;
1320};

1322static void
1323set_button_image_get_info_cb (GCancellable *cancellable,
	      GFileInfo    *info,
	      const GError *error,
	      gpointer      user_data)
1327{
gboolean cancelled = g_cancellable_is_cancelled (cancellable);
GIcon *icon;
struct SetButtonImageData *data = user_data;

if (cancelled)
  {
    g_free (data);
    g_object_unref (cancellable);
    return;
  }

g_assert (CTK_IS_PATH_BAR (data->path_bar))do { if ((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((data->path_bar)); GType __t = ((ctk_path_bar_get_type
 ())); gboolean __r; if (!__inst) __r = (0); else if (__inst->
g_class && __inst->g_class->g_type == __t) __r =
 (!(0)); else __r = g_type_check_instance_is_a (__inst, __t);
 __r; }))))) ; else g_assertion_message_expr ("Ctk", "ctkpathbar.c"
, 1339, ((const char*) (__func__)), "CTK_IS_PATH_BAR (data->path_bar)"
); } while (0);
g_assert (G_OBJECT (data->path_bar)->ref_count > 0)do { if (((((GObject*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((data->path_bar)), (((GType) ((20) <<
 (2))))))))->ref_count > 0) ; else g_assertion_message_expr
 ("Ctk", "ctkpathbar.c", 1340, ((const char*) (__func__)), "G_OBJECT (data->path_bar)->ref_count > 0"
); } while (0);

g_assert (cancellable == data->button_data->cancellable)do { if (cancellable == data->button_data->cancellable)
 ; else g_assertion_message_expr ("Ctk", "ctkpathbar.c", 1342
, ((const char*) (__func__)), "cancellable == data->button_data->cancellable"
); } while (0);
cancellable_async_done (data->path_bar, cancellable);
data->button_data->cancellable = NULL((void*)0);

if (error)
  goto out;

icon = g_file_info_get_symbolic_icon (info);
ctk_image_set_from_gicon (CTK_IMAGE (data->button_data->image)((((CtkImage*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((data->button_data->image)), ((ctk_image_get_type (
))))))), icon, CTK_ICON_SIZE_BUTTON);

switch (data->button_data->type)
  {
    case HOME_BUTTON:
      g_set_object (&data->path_bar->priv->home_icon, icon)(__extension__ ({ _Static_assert (sizeof *(&data->path_bar
->priv->home_icon) == sizeof (icon), "Expression evaluates to false"
); union { char *in; GObject **out; } _object_ptr; _object_ptr
.in = (char *) (&data->path_bar->priv->home_icon
); (void) (0 ? *(&data->path_bar->priv->home_icon
) = (icon), (0) : (0)); (g_set_object) (_object_ptr.out, (GObject
 *) icon); }));
break;

    case DESKTOP_BUTTON:
      g_set_object (&data->path_bar->priv->desktop_icon, icon)(__extension__ ({ _Static_assert (sizeof *(&data->path_bar
->priv->desktop_icon) == sizeof (icon), "Expression evaluates to false"
); union { char *in; GObject **out; } _object_ptr; _object_ptr
.in = (char *) (&data->path_bar->priv->desktop_icon
); (void) (0 ? *(&data->path_bar->priv->desktop_icon
) = (icon), (0) : (0)); (g_set_object) (_object_ptr.out, (GObject
 *) icon); }));
break;

    default:
break;
  };

1366out:
g_free (data);
1368}

1370static void
1371set_button_image (CtkPathBar *path_bar,
  ButtonData *button_data)
1373{
CtkFileSystemVolume *volume;
struct SetButtonImageData *data;

switch (button_data->type)
  {
  case ROOT_BUTTON:

    if (path_bar->priv->root_icon != NULL((void*)0))
      {
        ctk_image_set_from_gicon (CTK_IMAGE (button_data->image)((((CtkImage*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((button_data->image)), ((ctk_image_get_type ())))))), path_bar->priv->root_icon, CTK_ICON_SIZE_BUTTON);
 break;
}

    volume = _ctk_file_system_get_volume_for_file (path_bar->priv->file_system, path_bar->priv->root_file);
    if (volume == NULL((void*)0))
return;

    path_bar->priv->root_icon = _ctk_file_system_volume_get_symbolic_icon (volume);
    _ctk_file_system_volume_unref (volume);
    ctk_image_set_from_gicon (CTK_IMAGE (button_data->image)((((CtkImage*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((button_data->image)), ((ctk_image_get_type ())))))), path_bar->priv->root_icon, CTK_ICON_SIZE_BUTTON);

    break;

  case HOME_BUTTON:
    if (path_bar->priv->home_icon != NULL((void*)0))
      {
        ctk_image_set_from_gicon (CTK_IMAGE (button_data->image)((((CtkImage*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((button_data->image)), ((ctk_image_get_type ())))))), path_bar->priv->home_icon, CTK_ICON_SIZE_BUTTON);
 break;
}

    data = g_new0 (struct SetButtonImageData, 1)((struct SetButtonImageData *) g_malloc0_n ((1), sizeof (struct
 SetButtonImageData)));
    data->path_bar = path_bar;
    data->button_data = button_data;

    if (button_data->cancellable)
{
 cancel_cancellable (path_bar, button_data->cancellable);
}

    button_data->cancellable =
      _ctk_file_system_get_info (path_bar->priv->file_system,
		   path_bar->priv->home_file,
		   "standard::symbolic-icon",
		   set_button_image_get_info_cb,
		   data);
    add_cancellable (path_bar, button_data->cancellable);
    break;

  case DESKTOP_BUTTON:
    if (path_bar->priv->desktop_icon != NULL((void*)0))
      {
        ctk_image_set_from_gicon (CTK_IMAGE (button_data->image)((((CtkImage*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((button_data->image)), ((ctk_image_get_type ())))))), path_bar->priv->desktop_icon, CTK_ICON_SIZE_BUTTON);
 break;
}

    data = g_new0 (struct SetButtonImageData, 1)((struct SetButtonImageData *) g_malloc0_n ((1), sizeof (struct
 SetButtonImageData)));
    data->path_bar = path_bar;
    data->button_data = button_data;

    if (button_data->cancellable)
{
 cancel_cancellable (path_bar, button_data->cancellable);
}

    button_data->cancellable =
      _ctk_file_system_get_info (path_bar->priv->file_system,
		   path_bar->priv->desktop_file,
		   "standard::symbolic-icon",
		   set_button_image_get_info_cb,
		   data);
    add_cancellable (path_bar, button_data->cancellable);
    break;
  default:
    break;
  }
1449}

1451static void
1452button_data_free (ButtonData *button_data)
1453{
if (button_data->file)
  g_object_unref (button_data->file);
button_data->file = NULL((void*)0);

g_free (button_data->dir_name);
button_data->dir_name = NULL((void*)0);

button_data->button = NULL((void*)0);

g_free (button_data);
1464}

1466static const char *
1467get_dir_name (ButtonData *button_data)
1468{
return button_data->dir_name;
1470}

1472static void
1473ctk_path_bar_update_button_appearance (CtkPathBar *path_bar,
		       ButtonData *button_data,
		       gboolean    current_dir)
1476{
const gchar *dir_name = get_dir_name (button_data);
CtkStyleContext *context;

context = ctk_widget_get_style_context (button_data->button);

ctk_style_context_remove_class (context, "text-button");
ctk_style_context_remove_class (context, "image-button");

if (button_data->label != NULL((void*)0))
  {
    ctk_label_set_text (CTK_LABEL (button_data->label)((((CtkLabel*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((button_data->label)), ((ctk_label_get_type ())))))), dir_name);
    if (button_data->image == NULL((void*)0))
      ctk_style_context_add_class (context, "text-button");
  }

if (button_data->image != NULL((void*)0))
  {
    set_button_image (path_bar, button_data);
    if (button_data->label == NULL((void*)0))
      ctk_style_context_add_class (context, "image-button");
  }

if (ctk_toggle_button_get_active (CTK_TOGGLE_BUTTON (button_data->button)((((CtkToggleButton*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((button_data->button)), ((ctk_toggle_button_get_type (
)))))))) != current_dir)
  {
    button_data->ignore_changes = TRUE(!(0));
    ctk_toggle_button_set_active (CTK_TOGGLE_BUTTON (button_data->button)((((CtkToggleButton*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((button_data->button)), ((ctk_toggle_button_get_type (
))))))), current_dir);
    button_data->ignore_changes = FALSE(0);
  }
1505}

1507static ButtonType
1508find_button_type (CtkPathBar  *path_bar,
  GFile       *file)
1510{
if (path_bar->priv->root_file != NULL((void*)0) &&
    g_file_equal (file, path_bar->priv->root_file))
  return ROOT_BUTTON;
if (path_bar->priv->home_file != NULL((void*)0) &&
    g_file_equal (file, path_bar->priv->home_file))
  return HOME_BUTTON;
if (path_bar->priv->desktop_file != NULL((void*)0) &&
    g_file_equal (file, path_bar->priv->desktop_file))
  return DESKTOP_BUTTON;

return NORMAL_BUTTON;
1522}

1524static void
1525button_drag_data_get_cb (CtkWidget        *widget G_GNUC_UNUSED__attribute__ ((__unused__)),
                       CdkDragContext   *context G_GNUC_UNUSED__attribute__ ((__unused__)),
                       CtkSelectionData *selection_data,
                       guint             info G_GNUC_UNUSED__attribute__ ((__unused__)),
                       guint             time_ G_GNUC_UNUSED__attribute__ ((__unused__)),
                       gpointer          data)
1531{
ButtonData *button_data;
char *uris[2];

button_data = data;

uris[0] = g_file_get_uri (button_data->file);
uris[1] = NULL((void*)0);

ctk_selection_data_set_uris (selection_data, uris);

g_free (uris[0]);
1543}

1545static ButtonData *
1546make_directory_button (CtkPathBar  *path_bar,
       const char  *dir_name,
       GFile       *file,
       gboolean     current_dir,
       gboolean     file_is_hidden)
1551{
AtkObject *atk_obj;
CtkWidget *child = NULL((void*)0);
ButtonData *button_data;

file_is_hidden = !! file_is_hidden;
/* Is it a special button? */
button_data = g_new0 (ButtonData, 1)((ButtonData *) g_malloc0_n ((1), sizeof (ButtonData)));
button_data->type = find_button_type (path_bar, file);
button_data->button = ctk_toggle_button_new ();
atk_obj = ctk_widget_get_accessible (button_data->button);
ctk_widget_set_focus_on_click (button_data->button, FALSE(0));
ctk_widget_add_events (button_data->button, CDK_SCROLL_MASK);

switch (button_data->type)
  {
  case ROOT_BUTTON:
    button_data->image = ctk_image_new ();
    child = button_data->image;
    button_data->label = NULL((void*)0);
    atk_object_set_name (atk_obj, _("File System Root")((char *) g_dgettext ("ctk30", "File System Root")));
    break;
  case HOME_BUTTON:
  case DESKTOP_BUTTON:
    button_data->image = ctk_image_new ();
    button_data->label = ctk_label_new (NULL((void*)0));
    child = ctk_box_new (CTK_ORIENTATION_HORIZONTAL, 0);
    ctk_box_pack_start (CTK_BOX (child)((((CtkBox*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((child)), ((ctk_box_get_type ())))))), button_data->image, FALSE(0), FALSE(0), 0);
    ctk_box_pack_start (CTK_BOX (child)((((CtkBox*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((child)), ((ctk_box_get_type ())))))), button_data->label, FALSE(0), FALSE(0), 0);
    break;
  case NORMAL_BUTTON:
  default:
    button_data->label = ctk_label_new (NULL((void*)0));
    child = button_data->label;
    button_data->image = NULL((void*)0);
  }

button_data->dir_name = g_strdup (dir_name)g_strdup_inline (dir_name);
button_data->file = g_object_ref (file)((__typeof__ (file)) (g_object_ref) (file));
button_data->file_is_hidden = file_is_hidden;

ctk_container_add (CTK_CONTAINER (button_data->button)((((CtkContainer*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((button_data->button)), ((ctk_container_get_type ())))
))), child);
ctk_widget_show_all (button_data->button);

ctk_path_bar_update_button_appearance (path_bar, button_data, current_dir);

g_signal_connect (button_data->button, "clicked",g_signal_connect_data ((button_data->button), ("clicked"),
 (((GCallback) (button_clicked_cb))), (button_data), ((void*)
0), (GConnectFlags) 0)
    G_CALLBACK (button_clicked_cb),g_signal_connect_data ((button_data->button), ("clicked"),
 (((GCallback) (button_clicked_cb))), (button_data), ((void*)
0), (GConnectFlags) 0)
    button_data)g_signal_connect_data ((button_data->button), ("clicked"),
 (((GCallback) (button_clicked_cb))), (button_data), ((void*)
0), (GConnectFlags) 0);
g_object_weak_ref (G_OBJECT (button_data->button)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((button_data->button)), (((GType) ((20) << (2)))
))))),
     (GWeakNotify) button_data_free, button_data);

ctk_drag_source_set (button_data->button,
       CDK_BUTTON1_MASK,
       NULL((void*)0), 0,
       CDK_ACTION_COPY);
ctk_drag_source_add_uri_targets (button_data->button);
g_signal_connect (button_data->button, "drag-data-get",g_signal_connect_data ((button_data->button), ("drag-data-get"
), (((GCallback) (button_drag_data_get_cb))), (button_data), (
(void*)0), (GConnectFlags) 0)
    G_CALLBACK (button_drag_data_get_cb), button_data)g_signal_connect_data ((button_data->button), ("drag-data-get"
), (((GCallback) (button_drag_data_get_cb))), (button_data), (
(void*)0), (GConnectFlags) 0);

return button_data;
1612}

1614static gboolean
1615ctk_path_bar_check_parent_path (CtkPathBar         *path_bar,
		GFile              *file)
1617{
GList *list;
GList *current_path = NULL((void*)0);
gboolean need_new_fake_root = FALSE(0);

for (list = path_bar->priv->button_list; list; list = list->next)
  {
    ButtonData *button_data;

    button_data = list->data;
    if (g_file_equal (file, button_data->file))
{
 current_path = list;
 break;
}
    if (list == path_bar->priv->fake_root)
need_new_fake_root = TRUE(!(0));
  }

if (current_path)
  {
    if (need_new_fake_root)
{
 path_bar->priv->fake_root = NULL((void*)0);
 for (list = current_path; list; list = list->next)
   {
     ButtonData *button_data;

     button_data = list->data;
     if (BUTTON_IS_FAKE_ROOT (button_data)((button_data)->type == HOME_BUTTON))
{
  path_bar->priv->fake_root = list;
  break;
}
   }
}

    for (list = path_bar->priv->button_list; list; list = list->next)
{
 ctk_path_bar_update_button_appearance (path_bar,
				 BUTTON_DATA (list->data)((ButtonData *)(list->data)),
				 (list == current_path) ? TRUE(!(0)) : FALSE(0));
}

    if (!ctk_widget_get_child_visible (BUTTON_DATA (current_path->data)((ButtonData *)(current_path->data))->button))
{
 path_bar->priv->first_scrolled_button = current_path;
 ctk_widget_queue_resize (CTK_WIDGET (path_bar)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((path_bar)), ((ctk_widget_get_type ())))))));
}

    return TRUE(!(0));
  }
return FALSE(0);
1670}


1673struct SetFileInfo
1674{
GFile *file;
GFile *parent_file;
CtkPathBar *path_bar;
GList *new_buttons;
GList *fake_root;
gboolean first_directory;
1681};

1683static void
1684ctk_path_bar_set_file_finish (struct SetFileInfo *info,
                            gboolean            result)
1686{
if (result)
  {
    GList *l;
    CtkCssNode *prev;

    ctk_path_bar_clear_buttons (info->path_bar);
    info->path_bar->priv->button_list = g_list_reverse (info->new_buttons);
    info->path_bar->priv->fake_root = info->fake_root;
    prev = ctk_widget_get_css_node (info->path_bar->priv->down_slider_button);

    for (l = info->path_bar->priv->button_list; l; l = l->next)
{
 CtkWidget *button = BUTTON_DATA (l->data)((ButtonData *)(l->data))->button;
        CtkCssNode *node = ctk_widget_get_css_node (button);

        ctk_css_node_insert_before (ctk_widget_get_css_node (CTK_WIDGET (info->path_bar)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((info->path_bar)), ((ctk_widget_get_type ()))))))),
                                    node,
                                    prev);
 ctk_container_add (CTK_CONTAINER (info->path_bar)((((CtkContainer*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((info->path_bar)), ((ctk_container_get_type ())))))), button);
        prev = node;
}
  }
else
  {
    GList *l;

    for (l = info->new_buttons; l; l = l->next)
{
 ButtonData *button_data;

 button_data = BUTTON_DATA (l->data)((ButtonData *)(l->data));
 ctk_widget_destroy (button_data->button);
}

    g_list_free (info->new_buttons);
  }

if (info->file)
  g_object_unref (info->file);
if (info->parent_file)
  g_object_unref (info->parent_file);

g_free (info);
1730}

1732static void
1733ctk_path_bar_get_info_callback (GCancellable *cancellable,
	        GFileInfo    *info,
	        const GError *error G_GNUC_UNUSED__attribute__ ((__unused__)),
	        gpointer      data)
1737{
gboolean cancelled = g_cancellable_is_cancelled (cancellable);
struct SetFileInfo *file_info = data;
ButtonData *button_data;
const gchar *display_name;
gboolean is_hidden;

if (cancelled)
  {
    ctk_path_bar_set_file_finish (file_info, FALSE(0));
    g_object_unref (cancellable);
    return;
  }

g_assert (CTK_IS_PATH_BAR (file_info->path_bar))do { if ((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((file_info->path_bar)); GType __t = ((ctk_path_bar_get_type
 ())); gboolean __r; if (!__inst) __r = (0); else if (__inst->
g_class && __inst->g_class->g_type == __t) __r =
 (!(0)); else __r = g_type_check_instance_is_a (__inst, __t);
 __r; }))))) ; else g_assertion_message_expr ("Ctk", "ctkpathbar.c"
, 1751, ((const char*) (__func__)), "CTK_IS_PATH_BAR (file_info->path_bar)"
); } while (0);
g_assert (G_OBJECT (file_info->path_bar)->ref_count > 0)do { if (((((GObject*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((file_info->path_bar)), (((GType) ((20) <<
 (2))))))))->ref_count > 0) ; else g_assertion_message_expr
 ("Ctk", "ctkpathbar.c", 1752, ((const char*) (__func__)), "G_OBJECT (file_info->path_bar)->ref_count > 0"
); } while (0);

g_assert (cancellable == file_info->path_bar->priv->get_info_cancellable)do { if (cancellable == file_info->path_bar->priv->get_info_cancellable
) ; else g_assertion_message_expr ("Ctk", "ctkpathbar.c", 1754
, ((const char*) (__func__)), "cancellable == file_info->path_bar->priv->get_info_cancellable"
); } while (0);
cancellable_async_done (file_info->path_bar, cancellable);
file_info->path_bar->priv->get_info_cancellable = NULL((void*)0);

if (!info)
  {
    ctk_path_bar_set_file_finish (file_info, FALSE(0));
    return;
  }

display_name = g_file_info_get_display_name (info);
is_hidden = g_file_info_get_is_hidden (info) || g_file_info_get_is_backup (info);

button_data = make_directory_button (file_info->path_bar, display_name,
                                     file_info->file,
		       file_info->first_directory, is_hidden);
g_clear_object (&file_info->file)do { _Static_assert (sizeof *((&file_info->file)) == sizeof
 (gpointer), "Expression evaluates to false"); __typeof__ (((
&file_info->file))) _pp = ((&file_info->file));
 __typeof__ (*((&file_info->file))) _ptr = *_pp; *_pp =
 ((void*)0); if (_ptr) (g_object_unref) (_ptr); } while (0);

file_info->new_buttons = g_list_prepend (file_info->new_buttons, button_data);

if (BUTTON_IS_FAKE_ROOT (button_data)((button_data)->type == HOME_BUTTON))
  file_info->fake_root = file_info->new_buttons;

/* We have assigned the info for the innermost button, i.e. the deepest directory.
 * Now, go on to fetch the info for this directory's parent.
 */

file_info->file = file_info->parent_file;
file_info->first_directory = FALSE(0);

if (!file_info->file)
  {
    /* No parent?  Okay, we are done. */
    ctk_path_bar_set_file_finish (file_info, TRUE(!(0)));
    return;
  }

file_info->parent_file = g_file_get_parent (file_info->file);

/* Recurse asynchronously */
file_info->path_bar->priv->get_info_cancellable =
  _ctk_file_system_get_info (file_info->path_bar->priv->file_system,
	       file_info->file,
	       "standard::display-name,standard::is-hidden,standard::is-backup",
	       ctk_path_bar_get_info_callback,
	       file_info);
add_cancellable (file_info->path_bar, file_info->path_bar->priv->get_info_cancellable);
1801}

1803void
1804_ctk_path_bar_set_file (CtkPathBar *path_bar,
                      GFile      *file,
                      gboolean    keep_trail)
1807{
struct SetFileInfo *info;

g_return_if_fail (CTK_IS_PATH_BAR (path_bar))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((path_bar)); GType __t = ((ctk_path_bar_get_type ())); gboolean
 __r; if (!__inst) __r = (0); else if (__inst->g_class &&
 __inst->g_class->g_type == __t) __r = (!(0)); else __r
 = g_type_check_instance_is_a (__inst, __t); __r; })))))) { }
 else { g_return_if_fail_warning ("Ctk", ((const char*) (__func__
)), "CTK_IS_PATH_BAR (path_bar)"); return; } } while (0);
g_return_if_fail (G_IS_FILE (file))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((file)); GType __t = ((g_file_get_type ())); gboolean __r
; if (!__inst) __r = (0); else if (__inst->g_class &&
 __inst->g_class->g_type == __t) __r = (!(0)); else __r
 = g_type_check_instance_is_a (__inst, __t); __r; })))))) { }
 else { g_return_if_fail_warning ("Ctk", ((const char*) (__func__
)), "G_IS_FILE (file)"); return; } } while (0);

/* Check whether the new path is already present in the pathbar as buttons.
 * This could be a parent directory or a previous selected subdirectory.
 */
if (keep_trail && ctk_path_bar_check_parent_path (path_bar, file))
  return;

info = g_new0 (struct SetFileInfo, 1)((struct SetFileInfo *) g_malloc0_n ((1), sizeof (struct SetFileInfo
)));
info->file = g_object_ref (file)((__typeof__ (file)) (g_object_ref) (file));
info->path_bar = path_bar;
info->first_directory = TRUE(!(0));
info->parent_file = g_file_get_parent (info->file);

if (path_bar->priv->get_info_cancellable)
  {
    cancel_cancellable (path_bar, path_bar->priv->get_info_cancellable);
  }

path_bar->priv->get_info_cancellable =
  _ctk_file_system_get_info (path_bar->priv->file_system,
                             info->file,
                             "standard::display-name,standard::is-hidden,standard::is-backup",
                             ctk_path_bar_get_info_callback,
                             info);
add_cancellable (path_bar, path_bar->priv->get_info_cancellable);
1837}

1839/* FIXME: This should be a construct-only property */
1840void
1841_ctk_path_bar_set_file_system (CtkPathBar    *path_bar,
	       CtkFileSystem *file_system)
1843{
const char *home;

g_return_if_fail (CTK_IS_PATH_BAR (path_bar))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((path_bar)); GType __t = ((ctk_path_bar_get_type ())); gboolean
 __r; if (!__inst) __r = (0); else if (__inst->g_class &&
 __inst->g_class->g_type == __t) __r = (!(0)); else __r
 = g_type_check_instance_is_a (__inst, __t); __r; })))))) { }
 else { g_return_if_fail_warning ("Ctk", ((const char*) (__func__
)), "CTK_IS_PATH_BAR (path_bar)"); return; } } while (0);

g_assert (path_bar->priv->file_system == NULL)do { if (path_bar->priv->file_system == ((void*)0)) ; else
 g_assertion_message_expr ("Ctk", "ctkpathbar.c", 1848, ((const
 char*) (__func__)), "path_bar->priv->file_system == NULL"
); } while (0);

path_bar->priv->file_system = g_object_ref (file_system)((__typeof__ (file_system)) (g_object_ref) (file_system));

home = g_get_home_dir ();
if (home != NULL((void*)0))
  {
    const gchar *desktop;

    path_bar->priv->home_file = g_file_new_for_path (home);
    /* FIXME: Need file system backend specific way of getting the
     * Desktop path.
     */
    desktop = g_get_user_special_dir (G_USER_DIRECTORY_DESKTOP);
    if (desktop != NULL((void*)0))
      path_bar->priv->desktop_file = g_file_new_for_path (desktop);
    else 
      path_bar->priv->desktop_file = NULL((void*)0);
  }
else
  {
    path_bar->priv->home_file = NULL((void*)0);
    path_bar->priv->desktop_file = NULL((void*)0);
  }
path_bar->priv->root_file = g_file_new_for_path ("/");
1873}

1875/**
* _ctk_path_bar_up:
* @path_bar: a #CtkPathBar
* 
* If the selected button in the pathbar is not the furthest button “up” (in the
* root direction), act as if the user clicked on the next button up.
**/
1882void
1883_ctk_path_bar_up (CtkPathBar *path_bar)
1884{
GList *l;

for (l = path_bar->priv->button_list; l; l = l->next)
  {
    CtkWidget *button = BUTTON_DATA (l->data)((ButtonData *)(l->data))->button;
    if (ctk_toggle_button_get_active (CTK_TOGGLE_BUTTON (button)((((CtkToggleButton*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((button)), ((ctk_toggle_button_get_type ()))))))))
{
 if (l->next)
   {
     CtkWidget *next_button = BUTTON_DATA (l->next->data)((ButtonData *)(l->next->data))->button;
     button_clicked_cb (next_button, l->next->data);
   }
 break;
}
  }
1900}

1902/**
* _ctk_path_bar_down:
* @path_bar: a #CtkPathBar
* 
* If the selected button in the pathbar is not the furthest button “down” (in the
* leaf direction), act as if the user clicked on the next button down.
**/
1909void
1910_ctk_path_bar_down (CtkPathBar *path_bar)
1911{
GList *l;

for (l = path_bar->priv->button_list; l; l = l->next)
  {
    CtkWidget *button = BUTTON_DATA (l->data)((ButtonData *)(l->data))->button;
    if (ctk_toggle_button_get_active (CTK_TOGGLE_BUTTON (button)((((CtkToggleButton*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((button)), ((ctk_toggle_button_get_type ()))))))))
{
 if (l->prev)
   {
     CtkWidget *prev_button = BUTTON_DATA (l->prev->data)((ButtonData *)(l->prev->data))->button;
     button_clicked_cb (prev_button, l->prev->data);
   }
 break;
}
  }
1927}