../libvnck/tasklist.c

Bug Summary

File:	_build/../libvnck/tasklist.c
Warning:	line 1599, column 43 Access to field 'windows' results in a dereference of a null pointer (loaded from variable 'class_group_task')
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 tasklist.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/_build -fcoverage-compilation-dir=/rootdir/_build -resource-dir /usr/lib/llvm-19/lib/clang/19 -I libvnck/libvnck-3.so.0.3.0.p -I libvnck -I ../libvnck -I . -I .. -I /usr/include/cairo -I /usr/include/libpng16 -I /usr/include/freetype2 -I /usr/include/pixman-1 -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/ctk-3.0 -I /usr/include/pango-1.0 -I /usr/include/harfbuzz -I /usr/include/libmount -I /usr/include/blkid -I /usr/include/fribidi -I /usr/include/gdk-pixbuf-2.0 -I /usr/include/x86_64-linux-gnu -I /usr/include/webp -I /usr/include/gio-unix-2.0 -I /usr/include/atk-1.0 -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/startup-notification-1.0 -D _FILE_OFFSET_BITS=64 -D G_LOG_DOMAIN="Vnck" -D VNCK_I_KNOW_THIS_IS_UNSTABLE -D VNCK_LOCALEDIR="/usr/local/share/locale" -D VNCK_COMPILATION -D SN_API_NOT_YET_FROZEN=1 -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 -O0 -ferror-limit 19 -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -fcolor-diagnostics -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/2025-02-26-082554-9764-1 -x c ../libvnck/tasklist.c
1/* tasklist object */

3/*
* Copyright (C) 2001 Havoc Pennington
* Copyright (C) 2003 Kim Woelders
* Copyright (C) 2003 Red Hat, Inc.
* Copyright (C) 2003, 2005-2007 Vincent Untz
*
* 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/>.
21*/

23#include <config.h>

25#include <math.h>
26#include <string.h>
27#include <stdio.h>
28#include <glib/gi18n-lib.h>
29#include "tasklist.h"
30#include "window.h"
31#include "class-group.h"
32#include "window-action-menu.h"
33#include "vnck-image-menu-item-private.h"
34#include "workspace.h"
35#include "xutils.h"
36#include "private.h"

38/**
* SECTION:tasklist
* @short_description: a tasklist widget, showing the list of windows as a list
* of buttons.
* @see_also: #VnckScreen, #VnckSelector
* @stability: Unstable
*
* The #VnckTasklist represents client windows on a screen as a list of buttons
* labelled with the window titles and icons. Pressing a button can activate or
* minimize the represented window, and other typical actions are available
* through a popup menu. Windows needing attention can also be distinguished
* by a fade effect on the buttons representing them, to help attract the
* user's attention.
*
* The behavior of the #VnckTasklist can be customized in various ways, like
* grouping multiple windows of the same application in one button (see
* vnck_tasklist_set_grouping() and vnck_tasklist_set_grouping_limit()), or
* showing windows from all workspaces (see
* vnck_tasklist_set_include_all_workspaces()). The fade effect for windows
* needing attention can be controlled by various style properties like
* #VnckTasklist:fade-max-loops and #VnckTasklist:fade-opacity.
*
* The tasklist also acts as iconification destination. If there are multiple
* #VnckTasklist or other applications setting the iconification destination
* for windows, the iconification destinations might not be consistent among
* windows and it is not possible to determine which #VnckTasklist (or which
* other application) owns this propriety.
*/

67/* TODO:
*
*  Add total focused time to the grouping score function
*  Fine tune the grouping scoring function
*  Fix "changes" to icon for groups/applications
*  Maybe fine tune size_allocate() some more...
*  Better vertical layout handling
*  prefs
*  support for right-click menu merging w/ bonobo for the applet
*
*/


80#define VNCK_TYPE_TASK(vnck_task_get_type ())              (vnck_task_get_type ())
81#define VNCK_TASK(object)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((object)), ((vnck_task_get_type ()))))))           (G_TYPE_CHECK_INSTANCE_CAST ((object), VNCK_TYPE_TASK, VnckTask)(((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((object)), ((vnck_task_get_type ()))))))
82#define VNCK_TASK_CLASS(klass)((((VnckTaskClass*) (void *) g_type_check_class_cast ((GTypeClass
*) ((klass)), ((vnck_task_get_type ()))))))      (G_TYPE_CHECK_CLASS_CAST ((klass), VNCK_TYPE_TASK, VnckTaskClass)(((VnckTaskClass*) (void *) g_type_check_class_cast ((GTypeClass
*) ((klass)), ((vnck_task_get_type ()))))))
83#define VNCK_IS_TASK(object)(((__extension__ ({ GTypeInstance *__inst = (GTypeInstance*) (
(object)); GType __t = ((vnck_task_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; }))))        (G_TYPE_CHECK_INSTANCE_TYPE ((object), VNCK_TYPE_TASK)((__extension__ ({ GTypeInstance *__inst = (GTypeInstance*) (
(object)); GType __t = ((vnck_task_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; }))))
84#define VNCK_IS_TASK_CLASS(klass)(((__extension__ ({ GTypeClass *__class = (GTypeClass*) ((klass
)); GType __t = ((vnck_task_get_type ())); gboolean __r; if (
!__class) __r = (0); else if (__class->g_type == __t) __r =
 (!(0)); else __r = g_type_check_class_is_a (__class, __t); __r
; }))))   (G_TYPE_CHECK_CLASS_TYPE ((klass), VNCK_TYPE_TASK)((__extension__ ({ GTypeClass *__class = (GTypeClass*) ((klass
)); GType __t = ((vnck_task_get_type ())); gboolean __r; if (
!__class) __r = (0); else if (__class->g_type == __t) __r =
 (!(0)); else __r = g_type_check_class_is_a (__class, __t); __r
; }))))
85#define VNCK_TASK_GET_CLASS(obj)((((VnckTaskClass*) (((GTypeInstance*) ((obj)))->g_class))
))    (G_TYPE_INSTANCE_GET_CLASS ((obj), VNCK_TYPE_TASK, VnckTaskClass)(((VnckTaskClass*) (((GTypeInstance*) ((obj)))->g_class))))

87typedef struct _VnckTask        VnckTask;
88typedef struct _VnckTaskClass   VnckTaskClass;

90#define DEFAULT_GROUPING_LIMIT80 80

92#define MINI_ICON_SIZE_vnck_get_default_mini_icon_size () _vnck_get_default_mini_icon_size ()
93#define TASKLIST_BUTTON_PADDING4 4
94#define TASKLIST_TEXT_MAX_WIDTH25 25 /* maximum width in characters */

96#define N_SCREEN_CONNECTIONS5 5

98#define POINT_IN_RECT(xcoord, ycoord, rect)((xcoord) >= (rect).x && (xcoord) < ((rect).x +
 (rect).width) && (ycoord) >= (rect).y && (
ycoord) < ((rect).y + (rect).height)) \
((xcoord) >= (rect).x &&                   \
(xcoord) <  ((rect).x + (rect).width) &&  \
(ycoord) >= (rect).y &&                   \
(ycoord) <  ((rect).y + (rect).height))

104typedef enum
105{
VNCK_TASK_CLASS_GROUP,
VNCK_TASK_WINDOW,
VNCK_TASK_STARTUP_SEQUENCE
109} VnckTaskType;

111struct _VnckTask
112{
GObject parent_instance;

VnckTasklist *tasklist;

CtkWidget *button;
CtkWidget *image;
CtkWidget *label;

VnckTaskType type;

VnckClassGroup *class_group;
VnckWindow *window;
125#ifdef HAVE_STARTUP_NOTIFICATION1
SnStartupSequence *startup_sequence;
127#endif

gdouble grouping_score;

GList *windows; /* List of the VnckTask for the window,
     if this is a class group */
guint state_changed_tag;
guint icon_changed_tag;
guint name_changed_tag;
guint class_name_changed_tag;
guint class_icon_changed_tag;

/* task menu */
CtkWidget *menu;
/* ops menu */
CtkWidget *action_menu;

guint really_toggling : 1; /* Set when tasklist really wants
                            * to change the togglebutton state
                            */
guint was_active : 1;      /* used to fixup activation behavior */

guint button_activate;

guint32 dnd_timestamp;

time_t  start_needs_attention;
gdouble glow_start_time;
gdouble glow_factor;

guint button_glow;

gint row;
gint col;

guint resize_idle_id;
163};

165struct _VnckTaskClass
166{
GObjectClass parent_class;
168};

170typedef struct _skipped_window
171{
VnckWindow *window;
gulong tag;
174} skipped_window;

176struct _VnckTasklistPrivate
177{
VnckScreen *screen;

VnckTask *active_task; /* NULL if active window not in tasklist */
VnckTask *active_class_group; /* NULL if active window not in tasklist */

gboolean include_all_workspaces;

/* Calculated by update_lists */
GList *class_groups;
GList *windows;
GList *windows_without_class_group;

/* Not handled by update_lists */
GList *startup_sequences;

/* windows with _NET_WM_STATE_SKIP_TASKBAR set; connected to
 * "state_changed" signal, but excluded from tasklist.
 */
GList *skipped_windows;

GHashTable *class_group_hash;
GHashTable *win_hash;

gint max_button_width;
gint max_button_height;

gboolean switch_workspace_on_unminimize;
gboolean middle_click_close;

VnckTasklistGroupingType grouping;
gint grouping_limit;

guint activate_timeout_id;
guint screen_connections [N_SCREEN_CONNECTIONS5];

guint idle_callback_tag;

int *size_hints;
int size_hints_len;

VnckLoadIconFunction icon_loader;
void *icon_loader_data;
GDestroyNotify free_icon_loader_data;

222#ifdef HAVE_STARTUP_NOTIFICATION1
SnMonitorContext *sn_context;
guint startup_sequence_timeout;
225#endif

CdkMonitor *monitor;
CdkRectangle monitor_geometry;
CtkReliefStyle relief;
CtkOrientation orientation;

guint drag_start_time;

gboolean scroll_enabled;
235};

237static GType vnck_task_get_type (void);

239G_DEFINE_TYPE (VnckTask, vnck_task, G_TYPE_OBJECT)static void vnck_task_init (VnckTask *self); static void vnck_task_class_init
 (VnckTaskClass *klass); static GType vnck_task_get_type_once
 (void); static gpointer vnck_task_parent_class = ((void*)0);
 static gint VnckTask_private_offset; static void vnck_task_class_intern_init
 (gpointer klass) { vnck_task_parent_class = g_type_class_peek_parent
 (klass); if (VnckTask_private_offset != 0) g_type_class_adjust_private_offset
 (klass, &VnckTask_private_offset); vnck_task_class_init (
(VnckTaskClass*) klass); } __attribute__ ((__unused__)) static
 inline gpointer vnck_task_get_instance_private (VnckTask *self
) { return (((gpointer) ((guint8*) (self) + (glong) (VnckTask_private_offset
)))); } GType vnck_task_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
) (0 ? (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
 = vnck_task_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 vnck_task_get_type_once (void) {
 GType g_define_type_id = g_type_register_static_simple (((GType
) ((20) << (2))), g_intern_static_string ("VnckTask"), sizeof
 (VnckTaskClass), (GClassInitFunc)(void (*)(void)) vnck_task_class_intern_init
, sizeof (VnckTask), (GInstanceInitFunc)(void (*)(void)) vnck_task_init
, (GTypeFlags) 0); { {{};} } return g_define_type_id; };
240G_DEFINE_TYPE_WITH_PRIVATE (VnckTasklist, vnck_tasklist, CTK_TYPE_CONTAINER)static void vnck_tasklist_init (VnckTasklist *self); static void
 vnck_tasklist_class_init (VnckTasklistClass *klass); static GType
 vnck_tasklist_get_type_once (void); static gpointer vnck_tasklist_parent_class
 = ((void*)0); static gint VnckTasklist_private_offset; static
 void vnck_tasklist_class_intern_init (gpointer klass) { vnck_tasklist_parent_class
 = g_type_class_peek_parent (klass); if (VnckTasklist_private_offset
 != 0) g_type_class_adjust_private_offset (klass, &VnckTasklist_private_offset
); vnck_tasklist_class_init ((VnckTasklistClass*) klass); } __attribute__
 ((__unused__)) static inline gpointer vnck_tasklist_get_instance_private
 (VnckTasklist *self) { return (((gpointer) ((guint8*) (self)
 + (glong) (VnckTasklist_private_offset)))); } GType vnck_tasklist_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
 = vnck_tasklist_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 vnck_tasklist_get_type_once (void
) { GType g_define_type_id = g_type_register_static_simple ((
ctk_container_get_type ()), g_intern_static_string ("VnckTasklist"
), sizeof (VnckTasklistClass), (GClassInitFunc)(void (*)(void
)) vnck_tasklist_class_intern_init, sizeof (VnckTasklist), (GInstanceInitFunc
)(void (*)(void)) vnck_tasklist_init, (GTypeFlags) 0); { {{ VnckTasklist_private_offset
 = g_type_add_instance_private (g_define_type_id, sizeof (VnckTasklistPrivate
)); };} } return g_define_type_id; };

242enum
243{
TASK_ENTER_NOTIFY,
TASK_LEAVE_NOTIFY,
LAST_SIGNAL
247};

249static void vnck_task_finalize    (GObject       *object);

251static void vnck_task_stop_glow   (VnckTask *task);

253static VnckTask *vnck_task_new_from_window      (VnckTasklist    *tasklist,
				 VnckWindow      *window);
255static VnckTask *vnck_task_new_from_class_group (VnckTasklist    *tasklist,
				 VnckClassGroup  *class_group);
257#ifdef HAVE_STARTUP_NOTIFICATION1
258static VnckTask *vnck_task_new_from_startup_sequence (VnckTasklist      *tasklist,
                                                    SnStartupSequence *sequence);
260#endif
261static gboolean vnck_task_get_needs_attention (VnckTask *task);


264static char      *vnck_task_get_text (VnckTask *task,
                                    gboolean  icon_text,
                                    gboolean  include_state);
267static GdkPixbuf *vnck_task_get_icon (VnckTask *task);
268static gint       vnck_task_compare_alphabetically (gconstpointer  a,
                                                  gconstpointer  b);
270static gint       vnck_task_compare  (gconstpointer  a,
		      gconstpointer  b);
272static void       vnck_task_update_visible_state (VnckTask *task);
273static void       vnck_task_state_changed        (VnckWindow      *window,
                                                VnckWindowState  changed_mask,
                                                VnckWindowState  new_state,
                                                gpointer         data);

278static void       vnck_task_drag_begin    (CtkWidget          *widget,
                                         CdkDragContext     *context,
                                         VnckTask           *task);
281static void       vnck_task_drag_end      (CtkWidget          *widget,
                                         CdkDragContext     *context,
                                         VnckTask           *task);
284static void       vnck_task_drag_data_get (CtkWidget          *widget,
                                         CdkDragContext     *context,
                                         CtkSelectionData   *selection_data,
                                         guint               info,
                                         guint               time,
                                         VnckTask           *task);

291static void     vnck_tasklist_finalize      (GObject        *object);

293static void     vnck_tasklist_get_preferred_width (CtkWidget *widget,
                                                 int       *minimum_width,
                                                 int       *natural_width);
296static void     vnck_tasklist_get_preferred_height (CtkWidget *widget,
                                                  int       *minimum_height,
                                                  int       *natural_height);
299static void     vnck_tasklist_size_allocate (CtkWidget        *widget,
                                           CtkAllocation    *allocation);
301static void     vnck_tasklist_realize       (CtkWidget        *widget);
302static void     vnck_tasklist_unrealize     (CtkWidget        *widget);
303static gboolean vnck_tasklist_scroll_event  (CtkWidget        *widget,
                                           CdkEventScroll   *event);
305static void     vnck_tasklist_forall        (CtkContainer     *container,
                                           gboolean	       include_internals,
                                           CtkCallback       callback,
                                           gpointer          callback_data);
309static void     vnck_tasklist_remove	    (CtkContainer   *container,
			     CtkWidget	    *widget);
311static void     vnck_tasklist_free_tasks    (VnckTasklist   *tasklist);
312static void     vnck_tasklist_update_lists  (VnckTasklist   *tasklist);
313static int      vnck_tasklist_layout        (CtkAllocation  *allocation,
			     int             max_width,
			     int             max_height,
			     int             n_buttons,
                                           CtkOrientation  orientation,
			     int            *n_cols_out,
			     int            *n_rows_out);

321static void     vnck_tasklist_active_window_changed    (VnckScreen   *screen,
                                                      VnckWindow   *previous_window,
					VnckTasklist *tasklist);
324static void     vnck_tasklist_active_workspace_changed (VnckScreen   *screen,
                                                      VnckWorkspace *previous_workspace,
					VnckTasklist *tasklist);
327static void     vnck_tasklist_window_added             (VnckScreen   *screen,
					VnckWindow   *win,
					VnckTasklist *tasklist);
330static void     vnck_tasklist_window_removed           (VnckScreen   *screen,
					VnckWindow   *win,
					VnckTasklist *tasklist);
333static void     vnck_tasklist_viewports_changed        (VnckScreen   *screen,
					VnckTasklist *tasklist);
335static void     vnck_tasklist_connect_window           (VnckTasklist *tasklist,
					VnckWindow   *window);
337static void     vnck_tasklist_disconnect_window        (VnckTasklist *tasklist,
					VnckWindow   *window);

340static void     vnck_tasklist_change_active_task       (VnckTasklist *tasklist,
					VnckTask *active_task);
342static gboolean vnck_tasklist_change_active_timeout    (gpointer data);
343static void     vnck_tasklist_activate_task_window     (VnckTask *task,
                                                      guint32   timestamp);

346static void     vnck_tasklist_update_icon_geometries   (VnckTasklist *tasklist,
					GList        *visible_tasks);
348static void     vnck_tasklist_connect_screen           (VnckTasklist *tasklist);
349static void     vnck_tasklist_disconnect_screen        (VnckTasklist *tasklist);

351#ifdef HAVE_STARTUP_NOTIFICATION1
352static void     vnck_tasklist_sn_event                 (SnMonitorEvent *event,
                                                      void           *user_data);
354static void     vnck_tasklist_check_end_sequence       (VnckTasklist   *tasklist,
                                                      VnckWindow     *window);
356#endif

358/*
* Keep track of all tasklist instances so we can decide
* whether to show windows from all monitors in the
* tasklist
*/
363static GSList *tasklist_instances;

365static void
366vnck_task_init (VnckTask *task)
367{
task->type = VNCK_TASK_WINDOW;
task->resize_idle_id = 0;
370}

372static void
373vnck_task_class_init (VnckTaskClass *klass)
374{
GObjectClass *object_class = G_OBJECT_CLASS (klass)((((GObjectClass*) (void *) g_type_check_class_cast ((GTypeClass
*) ((klass)), (((GType) ((20) << (2))))))));

object_class->finalize = vnck_task_finalize;
378}

380static gboolean
381vnck_task_button_glow (VnckTask *task)
382{
gdouble now;
gfloat fade_opacity, loop_time;
gint fade_max_loops;
gboolean stopped;

now = g_get_real_time () / G_USEC_PER_SEC1000000;

if (task->glow_start_time <= G_MINDOUBLE2.2250738585072014e-308)
  task->glow_start_time = now;

ctk_widget_style_get (CTK_WIDGET (task->tasklist)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task->tasklist)), ((ctk_widget_get_type ())))))), "fade-opacity", &fade_opacity,
                                                   "fade-loop-time", &loop_time,
                                                   "fade-max-loops", &fade_max_loops,
                                                   NULL((void*)0));

if (task->button_glow == 0)
  {
    /* we're in "has stopped glowing" mode */
    task->glow_factor = (gdouble) fade_opacity * 0.5;
    stopped = TRUE(!(0));
  }
else
  {
    task->glow_factor =
      (gdouble) fade_opacity * (0.5 -
                                0.5 * cos ((now - task->glow_start_time) *
                                           M_PI3.14159265358979323846 * 2.0 / (gdouble) loop_time));

    if (now - task->start_needs_attention > (gdouble) loop_time * 1.0 * fade_max_loops)
      stopped = ABS (task->glow_factor - (gdouble) fade_opacity * 0.5)(((task->glow_factor - (gdouble) fade_opacity * 0.5) < 0
) ? -(task->glow_factor - (gdouble) fade_opacity * 0.5) : (
task->glow_factor - (gdouble) fade_opacity * 0.5)) < 0.05;
    else
      stopped = FALSE(0);
  }

ctk_widget_queue_draw (task->button);

if (stopped)
  vnck_task_stop_glow (task);

return !stopped;
423}

425static void
426vnck_task_clear_glow_start_timeout_id (VnckTask *task)
427{
task->button_glow = 0;
429}

431static void
432vnck_task_queue_glow (VnckTask *task)
433{
if (task->button_glow == 0)
  {
    task->glow_start_time = 0.0;

    /* The animation doesn't speed up or slow down based on the
     * timeout value, but instead will just appear smoother or
     * choppier.
     */
    task->button_glow =
      g_timeout_add_full (G_PRIORITY_DEFAULT_IDLE200,
                          50,
                          (GSourceFunc) vnck_task_button_glow, task,
                          (GDestroyNotify) vnck_task_clear_glow_start_timeout_id);
  }
448}

450static void
451vnck_task_stop_glow (VnckTask *task)
452{
/* We stop glowing, but we might still have the task colored,
 * so we don't reset the glow factor */
if (task->button_glow != 0)
  g_source_remove (task->button_glow);
457}

459static void
460vnck_task_reset_glow (VnckTask *task)
461{
vnck_task_stop_glow (task);
task->glow_factor = 0.0;
464}

466static void
467vnck_task_finalize (GObject *object)
468{
VnckTask *task;

task = VNCK_TASK (object)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((object)), ((vnck_task_get_type ()))))));

if (task->tasklist->priv->active_task == task)
  vnck_tasklist_change_active_task (task->tasklist, NULL((void*)0));

if (task->button)
  {
    g_object_remove_weak_pointer (G_OBJECT (task->button)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task->button)), (((GType) ((20) << (2)))))))),
                                  (void**) &task->button);
    ctk_widget_destroy (task->button);
    task->button = NULL((void*)0);
    task->image = NULL((void*)0);
    task->label = NULL((void*)0);
  }

486#ifdef HAVE_STARTUP_NOTIFICATION1
if (task->startup_sequence)
  {
    sn_startup_sequence_unref (task->startup_sequence);
    task->startup_sequence = NULL((void*)0);
  }
492#endif

g_list_free (task->windows);
task->windows = NULL((void*)0);

if (task->state_changed_tag != 0)
  {
    g_signal_handler_disconnect (task->window,
		   task->state_changed_tag);
    task->state_changed_tag = 0;
  }

if (task->icon_changed_tag != 0)
  {
    g_signal_handler_disconnect (task->window,
		   task->icon_changed_tag);
    task->icon_changed_tag = 0;
  }

if (task->name_changed_tag != 0)
  {
    g_signal_handler_disconnect (task->window,
		   task->name_changed_tag);
    task->name_changed_tag = 0;
  }

if (task->class_name_changed_tag != 0)
  {
    g_signal_handler_disconnect (task->class_group,
		   task->class_name_changed_tag);
    task->class_name_changed_tag = 0;
  }

if (task->class_icon_changed_tag != 0)
  {
    g_signal_handler_disconnect (task->class_group,
		   task->class_icon_changed_tag);
    task->class_icon_changed_tag = 0;
  }

if (task->class_group)
  {
    g_object_unref (task->class_group);
    task->class_group = NULL((void*)0);
  }

if (task->window)
  {
    g_object_unref (task->window);
    task->window = NULL((void*)0);
  }

if (task->menu)
  {
    ctk_widget_destroy (task->menu);
    task->menu = NULL((void*)0);
  }

if (task->action_menu)
  {
    g_object_remove_weak_pointer (G_OBJECT (task->action_menu)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task->action_menu)), (((GType) ((20) << (2)))))
))),
                                  (void**) &task->action_menu);
    ctk_widget_destroy (task->action_menu);
    task->action_menu = NULL((void*)0);
  }

if (task->button_activate != 0)
  {
    g_source_remove (task->button_activate);
    task->button_activate = 0;
  }

vnck_task_stop_glow (task);

if (task->resize_idle_id > 0)
  {
    g_source_remove (task->resize_idle_id);
    task->resize_idle_id = 0;
  }

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

575static guint signals[LAST_SIGNAL] = { 0 };

577static void
578vnck_tasklist_init (VnckTasklist *tasklist)
579{
CtkWidget *widget;
AtkObject *atk_obj;

widget = CTK_WIDGET (tasklist)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((tasklist)), ((ctk_widget_get_type ()))))));

ctk_widget_set_has_window (widget, FALSE(0));

tasklist->priv = vnck_tasklist_get_instance_private (tasklist);

tasklist->priv->class_group_hash = g_hash_table_new (NULL((void*)0), NULL((void*)0));
tasklist->priv->win_hash = g_hash_table_new (NULL((void*)0), NULL((void*)0));

tasklist->priv->grouping = VNCK_TASKLIST_AUTO_GROUP;
tasklist->priv->grouping_limit = DEFAULT_GROUPING_LIMIT80;

tasklist->priv->monitor = NULL((void*)0);
tasklist->priv->monitor_geometry.width = -1; /* invalid value */
tasklist->priv->relief = CTK_RELIEF_NORMAL;
tasklist->priv->orientation = CTK_ORIENTATION_HORIZONTAL;
tasklist->priv->scroll_enabled = TRUE(!(0));

atk_obj = ctk_widget_get_accessible (widget);
atk_object_set_name (atk_obj, _("Window List")((char *) g_dgettext ("libvnck-3.0", "Window List")));
atk_object_set_description (atk_obj, _("Tool to switch between visible windows")((char *) g_dgettext ("libvnck-3.0", "Tool to switch between visible windows"
)));

605#if 0
/* This doesn't work because, and I think this is because we have no window;
 * therefore, we use the scroll events on task buttons instead */
ctk_widget_add_events (widget, CDK_SCROLL_MASK);
609#endif
610}

612static void
613vnck_tasklist_class_init (VnckTasklistClass *klass)
614{
GObjectClass *object_class = G_OBJECT_CLASS (klass)((((GObjectClass*) (void *) g_type_check_class_cast ((GTypeClass
*) ((klass)), (((GType) ((20) << (2))))))));
CtkWidgetClass *widget_class = CTK_WIDGET_CLASS (klass)((((CtkWidgetClass*) (void *) g_type_check_class_cast ((GTypeClass
*) ((klass)), ((ctk_widget_get_type ()))))));
CtkContainerClass *container_class = CTK_CONTAINER_CLASS (klass)((((CtkContainerClass*) (void *) g_type_check_class_cast ((GTypeClass
*) ((klass)), ((ctk_container_get_type ()))))));

object_class->finalize = vnck_tasklist_finalize;

widget_class->get_preferred_width = vnck_tasklist_get_preferred_width;
widget_class->get_preferred_height = vnck_tasklist_get_preferred_height;
widget_class->size_allocate = vnck_tasklist_size_allocate;
widget_class->realize = vnck_tasklist_realize;
widget_class->unrealize = vnck_tasklist_unrealize;
626#if 0
/* See comment above ctk_widget_add_events() in vnck_tasklist_init() */
widget_class->scroll_event = vnck_tasklist_scroll_event;
629#endif

container_class->forall = vnck_tasklist_forall;
container_class->remove = vnck_tasklist_remove;

/**
 * VnckTasklist:fade-loop-time:
 *
 * When a window needs attention, a fade effect is drawn on the button
 * representing the window. This property controls the time one loop of this
 * fade effect takes, in seconds.
 *
 * Since: 2.16
 */
ctk_widget_class_install_style_property (widget_class,
                                         g_param_spec_float ("fade-loop-time",
                                                            "Loop time",
                                                            "The time one loop takes when fading, in seconds. Default: 3.0",
                                                            0.2, 10.0, 3.0,
                                                            G_PARAM_READABLE|G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB));

/**
 * VnckTasklist:fade-max-loops:
 *
 * When a window needs attention, a fade effect is drawn on the button
 * representing the window. This property controls the number of loops for
 * this fade effect. 0 means the button will only fade to the final color.
 *
 * Since: 2.20
 */
ctk_widget_class_install_style_property (widget_class,
                                         g_param_spec_int ("fade-max-loops",
                                                            "Maximum number of loops",
                                                            "The number of fading loops. 0 means the button will only fade to the final color. Default: 5",
                                                            0, 50, 5,
                                                            G_PARAM_READABLE|G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB));

/**
 * VnckTasklist:fade-overlay-rect:
 *
 * When a window needs attention, a fade effect is drawn on the button
 * representing the window. Set this property to %TRUE to enable a
 * compatibility mode for pixbuf engine themes that cannot react to color
 * changes. If enabled, a rectangle with the correct color will be drawn on
 * top of the button.
 *
 * Since: 2.16
 */
ctk_widget_class_install_style_property (widget_class,
                                         g_param_spec_boolean ("fade-overlay-rect",
                                                               "Overlay a rectangle, instead of modifying the background.",
                                                               "Compatibility mode for pixbuf engine themes that cannot react to color changes. If enabled, a rectangle with the correct color will be drawn on top of the button. Default: TRUE",
                                                               TRUE(!(0)),
                                                               G_PARAM_READABLE|G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB));

/**
 * VnckTasklist:fade-opacity:
 *
 * When a window needs attention, a fade effect is drawn on the button
 * representing the window. This property controls the final opacity that
 * will be reached by the fade effect.
 *
 * Since: 2.16
 */
ctk_widget_class_install_style_property (widget_class,
                                         g_param_spec_float ("fade-opacity",
                                                            "Final opacity",
                                                            "The final opacity that will be reached. Default: 0.8",
                                                            0.0, 1.0, 0.8,
                                                            G_PARAM_READABLE|G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB));

ctk_widget_class_set_css_name (widget_class, "vnck-tasklist");

/**
 * VnckTasklist::task-enter-notify:
 * @tasklist: the #VnckTasklist which emitted the signal.
 * @windows: the #GList with all the #VnckWindow belonging to the task.
 *
 * Emitted when the task is entered.
 */
signals[TASK_ENTER_NOTIFY] =
  g_signal_new ("task_enter_notify",
                G_OBJECT_CLASS_TYPE (object_class)((((GTypeClass*) (object_class))->g_type)),
                G_SIGNAL_RUN_LAST,
                0, NULL((void*)0), NULL((void*)0), NULL((void*)0),
                G_TYPE_NONE((GType) ((1) << (2))), 1,
                G_TYPE_POINTER((GType) ((17) << (2))));

/**
 * VnckTasklist::task-leave-notify:
 * @tasklist: the #VnckTasklist which emitted the signal.
 * @windows: the #GList with all the #VnckWindow belonging to the task.
 *
 * Emitted when the task is entered.
 */
signals[TASK_LEAVE_NOTIFY] =
  g_signal_new ("task_leave_notify",
                G_OBJECT_CLASS_TYPE (object_class)((((GTypeClass*) (object_class))->g_type)),
                G_SIGNAL_RUN_LAST,
                0, NULL((void*)0), NULL((void*)0), NULL((void*)0),
                G_TYPE_NONE((GType) ((1) << (2))), 1,
                G_TYPE_POINTER((GType) ((17) << (2))));
731}

733static void
734vnck_tasklist_free_skipped_windows (VnckTasklist  *tasklist)
735{
GList *l;

l = tasklist->priv->skipped_windows;

while (l != NULL((void*)0))
  {
    skipped_window *skipped = (skipped_window*) l->data;
    g_signal_handler_disconnect (skipped->window, skipped->tag);
    g_object_unref (skipped->window);
    g_free (skipped);
    l = l->next;
  }

g_list_free (tasklist->priv->skipped_windows);
750}

752static void
753vnck_tasklist_finalize (GObject *object)
754{
VnckTasklist *tasklist;

tasklist = VNCK_TASKLIST (object)((((VnckTasklist*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((object)), ((vnck_tasklist_get_type ()))))));

/* Tasks should have gone away due to removing their
 * buttons in container destruction
 */
g_assert (tasklist->priv->class_groups == NULL)do { if (tasklist->priv->class_groups == ((void*)0)) ; else
 g_assertion_message_expr ("Vnck", "../libvnck/tasklist.c", 762
, ((const char*) (__func__)), "tasklist->priv->class_groups == NULL"
); } while (0);
g_assert (tasklist->priv->windows == NULL)do { if (tasklist->priv->windows == ((void*)0)) ; else g_assertion_message_expr
 ("Vnck", "../libvnck/tasklist.c", 763, ((const char*) (__func__
)), "tasklist->priv->windows == NULL"); } while (0);
g_assert (tasklist->priv->windows_without_class_group == NULL)do { if (tasklist->priv->windows_without_class_group ==
 ((void*)0)) ; else g_assertion_message_expr ("Vnck", "../libvnck/tasklist.c"
, 764, ((const char*) (__func__)), "tasklist->priv->windows_without_class_group == NULL"
); } while (0);
g_assert (tasklist->priv->startup_sequences == NULL)do { if (tasklist->priv->startup_sequences == ((void*)0
)) ; else g_assertion_message_expr ("Vnck", "../libvnck/tasklist.c"
, 765, ((const char*) (__func__)), "tasklist->priv->startup_sequences == NULL"
); } while (0);
/* vnck_tasklist_free_tasks (tasklist); */

if (tasklist->priv->skipped_windows)
  {
    vnck_tasklist_free_skipped_windows (tasklist);
    tasklist->priv->skipped_windows = NULL((void*)0);
  }

g_hash_table_destroy (tasklist->priv->class_group_hash);
tasklist->priv->class_group_hash = NULL((void*)0);

g_hash_table_destroy (tasklist->priv->win_hash);
tasklist->priv->win_hash = NULL((void*)0);

if (tasklist->priv->activate_timeout_id != 0)
  {
    g_source_remove (tasklist->priv->activate_timeout_id);
    tasklist->priv->activate_timeout_id = 0;
  }

if (tasklist->priv->idle_callback_tag != 0)
  {
    g_source_remove (tasklist->priv->idle_callback_tag);
    tasklist->priv->idle_callback_tag = 0;
  }

g_free (tasklist->priv->size_hints);
tasklist->priv->size_hints = NULL((void*)0);
tasklist->priv->size_hints_len = 0;

if (tasklist->priv->free_icon_loader_data != NULL((void*)0))
  (* tasklist->priv->free_icon_loader_data) (tasklist->priv->icon_loader_data);
tasklist->priv->free_icon_loader_data = NULL((void*)0);
tasklist->priv->icon_loader_data = NULL((void*)0);

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

804/**
* vnck_tasklist_set_grouping:
* @tasklist: a #VnckTasklist.
* @grouping: a grouping policy.
*
* Sets the grouping policy for @tasklist to @grouping.
*/
811void
812vnck_tasklist_set_grouping (VnckTasklist            *tasklist,
	    VnckTasklistGroupingType grouping)
814{
g_return_if_fail (VNCK_IS_TASKLIST (tasklist))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((tasklist)); GType __t = ((vnck_tasklist_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 ("Vnck", ((const char*) (__func__
)), "VNCK_IS_TASKLIST (tasklist)"); return; } } while (0);

if (tasklist->priv->grouping == grouping)
  return;

tasklist->priv->grouping = grouping;
ctk_widget_queue_resize (CTK_WIDGET (tasklist)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((tasklist)), ((ctk_widget_get_type ())))))));
822}

824static void
825vnck_tasklist_set_relief_callback (VnckWindow   *win G_GNUC_UNUSED__attribute__ ((__unused__)),
		   VnckTask     *task,
		   VnckTasklist *tasklist)
828{
ctk_button_set_relief (CTK_BUTTON (task->button)((((CtkButton*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task->button)), ((ctk_button_get_type ())))))), tasklist->priv->relief);
830}

832/**
* vnck_tasklist_set_button_relief:
* @tasklist: a #VnckTasklist.
* @relief: a relief type.
*
* Sets the relief type of the buttons in @tasklist to @relief. The main use of
* this function is proper integration of #VnckTasklist in panels with
* non-system backgrounds.
*
* Since: 2.12
*/
843void
844vnck_tasklist_set_button_relief (VnckTasklist *tasklist, CtkReliefStyle relief)
845{
GList *walk;

g_return_if_fail (VNCK_IS_TASKLIST (tasklist))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((tasklist)); GType __t = ((vnck_tasklist_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 ("Vnck", ((const char*) (__func__
)), "VNCK_IS_TASKLIST (tasklist)"); return; } } while (0);

if (relief == tasklist->priv->relief)
  return;

tasklist->priv->relief = relief;

g_hash_table_foreach (tasklist->priv->win_hash,
                      (GHFunc) vnck_tasklist_set_relief_callback,
                      tasklist);
for (walk = tasklist->priv->class_groups; walk; walk = g_list_next (walk)((walk) ? (((GList *)(walk))->next) : ((void*)0)))
  ctk_button_set_relief (CTK_BUTTON (VNCK_TASK (walk->data)->button)((((CtkButton*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((walk->data)), ((vnck_task_get_type ()))))))->button
)), ((ctk_button_get_type ())))))), relief);
860}

862/**
* vnck_tasklist_set_middle_click_close:
* @tasklist: a #VnckTasklist.
* @middle_click_close: whether to close windows with middle click on
* button.
*
* Sets @tasklist to close windows with mouse middle click on button,
* according to @middle_click_close.
*
* Since: 3.4.6
*/
873void
874vnck_tasklist_set_middle_click_close (VnckTasklist  *tasklist,
		      gboolean       middle_click_close)
876{
g_return_if_fail (VNCK_IS_TASKLIST (tasklist))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((tasklist)); GType __t = ((vnck_tasklist_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 ("Vnck", ((const char*) (__func__
)), "VNCK_IS_TASKLIST (tasklist)"); return; } } while (0);

tasklist->priv->middle_click_close = middle_click_close;
880}

882/**
* vnck_tasklist_set_orientation:
* @tasklist: a #VnckTasklist.
* @orient: a CtkOrientation.
*
* Set the orientation of the @tasklist to match @orient.
* This function can be used to integrate a #VnckTasklist in vertical panels.
*
* Since: 3.4.6
*/
892void vnck_tasklist_set_orientation (VnckTasklist *tasklist,
		    CtkOrientation orient)
894{
g_return_if_fail (VNCK_IS_TASKLIST (tasklist))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((tasklist)); GType __t = ((vnck_tasklist_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 ("Vnck", ((const char*) (__func__
)), "VNCK_IS_TASKLIST (tasklist)"); return; } } while (0);

tasklist->priv->orientation = orient;
898}

900/**
* vnck_tasklist_set_scroll_enabled:
* @tasklist: a #VnckTasklist.
* @scroll_enabled: a boolean.
*
* Sets the scroll behavior of the @tasklist. When set to %TRUE, a scroll
* event over the tasklist will change the current window accordingly.
*
* Since: 3.24.0
*/
910void
911vnck_tasklist_set_scroll_enabled (VnckTasklist *tasklist,
                                gboolean      scroll_enabled)
913{
g_return_if_fail (VNCK_IS_TASKLIST (tasklist))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((tasklist)); GType __t = ((vnck_tasklist_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 ("Vnck", ((const char*) (__func__
)), "VNCK_IS_TASKLIST (tasklist)"); return; } } while (0);

tasklist->priv->scroll_enabled = scroll_enabled;
917}

919/**
* vnck_tasklist_get_scroll_enabled:
* @tasklist: a #VnckTasklist.
*
* Gets the scroll behavior of the @tasklist.
*
* Since: 3.24.0
*/
927gboolean
928vnck_tasklist_get_scroll_enabled (VnckTasklist *tasklist)
929{
g_return_val_if_fail (VNCK_IS_TASKLIST (tasklist), TRUE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((tasklist)); GType __t = ((vnck_tasklist_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 ("Vnck", ((const char*) (__func__
)), "VNCK_IS_TASKLIST (tasklist)"); return ((!(0))); } } while
 (0);

return tasklist->priv->scroll_enabled;
933}

935/**
* vnck_tasklist_set_switch_workspace_on_unminimize:
* @tasklist: a #VnckTasklist.
* @switch_workspace_on_unminimize: whether to activate the #VnckWorkspace a
* #VnckWindow is on when unminimizing it.
*
* Sets @tasklist to activate or not the #VnckWorkspace a #VnckWindow is on
* when unminimizing it, according to @switch_workspace_on_unminimize.
*
* FIXME: does it still work?
*/
946void
947vnck_tasklist_set_switch_workspace_on_unminimize (VnckTasklist  *tasklist,
				  gboolean       switch_workspace_on_unminimize)
949{
g_return_if_fail (VNCK_IS_TASKLIST (tasklist))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((tasklist)); GType __t = ((vnck_tasklist_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 ("Vnck", ((const char*) (__func__
)), "VNCK_IS_TASKLIST (tasklist)"); return; } } while (0);

tasklist->priv->switch_workspace_on_unminimize = switch_workspace_on_unminimize;
953}

955/**
* vnck_tasklist_set_include_all_workspaces:
* @tasklist: a #VnckTasklist.
* @include_all_workspaces: whether to display #VnckWindow from all
* #VnckWorkspace in @tasklist.
*
* Sets @tasklist to display #VnckWindow from all #VnckWorkspace or not,
* according to @include_all_workspaces.
*
* Note that if the active #VnckWorkspace has a viewport and if
* @include_all_workspaces is %FALSE, then only the #VnckWindow visible in the
* viewport are displayed in @tasklist. The rationale for this is that the
* viewport is generally used to implement workspace-like behavior. A
* side-effect of this is that, when using multiple #VnckWorkspace with
* viewport, it is not possible to show all #VnckWindow from a #VnckWorkspace
* (even those that are not visible in the viewport) in @tasklist without
* showing all #VnckWindow from all #VnckWorkspace.
*/
973void
974vnck_tasklist_set_include_all_workspaces (VnckTasklist *tasklist,
			  gboolean      include_all_workspaces)
976{
g_return_if_fail (VNCK_IS_TASKLIST (tasklist))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((tasklist)); GType __t = ((vnck_tasklist_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 ("Vnck", ((const char*) (__func__
)), "VNCK_IS_TASKLIST (tasklist)"); return; } } while (0);

include_all_workspaces = (include_all_workspaces != 0);

if (tasklist->priv->include_all_workspaces == include_all_workspaces)
  return;

tasklist->priv->include_all_workspaces = include_all_workspaces;
vnck_tasklist_update_lists (tasklist);
ctk_widget_queue_resize (CTK_WIDGET (tasklist)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((tasklist)), ((ctk_widget_get_type ())))))));
987}

989/**
* vnck_tasklist_set_grouping_limit:
* @tasklist: a #VnckTasklist.
* @limit: a size in pixels.
*
* Sets the maximum size of buttons in @tasklist before @tasklist tries to
* group #VnckWindow in the same #VnckApplication in only one button. This
* limit is valid only when the grouping policy of @tasklist is
* %VNCK_TASKLIST_AUTO_GROUP.
*/
999void
1000vnck_tasklist_set_grouping_limit (VnckTasklist *tasklist,
		  gint          limit)
1002{
g_return_if_fail (VNCK_IS_TASKLIST (tasklist))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((tasklist)); GType __t = ((vnck_tasklist_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 ("Vnck", ((const char*) (__func__
)), "VNCK_IS_TASKLIST (tasklist)"); return; } } while (0);

if (tasklist->priv->grouping_limit == limit)
  return;

tasklist->priv->grouping_limit = limit;
ctk_widget_queue_resize (CTK_WIDGET (tasklist)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((tasklist)), ((ctk_widget_get_type ())))))));
1010}

1012/**
* vnck_tasklist_set_icon_loader:
* @tasklist: a #VnckTasklist
* @load_icon_func: icon loader function
* @data: data for icon loader function
* @free_data_func: function to free the data
*
* Sets a function to be used for loading icons.
*
* Since: 2.2
**/
1023void
1024vnck_tasklist_set_icon_loader (VnckTasklist         *tasklist,
                             VnckLoadIconFunction  load_icon_func,
                             void                 *data,
                             GDestroyNotify        free_data_func)
1028{
g_return_if_fail (VNCK_IS_TASKLIST (tasklist))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((tasklist)); GType __t = ((vnck_tasklist_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 ("Vnck", ((const char*) (__func__
)), "VNCK_IS_TASKLIST (tasklist)"); return; } } while (0);

if (tasklist->priv->free_icon_loader_data != NULL((void*)0))
  (* tasklist->priv->free_icon_loader_data) (tasklist->priv->icon_loader_data);

tasklist->priv->icon_loader = load_icon_func;
tasklist->priv->icon_loader_data = data;
tasklist->priv->free_icon_loader_data = free_data_func;
1037}

1039/* returns the maximal possible button width (i.e. if you
* don't want to stretch the buttons to fill the alloctions
* the width can be smaller) */
1042static int
1043vnck_tasklist_layout (CtkAllocation *allocation,
      int            max_width,
      int            max_height,
      int            n_buttons,
      CtkOrientation orientation,
      int           *n_cols_out,
      int           *n_rows_out)
1050{
int n_cols, n_rows;

if (n_buttons == 0)
  {
    *n_cols_out = 0;
    *n_rows_out = 0;
    return 0;
  }

if (orientation == CTK_ORIENTATION_HORIZONTAL)
  {
    /* How many rows fit in the allocation */
    n_rows = allocation->height / max_height;

    /* Don't have more rows than buttons */
    n_rows = MIN (n_rows, n_buttons)(((n_rows) < (n_buttons)) ? (n_rows) : (n_buttons));

    /* At least one row */
    n_rows = MAX (n_rows, 1)(((n_rows) > (1)) ? (n_rows) : (1));

    /* We want to use as many cols as possible to limit the width */
    n_cols = (n_buttons + n_rows - 1) / n_rows;

    /* At least one column */
    n_cols = MAX (n_cols, 1)(((n_cols) > (1)) ? (n_cols) : (1));
  }
else
  {
    /* How many cols fit in the allocation */
    n_cols = allocation->width / max_width;

    /* Don't have more cols than buttons */
    n_cols = MIN (n_cols, n_buttons)(((n_cols) < (n_buttons)) ? (n_cols) : (n_buttons));

    /* At least one col */
    n_cols = MAX (n_cols, 1)(((n_cols) > (1)) ? (n_cols) : (1));

    /* We want to use as many rows as possible to limit the height */
    n_rows = (n_buttons + n_cols - 1) / n_cols;

    /* At least one row */
    n_rows = MAX (n_rows, 1)(((n_rows) > (1)) ? (n_rows) : (1));
  }

*n_cols_out = n_cols;
*n_rows_out = n_rows;

return allocation->width / n_cols;
1099}

1101static void
1102vnck_tasklist_score_groups (VnckTasklist *tasklist G_GNUC_UNUSED__attribute__ ((__unused__)),
	    GList        *ungrouped_class_groups)
1104{
VnckTask *class_group_task;
VnckTask *win_task;
GList *l, *w;
const char *first_name = NULL((void*)0);
int n_windows;
int n_same_title;
double same_window_ratio;

l = ungrouped_class_groups;
while (l != NULL((void*)0))
  {
    class_group_task = VNCK_TASK (l->data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((l->data)), ((vnck_task_get_type ()))))));

    n_windows = g_list_length (class_group_task->windows);

    n_same_title = 0;
    w = class_group_task->windows;
    while (w != NULL((void*)0))
{
 win_task = VNCK_TASK (w->data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((w->data)), ((vnck_task_get_type ()))))));

 if (first_name == NULL((void*)0))
   {
            if (vnck_window_has_icon_name (win_task->window))
              first_name = vnck_window_get_icon_name (win_task->window);
            else
              first_name = vnck_window_get_name (win_task->window);
     n_same_title++;
   }
 else
   {
            const char *name;

            if (vnck_window_has_icon_name (win_task->window))
              name = vnck_window_get_icon_name (win_task->window);
            else
              name = vnck_window_get_name (win_task->window);

     if (strcmp (name, first_name) == 0)
n_same_title++;
   }

 w = w->next;
}
    same_window_ratio = (double)n_same_title/(double)n_windows;

    /* FIXME: This is fairly bogus and should be researched more.
     *        XP groups by least used, so we probably want to add
     *        total focused time to this expression.
     */
    class_group_task->grouping_score = -same_window_ratio * 5 + n_windows;

    l = l->next;
  }
1159}

1161static GList *
1162vnck_task_get_highest_scored (GList     *ungrouped_class_groups,
	      VnckTask **class_group_task_out)
1164{
VnckTask *class_group_task;
VnckTask *best_task = NULL((void*)0);
10
←
'best_task' initialized to a null pointer value→
double max_score = -1000000000.0; /* Large negative score */
GList *l;

l = ungrouped_class_groups;
while (l10.1
'l' is not equal to NULL
 != NULL((void*)0))
11
←
Loop condition is true.  Entering loop body→
14
←
Loop condition is false. Execution continues on line 1184→
  {
    class_group_task = VNCK_TASK (l->data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((l->data)), ((vnck_task_get_type ()))))));

    if (class_group_task->grouping_score >= max_score)
12
←
Assuming 'max_score' is > field 'grouping_score'→
13
←
Taking false branch→
{
 max_score = class_group_task->grouping_score;
 best_task = class_group_task;
}

    l = l->next;
  }

*class_group_task_out = best_task;
15
←
Null pointer value stored to 'class_group_task'→

return g_list_remove (ungrouped_class_groups, best_task);
1187}

1189static int
1190vnck_tasklist_get_button_size (CtkWidget *widget)
1191{
CtkStyleContext *style_context;
CtkStateFlags state;
PangoContext *context;
PangoFontMetrics *metrics;
PangoFontDescription *description;
gint char_width;
gint text_width;
gint width;

style_context = ctk_widget_get_style_context (widget);
state = ctk_style_context_get_state (style_context);
ctk_style_context_get (style_context, state, CTK_STYLE_PROPERTY_FONT"font", &description, NULL((void*)0));

context = ctk_widget_get_pango_context (widget);
metrics = pango_context_get_metrics (context, description,
                                     pango_context_get_language (context));
char_width = pango_font_metrics_get_approximate_char_width (metrics);
pango_font_metrics_unref (metrics);
text_width = PANGO_PIXELS (TASKLIST_TEXT_MAX_WIDTH * char_width)(((int)(25 * char_width) + 512) >> 10);

width = text_width + 2 * TASKLIST_BUTTON_PADDING4
 + MINI_ICON_SIZE_vnck_get_default_mini_icon_size () + 2 * TASKLIST_BUTTON_PADDING4;

return width;
1216}

1218static void
1219vnck_tasklist_size_request  (CtkWidget      *widget,
                           CtkRequisition *requisition)
1221{
VnckTasklist *tasklist;
CtkRequisition child_req;
CtkAllocation  tasklist_allocation;
CtkAllocation  fake_allocation;
int max_height = 1;
int max_width = 1;
/* int u_width, u_height; */
GList *l;
GArray *array;
GList *ungrouped_class_groups;
int n_windows;
int n_startup_sequences;
int n_rows;
int n_cols, last_n_cols;
int n_grouped_buttons;
gboolean score_set;
int val;
VnckTask *class_group_task;
int lowest_range;
int grouping_limit;

tasklist = VNCK_TASKLIST (widget)((((VnckTasklist*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((vnck_tasklist_get_type ()))))));

/* Calculate max needed height and width of the buttons */
1246#define GET_MAX_WIDTH_HEIGHT_FROM_BUTTONS(list)l = list; while (l != ((void*)0)) { VnckTask *task = ((((VnckTask
*) (void *) g_type_check_instance_cast ((GTypeInstance*) ((l->
data)), ((vnck_task_get_type ())))))); ctk_widget_get_preferred_size
 (task->button, &child_req, ((void*)0)); max_height = (
((child_req.height) > (max_height)) ? (child_req.height) :
 (max_height)); max_width = (((child_req.width) > (max_width
)) ? (child_req.width) : (max_width)); l = l->next; }                 \
l = list;                                                     \
while (l != NULL((void*)0))                                             \
  {                                                           \
    VnckTask *task = VNCK_TASK (l->data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((l->data)), ((vnck_task_get_type ()))))));                     \
                                                              \
    ctk_widget_get_preferred_size (task->button,              \
                                   &child_req, NULL((void*)0));         \
                                                              \
    max_height = MAX (child_req.height,                       \(((child_req.height) > (max_height)) ? (child_req.height) :
 (max_height))
	max_height)(((child_req.height) > (max_height)) ? (child_req.height) :
 (max_height));                            \
    max_width = MAX (child_req.width,                         \(((child_req.width) > (max_width)) ? (child_req.width) : (
max_width))
       max_width)(((child_req.width) > (max_width)) ? (child_req.width) : (
max_width));                              \
                                                              \
    l = l->next;                                              \
  }

GET_MAX_WIDTH_HEIGHT_FROM_BUTTONS (tasklist->priv->windows)l = tasklist->priv->windows; while (l != ((void*)0)) { VnckTask
 *task = ((((VnckTask*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((l->data)), ((vnck_task_get_type ())))))
); ctk_widget_get_preferred_size (task->button, &child_req
, ((void*)0)); max_height = (((child_req.height) > (max_height
)) ? (child_req.height) : (max_height)); max_width = (((child_req
.width) > (max_width)) ? (child_req.width) : (max_width));
 l = l->next; }
GET_MAX_WIDTH_HEIGHT_FROM_BUTTONS (tasklist->priv->class_groups)l = tasklist->priv->class_groups; while (l != ((void*)0
)) { VnckTask *task = ((((VnckTask*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((l->data)), ((vnck_task_get_type ())))
))); ctk_widget_get_preferred_size (task->button, &child_req
, ((void*)0)); max_height = (((child_req.height) > (max_height
)) ? (child_req.height) : (max_height)); max_width = (((child_req
.width) > (max_width)) ? (child_req.width) : (max_width));
 l = l->next; }
GET_MAX_WIDTH_HEIGHT_FROM_BUTTONS (tasklist->priv->startup_sequences)l = tasklist->priv->startup_sequences; while (l != ((void
*)0)) { VnckTask *task = ((((VnckTask*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((l->data)), ((vnck_task_get_type ())))
))); ctk_widget_get_preferred_size (task->button, &child_req
, ((void*)0)); max_height = (((child_req.height) > (max_height
)) ? (child_req.height) : (max_height)); max_width = (((child_req
.width) > (max_width)) ? (child_req.width) : (max_width));
 l = l->next; }

/* Note that the fact that we nearly don't care about the width/height
 * requested by the buttons makes it possible to hide/show the label/image
 * in vnck_task_size_allocated(). If we really cared about those, this
 * wouldn't work since our call to ctk_widget_size_request() does not take
 * into account the hidden widgets.
 */
tasklist->priv->max_button_width = vnck_tasklist_get_button_size (widget);
tasklist->priv->max_button_height = max_height;

ctk_widget_get_allocation (CTK_WIDGET (tasklist)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((tasklist)), ((ctk_widget_get_type ())))))), &tasklist_allocation);

fake_allocation.width = tasklist_allocation.width;
fake_allocation.height = tasklist_allocation.height;

array = g_array_new (FALSE(0), FALSE(0), sizeof (int));

/* Calculate size_hints list */

n_windows = g_list_length (tasklist->priv->windows);
n_startup_sequences = g_list_length (tasklist->priv->startup_sequences);
n_grouped_buttons = 0;
ungrouped_class_groups = g_list_copy (tasklist->priv->class_groups);
score_set = FALSE(0);

grouping_limit = MIN (tasklist->priv->grouping_limit,(((tasklist->priv->grouping_limit) < (tasklist->priv
->max_button_width)) ? (tasklist->priv->grouping_limit
) : (tasklist->priv->max_button_width))
	tasklist->priv->max_button_width)(((tasklist->priv->grouping_limit) < (tasklist->priv
->max_button_width)) ? (tasklist->priv->grouping_limit
) : (tasklist->priv->max_button_width));

/* Try ungrouped mode */
vnck_tasklist_layout (&fake_allocation,
	tasklist->priv->max_button_width,
	tasklist->priv->max_button_height,
	n_windows + n_startup_sequences,
	tasklist->priv->orientation,
	&n_cols, &n_rows);

last_n_cols = G_MAXINT2147483647;
lowest_range = G_MAXINT2147483647;
if (tasklist->priv->grouping != VNCK_TASKLIST_ALWAYS_GROUP)
  {
    if (tasklist->priv->orientation == CTK_ORIENTATION_HORIZONTAL)
      {
        val = n_cols * tasklist->priv->max_button_width;
        g_array_insert_val (array, array->len, val)g_array_insert_vals (array, array->len, &(val), 1);
        val = n_cols * grouping_limit;
        g_array_insert_val (array, array->len, val)g_array_insert_vals (array, array->len, &(val), 1);

        last_n_cols = n_cols;
        lowest_range = val;
      }
    else
      {
        val = n_rows * tasklist->priv->max_button_height;
        g_array_insert_val (array, array->len, val)g_array_insert_vals (array, array->len, &(val), 1);
        val = n_rows * grouping_limit;
        g_array_insert_val (array, array->len, val)g_array_insert_vals (array, array->len, &(val), 1);

        last_n_cols = n_rows;
        lowest_range = val;
      }
  }

while (ungrouped_class_groups != NULL((void*)0) &&
tasklist->priv->grouping != VNCK_TASKLIST_NEVER_GROUP)
  {
    if (!score_set)
      {
        vnck_tasklist_score_groups (tasklist, ungrouped_class_groups);
        score_set = TRUE(!(0));
      }

    ungrouped_class_groups = vnck_task_get_highest_scored (ungrouped_class_groups, &class_group_task);

    n_grouped_buttons += g_list_length (class_group_task->windows) - 1;

    vnck_tasklist_layout (&fake_allocation,
	    tasklist->priv->max_button_width,
	    tasklist->priv->max_button_height,
	    n_startup_sequences + n_windows - n_grouped_buttons,
	    tasklist->priv->orientation,
	    &n_cols, &n_rows);

    if (tasklist->priv->orientation == CTK_ORIENTATION_HORIZONTAL)
      {
        if (n_cols != last_n_cols &&
            (tasklist->priv->grouping == VNCK_TASKLIST_AUTO_GROUP ||
             ungrouped_class_groups == NULL((void*)0)))
          {
            val = n_cols * tasklist->priv->max_button_width;
            if (val >= lowest_range)
              {
                /* Overlaps old range */
                g_assert (array->len > 0)do { if (array->len > 0) ; else g_assertion_message_expr
 ("Vnck", "../libvnck/tasklist.c", 1358, ((const char*) (__func__
)), "array->len > 0"); } while (0);
                lowest_range = n_cols * grouping_limit;
                g_array_index(array, int, array->len-1)(((int*) (void *) (array)->data) [(array->len-1)]) = lowest_range;
              }
            else
              {
                /* Full new range */
                g_array_insert_val (array, array->len, val)g_array_insert_vals (array, array->len, &(val), 1);
                val = n_cols * grouping_limit;
                g_array_insert_val (array, array->len, val)g_array_insert_vals (array, array->len, &(val), 1);
                lowest_range = val;
              }

            last_n_cols = n_cols;
          }
      }
    else
      {
        if (n_rows != last_n_cols &&
            (tasklist->priv->grouping == VNCK_TASKLIST_AUTO_GROUP ||
             ungrouped_class_groups == NULL((void*)0)))
          {
            val = n_rows * tasklist->priv->max_button_height;
            if (val >= lowest_range)
              {
                /* Overlaps old range */
                g_assert (array->len > 0)do { if (array->len > 0) ; else g_assertion_message_expr
 ("Vnck", "../libvnck/tasklist.c", 1384, ((const char*) (__func__
)), "array->len > 0"); } while (0);
                lowest_range = n_rows * grouping_limit;
                g_array_index (array, int, array->len-1)(((int*) (void *) (array)->data) [(array->len-1)]) = lowest_range;
              }
            else
              {
                /* Full new range */
                g_array_insert_val (array, array->len, val)g_array_insert_vals (array, array->len, &(val), 1);
                val = n_rows * grouping_limit;
                g_array_insert_val (array, array->len, val)g_array_insert_vals (array, array->len, &(val), 1);
                lowest_range = val;
              }

            last_n_cols = n_rows;
          }
      }
  }

g_list_free (ungrouped_class_groups);

/* Always let you go down to a zero size: */
if (array->len > 0)
  {
    g_array_index(array, int, array->len-1)(((int*) (void *) (array)->data) [(array->len-1)]) = 0;
  }
else
  {
    val = 0;
    g_array_insert_val (array, 0, val)g_array_insert_vals (array, 0, &(val), 1);
    g_array_insert_val (array, 0, val)g_array_insert_vals (array, 0, &(val), 1);
  }

if (tasklist->priv->size_hints)
  g_free (tasklist->priv->size_hints);

tasklist->priv->size_hints_len = array->len;
tasklist->priv->size_hints = (int *)g_array_free (array, FALSE(0));

if (tasklist->priv->orientation == CTK_ORIENTATION_HORIZONTAL)
  {
    requisition->width = tasklist->priv->size_hints[0];
    requisition->height = fake_allocation.height;
  }
else
  {
    requisition->width = fake_allocation.width;
    requisition->height = tasklist->priv->size_hints[0];
  }
1432}

1434static void
1435vnck_tasklist_get_preferred_width (CtkWidget *widget,
                                 int       *minimum_width,
                                 int       *natural_width)
1438{
CtkRequisition req;

vnck_tasklist_size_request (widget, &req);

*minimum_width = *natural_width = req.width;
1444}

1446static void
1447vnck_tasklist_get_preferred_height (CtkWidget *widget,
                                 int       *minimum_height,
                                 int       *natural_height)
1450{
CtkRequisition req;

vnck_tasklist_size_request (widget, &req);

*minimum_height = *natural_height = req.height;
1456}


1459/**
* vnck_tasklist_get_size_hint_list:
* @tasklist: a #VnckTasklist.
* @n_elements: return location for the number of elements in the array
* returned by this function. This number should always be pair.
*
* Since a #VnckTasklist does not have a fixed size (#VnckWindow can be grouped
* when needed, for example), the standard size request mechanism in CTK+ is
* not enough to announce what sizes can be used by @tasklist. The size hints
* mechanism is a solution for this. See panel_applet_set_size_hints() for more
* information.
*
* Return value: a list of size hints that can be used to allocate an
* appropriate size for @tasklist.
*/
1474const int *
1475vnck_tasklist_get_size_hint_list (VnckTasklist  *tasklist,
		  int           *n_elements)
1477{
g_return_val_if_fail (VNCK_IS_TASKLIST (tasklist), NULL)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((tasklist)); GType __t = ((vnck_tasklist_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 ("Vnck", ((const char*) (__func__
)), "VNCK_IS_TASKLIST (tasklist)"); return (((void*)0)); } } while
 (0);
g_return_val_if_fail (n_elements != NULL, NULL)do { if ((n_elements != ((void*)0))) { } else { g_return_if_fail_warning
 ("Vnck", ((const char*) (__func__)), "n_elements != NULL"); return
 (((void*)0)); } } while (0);

*n_elements = tasklist->priv->size_hints_len;
return tasklist->priv->size_hints;
1483}

1485static gboolean
1486task_button_queue_resize (gpointer user_data)
1487{
VnckTask *task = VNCK_TASK (user_data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((user_data)), ((vnck_task_get_type ()))))));

ctk_widget_queue_resize (task->button);
task->resize_idle_id = 0;

return G_SOURCE_REMOVE(0);
1494}

1496static void
1497vnck_task_size_allocated (CtkWidget     *widget,
                        CtkAllocation *allocation,
                        gpointer       data)
1500{
VnckTask        *task = VNCK_TASK (data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((data)), ((vnck_task_get_type ()))))));
CtkStyleContext *context;
CtkStateFlags    state;
CtkBorder        padding;
int              min_image_width;
gboolean         old_image_visible;
gboolean         old_label_visible;

context = ctk_widget_get_style_context (widget);
state = ctk_style_context_get_state (context);
ctk_style_context_get_padding (context, state, &padding);

min_image_width = MINI_ICON_SIZE_vnck_get_default_mini_icon_size () +
                  padding.left + padding.right +
                  2 * TASKLIST_BUTTON_PADDING4;
old_image_visible = ctk_widget_get_visible (task->image);
old_label_visible = ctk_widget_get_visible (task->label);

if ((allocation->width < min_image_width + 2 * TASKLIST_BUTTON_PADDING4) &&
    (allocation->width >= min_image_width)) {
  ctk_widget_show (task->image);
  ctk_widget_hide (task->label);
} else if (allocation->width < min_image_width) {
  ctk_widget_hide (task->image);
  ctk_widget_show (task->label);
} else {
  ctk_widget_show (task->image);
  ctk_widget_show (task->label);
}

if (old_image_visible != ctk_widget_get_visible (task->image) ||
    old_label_visible != ctk_widget_get_visible (task->label))
  {
    if (task->resize_idle_id == 0)
      task->resize_idle_id = g_idle_add (task_button_queue_resize, task);
  }
1537}

1539static void
1540vnck_tasklist_size_allocate (CtkWidget      *widget,
                           CtkAllocation  *allocation)
1542{
CtkAllocation child_allocation;
VnckTasklist *tasklist;
VnckTask *class_group_task;
int n_windows;
int n_startup_sequences;
GList *l;
int button_width;
int total_width;
int n_rows;
int n_cols;
int n_grouped_buttons;
int i;
gboolean score_set;
GList *ungrouped_class_groups;
VnckTask *win_task;
GList *visible_tasks = NULL((void*)0);
GList *windows_sorted = NULL((void*)0);
int grouping_limit;

if (allocation->width <= 1 || allocation->height <= 1)
1
Assuming field 'width' is > 1→
2
←
Assuming field 'height' is > 1→
3
←
Taking false branch→
  {
    CTK_WIDGET_CLASS (vnck_tasklist_parent_class)((((CtkWidgetClass*) (void *) g_type_check_class_cast ((GTypeClass
*) ((vnck_tasklist_parent_class)), ((ctk_widget_get_type ()))
))))->size_allocate (widget, allocation);
    return;
  }

tasklist = VNCK_TASKLIST (widget)((((VnckTasklist*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((vnck_tasklist_get_type ()))))));

n_windows = g_list_length (tasklist->priv->windows);
n_startup_sequences = g_list_length (tasklist->priv->startup_sequences);
n_grouped_buttons = 0;
ungrouped_class_groups = g_list_copy (tasklist->priv->class_groups);
score_set = FALSE(0);

grouping_limit = MIN (tasklist->priv->grouping_limit,(((tasklist->priv->grouping_limit) < (tasklist->priv
->max_button_width)) ? (tasklist->priv->grouping_limit
) : (tasklist->priv->max_button_width))
4
←
Assuming field 'grouping_limit' is >= field 'max_button_width'→
5
←
'?' condition is false→
	tasklist->priv->max_button_width)(((tasklist->priv->grouping_limit) < (tasklist->priv
->max_button_width)) ? (tasklist->priv->grouping_limit
) : (tasklist->priv->max_button_width));

/* Try ungrouped mode */
button_width = vnck_tasklist_layout (allocation,
		       tasklist->priv->max_button_width,
		       tasklist->priv->max_button_height,
		       n_startup_sequences + n_windows,
		       tasklist->priv->orientation,
		       &n_cols, &n_rows);
while (ungrouped_class_groups != NULL((void*)0) &&
6
←
Assuming 'ungrouped_class_groups' is not equal to NULL→
((tasklist->priv->grouping == VNCK_TASKLIST_ALWAYS_GROUP) ||
7
←
Assuming field 'grouping' is equal to VNCK_TASKLIST_ALWAYS_GROUP→
 ((tasklist->priv->grouping == VNCK_TASKLIST_AUTO_GROUP) &&
  (button_width < grouping_limit))))
  {
    if (!score_set7.1
'score_set' is 0
)
8
←
Taking true branch→
{
 vnck_tasklist_score_groups (tasklist, ungrouped_class_groups);
 score_set = TRUE(!(0));
}

    ungrouped_class_groups = vnck_task_get_highest_scored (ungrouped_class_groups, &class_group_task);
9
←
Calling 'vnck_task_get_highest_scored'→
16
←
Returning from 'vnck_task_get_highest_scored'→

    n_grouped_buttons += g_list_length (class_group_task->windows) - 1;
17
←
Access to field 'windows' results in a dereference of a null pointer (loaded from variable 'class_group_task')

    if (g_list_length (class_group_task->windows) > 1)
{
 visible_tasks = g_list_prepend (visible_tasks, class_group_task);

        /* Sort */
        class_group_task->windows = g_list_sort (class_group_task->windows,
                                                 vnck_task_compare_alphabetically);

 /* Hide all this group's windows */
 l = class_group_task->windows;
 while (l != NULL((void*)0))
   {
     win_task = VNCK_TASK (l->data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((l->data)), ((vnck_task_get_type ()))))));

     ctk_widget_set_child_visible (CTK_WIDGET (win_task->button)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((win_task->button)), ((ctk_widget_get_type ())))))), FALSE(0));

     l = l->next;
   }
}
    else
{
 visible_tasks = g_list_prepend (visible_tasks, class_group_task->windows->data);
 ctk_widget_set_child_visible (CTK_WIDGET (class_group_task->button)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((class_group_task->button)), ((ctk_widget_get_type ())
))))), FALSE(0));
      }

    button_width = vnck_tasklist_layout (allocation,
			   tasklist->priv->max_button_width,
			   tasklist->priv->max_button_height,
			   n_startup_sequences + n_windows - n_grouped_buttons,
			   tasklist->priv->orientation,
			   &n_cols, &n_rows);
  }

/* Add all ungrouped windows to visible_tasks, and hide their class groups */
l = ungrouped_class_groups;
while (l != NULL((void*)0))
  {
    class_group_task = VNCK_TASK (l->data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((l->data)), ((vnck_task_get_type ()))))));

    visible_tasks = g_list_concat (visible_tasks, g_list_copy (class_group_task->windows));
    ctk_widget_set_child_visible (CTK_WIDGET (class_group_task->button)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((class_group_task->button)), ((ctk_widget_get_type ())
))))), FALSE(0));

    l = l->next;
  }

/* Add all windows that are ungrouped because they don't belong to any class
 * group */
l = tasklist->priv->windows_without_class_group;
while (l != NULL((void*)0))
  {
    VnckTask *task;

    task = VNCK_TASK (l->data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((l->data)), ((vnck_task_get_type ()))))));
    visible_tasks = g_list_append (visible_tasks, task);

    l = l->next;
  }

/* Add all startup sequences */
visible_tasks = g_list_concat (visible_tasks, g_list_copy (tasklist->priv->startup_sequences));

/* Sort */
visible_tasks = g_list_sort (visible_tasks, vnck_task_compare);

/* Allocate children */
l = visible_tasks;
i = 0;
total_width = tasklist->priv->max_button_width * n_cols;
total_width = MIN (total_width, allocation->width)(((total_width) < (allocation->width)) ? (total_width) :
 (allocation->width));
/* FIXME: this is obviously wrong, but if we don't this, some space that the
 * panel allocated to us won't have the panel popup menu, but the tasklist
 * popup menu */
total_width = allocation->width;
while (l != NULL((void*)0))
  {
    VnckTask *task = VNCK_TASK (l->data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((l->data)), ((vnck_task_get_type ()))))));
    int row = i % n_rows;
    int col = i / n_rows;

    if (ctk_widget_get_direction (widget) == CTK_TEXT_DIR_RTL)
      col = n_cols - col - 1;

    child_allocation.x = total_width*col / n_cols;
    child_allocation.y = allocation->height*row / n_rows;
    child_allocation.width = total_width*(col + 1) / n_cols - child_allocation.x;
    child_allocation.height = allocation->height*(row + 1) / n_rows - child_allocation.y;
    child_allocation.x += allocation->x;
    child_allocation.y += allocation->y;

    ctk_widget_size_allocate (task->button, &child_allocation);
    ctk_widget_set_child_visible (CTK_WIDGET (task->button)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task->button)), ((ctk_widget_get_type ())))))), TRUE(!(0)));

    if (task->type != VNCK_TASK_STARTUP_SEQUENCE)
      {
        GList *ll;

        /* Build sorted windows list */
        if (g_list_length (task->windows) > 1)
          windows_sorted = g_list_concat (windows_sorted,
                                         g_list_copy (task->windows));
        else
          windows_sorted = g_list_append (windows_sorted, task);
        task->row = row;
        task->col = col;
        for (ll = task->windows; ll; ll = ll->next)
          {
            VNCK_TASK (ll->data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((ll->data)), ((vnck_task_get_type ()))))))->row = row;
            VNCK_TASK (ll->data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((ll->data)), ((vnck_task_get_type ()))))))->col = col;
          }
      }
    i++;
    l = l->next;
  }

/* Update icon geometries. */
vnck_tasklist_update_icon_geometries (tasklist, visible_tasks);

g_list_free (visible_tasks);
g_list_free (tasklist->priv->windows);
g_list_free (ungrouped_class_groups);
tasklist->priv->windows = windows_sorted;

CTK_WIDGET_CLASS (vnck_tasklist_parent_class)((((CtkWidgetClass*) (void *) g_type_check_class_cast ((GTypeClass
*) ((vnck_tasklist_parent_class)), ((ctk_widget_get_type ()))
))))->size_allocate (widget,
                                                              allocation);
1725}

1727static void
1728foreach_tasklist (VnckTasklist *tasklist,
  gpointer      user_data G_GNUC_UNUSED__attribute__ ((__unused__)))
1730{
vnck_tasklist_update_lists (tasklist);
1732}

1734static void
1735vnck_tasklist_realize (CtkWidget *widget)
1736{
VnckTasklist *tasklist;
CdkScreen *cdkscreen;

tasklist = VNCK_TASKLIST (widget)((((VnckTasklist*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((vnck_tasklist_get_type ()))))));

cdkscreen = ctk_widget_get_screen (widget);
tasklist->priv->screen = vnck_screen_get (cdk_x11_screen_get_screen_number (cdkscreen));
g_assert (tasklist->priv->screen != NULL)do { if (tasklist->priv->screen != ((void*)0)) ; else g_assertion_message_expr
 ("Vnck", "../libvnck/tasklist.c", 1744, ((const char*) (__func__
)), "tasklist->priv->screen != NULL"); } while (0);

1746#ifdef HAVE_STARTUP_NOTIFICATION1
tasklist->priv->sn_context =
  sn_monitor_context_new (_vnck_screen_get_sn_display (tasklist->priv->screen),
                          vnck_screen_get_number (tasklist->priv->screen),
                          vnck_tasklist_sn_event,
                          tasklist,
                          NULL((void*)0));
1753#endif

(* CTK_WIDGET_CLASS (vnck_tasklist_parent_class)((((CtkWidgetClass*) (void *) g_type_check_class_cast ((GTypeClass
*) ((vnck_tasklist_parent_class)), ((ctk_widget_get_type ()))
))))->realize) (widget);

tasklist_instances = g_slist_append (tasklist_instances, tasklist);
g_slist_foreach (tasklist_instances, (GFunc) foreach_tasklist, NULL((void*)0));

vnck_tasklist_update_lists (tasklist);

vnck_tasklist_connect_screen (tasklist);
1763}

1765static void
1766vnck_tasklist_unrealize (CtkWidget *widget)
1767{
VnckTasklist *tasklist;

tasklist = VNCK_TASKLIST (widget)((((VnckTasklist*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((vnck_tasklist_get_type ()))))));

vnck_tasklist_disconnect_screen (tasklist);
tasklist->priv->screen = NULL((void*)0);

1775#ifdef HAVE_STARTUP_NOTIFICATION1
sn_monitor_context_unref (tasklist->priv->sn_context);
tasklist->priv->sn_context = NULL((void*)0);
1778#endif

(* CTK_WIDGET_CLASS (vnck_tasklist_parent_class)((((CtkWidgetClass*) (void *) g_type_check_class_cast ((GTypeClass
*) ((vnck_tasklist_parent_class)), ((ctk_widget_get_type ()))
))))->unrealize) (widget);

tasklist_instances = g_slist_remove (tasklist_instances, tasklist);
g_slist_foreach (tasklist_instances, (GFunc) foreach_tasklist, NULL((void*)0));
1784}

1786static void
1787vnck_tasklist_forall (CtkContainer *container,
      gboolean      include_internals G_GNUC_UNUSED__attribute__ ((__unused__)),
      CtkCallback   callback,
      gpointer      callback_data)
1791{
VnckTasklist *tasklist;
GList *tmp;

tasklist = VNCK_TASKLIST (container)((((VnckTasklist*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((container)), ((vnck_tasklist_get_type ()))))));

tmp = tasklist->priv->windows;
while (tmp != NULL((void*)0))
  {
    VnckTask *task = VNCK_TASK (tmp->data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((tmp->data)), ((vnck_task_get_type ()))))));
    tmp = tmp->next;

    (* callback) (task->button, callback_data);
  }

tmp = tasklist->priv->class_groups;
while (tmp != NULL((void*)0))
  {
    VnckTask *task = VNCK_TASK (tmp->data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((tmp->data)), ((vnck_task_get_type ()))))));
    tmp = tmp->next;

    (* callback) (task->button, callback_data);
  }

tmp = tasklist->priv->startup_sequences;
while (tmp != NULL((void*)0))
  {
    VnckTask *task = VNCK_TASK (tmp->data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((tmp->data)), ((vnck_task_get_type ()))))));
    tmp = tmp->next;

    (* callback) (task->button, callback_data);
  }
1823}

1825static void
1826vnck_tasklist_remove (CtkContainer   *container,
      CtkWidget	     *widget)
1828{
VnckTasklist *tasklist;
GList *tmp;

g_return_if_fail (VNCK_IS_TASKLIST (container))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((container)); GType __t = ((vnck_tasklist_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 ("Vnck", ((const char*) (__func__
)), "VNCK_IS_TASKLIST (container)"); return; } } while (0);
g_return_if_fail (widget != NULL)do { if ((widget != ((void*)0))) { } else { g_return_if_fail_warning
 ("Vnck", ((const char*) (__func__)), "widget != NULL"); return
; } } while (0);

tasklist = VNCK_TASKLIST (container)((((VnckTasklist*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((container)), ((vnck_tasklist_get_type ()))))));

/* it's safer to handle windows_without_class_group before windows */
tmp = tasklist->priv->windows_without_class_group;
while (tmp != NULL((void*)0))
  {
    VnckTask *task = VNCK_TASK (tmp->data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((tmp->data)), ((vnck_task_get_type ()))))));
    tmp = tmp->next;

    if (task->button == widget)
{
 tasklist->priv->windows_without_class_group =
   g_list_remove (tasklist->priv->windows_without_class_group,
	   task);
        g_object_unref (task);
 break;
}
  }

tmp = tasklist->priv->windows;
while (tmp != NULL((void*)0))
  {
    VnckTask *task = VNCK_TASK (tmp->data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((tmp->data)), ((vnck_task_get_type ()))))));
    tmp = tmp->next;

    if (task->button == widget)
{
 g_hash_table_remove (tasklist->priv->win_hash,
	       task->window);
 tasklist->priv->windows =
   g_list_remove (tasklist->priv->windows,
	   task);

        ctk_widget_unparent (widget);
        g_object_unref (task);
 break;
}
  }

tmp = tasklist->priv->class_groups;
while (tmp != NULL((void*)0))
  {
    VnckTask *task = VNCK_TASK (tmp->data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((tmp->data)), ((vnck_task_get_type ()))))));
    tmp = tmp->next;

    if (task->button == widget)
{
 g_hash_table_remove (tasklist->priv->class_group_hash,
	       task->class_group);
 tasklist->priv->class_groups =
   g_list_remove (tasklist->priv->class_groups,
	   task);

        ctk_widget_unparent (widget);
        g_object_unref (task);
 break;
}
  }

tmp = tasklist->priv->startup_sequences;
while (tmp != NULL((void*)0))
  {
    VnckTask *task = VNCK_TASK (tmp->data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((tmp->data)), ((vnck_task_get_type ()))))));
    tmp = tmp->next;

    if (task->button == widget)
{
 tasklist->priv->startup_sequences =
   g_list_remove (tasklist->priv->startup_sequences,
	   task);

        ctk_widget_unparent (widget);
        g_object_unref (task);
 break;
}
  }

ctk_widget_queue_resize (CTK_WIDGET (container)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((container)), ((ctk_widget_get_type ())))))));
1913}

1915static void
1916vnck_tasklist_connect_screen (VnckTasklist *tasklist)
1917{
GList *windows;
guint *c;
int    i;
VnckScreen *screen;

g_return_if_fail (tasklist->priv->screen != NULL)do { if ((tasklist->priv->screen != ((void*)0))) { } else
 { g_return_if_fail_warning ("Vnck", ((const char*) (__func__
)), "tasklist->priv->screen != NULL"); return; } } while
 (0);

screen = tasklist->priv->screen;

i = 0;
c = tasklist->priv->screen_connections;

c [i++] = g_signal_connect_object (G_OBJECT (screen)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((screen)), (((GType) ((20) << (2)))))))), "active_window_changed",
                                   G_CALLBACK (vnck_tasklist_active_window_changed)((GCallback) (vnck_tasklist_active_window_changed)),
                                   tasklist, 0);
c [i++] = g_signal_connect_object (G_OBJECT (screen)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((screen)), (((GType) ((20) << (2)))))))), "active_workspace_changed",
                                   G_CALLBACK (vnck_tasklist_active_workspace_changed)((GCallback) (vnck_tasklist_active_workspace_changed)),
                                   tasklist, 0);
c [i++] = g_signal_connect_object (G_OBJECT (screen)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((screen)), (((GType) ((20) << (2)))))))), "window_opened",
                                   G_CALLBACK (vnck_tasklist_window_added)((GCallback) (vnck_tasklist_window_added)),
                                   tasklist, 0);
c [i++] = g_signal_connect_object (G_OBJECT (screen)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((screen)), (((GType) ((20) << (2)))))))), "window_closed",
                                   G_CALLBACK (vnck_tasklist_window_removed)((GCallback) (vnck_tasklist_window_removed)),
                                   tasklist, 0);
c [i++] = g_signal_connect_object (G_OBJECT (screen)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((screen)), (((GType) ((20) << (2)))))))), "viewports_changed",
                                   G_CALLBACK (vnck_tasklist_viewports_changed)((GCallback) (vnck_tasklist_viewports_changed)),
                                   tasklist, 0);


g_assert (i == N_SCREEN_CONNECTIONS)do { if (i == 5) ; else g_assertion_message_expr ("Vnck", "../libvnck/tasklist.c"
, 1947, ((const char*) (__func__)), "i == N_SCREEN_CONNECTIONS"
); } while (0);

windows = vnck_screen_get_windows (screen);
while (windows != NULL((void*)0))
  {
    vnck_tasklist_connect_window (tasklist, windows->data);
    windows = windows->next;
  }
1955}

1957static void
1958vnck_tasklist_disconnect_screen (VnckTasklist *tasklist)
1959{
GList *windows;
int    i;

windows = vnck_screen_get_windows (tasklist->priv->screen);
while (windows != NULL((void*)0))
  {
    vnck_tasklist_disconnect_window (tasklist, windows->data);
    windows = windows->next;
  }

i = 0;
while (i < N_SCREEN_CONNECTIONS5)
  {
    if (tasklist->priv->screen_connections [i] != 0)
      g_signal_handler_disconnect (G_OBJECT (tasklist->priv->screen)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((tasklist->priv->screen)), (((GType) ((20) <<
 (2)))))))),
                                   tasklist->priv->screen_connections [i]);

    tasklist->priv->screen_connections [i] = 0;

    ++i;
  }

g_assert (i == N_SCREEN_CONNECTIONS)do { if (i == 5) ; else g_assertion_message_expr ("Vnck", "../libvnck/tasklist.c"
, 1982, ((const char*) (__func__)), "i == N_SCREEN_CONNECTIONS"
); } while (0);

1984#ifdef HAVE_STARTUP_NOTIFICATION1
if (tasklist->priv->startup_sequence_timeout != 0)
  {
    g_source_remove (tasklist->priv->startup_sequence_timeout);
    tasklist->priv->startup_sequence_timeout = 0;
  }
1990#endif
1991}

1993static gboolean
1994vnck_tasklist_scroll_event (CtkWidget      *widget,
                          CdkEventScroll *event)
1996{
/* use the fact that tasklist->priv->windows is sorted
 * see vnck_tasklist_size_allocate() */
VnckTasklist *tasklist;
CtkTextDirection ltr;
GList *window;
gint row = 0;
gint col = 0;

tasklist = VNCK_TASKLIST (widget)((((VnckTasklist*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((vnck_tasklist_get_type ()))))));

if (!tasklist->priv->scroll_enabled)
  return FALSE(0);

window = g_list_find (tasklist->priv->windows,
                      tasklist->priv->active_task);
if (window)
  {
    row = VNCK_TASK (window->data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((window->data)), ((vnck_task_get_type ()))))))->row;
    col = VNCK_TASK (window->data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((window->data)), ((vnck_task_get_type ()))))))->col;
  }
else
  if (tasklist->priv->activate_timeout_id)
    /* There is no active_task yet, but there will be one after the timeout.
     * It occurs if we change the active task too fast. */
    return TRUE(!(0));

ltr = (ctk_widget_get_direction (CTK_WIDGET (tasklist)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((tasklist)), ((ctk_widget_get_type ()))))))) != CTK_TEXT_DIR_RTL);

switch (event->direction)
  {
    case CDK_SCROLL_UP:
      if (!window)
        window = g_list_last (tasklist->priv->windows);
      else
        window = window->prev;
    break;

    case CDK_SCROLL_DOWN:
      if (!window)
        window = tasklist->priv->windows;
      else
        window = window->next;
    break;

2041#define TASKLIST_GET_MOST_LEFT(ltr, window, tasklist)   \
do                                                    \
  {                                                   \
    if (ltr)                                          \
      window = tasklist->priv->windows;               \
    else                                              \
      window = g_list_last (tasklist->priv->windows); \
  } while (0)

2050#define TASKLIST_GET_MOST_RIGHT(ltr, window, tasklist)  \
do                                                    \
  {                                                   \
    if (ltr)                                          \
      window = g_list_last (tasklist->priv->windows); \
    else                                              \
      window = tasklist->priv->windows;               \
  } while (0)

    case CDK_SCROLL_LEFT:
      if (!window)
        TASKLIST_GET_MOST_RIGHT (ltr, window, tasklist);
      else
        {
          /* Search the first window on the previous colomn at same row */
          if (ltr)
            {
              while (window && (VNCK_TASK(window->data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((window->data)), ((vnck_task_get_type ()))))))->row != row ||
                                VNCK_TASK(window->data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((window->data)), ((vnck_task_get_type ()))))))->col != col-1))
                window = window->prev;
            }
          else
            {
              while (window && (VNCK_TASK(window->data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((window->data)), ((vnck_task_get_type ()))))))->row != row ||
                                VNCK_TASK(window->data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((window->data)), ((vnck_task_get_type ()))))))->col != col-1))
                window = window->next;
            }
          /* If no window found, select the top/bottom left one */
          if (!window)
            TASKLIST_GET_MOST_LEFT (ltr, window, tasklist);
        }
    break;

    case CDK_SCROLL_RIGHT:
      if (!window)
        TASKLIST_GET_MOST_LEFT (ltr, window, tasklist);
      else
        {
          /* Search the first window on the next colomn at same row */
          if (ltr)
            {
              while (window && (VNCK_TASK(window->data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((window->data)), ((vnck_task_get_type ()))))))->row != row ||
                                VNCK_TASK(window->data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((window->data)), ((vnck_task_get_type ()))))))->col != col+1))
                window = window->next;
            }
          else
            {
              while (window && (VNCK_TASK(window->data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((window->data)), ((vnck_task_get_type ()))))))->row != row ||
                                VNCK_TASK(window->data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((window->data)), ((vnck_task_get_type ()))))))->col != col+1))
                window = window->prev;
            }
          /* If no window found, select the top/bottom right one */
          if (!window)
            TASKLIST_GET_MOST_RIGHT (ltr, window, tasklist);
        }
    break;

    case CDK_SCROLL_SMOOTH:
      window = NULL((void*)0);
    break;

2111#undef TASKLIST_GET_MOST_LEFT
2112#undef TASKLIST_GET_MOST_RIGHT

    default:
      g_assert_not_reached ()do { g_assertion_message_expr ("Vnck", "../libvnck/tasklist.c"
, 2115, ((const char*) (__func__)), ((void*)0)); } while (0);
  }

if (window)
  vnck_tasklist_activate_task_window (window->data, event->time);

return TRUE(!(0));
2122}

2124/**
* vnck_tasklist_new:
*
* Creates a new #VnckTasklist. The #VnckTasklist will list #VnckWindow of the
* #VnckScreen it is on.
*
* Return value: a newly created #VnckTasklist.
*/
2132CtkWidget*
2133vnck_tasklist_new (void)
2134{
VnckTasklist *tasklist;

tasklist = g_object_new (VNCK_TYPE_TASKLIST(vnck_tasklist_get_type ()), NULL((void*)0));

return CTK_WIDGET (tasklist)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((tasklist)), ((ctk_widget_get_type ()))))));
2140}

2142static void
2143vnck_tasklist_free_tasks (VnckTasklist *tasklist)
2144{
GList *l;

tasklist->priv->active_task = NULL((void*)0);
tasklist->priv->active_class_group = NULL((void*)0);

if (tasklist->priv->windows)
  {
    l = tasklist->priv->windows;
    while (l != NULL((void*)0))
{
 VnckTask *task = VNCK_TASK (l->data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((l->data)), ((vnck_task_get_type ()))))));
 l = l->next;
        /* if we just unref the task it means we lose our ref to the
         * task before we unparent the button, which breaks stuff.
         */
 ctk_widget_destroy (task->button);
}
  }
g_assert (tasklist->priv->windows == NULL)do { if (tasklist->priv->windows == ((void*)0)) ; else g_assertion_message_expr
 ("Vnck", "../libvnck/tasklist.c", 2163, ((const char*) (__func__
)), "tasklist->priv->windows == NULL"); } while (0);
g_assert (tasklist->priv->windows_without_class_group == NULL)do { if (tasklist->priv->windows_without_class_group ==
 ((void*)0)) ; else g_assertion_message_expr ("Vnck", "../libvnck/tasklist.c"
, 2164, ((const char*) (__func__)), "tasklist->priv->windows_without_class_group == NULL"
); } while (0);
g_assert (g_hash_table_size (tasklist->priv->win_hash) == 0)do { if (g_hash_table_size (tasklist->priv->win_hash) ==
 0) ; else g_assertion_message_expr ("Vnck", "../libvnck/tasklist.c"
, 2165, ((const char*) (__func__)), "g_hash_table_size (tasklist->priv->win_hash) == 0"
); } while (0);

if (tasklist->priv->class_groups)
  {
    l = tasklist->priv->class_groups;
    while (l != NULL((void*)0))
{
 VnckTask *task = VNCK_TASK (l->data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((l->data)), ((vnck_task_get_type ()))))));
 l = l->next;
        /* if we just unref the task it means we lose our ref to the
         * task before we unparent the button, which breaks stuff.
         */
 ctk_widget_destroy (task->button);
}
  }

g_assert (tasklist->priv->class_groups == NULL)do { if (tasklist->priv->class_groups == ((void*)0)) ; else
 g_assertion_message_expr ("Vnck", "../libvnck/tasklist.c", 2181
, ((const char*) (__func__)), "tasklist->priv->class_groups == NULL"
); } while (0);
g_assert (g_hash_table_size (tasklist->priv->class_group_hash) == 0)do { if (g_hash_table_size (tasklist->priv->class_group_hash
) == 0) ; else g_assertion_message_expr ("Vnck", "../libvnck/tasklist.c"
, 2182, ((const char*) (__func__)), "g_hash_table_size (tasklist->priv->class_group_hash) == 0"
); } while (0);

if (tasklist->priv->skipped_windows)
  {
    vnck_tasklist_free_skipped_windows (tasklist);
    tasklist->priv->skipped_windows = NULL((void*)0);
  }
2189}


2192/*
* This function determines if a window should be included in the tasklist.
*/
2195static gboolean
2196tasklist_include_window_impl (VnckTasklist *tasklist,
                            VnckWindow   *win,
                            gboolean      check_for_skipped_list)
2199{
VnckWorkspace *active_workspace;
int x, y, w, h;

if (!check_for_skipped_list &&
    vnck_window_get_state (win) & VNCK_WINDOW_STATE_SKIP_TASKLIST)
  return FALSE(0);

if (tasklist->priv->monitor != NULL((void*)0))
  {
    CdkDisplay *display;
    CdkMonitor *monitor;

    vnck_window_get_geometry (win, &x, &y, &w, &h);

    /* Don't include the window if its center point is not on the same monitor */

    display = cdk_display_get_default ();
    monitor = cdk_display_get_monitor_at_point (display, x + w / 2, y + h / 2);

    if (monitor != tasklist->priv->monitor)
      return FALSE(0);
  }

/* Remainder of checks aren't relevant for checking if the window should
 * be in the skipped list.
 */
if (check_for_skipped_list)
  return TRUE(!(0));

if (tasklist->priv->include_all_workspaces)
  return TRUE(!(0));

if (vnck_window_is_pinned (win))
  return TRUE(!(0));

active_workspace = vnck_screen_get_active_workspace (tasklist->priv->screen);
if (active_workspace == NULL((void*)0))
  return TRUE(!(0));

if (vnck_window_or_transient_needs_attention (win))
  return TRUE(!(0));

if (active_workspace != vnck_window_get_workspace (win))
  return FALSE(0);

if (!vnck_workspace_is_virtual (active_workspace))
  return TRUE(!(0));

return vnck_window_is_in_viewport (win, active_workspace);
2249}

2251static gboolean
2252tasklist_include_in_skipped_list (VnckTasklist *tasklist, VnckWindow *win)
2253{
return tasklist_include_window_impl (tasklist,
                                     win,
                                     TRUE(!(0)) /* check_for_skipped_list */);
2257}

2259static gboolean
2260vnck_tasklist_include_window (VnckTasklist *tasklist, VnckWindow *win)
2261{
return tasklist_include_window_impl (tasklist,
                                     win,
                                     FALSE(0) /* check_for_skipped_list */);
2265}

2267static void
2268vnck_tasklist_update_lists (VnckTasklist *tasklist)
2269{
CdkWindow *tasklist_window;
GList *windows;
VnckWindow *win;
VnckClassGroup *class_group;
GList *l;
VnckTask *win_task;
VnckTask *class_group_task;

vnck_tasklist_free_tasks (tasklist);

/* vnck_tasklist_update_lists() will be called on realize */
if (!ctk_widget_get_realized (CTK_WIDGET (tasklist)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((tasklist)), ((ctk_widget_get_type ()))))))))
  return;

tasklist_window = ctk_widget_get_window (CTK_WIDGET (tasklist)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((tasklist)), ((ctk_widget_get_type ())))))));

if (tasklist_window != NULL((void*)0))
  {
    /*
     * only show windows from this monitor if there is more than one tasklist running
     */
    if (tasklist_instances == NULL((void*)0) || tasklist_instances->next == NULL((void*)0))
      {
        tasklist->priv->monitor = NULL((void*)0);
      }
    else
      {
        CdkDisplay *display;
        CdkMonitor *monitor;

        display = cdk_display_get_default ();
        monitor = cdk_display_get_monitor_at_window (display, tasklist_window);

        if (monitor != tasklist->priv->monitor)
          {
            tasklist->priv->monitor = monitor;
            cdk_monitor_get_geometry (monitor, &tasklist->priv->monitor_geometry);
          }
      }
  }

l = windows = vnck_screen_get_windows (tasklist->priv->screen);
while (l != NULL((void*)0))
  {
    win = VNCK_WINDOW (l->data)((((VnckWindow*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((l->data)), ((vnck_window_get_type ()))))));

    if (vnck_tasklist_include_window (tasklist, win))
{
 win_task = vnck_task_new_from_window (tasklist, win);
 tasklist->priv->windows = g_list_prepend (tasklist->priv->windows, win_task);
 g_hash_table_insert (tasklist->priv->win_hash, win, win_task);

 ctk_widget_set_parent (win_task->button, CTK_WIDGET (tasklist)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((tasklist)), ((ctk_widget_get_type ())))))));
 ctk_widget_show (win_task->button);

 /* Class group */

 class_group = vnck_window_get_class_group (win);
        /* don't group windows if they do not belong to any class */
        if (strcmp (vnck_class_group_get_id (class_group), "") != 0)
          {
            class_group_task =
                      g_hash_table_lookup (tasklist->priv->class_group_hash,
                                           class_group);

            if (class_group_task == NULL((void*)0))
              {
                class_group_task =
                                vnck_task_new_from_class_group (tasklist,
                                                                class_group);
                ctk_widget_set_parent (class_group_task->button,
                                       CTK_WIDGET (tasklist)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((tasklist)), ((ctk_widget_get_type ())))))));
                ctk_widget_show (class_group_task->button);

                tasklist->priv->class_groups =
                                g_list_prepend (tasklist->priv->class_groups,
                                                class_group_task);
                g_hash_table_insert (tasklist->priv->class_group_hash,
                                     class_group, class_group_task);
              }

            class_group_task->windows =
                                  g_list_prepend (class_group_task->windows,
                                                  win_task);
          }
        else
          {
            g_object_ref (win_task)((__typeof__ (win_task)) (g_object_ref) (win_task));
            tasklist->priv->windows_without_class_group =
                            g_list_prepend (tasklist->priv->windows_without_class_group,
                                            win_task);
          }
}
    else if (tasklist_include_in_skipped_list (tasklist, win))
      {
        skipped_window *skipped = g_new0 (skipped_window, 1)((skipped_window *) g_malloc0_n ((1), sizeof (skipped_window)
));
        skipped->window = g_object_ref (win)((__typeof__ (win)) (g_object_ref) (win));
        skipped->tag = g_signal_connect (G_OBJECT (win),g_signal_connect_data ((((((GObject*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((win)), (((GType) ((20) << (2))))))
))), ("state_changed"), (((GCallback) (vnck_task_state_changed
))), (tasklist), ((void*)0), (GConnectFlags) 0)
                                         "state_changed",g_signal_connect_data ((((((GObject*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((win)), (((GType) ((20) << (2))))))
))), ("state_changed"), (((GCallback) (vnck_task_state_changed
))), (tasklist), ((void*)0), (GConnectFlags) 0)
                                         G_CALLBACK (vnck_task_state_changed),g_signal_connect_data ((((((GObject*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((win)), (((GType) ((20) << (2))))))
))), ("state_changed"), (((GCallback) (vnck_task_state_changed
))), (tasklist), ((void*)0), (GConnectFlags) 0)
                                         tasklist)g_signal_connect_data ((((((GObject*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((win)), (((GType) ((20) << (2))))))
))), ("state_changed"), (((GCallback) (vnck_task_state_changed
))), (tasklist), ((void*)0), (GConnectFlags) 0);
        tasklist->priv->skipped_windows =
          g_list_prepend (tasklist->priv->skipped_windows,
                          (gpointer) skipped);
      }

    l = l->next;
  }

/* Sort the class group list */
l = tasklist->priv->class_groups;
while (l)
  {
    class_group_task = VNCK_TASK (l->data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((l->data)), ((vnck_task_get_type ()))))));

    class_group_task->windows = g_list_sort (class_group_task->windows, vnck_task_compare);

    /* so the number of windows in the task gets reset on the
     * task label
     */
    vnck_task_update_visible_state (class_group_task);

    l = l->next;
  }

/* since we cleared active_window we need to reset it */
vnck_tasklist_active_window_changed (tasklist->priv->screen, NULL((void*)0), tasklist);

ctk_widget_queue_resize (CTK_WIDGET (tasklist)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((tasklist)), ((ctk_widget_get_type ())))))));
2399}

2401static void
2402vnck_tasklist_change_active_task (VnckTasklist *tasklist, VnckTask *active_task)
2403{
if (active_task &&
    active_task == tasklist->priv->active_task)
  return;

g_assert (active_task == NULL ||do { if (active_task == ((void*)0) || active_task->type !=
 VNCK_TASK_STARTUP_SEQUENCE) ; else g_assertion_message_expr (
"Vnck", "../libvnck/tasklist.c", 2409, ((const char*) (__func__
)), "active_task == NULL || active_task->type != VNCK_TASK_STARTUP_SEQUENCE"
); } while (0)
          active_task->type != VNCK_TASK_STARTUP_SEQUENCE)do { if (active_task == ((void*)0) || active_task->type !=
 VNCK_TASK_STARTUP_SEQUENCE) ; else g_assertion_message_expr (
"Vnck", "../libvnck/tasklist.c", 2409, ((const char*) (__func__
)), "active_task == NULL || active_task->type != VNCK_TASK_STARTUP_SEQUENCE"
); } while (0);

if (tasklist->priv->active_task)
  {
    tasklist->priv->active_task->really_toggling = TRUE(!(0));
    ctk_toggle_button_set_active (CTK_TOGGLE_BUTTON (tasklist->priv->active_task->button)((((CtkToggleButton*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((tasklist->priv->active_task->button)), ((ctk_toggle_button_get_type
 ())))))),
		    FALSE(0));
    tasklist->priv->active_task->really_toggling = FALSE(0);
  }

tasklist->priv->active_task = active_task;

if (tasklist->priv->active_task)
  {
    tasklist->priv->active_task->really_toggling = TRUE(!(0));
    ctk_toggle_button_set_active (CTK_TOGGLE_BUTTON (tasklist->priv->active_task->button)((((CtkToggleButton*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((tasklist->priv->active_task->button)), ((ctk_toggle_button_get_type
 ())))))),
		    TRUE(!(0)));
    tasklist->priv->active_task->really_toggling = FALSE(0);
  }

if (active_task)
  {
    active_task = g_hash_table_lookup (tasklist->priv->class_group_hash,
			 active_task->class_group);

    if (active_task &&
 active_task == tasklist->priv->active_class_group)
return;

    if (tasklist->priv->active_class_group)
{
 tasklist->priv->active_class_group->really_toggling = TRUE(!(0));
 ctk_toggle_button_set_active (CTK_TOGGLE_BUTTON (tasklist->priv->active_class_group->button)((((CtkToggleButton*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((tasklist->priv->active_class_group->button)), (
(ctk_toggle_button_get_type ())))))),
			FALSE(0));
 tasklist->priv->active_class_group->really_toggling = FALSE(0);
}

    tasklist->priv->active_class_group = active_task;

    if (tasklist->priv->active_class_group)
{
 tasklist->priv->active_class_group->really_toggling = TRUE(!(0));
 ctk_toggle_button_set_active (CTK_TOGGLE_BUTTON (tasklist->priv->active_class_group->button)((((CtkToggleButton*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((tasklist->priv->active_class_group->button)), (
(ctk_toggle_button_get_type ())))))),
			TRUE(!(0)));
 tasklist->priv->active_class_group->really_toggling = FALSE(0);
}
  }
2456}

2458static void
2459vnck_tasklist_update_icon_geometries (VnckTasklist *tasklist G_GNUC_UNUSED__attribute__ ((__unused__)),
		      GList        *visible_tasks)
2461{
gint x, y, width, height;
GList *l1;

for (l1 = visible_tasks; l1; l1 = l1->next) {
VnckTask *task = VNCK_TASK (l1->data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((l1->data)), ((vnck_task_get_type ()))))));
              CtkAllocation allocation;

if (!ctk_widget_get_realized (task->button))
	continue;

              /* Let's cheat with some internal knowledge of CtkButton: in a
               * CtkButton, the window is the same as the parent window. So
               * to know the position of the widget, we should use the
               * the position of the parent window and the allocation information. */

              ctk_widget_get_allocation (task->button, &allocation);

              cdk_window_get_origin (ctk_widget_get_parent_window (task->button),
                                     &x, &y);

              x += allocation.x;
              y += allocation.y;
              width = allocation.width;
              height = allocation.height;

if (task->window)
	vnck_window_set_icon_geometry (task->window,
				       x, y, width, height);
else {
	GList *l2;

	for (l2 = task->windows; l2; l2 = l2->next) {
		VnckTask *win_task = VNCK_TASK (l2->data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((l2->data)), ((vnck_task_get_type ()))))));

		g_assert (win_task->window)do { if (win_task->window) ; else g_assertion_message_expr
 ("Vnck", "../libvnck/tasklist.c", 2496, ((const char*) (__func__
)), "win_task->window"); } while (0);

		vnck_window_set_icon_geometry (win_task->window,
					       x, y, width, height);
	}
}
}
2503}

2505static void
2506vnck_tasklist_active_window_changed (VnckScreen   *screen,
		     VnckWindow   *previous_window G_GNUC_UNUSED__attribute__ ((__unused__)),
		     VnckTasklist *tasklist)
2509{
VnckWindow *active_window;
VnckWindow *initial_window;
VnckTask *active_task = NULL((void*)0);

/* FIXME: check for group modal window */
initial_window = active_window = vnck_screen_get_active_window (screen);
active_task = g_hash_table_lookup (tasklist->priv->win_hash, active_window);
while (active_window && !active_task)
  {
    active_window = vnck_window_get_transient (active_window);
    active_task = g_hash_table_lookup (tasklist->priv->win_hash,
                                       active_window);
    /* Check for transient cycles */
    if (active_window == initial_window)
      break;
  }

vnck_tasklist_change_active_task (tasklist, active_task);
2528}

2530static void
2531vnck_tasklist_active_workspace_changed (VnckScreen    *screen G_GNUC_UNUSED__attribute__ ((__unused__)),
			VnckWorkspace *previous_workspace G_GNUC_UNUSED__attribute__ ((__unused__)),
			VnckTasklist  *tasklist)
2534{
vnck_tasklist_update_lists (tasklist);
ctk_widget_queue_resize (CTK_WIDGET (tasklist)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((tasklist)), ((ctk_widget_get_type ())))))));
2537}

2539static void
2540vnck_tasklist_window_changed_workspace (VnckWindow   *window,
			VnckTasklist *tasklist)
2542{
VnckWorkspace *active_ws;
VnckWorkspace *window_ws;
gboolean       need_update;
GList         *l;

active_ws = vnck_screen_get_active_workspace (tasklist->priv->screen);
window_ws = vnck_window_get_workspace (window);

if (!window_ws)
  return;

need_update = FALSE(0);

if (active_ws == window_ws)
  need_update = TRUE(!(0));

l = tasklist->priv->windows;
while (!need_update && l != NULL((void*)0))
  {
    VnckTask *task = l->data;

    if (task->type == VNCK_TASK_WINDOW &&
        task->window == window)
      need_update = TRUE(!(0));

    l = l->next;
  }

if (need_update)
  {
    vnck_tasklist_update_lists (tasklist);
    ctk_widget_queue_resize (CTK_WIDGET (tasklist)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((tasklist)), ((ctk_widget_get_type ())))))));
  }
2576}

2578static gboolean
2579do_vnck_tasklist_update_lists (gpointer data)
2580{
VnckTasklist *tasklist = VNCK_TASKLIST (data)((((VnckTasklist*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((data)), ((vnck_tasklist_get_type ()))))));

tasklist->priv->idle_callback_tag = 0;

vnck_tasklist_update_lists (tasklist);

return FALSE(0);
2588}

2590static void
2591vnck_tasklist_window_changed_geometry (VnckWindow   *window,
		       VnckTasklist *tasklist)
2593{
CdkWindow *tasklist_window;
VnckTask *win_task;
gboolean show;
gboolean monitor_changed;
int x, y, w, h;

if (tasklist->priv->idle_callback_tag != 0)
  return;

tasklist_window = ctk_widget_get_window (CTK_WIDGET (tasklist)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((tasklist)), ((ctk_widget_get_type ())))))));

/*
 * If the (parent of the) tasklist itself skips
 * the tasklist, we need an extra check whether
 * the tasklist itself possibly changed monitor.
 */
monitor_changed = FALSE(0);
if (tasklist->priv->monitor != NULL((void*)0) &&
    (vnck_window_get_state (window) & VNCK_WINDOW_STATE_SKIP_TASKLIST) &&
    tasklist_window != NULL((void*)0))
  {
    /* Do the extra check only if there is a suspect of a monitor change (= this window is off monitor) */
    vnck_window_get_geometry (window, &x, &y, &w, &h);
    if (!POINT_IN_RECT (x + w / 2, y + h / 2, tasklist->priv->monitor_geometry)((x + w / 2) >= (tasklist->priv->monitor_geometry).x
 && (x + w / 2) < ((tasklist->priv->monitor_geometry
).x + (tasklist->priv->monitor_geometry).width) &&
 (y + h / 2) >= (tasklist->priv->monitor_geometry).y
 && (y + h / 2) < ((tasklist->priv->monitor_geometry
).y + (tasklist->priv->monitor_geometry).height)))
      {
        CdkDisplay *display;
        CdkMonitor *monitor;

        display = cdk_display_get_default ();
        monitor = cdk_display_get_monitor_at_window (display, tasklist_window);

        monitor_changed = (monitor != tasklist->priv->monitor);
      }
  }

/*
 * We want to re-generate the task list if
 * the window is shown but shouldn't be or
 * the window isn't shown but should be or
 * the tasklist itself changed monitor.
 */
win_task = g_hash_table_lookup (tasklist->priv->win_hash, window);
show = vnck_tasklist_include_window (tasklist, window);
if (((win_task == NULL((void*)0) && !show) || (win_task != NULL((void*)0) && show)) &&
    !monitor_changed)
  return;

/* Don't keep any stale references */
ctk_widget_queue_draw (CTK_WIDGET (tasklist)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((tasklist)), ((ctk_widget_get_type ())))))));

tasklist->priv->idle_callback_tag = g_idle_add (do_vnck_tasklist_update_lists, tasklist);
2645}

2647static void
2648vnck_tasklist_connect_window (VnckTasklist *tasklist,
	      VnckWindow   *window)
2650{
g_signal_connect_object (window, "workspace_changed",
	   G_CALLBACK (vnck_tasklist_window_changed_workspace)((GCallback) (vnck_tasklist_window_changed_workspace)),
	   tasklist, 0);
g_signal_connect_object (window, "geometry_changed",
	   G_CALLBACK (vnck_tasklist_window_changed_geometry)((GCallback) (vnck_tasklist_window_changed_geometry)),
	   tasklist, 0);
2657}

2659static void
2660vnck_tasklist_disconnect_window (VnckTasklist *tasklist,
	         VnckWindow   *window)
2662{
g_signal_handlers_disconnect_by_func (window,g_signal_handlers_disconnect_matched ((window), (GSignalMatchType
) (G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA), 0, 0, ((void*)
0), (vnck_tasklist_window_changed_workspace), (tasklist))
                                      vnck_tasklist_window_changed_workspace,g_signal_handlers_disconnect_matched ((window), (GSignalMatchType
) (G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA), 0, 0, ((void*)
0), (vnck_tasklist_window_changed_workspace), (tasklist))
                                      tasklist)g_signal_handlers_disconnect_matched ((window), (GSignalMatchType
) (G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA), 0, 0, ((void*)
0), (vnck_tasklist_window_changed_workspace), (tasklist));
g_signal_handlers_disconnect_by_func (window,g_signal_handlers_disconnect_matched ((window), (GSignalMatchType
) (G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA), 0, 0, ((void*)
0), (vnck_tasklist_window_changed_geometry), (tasklist))
                                      vnck_tasklist_window_changed_geometry,g_signal_handlers_disconnect_matched ((window), (GSignalMatchType
) (G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA), 0, 0, ((void*)
0), (vnck_tasklist_window_changed_geometry), (tasklist))
                                      tasklist)g_signal_handlers_disconnect_matched ((window), (GSignalMatchType
) (G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA), 0, 0, ((void*)
0), (vnck_tasklist_window_changed_geometry), (tasklist));
2669}

2671static void
2672vnck_tasklist_window_added (VnckScreen   *screen G_GNUC_UNUSED__attribute__ ((__unused__)),
	    VnckWindow   *win,
	    VnckTasklist *tasklist)
2675{
2676#ifdef HAVE_STARTUP_NOTIFICATION1
vnck_tasklist_check_end_sequence (tasklist, win);
2678#endif

vnck_tasklist_connect_window (tasklist, win);

vnck_tasklist_update_lists (tasklist);
ctk_widget_queue_resize (CTK_WIDGET (tasklist)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((tasklist)), ((ctk_widget_get_type ())))))));
2684}

2686static void
2687vnck_tasklist_window_removed (VnckScreen   *screen G_GNUC_UNUSED__attribute__ ((__unused__)),
	      VnckWindow   *win G_GNUC_UNUSED__attribute__ ((__unused__)),
	      VnckTasklist *tasklist)
2690{
vnck_tasklist_update_lists (tasklist);
ctk_widget_queue_resize (CTK_WIDGET (tasklist)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((tasklist)), ((ctk_widget_get_type ())))))));
2693}

2695static void
2696vnck_tasklist_viewports_changed (VnckScreen   *screen G_GNUC_UNUSED__attribute__ ((__unused__)),
		 VnckTasklist *tasklist)
2698{
vnck_tasklist_update_lists (tasklist);
ctk_widget_queue_resize (CTK_WIDGET (tasklist)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((tasklist)), ((ctk_widget_get_type ())))))));
2701}

2703static gboolean
2704vnck_tasklist_change_active_timeout (gpointer data)
2705{
VnckTasklist *tasklist = VNCK_TASKLIST (data)((((VnckTasklist*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((data)), ((vnck_tasklist_get_type ()))))));

tasklist->priv->activate_timeout_id = 0;

vnck_tasklist_active_window_changed (tasklist->priv->screen, NULL((void*)0), tasklist);

return FALSE(0);
2713}

2715static void
2716vnck_task_menu_activated (CtkMenuItem *menu_item G_GNUC_UNUSED__attribute__ ((__unused__)),
	  gpointer     data)
2718{
VnckTask *task = VNCK_TASK (data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((data)), ((vnck_task_get_type ()))))));

/* This is an "activate" callback function so ctk_get_current_event_time()
 * will suffice.
 */
vnck_tasklist_activate_task_window (task, ctk_get_current_event_time ());
2725}

2727static void
2728vnck_tasklist_activate_next_in_class_group (VnckTask *task,
                                          guint32   timestamp)
2730{
VnckTask *activate_task;
gboolean  activate_next;
GList    *l;

activate_task = NULL((void*)0);
activate_next = FALSE(0);

l = task->windows;
while (l)
  {
    VnckTask *tmp;

    tmp = VNCK_TASK (l->data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((l->data)), ((vnck_task_get_type ()))))));

    if (vnck_window_is_most_recently_activated (tmp->window))
      activate_next = TRUE(!(0));
    else if (activate_next)
      {
        activate_task = tmp;
        break;
      }

    l = l->next;
  }

/* no task in this group is active, or only the last one => activate
 * the first task */
if (!activate_task && task->windows)
  activate_task = VNCK_TASK (task->windows->data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task->windows->data)), ((vnck_task_get_type ()))))
));

if (activate_task)
  {
    task->was_active = FALSE(0);
    vnck_tasklist_activate_task_window (activate_task, timestamp);
  }
2766}

2768static void
2769vnck_tasklist_activate_task_window (VnckTask *task,
                                  guint32   timestamp)
2771{
VnckTasklist *tasklist;
VnckWindowState state;
VnckWorkspace *active_ws;
VnckWorkspace *window_ws;

tasklist = task->tasklist;

if (task->window == NULL((void*)0))
  return;

state = vnck_window_get_state (task->window);

active_ws = vnck_screen_get_active_workspace (tasklist->priv->screen);
window_ws = vnck_window_get_workspace (task->window);

if (state & VNCK_WINDOW_STATE_MINIMIZED)
  {
    if (window_ws &&
        active_ws != window_ws &&
        !tasklist->priv->switch_workspace_on_unminimize)
      vnck_workspace_activate (window_ws, timestamp);

    vnck_window_activate_transient (task->window, timestamp);
  }
else
  {
    if ((task->was_active ||
         vnck_window_transient_is_most_recently_activated (task->window)) &&
        (!window_ws || active_ws == window_ws))
{
 task->was_active = FALSE(0);
 vnck_window_minimize (task->window);
 return;
}
    else
{
        /* FIXME: THIS IS SICK AND WRONG AND BUGGY.  See the end of
         * http://mail.gnome.org/archives/wm-spec-list/2005-July/msg00032.html
         * There should only be *one* activate call.
         */
        if (window_ws)
          vnck_workspace_activate (window_ws, timestamp);

        vnck_window_activate_transient (task->window, timestamp);
      }
  }


if (tasklist->priv->activate_timeout_id)
  g_source_remove (tasklist->priv->activate_timeout_id);

tasklist->priv->activate_timeout_id =
  g_timeout_add (500, &vnck_tasklist_change_active_timeout, tasklist);

vnck_tasklist_change_active_task (tasklist, task);
2827}

2829static void
2830vnck_task_close_all (CtkMenuItem *menu_item G_GNUC_UNUSED__attribute__ ((__unused__)),
     gpointer     data)
2832{
VnckTask *task = VNCK_TASK (data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((data)), ((vnck_task_get_type ()))))));
GList *l;

l = task->windows;
while (l)
  {
    VnckTask *child = VNCK_TASK (l->data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((l->data)), ((vnck_task_get_type ()))))));
    vnck_window_close (child->window, ctk_get_current_event_time ());
    l = l->next;
  }
2843}

2845static void
2846vnck_task_unminimize_all (CtkMenuItem *menu_item G_GNUC_UNUSED__attribute__ ((__unused__)),
	  gpointer     data)
2848{
VnckTask *task = VNCK_TASK (data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((data)), ((vnck_task_get_type ()))))));
GList *l;

l = task->windows;
while (l)
  {
    VnckTask *child = VNCK_TASK (l->data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((l->data)), ((vnck_task_get_type ()))))));
    /* This is inside an activate callback, so ctk_get_current_event_time()
     * will work.
     */
    vnck_window_unminimize (child->window, ctk_get_current_event_time ());
    l = l->next;
  }
2862}

2864static void
2865vnck_task_minimize_all (CtkMenuItem *menu_item G_GNUC_UNUSED__attribute__ ((__unused__)),
	gpointer     data)
2867{
VnckTask *task = VNCK_TASK (data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((data)), ((vnck_task_get_type ()))))));
GList *l;

l = task->windows;
while (l)
  {
    VnckTask *child = VNCK_TASK (l->data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((l->data)), ((vnck_task_get_type ()))))));
    vnck_window_minimize (child->window);
    l = l->next;
  }
2878}

2880static void
2881vnck_task_unmaximize_all (CtkMenuItem *menu_item G_GNUC_UNUSED__attribute__ ((__unused__)),
	  gpointer     data)
2883{
VnckTask *task = VNCK_TASK (data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((data)), ((vnck_task_get_type ()))))));
GList *l;

l = task->windows;
while (l)
  {
    VnckTask *child = VNCK_TASK (l->data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((l->data)), ((vnck_task_get_type ()))))));
    vnck_window_unmaximize (child->window);
    l = l->next;
  }
2894}

2896static void
2897vnck_task_maximize_all (CtkMenuItem *menu_item G_GNUC_UNUSED__attribute__ ((__unused__)),
	gpointer     data)
2899{
VnckTask *task = VNCK_TASK (data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((data)), ((vnck_task_get_type ()))))));
GList *l;

l = task->windows;
while (l)
  {
    VnckTask *child = VNCK_TASK (l->data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((l->data)), ((vnck_task_get_type ()))))));
    vnck_window_maximize (child->window);
    l = l->next;
  }
2910}

2912static void
2913vnck_task_popup_menu (VnckTask *task,
                    gboolean  action_submenu)
2915{
CtkWidget *menu;
VnckTask *win_task;
char *text;
GdkPixbuf *pixbuf;
CtkWidget *menu_item;
GList *l, *list;

g_return_if_fail (task->type == VNCK_TASK_CLASS_GROUP)do { if ((task->type == VNCK_TASK_CLASS_GROUP)) { } else {
 g_return_if_fail_warning ("Vnck", ((const char*) (__func__))
, "task->type == VNCK_TASK_CLASS_GROUP"); return; } } while
 (0);

if (task->class_group == NULL((void*)0))
  return;

if (task->menu == NULL((void*)0))
  {
    task->menu = ctk_menu_new ();
    g_object_ref_sink (task->menu)((__typeof__ (task->menu)) (g_object_ref_sink) (task->menu
));
  }

menu = task->menu;

/* Remove old menu content */
list = ctk_container_get_children (CTK_CONTAINER (menu)((((CtkContainer*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((menu)), ((ctk_container_get_type ())))))));
l = list;
while (l)
  {
    CtkWidget *child = CTK_WIDGET (l->data)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((l->data)), ((ctk_widget_get_type ()))))));
    ctk_container_remove (CTK_CONTAINER (menu)((((CtkContainer*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((menu)), ((ctk_container_get_type ())))))), child);
    l = l->next;
  }
g_list_free (list);

l = task->windows;
while (l)
  {
    win_task = VNCK_TASK (l->data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((l->data)), ((vnck_task_get_type ()))))));

    text = vnck_task_get_text (win_task, TRUE(!(0)), TRUE(!(0)));
    menu_item = vnck_image_menu_item_new_with_label (text);
    g_free (text);

    if (vnck_task_get_needs_attention (win_task))
      _make_ctk_label_bold (CTK_LABEL (ctk_bin_get_child (CTK_BIN (menu_item)))((((CtkLabel*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((ctk_bin_get_child (((((CtkBin*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((menu_item)), ((ctk_bin_get_type ()))))))
))), ((ctk_label_get_type ())))))));

    text = vnck_task_get_text (win_task, FALSE(0), FALSE(0));
    ctk_widget_set_tooltip_text (menu_item, text);
    g_free (text);

    pixbuf = vnck_task_get_icon (win_task);
    if (pixbuf)
      {
        VnckImageMenuItem *item;

        item = VNCK_IMAGE_MENU_ITEM (menu_item);

        vnck_image_menu_item_set_image_from_icon_pixbuf (item, pixbuf);
        g_object_unref (pixbuf);
      }

    ctk_widget_show (menu_item);

    if (action_submenu)
      ctk_menu_item_set_submenu (CTK_MENU_ITEM (menu_item)((((CtkMenuItem*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((menu_item)), ((ctk_menu_item_get_type ())))))),
                                 vnck_action_menu_new (win_task->window));
    else
      {
        static const CtkTargetEntry targets[] = {
          { (gchar *) "application/x-vnck-window-id", 0, 0 }
        };

        g_signal_connect_object (G_OBJECT (menu_item)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((menu_item)), (((GType) ((20) << (2)))))))), "activate",
                                 G_CALLBACK (vnck_task_menu_activated)((GCallback) (vnck_task_menu_activated)),
                                 G_OBJECT (win_task)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((win_task)), (((GType) ((20) << (2)))))))),
                                 0);


        ctk_drag_source_set (menu_item, CDK_BUTTON1_MASK,
                             targets, 1, CDK_ACTION_MOVE);
        g_signal_connect_object (G_OBJECT(menu_item)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((menu_item)), (((GType) ((20) << (2)))))))), "drag_begin",
                                 G_CALLBACK (vnck_task_drag_begin)((GCallback) (vnck_task_drag_begin)),
                                 G_OBJECT (win_task)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((win_task)), (((GType) ((20) << (2)))))))),
                                 0);
        g_signal_connect_object (G_OBJECT(menu_item)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((menu_item)), (((GType) ((20) << (2)))))))), "drag_end",
                                 G_CALLBACK (vnck_task_drag_end)((GCallback) (vnck_task_drag_end)),
                                 G_OBJECT (win_task)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((win_task)), (((GType) ((20) << (2)))))))),
                                 0);
        g_signal_connect_object (G_OBJECT(menu_item)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((menu_item)), (((GType) ((20) << (2)))))))), "drag_data_get",
                                 G_CALLBACK (vnck_task_drag_data_get)((GCallback) (vnck_task_drag_data_get)),
                                 G_OBJECT (win_task)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((win_task)), (((GType) ((20) << (2)))))))),
                                 0);
      }

    ctk_menu_shell_append (CTK_MENU_SHELL (menu)((((CtkMenuShell*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((menu)), ((ctk_menu_shell_get_type ())))))), menu_item);

    l = l->next;
  }

/* In case of Right click, show Minimize All, Unminimize All, Close All*/
if (action_submenu)
  {
    CtkWidget *separator;

    separator = ctk_separator_menu_item_new ();
    ctk_widget_show (separator);
    ctk_menu_shell_append (CTK_MENU_SHELL (menu)((((CtkMenuShell*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((menu)), ((ctk_menu_shell_get_type ())))))), separator);

    menu_item = ctk_menu_item_new_with_mnemonic (_("Mi_nimize All")((char *) g_dgettext ("libvnck-3.0", "Mi_nimize All")));
    ctk_widget_show (menu_item);
    ctk_menu_shell_append (CTK_MENU_SHELL (menu)((((CtkMenuShell*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((menu)), ((ctk_menu_shell_get_type ())))))), menu_item);
    g_signal_connect_object (G_OBJECT (menu_item)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((menu_item)), (((GType) ((20) << (2)))))))), "activate",
   		       G_CALLBACK (vnck_task_minimize_all)((GCallback) (vnck_task_minimize_all)),
	       G_OBJECT (task)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task)), (((GType) ((20) << (2)))))))),
	       0);

    menu_item =  ctk_menu_item_new_with_mnemonic (_("Un_minimize All")((char *) g_dgettext ("libvnck-3.0", "Un_minimize All")));
    ctk_widget_show (menu_item);
    ctk_menu_shell_append (CTK_MENU_SHELL (menu)((((CtkMenuShell*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((menu)), ((ctk_menu_shell_get_type ())))))), menu_item);
    g_signal_connect_object (G_OBJECT (menu_item)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((menu_item)), (((GType) ((20) << (2)))))))), "activate",
			       G_CALLBACK (vnck_task_unminimize_all)((GCallback) (vnck_task_unminimize_all)),
	       G_OBJECT (task)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task)), (((GType) ((20) << (2)))))))),
	       0);

    menu_item = ctk_menu_item_new_with_mnemonic (_("Ma_ximize All")((char *) g_dgettext ("libvnck-3.0", "Ma_ximize All")));
    ctk_widget_show (menu_item);
    ctk_menu_shell_append (CTK_MENU_SHELL (menu)((((CtkMenuShell*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((menu)), ((ctk_menu_shell_get_type ())))))), menu_item);
    g_signal_connect_object (G_OBJECT (menu_item)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((menu_item)), (((GType) ((20) << (2)))))))), "activate",
			       G_CALLBACK (vnck_task_maximize_all)((GCallback) (vnck_task_maximize_all)),
	       G_OBJECT (task)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task)), (((GType) ((20) << (2)))))))),
	       0);

    menu_item =  ctk_menu_item_new_with_mnemonic (_("_Unmaximize All")((char *) g_dgettext ("libvnck-3.0", "_Unmaximize All")));
    ctk_widget_show (menu_item);
    ctk_menu_shell_append (CTK_MENU_SHELL (menu)((((CtkMenuShell*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((menu)), ((ctk_menu_shell_get_type ())))))), menu_item);
    g_signal_connect_object (G_OBJECT (menu_item)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((menu_item)), (((GType) ((20) << (2)))))))), "activate",
			       G_CALLBACK (vnck_task_unmaximize_all)((GCallback) (vnck_task_unmaximize_all)),
	       G_OBJECT (task)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task)), (((GType) ((20) << (2)))))))),
	       0);

    separator = ctk_separator_menu_item_new ();
    ctk_widget_show (separator);
    ctk_menu_shell_append (CTK_MENU_SHELL (menu)((((CtkMenuShell*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((menu)), ((ctk_menu_shell_get_type ())))))), separator);

    menu_item = ctk_menu_item_new_with_mnemonic(_("_Close All")((char *) g_dgettext ("libvnck-3.0", "_Close All")));
    ctk_widget_show (menu_item);
    ctk_menu_shell_append (CTK_MENU_SHELL (menu)((((CtkMenuShell*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((menu)), ((ctk_menu_shell_get_type ())))))), menu_item);
    g_signal_connect_object (G_OBJECT (menu_item)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((menu_item)), (((GType) ((20) << (2)))))))), "activate",
	       G_CALLBACK (vnck_task_close_all)((GCallback) (vnck_task_close_all)),
	       G_OBJECT (task)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task)), (((GType) ((20) << (2)))))))),
	       0);
  }

ctk_menu_set_screen (CTK_MENU (menu)((((CtkMenu*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((menu)), ((ctk_menu_get_type ())))))),
       _vnck_screen_get_cdk_screen (task->tasklist->priv->screen));

ctk_widget_show (menu);
ctk_menu_popup_at_widget (CTK_MENU (menu)((((CtkMenu*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((menu)), ((ctk_menu_get_type ())))))), task->button,
                          CDK_GRAVITY_SOUTH_WEST,
                          CDK_GRAVITY_NORTH_WEST,
                          NULL((void*)0));
3074}

3076static void
3077vnck_task_button_toggled (CtkButton *button,
	  VnckTask  *task)
3079{
/* Did we really want to change the state of the togglebutton? */
if (task->really_toggling)
  return;

/* Undo the toggle */
task->really_toggling = TRUE(!(0));
ctk_toggle_button_set_active (CTK_TOGGLE_BUTTON (button)((((CtkToggleButton*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((button)), ((ctk_toggle_button_get_type ())))))),
		!ctk_toggle_button_get_active (CTK_TOGGLE_BUTTON (button)((((CtkToggleButton*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((button)), ((ctk_toggle_button_get_type ()))))))));
task->really_toggling = FALSE(0);

switch (task->type)
  {
  case VNCK_TASK_CLASS_GROUP:
    vnck_task_popup_menu (task, FALSE(0));
    break;
  case VNCK_TASK_WINDOW:
    if (task->window == NULL((void*)0))
return;

    /* This should only be called by clicking on the task button, so
     * ctk_get_current_event_time() should be fine here...
     */
    vnck_tasklist_activate_task_window (task, ctk_get_current_event_time ());
    break;
  case VNCK_TASK_STARTUP_SEQUENCE:
    break;
  default:
    break;
  }
3109}

3111static char *
3112vnck_task_get_text (VnckTask *task,
                  gboolean  icon_text,
                  gboolean  include_state)
3115{
const char *name;

switch (task->type)
  {
  case VNCK_TASK_CLASS_GROUP:
    name = vnck_class_group_get_name (task->class_group);
    if (name[0] != 0)
return g_strdup_printf ("%s (%d)",
		name,
		g_list_length (task->windows));
    else
return g_strdup_printf ("(%d)",
		g_list_length (task->windows));

  case VNCK_TASK_WINDOW:
    return _vnck_window_get_name_for_display (task->window,
                                              icon_text, include_state);
    break;

  case VNCK_TASK_STARTUP_SEQUENCE:
3136#ifdef HAVE_STARTUP_NOTIFICATION1
    name = sn_startup_sequence_get_description (task->startup_sequence);
    if (name == NULL((void*)0))
      name = sn_startup_sequence_get_name (task->startup_sequence);
    if (name == NULL((void*)0))
      name = sn_startup_sequence_get_binary_name (task->startup_sequence);

    return g_strdup (name)g_strdup_inline (name);
3144#else
    return NULL((void*)0);
3146#endif
    break;

  default:
    break;
  }

return NULL((void*)0);
3154}

3156static void
3157vnck_dimm_icon (GdkPixbuf *pixbuf)
3158{
int x, y, pixel_stride, row_stride;
guchar *row, *pixels;
int w, h;

g_assert (pixbuf != NULL)do { if (pixbuf != ((void*)0)) ; else g_assertion_message_expr
 ("Vnck", "../libvnck/tasklist.c", 3163, ((const char*) (__func__
)), "pixbuf != NULL"); } while (0);

w = gdk_pixbuf_get_width (pixbuf);
h = gdk_pixbuf_get_height (pixbuf);

g_assert (gdk_pixbuf_get_has_alpha (pixbuf))do { if (gdk_pixbuf_get_has_alpha (pixbuf)) ; else g_assertion_message_expr
 ("Vnck", "../libvnck/tasklist.c", 3168, ((const char*) (__func__
)), "gdk_pixbuf_get_has_alpha (pixbuf)"); } while (0);

pixel_stride = 4;

row = gdk_pixbuf_get_pixels (pixbuf);
row_stride = gdk_pixbuf_get_rowstride (pixbuf);

for (y = 0; y < h; y++)
  {
    pixels = row;

    for (x = 0; x < w; x++)
{
 pixels[3] /= 2;

 pixels += pixel_stride;
}

    row += row_stride;
  }
3188}

3190static GdkPixbuf *
3191vnck_task_scale_icon (GdkPixbuf *orig, gboolean minimized)
3192{
int w, h;
GdkPixbuf *pixbuf;

if (!orig)
  return NULL((void*)0);

w = gdk_pixbuf_get_width (orig);
h = gdk_pixbuf_get_height (orig);

if (h != (int) MINI_ICON_SIZE_vnck_get_default_mini_icon_size () ||
    !gdk_pixbuf_get_has_alpha (orig))
  {
    double scale;

    pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB,
	       TRUE(!(0)),
	       8,
	       MINI_ICON_SIZE_vnck_get_default_mini_icon_size () * w / (double) h,
	       MINI_ICON_SIZE_vnck_get_default_mini_icon_size ());

    scale = MINI_ICON_SIZE_vnck_get_default_mini_icon_size () / (double) gdk_pixbuf_get_height (orig);

    gdk_pixbuf_scale (orig,
	pixbuf,
	0, 0,
	gdk_pixbuf_get_width (pixbuf),
	gdk_pixbuf_get_height (pixbuf),
	0, 0,
	scale, scale,
	GDK_INTERP_HYPER);
  }
else
  pixbuf = orig;

if (minimized)
  {
    if (orig == pixbuf)
pixbuf = gdk_pixbuf_copy (orig);

    vnck_dimm_icon (pixbuf);
  }

if (orig == pixbuf)
  g_object_ref (pixbuf)((__typeof__ (pixbuf)) (g_object_ref) (pixbuf));

return pixbuf;
3239}


3242static GdkPixbuf *
3243vnck_task_get_icon (VnckTask *task)
3244{
VnckWindowState state;
GdkPixbuf *pixbuf;

pixbuf = NULL((void*)0);

switch (task->type)
  {
  case VNCK_TASK_CLASS_GROUP:
    pixbuf = vnck_task_scale_icon (vnck_class_group_get_mini_icon (task->class_group),
		     FALSE(0));
    break;

  case VNCK_TASK_WINDOW:
    state = vnck_window_get_state (task->window);

    pixbuf =  vnck_task_scale_icon (vnck_window_get_mini_icon (task->window),
		      state & VNCK_WINDOW_STATE_MINIMIZED);
    break;

  case VNCK_TASK_STARTUP_SEQUENCE:
3265#ifdef HAVE_STARTUP_NOTIFICATION1
    if (task->tasklist->priv->icon_loader != NULL((void*)0))
      {
        const char *icon;

        icon = sn_startup_sequence_get_icon_name (task->startup_sequence);
        if (icon != NULL((void*)0))
          {
            GdkPixbuf *loaded;

            loaded =  (* task->tasklist->priv->icon_loader) (icon,
                                                             MINI_ICON_SIZE_vnck_get_default_mini_icon_size (),
                                                             0,
                                                             task->tasklist->priv->icon_loader_data);

            if (loaded != NULL((void*)0))
              {
                pixbuf = vnck_task_scale_icon (loaded, FALSE(0));
                g_object_unref (G_OBJECT (loaded)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((loaded)), (((GType) ((20) << (2)))))))));
              }
          }
      }

    if (pixbuf == NULL((void*)0))
      {
        _vnck_get_fallback_icons (NULL((void*)0), 0, 0,
                                  &pixbuf, MINI_ICON_SIZE_vnck_get_default_mini_icon_size (), MINI_ICON_SIZE_vnck_get_default_mini_icon_size ());
      }
3293#endif
    break;

  default:
    break;
  }

return pixbuf;
3301}

3303static gboolean
3304vnck_task_get_needs_attention (VnckTask *task)
3305{
GList *l;
VnckTask *win_task;
gboolean needs_attention;

needs_attention = FALSE(0);

switch (task->type)
  {
  case VNCK_TASK_CLASS_GROUP:
    task->start_needs_attention = 0;
    l = task->windows;
    while (l)
{
 win_task = VNCK_TASK (l->data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((l->data)), ((vnck_task_get_type ()))))));

 if (vnck_window_or_transient_needs_attention (win_task->window))
   {
     needs_attention = TRUE(!(0));
            task->start_needs_attention = MAX (task->start_needs_attention, _vnck_window_or_transient_get_needs_attention_time (win_task->window))(((task->start_needs_attention) > (_vnck_window_or_transient_get_needs_attention_time
 (win_task->window))) ? (task->start_needs_attention) :
 (_vnck_window_or_transient_get_needs_attention_time (win_task
->window)));
     break;
   }

 l = l->next;
}
    break;

  case VNCK_TASK_WINDOW:
    needs_attention =
vnck_window_or_transient_needs_attention (task->window);
    task->start_needs_attention = _vnck_window_or_transient_get_needs_attention_time (task->window);
    break;

  case VNCK_TASK_STARTUP_SEQUENCE:
  default:
    break;
  }

return needs_attention != FALSE(0);
3344}

3346static void
3347vnck_task_update_visible_state (VnckTask *task)
3348{
GdkPixbuf *pixbuf;
char *text;

pixbuf = vnck_task_get_icon (task);
ctk_image_set_from_pixbuf (CTK_IMAGE (task->image)((((CtkImage*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task->image)), ((ctk_image_get_type ())))))),
	     pixbuf);
if (pixbuf)
  g_object_unref (pixbuf);

text = vnck_task_get_text (task, TRUE(!(0)), TRUE(!(0)));
if (text != NULL((void*)0))
  {
    ctk_label_set_text (CTK_LABEL (task->label)((((CtkLabel*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task->label)), ((ctk_label_get_type ())))))), text);
    if (vnck_task_get_needs_attention (task))
      {
        _make_ctk_label_bold ((CTK_LABEL (task->label)((((CtkLabel*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task->label)), ((ctk_label_get_type ()))))))));
        vnck_task_queue_glow (task);
      }
    else
      {
        _make_ctk_label_normal ((CTK_LABEL (task->label)((((CtkLabel*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task->label)), ((ctk_label_get_type ()))))))));
        vnck_task_reset_glow (task);
      }
    g_free (text);
  }

text = vnck_task_get_text (task, FALSE(0), FALSE(0));
/* if text is NULL, this unsets the tooltip, which is probably what we'd want
 * to do */
ctk_widget_set_tooltip_text (task->button, text);
g_free (text);

ctk_widget_queue_resize (CTK_WIDGET (task->tasklist)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task->tasklist)), ((ctk_widget_get_type ())))))));
3382}

3384static void
3385vnck_task_state_changed (VnckWindow     *window,
	 VnckWindowState changed_mask,
	 VnckWindowState new_state G_GNUC_UNUSED__attribute__ ((__unused__)),
	 gpointer        data)
3389{
VnckTasklist *tasklist = VNCK_TASKLIST (data)((((VnckTasklist*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((data)), ((vnck_tasklist_get_type ()))))));

if (changed_mask & VNCK_WINDOW_STATE_SKIP_TASKLIST)
  {
    vnck_tasklist_update_lists  (tasklist);
    ctk_widget_queue_resize (CTK_WIDGET (tasklist)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((tasklist)), ((ctk_widget_get_type ())))))));
    return;
  }

if ((changed_mask & VNCK_WINDOW_STATE_DEMANDS_ATTENTION) ||
    (changed_mask & VNCK_WINDOW_STATE_URGENT))
  {
    VnckWorkspace *active_workspace =
      vnck_screen_get_active_workspace (tasklist->priv->screen);

    if (active_workspace                              &&
        (active_workspace != vnck_window_get_workspace (window) ||
  (vnck_workspace_is_virtual (active_workspace) &&
   !vnck_window_is_in_viewport (window, active_workspace))))
      {
        vnck_tasklist_update_lists (tasklist);
        ctk_widget_queue_resize (CTK_WIDGET (tasklist)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((tasklist)), ((ctk_widget_get_type ())))))));
      }
  }

if ((changed_mask & VNCK_WINDOW_STATE_MINIMIZED)         ||
    (changed_mask & VNCK_WINDOW_STATE_DEMANDS_ATTENTION) ||
    (changed_mask & VNCK_WINDOW_STATE_URGENT))
  {
    VnckTask *win_task = NULL((void*)0);

    /* FIXME: Handle group modal dialogs */
    for (; window && !win_task; window = vnck_window_get_transient (window))
      win_task = g_hash_table_lookup (tasklist->priv->win_hash, window);

    if (win_task)
{
 VnckTask *class_group_task;

 vnck_task_update_visible_state (win_task);

 class_group_task =
          g_hash_table_lookup (tasklist->priv->class_group_hash,
                               win_task->class_group);

 if (class_group_task)
   vnck_task_update_visible_state (class_group_task);
}
  }

3440}

3442static void
3443vnck_task_icon_changed (VnckWindow *window G_GNUC_UNUSED__attribute__ ((__unused__)),
	gpointer    data)
3445{
VnckTask *task = VNCK_TASK (data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((data)), ((vnck_task_get_type ()))))));

if (task)
  vnck_task_update_visible_state (task);
3450}

3452static void
3453vnck_task_name_changed (VnckWindow *window G_GNUC_UNUSED__attribute__ ((__unused__)),
	gpointer    data)
3455{
VnckTask *task = VNCK_TASK (data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((data)), ((vnck_task_get_type ()))))));

if (task)
  vnck_task_update_visible_state (task);
3460}

3462static void
3463vnck_task_class_name_changed (VnckClassGroup *class_group G_GNUC_UNUSED__attribute__ ((__unused__)),
	      gpointer        data)
3465{
VnckTask *task = VNCK_TASK (data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((data)), ((vnck_task_get_type ()))))));

if (task)
  vnck_task_update_visible_state (task);
3470}

3472static void
3473vnck_task_class_icon_changed (VnckClassGroup *class_group G_GNUC_UNUSED__attribute__ ((__unused__)),
	      gpointer        data)
3475{
VnckTask *task = VNCK_TASK (data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((data)), ((vnck_task_get_type ()))))));

if (task)
  vnck_task_update_visible_state (task);
3480}

3482static gboolean
3483vnck_task_motion_timeout (gpointer data)
3484{
VnckWorkspace *ws;
VnckTask *task = VNCK_TASK (data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((data)), ((vnck_task_get_type ()))))));

task->button_activate = 0;

/* FIXME: THIS IS SICK AND WRONG AND BUGGY.  See the end of
 * http://mail.gnome.org/archives/wm-spec-list/2005-July/msg00032.html
 * There should only be *one* activate call.
 */
ws = vnck_window_get_workspace (task->window);
if (ws && ws != vnck_screen_get_active_workspace (vnck_screen_get_default ()))
{
  vnck_workspace_activate (ws, task->dnd_timestamp);
}
vnck_window_activate_transient (task->window, task->dnd_timestamp);

task->dnd_timestamp = 0;

return FALSE(0);
3504}

3506static void
3507vnck_task_drag_leave (CtkWidget      *widget,
      CdkDragContext *context G_GNUC_UNUSED__attribute__ ((__unused__)),
      guint           time G_GNUC_UNUSED__attribute__ ((__unused__)),
      VnckTask       *task)
3511{
if (task->button_activate != 0)
  {
    g_source_remove (task->button_activate);
    task->button_activate = 0;
  }

ctk_drag_unhighlight (widget);
3519}

3521static gboolean
3522vnck_task_drag_motion (CtkWidget      *widget,
       CdkDragContext *context,
       gint            x G_GNUC_UNUSED__attribute__ ((__unused__)),
       gint            y G_GNUC_UNUSED__attribute__ ((__unused__)),
       guint           time,
       VnckTask       *task)
3528{
if (ctk_drag_dest_find_target (widget, context, NULL((void*)0)))
  {
    ctk_drag_highlight (widget);
    cdk_drag_status (context, cdk_drag_context_get_suggested_action (context), time);
  }
else
  {
    task->dnd_timestamp = time;

    if (task->button_activate == 0 && task->type == VNCK_TASK_WINDOW)
      {
         task->button_activate = g_timeout_add_seconds (VNCK_ACTIVATE_TIMEOUT1,
                                                        vnck_task_motion_timeout,
                                                        task);
      }

    cdk_drag_status (context, 0, time);
  }
return TRUE(!(0));
3548}

3550static void
3551vnck_task_drag_begin (CtkWidget      *widget G_GNUC_UNUSED__attribute__ ((__unused__)),
      CdkDragContext *context,
      VnckTask       *task)
3554{
_vnck_window_set_as_drag_icon (task->window, context,
                               CTK_WIDGET (task->tasklist)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task->tasklist)), ((ctk_widget_get_type ())))))));

task->tasklist->priv->drag_start_time = ctk_get_current_event_time ();
3559}

3561static void
3562vnck_task_drag_end (CtkWidget      *widget G_GNUC_UNUSED__attribute__ ((__unused__)),
    CdkDragContext *context G_GNUC_UNUSED__attribute__ ((__unused__)),
    VnckTask       *task)
3565{
task->tasklist->priv->drag_start_time = 0;
3567}

3569static void
3570vnck_task_drag_data_get (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__)),
	 VnckTask         *task)
3576{
gulong xid;

xid = vnck_window_get_xid (task->window);
ctk_selection_data_set (selection_data,
                        ctk_selection_data_get_target (selection_data),
	  8, (guchar *)&xid, sizeof (gulong));
3583}

3585static void
3586vnck_task_drag_data_received (CtkWidget        *widget G_GNUC_UNUSED__attribute__ ((__unused__)),
	      CdkDragContext   *context,
	      gint              x G_GNUC_UNUSED__attribute__ ((__unused__)),
	      gint              y G_GNUC_UNUSED__attribute__ ((__unused__)),
	      CtkSelectionData *data,
	      guint             info G_GNUC_UNUSED__attribute__ ((__unused__)),
	      guint             time,
	      VnckTask         *target_task)
3594{
VnckTasklist *tasklist;
GList        *l, *windows;
VnckWindow   *window;
gulong       *xid;
guint         new_order, old_order, order;
VnckWindow   *found_window;

if ((ctk_selection_data_get_length (data) != sizeof (gulong)) ||
    (ctk_selection_data_get_format (data) != 8))
  {
    ctk_drag_finish (context, FALSE(0), FALSE(0), time);
    return;
  }

tasklist = target_task->tasklist;
xid = (gulong *) ctk_selection_data_get_data (data);
found_window = NULL((void*)0);
new_order = 0;
windows = vnck_screen_get_windows (tasklist->priv->screen);

for (l = windows; l; l = l->next)
  {
     window = VNCK_WINDOW (l->data)((((VnckWindow*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((l->data)), ((vnck_window_get_type ()))))));
     if (vnck_window_get_xid (window) == *xid)
       {
          old_order = vnck_window_get_sort_order (window);
          new_order = vnck_window_get_sort_order (target_task->window);
          if (old_order < new_order)
            new_order++;
          found_window = window;
          break;
       }
  }

if (target_task->window == found_window)
  {
    CtkSettings  *settings;
    guint         double_click_time;

    settings = ctk_settings_get_for_screen (ctk_widget_get_screen (CTK_WIDGET (tasklist)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((tasklist)), ((ctk_widget_get_type ()))))))));
    double_click_time = 0;
    g_object_get (G_OBJECT (settings)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((settings)), (((GType) ((20) << (2)))))))),
                  "ctk-double-click-time", &double_click_time,
                  NULL((void*)0));

    if ((time - tasklist->priv->drag_start_time) < double_click_time)
      {
        vnck_tasklist_activate_task_window (target_task, time);
        ctk_drag_finish (context, TRUE(!(0)), FALSE(0), time);
        return;
      }
  }

if (found_window)
  {
     for (l = windows; l; l = l->next)
       {
          window = VNCK_WINDOW (l->data)((((VnckWindow*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((l->data)), ((vnck_window_get_type ()))))));
          order = vnck_window_get_sort_order (window);
          if (order >= new_order)
            vnck_window_set_sort_order (window, order + 1);
       }
     vnck_window_set_sort_order (found_window, new_order);

     if (!tasklist->priv->include_all_workspaces &&
         !vnck_window_is_pinned (found_window))
       {
         VnckWorkspace *active_space;
         active_space = vnck_screen_get_active_workspace (tasklist->priv->screen);
         vnck_window_move_to_workspace (found_window, active_space);
       }

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

  ctk_drag_finish (context, TRUE(!(0)), FALSE(0), time);
3671}

3673static gboolean
3674vnck_task_button_press_event (CtkWidget      *widget G_GNUC_UNUSED__attribute__ ((__unused__)),
	      CdkEventButton *event,
	      gpointer        data)
3677{
VnckTask *task = VNCK_TASK (data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((data)), ((vnck_task_get_type ()))))));

switch (task->type)
  {
  case VNCK_TASK_CLASS_GROUP:
    if (event->button == 2)
      vnck_tasklist_activate_next_in_class_group (task, event->time);
    else
      vnck_task_popup_menu (task,
                            event->button == 3);
    return TRUE(!(0));

  case VNCK_TASK_WINDOW:
    if (event->button == 1)
      {
        /* is_most_recently_activated == is_active for click &
  * sloppy focus methods.  We use the former here because
  * 'mouse' focus provides a special case.  In that case, no
  * window will be active, but if a window was the most
  * recently active one (i.e. user moves mouse straight from
  * window to tasklist), then we should still minimize it.
         */
        if (vnck_window_is_most_recently_activated (task->window))
          task->was_active = TRUE(!(0));
        else
          task->was_active = FALSE(0);

        return FALSE(0);
      }
    else if (event->button == 2)
      {
        /* middle-click close window */
        if (task->tasklist->priv->middle_click_close == TRUE(!(0)))
          {
            vnck_window_close (task->window, ctk_get_current_event_time ());
            return TRUE(!(0));
          }
      }
    else if (event->button == 3)
      {
        if (task->action_menu)
          ctk_widget_destroy (task->action_menu);

        g_assert (task->action_menu == NULL)do { if (task->action_menu == ((void*)0)) ; else g_assertion_message_expr
 ("Vnck", "../libvnck/tasklist.c", 3721, ((const char*) (__func__
)), "task->action_menu == NULL"); } while (0);

        task->action_menu = vnck_action_menu_new (task->window);

        g_object_add_weak_pointer (G_OBJECT (task->action_menu)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task->action_menu)), (((GType) ((20) << (2)))))
))),
                                   (void**) &task->action_menu);

        ctk_menu_set_screen (CTK_MENU (task->action_menu)((((CtkMenu*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task->action_menu)), ((ctk_menu_get_type ())))))),
                             _vnck_screen_get_cdk_screen (task->tasklist->priv->screen));

        ctk_widget_show (task->action_menu);
        ctk_menu_popup_at_widget (CTK_MENU (task->action_menu)((((CtkMenu*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task->action_menu)), ((ctk_menu_get_type ())))))), task->button,
                                  CDK_GRAVITY_SOUTH_WEST,
                                  CDK_GRAVITY_NORTH_WEST,
                                  (CdkEvent *) event);

        g_signal_connect (task->action_menu, "selection-done",g_signal_connect_data ((task->action_menu), ("selection-done"
), (((GCallback) (ctk_widget_destroy))), (((void*)0)), ((void
*)0), (GConnectFlags) 0)
                          G_CALLBACK (ctk_widget_destroy), NULL)g_signal_connect_data ((task->action_menu), ("selection-done"
), (((GCallback) (ctk_widget_destroy))), (((void*)0)), ((void
*)0), (GConnectFlags) 0);

        return TRUE(!(0));
      }
    break;

  case VNCK_TASK_STARTUP_SEQUENCE:
  default:
    break;
  }

return FALSE(0);
3750}

3752static GList*
3753vnck_task_extract_windows (VnckTask *task)
3754{
GList *windows = NULL((void*)0);
GList *l;

/* Add the ungrouped window in the task */
if (task->window != NULL((void*)0))
  {
    windows = g_list_prepend (windows, task->window);
  }

/* Add any grouped windows available in the task */
for (l = task->windows; l != NULL((void*)0); l = l->next)
  {
    VnckTask *t = VNCK_TASK (l->data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((l->data)), ((vnck_task_get_type ()))))));
    windows = g_list_prepend (windows, t->window);
  }

return g_list_reverse (windows);
3772}

3774static gboolean
3775vnck_task_enter_notify_event (CtkWidget *widget G_GNUC_UNUSED__attribute__ ((__unused__)),
	      CdkEvent  *event G_GNUC_UNUSED__attribute__ ((__unused__)),
	      gpointer   data)
3778{
VnckTask *task = VNCK_TASK (data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((data)), ((vnck_task_get_type ()))))));
GList *windows = vnck_task_extract_windows (task);

g_signal_emit (G_OBJECT (task->tasklist)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task->tasklist)), (((GType) ((20) << (2)))))))),
               signals[TASK_ENTER_NOTIFY],
               0, windows);

g_list_free (windows);

return FALSE(0);
3789}

3791static gboolean
3792vnck_task_leave_notify_event (CtkWidget *widget G_GNUC_UNUSED__attribute__ ((__unused__)),
	      CdkEvent  *event G_GNUC_UNUSED__attribute__ ((__unused__)),
	      gpointer   data)
3795{
VnckTask *task = VNCK_TASK (data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((data)), ((vnck_task_get_type ()))))));
GList *windows = vnck_task_extract_windows (task);

g_signal_emit (G_OBJECT (task->tasklist)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task->tasklist)), (((GType) ((20) << (2)))))))),
               signals[TASK_LEAVE_NOTIFY],
               0, windows);

g_list_free (windows);

return FALSE(0);
3806}

3808static gboolean
3809vnck_task_scroll_event (CtkWidget *widget G_GNUC_UNUSED__attribute__ ((__unused__)),
	CdkEvent  *event,
	gpointer   data)
3812{
VnckTask *task = VNCK_TASK (data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((data)), ((vnck_task_get_type ()))))));

return vnck_tasklist_scroll_event (CTK_WIDGET (task->tasklist)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task->tasklist)), ((ctk_widget_get_type ())))))), (CdkEventScroll *) event);
3816}

3818static gboolean
3819vnck_task_draw (CtkWidget *widget,
              cairo_t   *cr,
              gpointer   data);

3823static void
3824vnck_task_create_widgets (VnckTask *task, CtkReliefStyle relief)
3825{
CtkWidget *hbox;
GdkPixbuf *pixbuf;
char *text;
static const CtkTargetEntry targets[] = {
  { (gchar *) "application/x-vnck-window-id", 0, 0 }
};

if (task->type == VNCK_TASK_STARTUP_SEQUENCE)
  task->button = ctk_button_new ();
else
  task->button = ctk_toggle_button_new ();

ctk_button_set_relief (CTK_BUTTON (task->button)((((CtkButton*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task->button)), ((ctk_button_get_type ())))))), relief);

task->button_activate = 0;
g_object_add_weak_pointer (G_OBJECT (task->button)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task->button)), (((GType) ((20) << (2)))))))),
                           (void**) &task->button);

ctk_widget_set_name (task->button,
       "tasklist-button");

if (task->type == VNCK_TASK_WINDOW)
  {
    ctk_drag_source_set (CTK_WIDGET (task->button)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task->button)), ((ctk_widget_get_type ())))))),
                         CDK_BUTTON1_MASK,
                         targets, 1,
                         CDK_ACTION_MOVE);
    ctk_drag_dest_set (CTK_WIDGET (task->button)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task->button)), ((ctk_widget_get_type ())))))), CTK_DEST_DEFAULT_DROP,
                       targets, 1, CDK_ACTION_MOVE);
  }
else
  ctk_drag_dest_set (CTK_WIDGET (task->button)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task->button)), ((ctk_widget_get_type ())))))), 0,
                     NULL((void*)0), 0, CDK_ACTION_DEFAULT);

hbox = ctk_box_new (CTK_ORIENTATION_HORIZONTAL, 0);

pixbuf = vnck_task_get_icon (task);
if (pixbuf)
  {
    task->image = ctk_image_new_from_pixbuf (pixbuf);
    g_object_unref (pixbuf);
  }
else
  task->image = ctk_image_new ();

ctk_widget_show (task->image);

text = vnck_task_get_text (task, TRUE(!(0)), TRUE(!(0)));
task->label = ctk_label_new (text);
ctk_label_set_xalign (CTK_LABEL (task->label)((((CtkLabel*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task->label)), ((ctk_label_get_type ())))))), 0.0);
ctk_label_set_ellipsize (CTK_LABEL (task->label)((((CtkLabel*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task->label)), ((ctk_label_get_type ())))))),
                        PANGO_ELLIPSIZE_END);

if (vnck_task_get_needs_attention (task))
  {
    _make_ctk_label_bold ((CTK_LABEL (task->label)((((CtkLabel*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task->label)), ((ctk_label_get_type ()))))))));
    vnck_task_queue_glow (task);
  }

ctk_widget_show (task->label);

ctk_box_pack_start (CTK_BOX (hbox)((((CtkBox*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((hbox)), ((ctk_box_get_type ())))))), task->image, FALSE(0), FALSE(0),
      TASKLIST_BUTTON_PADDING4);
ctk_box_pack_start (CTK_BOX (hbox)((((CtkBox*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((hbox)), ((ctk_box_get_type ())))))), task->label, TRUE(!(0)), TRUE(!(0)),
      TASKLIST_BUTTON_PADDING4);

ctk_container_add (CTK_CONTAINER (task->button)((((CtkContainer*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task->button)), ((ctk_container_get_type ())))))), hbox);
ctk_widget_show (hbox);
g_free (text);

text = vnck_task_get_text (task, FALSE(0), FALSE(0));
ctk_widget_set_tooltip_text (task->button, text);
g_free (text);

/* Set up signals */
if (CTK_IS_TOGGLE_BUTTON (task->button)(((__extension__ ({ GTypeInstance *__inst = (GTypeInstance*) (
(task->button)); GType __t = ((ctk_toggle_button_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; })))))
  g_signal_connect_object (G_OBJECT (task->button)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task->button)), (((GType) ((20) << (2)))))))), "toggled",
                           G_CALLBACK (vnck_task_button_toggled)((GCallback) (vnck_task_button_toggled)),
                           G_OBJECT (task)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task)), (((GType) ((20) << (2)))))))),
                           0);

g_signal_connect_object (G_OBJECT (task->button)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task->button)), (((GType) ((20) << (2)))))))), "size_allocate",
                         G_CALLBACK (vnck_task_size_allocated)((GCallback) (vnck_task_size_allocated)),
                         G_OBJECT (task)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task)), (((GType) ((20) << (2)))))))),
                         0);

g_signal_connect_object (G_OBJECT (task->button)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task->button)), (((GType) ((20) << (2)))))))), "button_press_event",
                         G_CALLBACK (vnck_task_button_press_event)((GCallback) (vnck_task_button_press_event)),
                         G_OBJECT (task)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task)), (((GType) ((20) << (2)))))))),
                         0);

g_signal_connect_object (G_OBJECT (task->button)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task->button)), (((GType) ((20) << (2)))))))), "enter_notify_event",
                         G_CALLBACK (vnck_task_enter_notify_event)((GCallback) (vnck_task_enter_notify_event)),
                         G_OBJECT (task)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task)), (((GType) ((20) << (2)))))))),
                         0);

g_signal_connect_object (G_OBJECT (task->button)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task->button)), (((GType) ((20) << (2)))))))), "leave_notify_event",
                         G_CALLBACK (vnck_task_leave_notify_event)((GCallback) (vnck_task_leave_notify_event)),
                         G_OBJECT (task)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task)), (((GType) ((20) << (2)))))))),
                         0);

ctk_widget_add_events (task->button, CDK_SCROLL_MASK);
g_signal_connect_object (G_OBJECT (task->button)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task->button)), (((GType) ((20) << (2)))))))), "scroll_event",
                         G_CALLBACK (vnck_task_scroll_event)((GCallback) (vnck_task_scroll_event)),
                         G_OBJECT (task)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task)), (((GType) ((20) << (2)))))))),
                         0);

g_signal_connect_object (G_OBJECT(task->button)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task->button)), (((GType) ((20) << (2)))))))), "drag_motion",
                         G_CALLBACK (vnck_task_drag_motion)((GCallback) (vnck_task_drag_motion)),
                         G_OBJECT (task)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task)), (((GType) ((20) << (2)))))))),
                         0);

if (task->type == VNCK_TASK_WINDOW)
  {
    g_signal_connect_object (G_OBJECT (task->button)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task->button)), (((GType) ((20) << (2)))))))), "drag_data_received",
                             G_CALLBACK (vnck_task_drag_data_received)((GCallback) (vnck_task_drag_data_received)),
                             G_OBJECT (task)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task)), (((GType) ((20) << (2)))))))),
                             0);

  }

g_signal_connect_object (G_OBJECT(task->button)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task->button)), (((GType) ((20) << (2)))))))), "drag_leave",
                         G_CALLBACK (vnck_task_drag_leave)((GCallback) (vnck_task_drag_leave)),
                         G_OBJECT (task)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task)), (((GType) ((20) << (2)))))))),
                         0);

if (task->type == VNCK_TASK_WINDOW) {
    g_signal_connect_object (G_OBJECT(task->button)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task->button)), (((GType) ((20) << (2)))))))), "drag_data_get",
                             G_CALLBACK (vnck_task_drag_data_get)((GCallback) (vnck_task_drag_data_get)),
                             G_OBJECT (task)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task)), (((GType) ((20) << (2)))))))),
                             0);

    g_signal_connect_object (G_OBJECT(task->button)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task->button)), (((GType) ((20) << (2)))))))), "drag_begin",
                             G_CALLBACK (vnck_task_drag_begin)((GCallback) (vnck_task_drag_begin)),
                             G_OBJECT (task)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task)), (((GType) ((20) << (2)))))))),
                             0);

    g_signal_connect_object (G_OBJECT(task->button)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task->button)), (((GType) ((20) << (2)))))))), "drag_end",
                             G_CALLBACK (vnck_task_drag_end)((GCallback) (vnck_task_drag_end)),
                             G_OBJECT (task)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task)), (((GType) ((20) << (2)))))))),
                             0);
}

switch (task->type)
  {
  case VNCK_TASK_CLASS_GROUP:
    task->class_name_changed_tag = g_signal_connect (G_OBJECT (task->class_group), "name_changed",g_signal_connect_data ((((((GObject*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((task->class_group)), (((GType) ((20) <<
 (2))))))))), ("name_changed"), (((GCallback) (vnck_task_class_name_changed
))), (task), ((void*)0), (GConnectFlags) 0)
				       G_CALLBACK (vnck_task_class_name_changed), task)g_signal_connect_data ((((((GObject*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((task->class_group)), (((GType) ((20) <<
 (2))))))))), ("name_changed"), (((GCallback) (vnck_task_class_name_changed
))), (task), ((void*)0), (GConnectFlags) 0);
    task->class_icon_changed_tag = g_signal_connect (G_OBJECT (task->class_group), "icon_changed",g_signal_connect_data ((((((GObject*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((task->class_group)), (((GType) ((20) <<
 (2))))))))), ("icon_changed"), (((GCallback) (vnck_task_class_icon_changed
))), (task), ((void*)0), (GConnectFlags) 0)
				       G_CALLBACK (vnck_task_class_icon_changed), task)g_signal_connect_data ((((((GObject*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((task->class_group)), (((GType) ((20) <<
 (2))))))))), ("icon_changed"), (((GCallback) (vnck_task_class_icon_changed
))), (task), ((void*)0), (GConnectFlags) 0);
    break;

  case VNCK_TASK_WINDOW:
    task->state_changed_tag = g_signal_connect (G_OBJECT (task->window), "state_changed",g_signal_connect_data ((((((GObject*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((task->window)), (((GType) ((20) <<
 (2))))))))), ("state_changed"), (((GCallback) (vnck_task_state_changed
))), (task->tasklist), ((void*)0), (GConnectFlags) 0)
                                                G_CALLBACK (vnck_task_state_changed), task->tasklist)g_signal_connect_data ((((((GObject*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((task->window)), (((GType) ((20) <<
 (2))))))))), ("state_changed"), (((GCallback) (vnck_task_state_changed
))), (task->tasklist), ((void*)0), (GConnectFlags) 0);
    task->icon_changed_tag = g_signal_connect (G_OBJECT (task->window), "icon_changed",g_signal_connect_data ((((((GObject*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((task->window)), (((GType) ((20) <<
 (2))))))))), ("icon_changed"), (((GCallback) (vnck_task_icon_changed
))), (task), ((void*)0), (GConnectFlags) 0)
                                               G_CALLBACK (vnck_task_icon_changed), task)g_signal_connect_data ((((((GObject*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((task->window)), (((GType) ((20) <<
 (2))))))))), ("icon_changed"), (((GCallback) (vnck_task_icon_changed
))), (task), ((void*)0), (GConnectFlags) 0);
    task->name_changed_tag = g_signal_connect (G_OBJECT (task->window), "name_changed",g_signal_connect_data ((((((GObject*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((task->window)), (((GType) ((20) <<
 (2))))))))), ("name_changed"), (((GCallback) (vnck_task_name_changed
))), (task), ((void*)0), (GConnectFlags) 0)
				 G_CALLBACK (vnck_task_name_changed), task)g_signal_connect_data ((((((GObject*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((task->window)), (((GType) ((20) <<
 (2))))))))), ("name_changed"), (((GCallback) (vnck_task_name_changed
))), (task), ((void*)0), (GConnectFlags) 0);
    break;

  case VNCK_TASK_STARTUP_SEQUENCE:
    break;

  default:
    g_assert_not_reached ()do { g_assertion_message_expr ("Vnck", "../libvnck/tasklist.c"
, 3991, ((const char*) (__func__)), ((void*)0)); } while (0);
  }

g_signal_connect_object (task->button, "draw",
                         G_CALLBACK (vnck_task_draw)((GCallback) (vnck_task_draw)),
                         G_OBJECT (task)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task)), (((GType) ((20) << (2)))))))),
                         G_CONNECT_AFTER);
3998}

4000#define ARROW_SPACE4 4
4001#define ARROW_SIZE12 12
4002#define INDICATOR_SIZE7 7

4004static gboolean
4005vnck_task_draw (CtkWidget *widget,
              cairo_t   *cr,
              gpointer   data)
4008{
int x, y;
VnckTask *task;
CtkStyleContext *context;
CtkStateFlags state;
CtkBorder padding;
CtkWidget    *tasklist_widget;
gint width, height;
gboolean overlay_rect;
gint arrow_width;
gint arrow_height;
CdkRGBA color;

task = VNCK_TASK (data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((data)), ((vnck_task_get_type ()))))));

switch (task->type)
  {
  case VNCK_TASK_CLASS_GROUP:
    context = ctk_widget_get_style_context (widget);

    state = ctk_style_context_get_state (context);
    ctk_style_context_get_padding (context, state, &padding);

    state = (task->tasklist->priv->active_class_group == task) ?
            CTK_STATE_FLAG_ACTIVE : CTK_STATE_FLAG_NORMAL;

    ctk_style_context_save (context);
    ctk_style_context_set_state (context, state);
    ctk_style_context_get_color (context, state, &color);
    ctk_style_context_restore (context);

    x = ctk_widget_get_allocated_width (widget) -
        (ctk_container_get_border_width (CTK_CONTAINER (widget)((((CtkContainer*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((ctk_container_get_type ()))))))) + padding.right + ARROW_SIZE12);
    y = ctk_widget_get_allocated_height (widget) / 2;

    arrow_width = INDICATOR_SIZE7 + ((INDICATOR_SIZE7 % 2) - 1);
    arrow_height = arrow_width / 2 + 1;
    x += (ARROW_SIZE12 - arrow_width) / 2;
    y -= (2 * arrow_height + ARROW_SPACE4) / 2;

    cairo_save (cr);
    cdk_cairo_set_source_rgba (cr, &color);

    /* Up arrow */
    cairo_move_to (cr, x, y + arrow_height);
    cairo_line_to (cr, x + arrow_width / 2., y);
    cairo_line_to (cr, x + arrow_width, y + arrow_height);
    cairo_close_path (cr);
    cairo_fill (cr);

    /* Down arrow */
    y += arrow_height + ARROW_SPACE4;
    cairo_move_to (cr, x, y);
    cairo_line_to (cr, x + arrow_width, y);
    cairo_line_to (cr, x + arrow_width / 2., y + arrow_height);
    cairo_close_path (cr);
    cairo_fill (cr);

    cairo_restore (cr);

    break;

  case VNCK_TASK_WINDOW:
  case VNCK_TASK_STARTUP_SEQUENCE:
  default:
    break;
  }

if (task->glow_factor == 0.0)
  return FALSE(0);

/* push a translucent overlay to paint to, so we can blend later */
cairo_push_group_with_content (cr, CAIRO_CONTENT_COLOR_ALPHA);

width = ctk_widget_get_allocated_width (task->button);
height = ctk_widget_get_allocated_height (task->button);

tasklist_widget = CTK_WIDGET (task->tasklist)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task->tasklist)), ((ctk_widget_get_type ()))))));

context = ctk_widget_get_style_context (task->button);

/* first draw the button */
ctk_widget_style_get (tasklist_widget, "fade-overlay-rect", &overlay_rect, NULL((void*)0));
if (overlay_rect)
  {
    ctk_style_context_save (context);
    ctk_style_context_set_state (context, CTK_STATE_FLAG_SELECTED);

    /* Draw a rectangle with selected background color */
    ctk_render_background (context, cr, 0, 0, width, height);

    ctk_style_context_restore (context);
  }
else
  {
    ctk_style_context_save (context);
    ctk_style_context_set_state (context, CTK_STATE_FLAG_SELECTED);
    ctk_style_context_add_class (context, CTK_STYLE_CLASS_BUTTON"button");

    cairo_save (cr);
    ctk_render_background (context, cr, 0, 0, width, height);
    ctk_render_frame (context, cr, 0, 0, width, height);
    cairo_restore (cr);

    ctk_style_context_restore (context);
  }

/* then the contents */
ctk_container_propagate_draw (CTK_CONTAINER (task->button)((((CtkContainer*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task->button)), ((ctk_container_get_type ())))))),
                              ctk_bin_get_child (CTK_BIN (task->button)((((CtkBin*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((task->button)), ((ctk_bin_get_type ()))))))),
                              cr);
/* finally blend it */
cairo_pop_group_to_source (cr);
cairo_paint_with_alpha (cr, task->glow_factor);

return FALSE(0);
4124}

4126static gint
4127vnck_task_compare_alphabetically (gconstpointer a,
                                gconstpointer b)
4129{
char *text1;
char *text2;
gint  result;

text1 = vnck_task_get_text (VNCK_TASK (a)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((a)), ((vnck_task_get_type ())))))), TRUE(!(0)), FALSE(0));
text2 = vnck_task_get_text (VNCK_TASK (b)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((b)), ((vnck_task_get_type ())))))), TRUE(!(0)), FALSE(0));

result= g_utf8_collate (text1, text2);

g_free (text1);
g_free (text2);

return result;
4143}

4145static gint
4146compare_class_group_tasks (VnckTask *task1, VnckTask *task2)
4147{
const char *name1, *name2;

name1 = vnck_class_group_get_name (task1->class_group);
name2 = vnck_class_group_get_name (task2->class_group);

return g_utf8_collate (name1, name2);
4154}

4156static gint
4157vnck_task_compare (gconstpointer  a,
   gconstpointer  b)
4159{
VnckTask *task1 = VNCK_TASK (a)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((a)), ((vnck_task_get_type ()))))));
VnckTask *task2 = VNCK_TASK (b)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((b)), ((vnck_task_get_type ()))))));
gint pos1, pos2;

pos1 = pos2 = 0;  /* silence the compiler */

switch (task1->type)
  {
  case VNCK_TASK_CLASS_GROUP:
    if (task2->type == VNCK_TASK_CLASS_GROUP)
return compare_class_group_tasks (task1, task2);
    else
return -1; /* Sort groups before everything else */

  case VNCK_TASK_WINDOW:
    pos1 = vnck_window_get_sort_order (task1->window);
    break;
  case VNCK_TASK_STARTUP_SEQUENCE:
    pos1 = G_MAXINT2147483647; /* startup sequences are sorted at the end. */
    break;           /* Changing this will break scrolling.      */

  default:
    break;
  }

switch (task2->type)
  {
  case VNCK_TASK_CLASS_GROUP:
    if (task1->type == VNCK_TASK_CLASS_GROUP)
return compare_class_group_tasks (task1, task2);
    else
return 1; /* Sort groups before everything else */

  case VNCK_TASK_WINDOW:
    pos2 = vnck_window_get_sort_order (task2->window);
    break;
  case VNCK_TASK_STARTUP_SEQUENCE:
    pos2 = G_MAXINT2147483647;
    break;

  default:
    break;
  }

if (pos1 < pos2)
  return -1;
else if (pos1 > pos2)
  return 1;
else
  return 0; /* should only happen if there's multiple processes being
             * started, and then who cares about sort order... */
4211}

4213static void
4214remove_startup_sequences_for_window (VnckTasklist *tasklist,
                                   VnckWindow   *window)
4216{
4217#ifdef HAVE_STARTUP_NOTIFICATION1
const char *win_id;
GList *tmp;

win_id = _vnck_window_get_startup_id (window);
if (win_id == NULL((void*)0))
  return;

tmp = tasklist->priv->startup_sequences;
while (tmp != NULL((void*)0))
  {
    VnckTask *task = tmp->data;
    GList *next = tmp->next;
    const char *task_id;

    g_assert (task->type == VNCK_TASK_STARTUP_SEQUENCE)do { if (task->type == VNCK_TASK_STARTUP_SEQUENCE) ; else g_assertion_message_expr
 ("Vnck", "../libvnck/tasklist.c", 4232, ((const char*) (__func__
)), "task->type == VNCK_TASK_STARTUP_SEQUENCE"); } while (
0);

    task_id = sn_startup_sequence_get_id (task->startup_sequence);

    if (task_id && strcmp (task_id, win_id) == 0)
      ctk_widget_destroy (task->button);

    tmp = next;
  }
4241#else
; /* nothing */
4243#endif
4244}

4246static VnckTask *
4247vnck_task_new_from_window (VnckTasklist *tasklist,
	   VnckWindow   *window)
4249{
VnckTask *task;

task = g_object_new (VNCK_TYPE_TASK(vnck_task_get_type ()), NULL((void*)0));
task->type = VNCK_TASK_WINDOW;
task->window = g_object_ref (window)((__typeof__ (window)) (g_object_ref) (window));
task->class_group = g_object_ref (vnck_window_get_class_group (window))((__typeof__ (vnck_window_get_class_group (window))) (g_object_ref
) (vnck_window_get_class_group (window)));
task->tasklist = tasklist;

vnck_task_create_widgets (task, tasklist->priv->relief);

remove_startup_sequences_for_window (tasklist, window);

return task;
4263}

4265static VnckTask *
4266vnck_task_new_from_class_group (VnckTasklist   *tasklist,
		VnckClassGroup *class_group)
4268{
VnckTask *task;

task = g_object_new (VNCK_TYPE_TASK(vnck_task_get_type ()), NULL((void*)0));

task->type = VNCK_TASK_CLASS_GROUP;
task->window = NULL((void*)0);
task->class_group = g_object_ref (class_group)((__typeof__ (class_group)) (g_object_ref) (class_group));
task->tasklist = tasklist;

vnck_task_create_widgets (task, tasklist->priv->relief);

return task;
4281}

4283#ifdef HAVE_STARTUP_NOTIFICATION1
4284static VnckTask*
4285vnck_task_new_from_startup_sequence (VnckTasklist      *tasklist,
                                   SnStartupSequence *sequence)
4287{
VnckTask *task;

task = g_object_new (VNCK_TYPE_TASK(vnck_task_get_type ()), NULL((void*)0));

task->type = VNCK_TASK_STARTUP_SEQUENCE;
task->window = NULL((void*)0);
task->class_group = NULL((void*)0);
task->startup_sequence = sequence;
sn_startup_sequence_ref (task->startup_sequence);
task->tasklist = tasklist;

vnck_task_create_widgets (task, tasklist->priv->relief);

return task;
4302}

4304/* This should be fairly long, as it should never be required unless
* apps or .desktop files are buggy, and it's confusing if
* OpenOffice or whatever seems to stop launching - people
* might decide they need to launch it again.
*/
4309#define STARTUP_TIMEOUT15000 15000

4311static gboolean
4312sequence_timeout_callback (void *user_data)
4313{
VnckTasklist *tasklist = user_data;
GList *tmp;
gint64 now;
long tv_sec, tv_usec;
double elapsed;

now = g_get_real_time ();

restart:
tmp = tasklist->priv->startup_sequences;
while (tmp != NULL((void*)0))
  {
    VnckTask *task = VNCK_TASK (tmp->data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((tmp->data)), ((vnck_task_get_type ()))))));

    sn_startup_sequence_get_last_active_time (task->startup_sequence,
                                              &tv_sec, &tv_usec);

    elapsed = (now - (tv_sec * G_USEC_PER_SEC1000000 + tv_usec)) / 1000.0;

    if (elapsed > STARTUP_TIMEOUT15000)
      {
        g_assert (task->button != NULL)do { if (task->button != ((void*)0)) ; else g_assertion_message_expr
 ("Vnck", "../libvnck/tasklist.c", 4335, ((const char*) (__func__
)), "task->button != NULL"); } while (0);
        /* removes task from list as a side effect */
        ctk_widget_destroy (task->button);

        goto restart; /* don't iterate over changed list, just restart;
                       * not efficient but who cares here.
                       */
      }

    tmp = tmp->next;
  }

if (tasklist->priv->startup_sequences == NULL((void*)0))
  {
    tasklist->priv->startup_sequence_timeout = 0;
    return FALSE(0);
  }
else
  return TRUE(!(0));
4354}

4356static void
4357vnck_tasklist_sn_event (SnMonitorEvent *event,
                      void           *user_data)
4359{
VnckTasklist *tasklist;

tasklist = VNCK_TASKLIST (user_data)((((VnckTasklist*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((user_data)), ((vnck_tasklist_get_type ()))))));

switch (sn_monitor_event_get_type (event))
  {
  case SN_MONITOR_EVENT_INITIATED:
    {
      VnckTask *task;

      task = vnck_task_new_from_startup_sequence (tasklist,
                                                  sn_monitor_event_get_startup_sequence (event));

      ctk_widget_set_parent (task->button, CTK_WIDGET (tasklist)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((tasklist)), ((ctk_widget_get_type ())))))));
      ctk_widget_show (task->button);

      tasklist->priv->startup_sequences =
        g_list_prepend (tasklist->priv->startup_sequences,
                        task);

      if (tasklist->priv->startup_sequence_timeout == 0)
        {
          tasklist->priv->startup_sequence_timeout =
            g_timeout_add_seconds (1, sequence_timeout_callback,
                                   tasklist);
        }

      ctk_widget_queue_resize (CTK_WIDGET (tasklist)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((tasklist)), ((ctk_widget_get_type ())))))));
    }
    break;

  case SN_MONITOR_EVENT_COMPLETED:
    {
      GList *tmp;
      tmp = tasklist->priv->startup_sequences;
      while (tmp != NULL((void*)0))
        {
          VnckTask *task = VNCK_TASK (tmp->data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((tmp->data)), ((vnck_task_get_type ()))))));

          if (task->startup_sequence ==
              sn_monitor_event_get_startup_sequence (event))
            {
              g_assert (task->button != NULL)do { if (task->button != ((void*)0)) ; else g_assertion_message_expr
 ("Vnck", "../libvnck/tasklist.c", 4402, ((const char*) (__func__
)), "task->button != NULL"); } while (0);
              /* removes task from list as a side effect */
              ctk_widget_destroy (task->button);
              break;
            }

          tmp = tmp->next;
        }
    }
    break;

  case SN_MONITOR_EVENT_CHANGED:
    break;

  case SN_MONITOR_EVENT_CANCELED:
    break;

  default:
    break;
  }

if (tasklist->priv->startup_sequences == NULL((void*)0) &&
    tasklist->priv->startup_sequence_timeout != 0)
  {
    g_source_remove (tasklist->priv->startup_sequence_timeout);
    tasklist->priv->startup_sequence_timeout = 0;
  }
4429}

4431static void
4432vnck_tasklist_check_end_sequence (VnckTasklist   *tasklist,
                                VnckWindow     *window)
4434{
const char *res_class;
const char *res_name;
GList *tmp;

if (tasklist->priv->startup_sequences == NULL((void*)0))
  return;

res_class = vnck_window_get_class_group_name (window);
res_name = vnck_window_get_class_instance_name (window);

if (res_class == NULL((void*)0) && res_name == NULL((void*)0))
  return;

tmp = tasklist->priv->startup_sequences;
while (tmp != NULL((void*)0))
  {
    VnckTask *task = VNCK_TASK (tmp->data)((((VnckTask*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((tmp->data)), ((vnck_task_get_type ()))))));
    const char *wmclass;

    wmclass = sn_startup_sequence_get_wmclass (task->startup_sequence);

    if (wmclass != NULL((void*)0) &&
        ((res_class && strcmp (res_class, wmclass) == 0) ||
         (res_name && strcmp (res_name, wmclass) == 0)))
      {
        sn_startup_sequence_complete (task->startup_sequence);

        g_assert (task->button != NULL)do { if (task->button != ((void*)0)) ; else g_assertion_message_expr
 ("Vnck", "../libvnck/tasklist.c", 4462, ((const char*) (__func__
)), "task->button != NULL"); } while (0);
        /* removes task from list as a side effect */
        ctk_widget_destroy (task->button);

        /* only match one */
        return;
      }

    tmp = tmp->next;
  }
4472}

4474#endif /* HAVE_STARTUP_NOTIFICATION */