=== added directory 'applets/stack' === added file 'applets/stack/Makefile.am' --- applets/stack/Makefile.am 1970-01-01 00:00:00 +0000 +++ applets/stack/Makefile.am 2007-08-01 08:30:03 +0000 @@ -0,0 +1,56 @@ +INCLUDES = \ + -I$(srcdir) \ + -DGNOMELOCALEDIR=\""$(datadir)/locale"\" \ + $(DISABLE_DEPRECATED_CFLAGS) \ + $(AWN_CFLAGS) \ + -DPREFIX=\"$(prefix)\" \ + -DSYSCONFDIR=\"$(sysconfdir)\" \ + -DDATADIR=\"$(datadir)\" \ + -DLIBDIR=\"$(libdir)\" \ + -I$(top_builddir)/libawn + +STACK_SOURCES = \ + applet.c \ + stack-applet.c \ + stack-cairo.c \ + stack-container.c \ + stack-icon.c \ + stack-pixbuf-utils.c \ + stack-gconf.c + +STACK_LDADD = \ + $(DEPS_LIBS) \ + $(AWN_LIBS) \ + $(top_builddir)/libawn/libawn.la + +stacklibdir = $(libdir)/awn/applets/stack/ +stacklib_LTLIBRARIES = stack.la +stack_la_SOURCES = $(STACK_SOURCES) +stack_la_LIBADD = $(STACK_LDADD) +stack_la_LDFLAGS = -module -avoid-version +stack_la_CFLAGS = + +schemasdir = @GCONF_SCHEMA_FILE_DIR@ +schemas_in_files = stack.schemas.in +schemas_DATA = $(schemas_in_files:.schemas.in=.schemas) + +@INTLTOOL_SCHEMAS_RULE@ + +if GCONF_SCHEMAS_INSTALL +install-data-local: $(schemas_DATA) + GCONF_CONFIG_SOURCE=$(GCONF_SCHEMA_CONFIG_SOURCE) $(GCONFTOOL) --makefile-install-rule $(schemas_DATA) +endif + + +desktopdir = $(libdir)/awn/applets + +desktop_DATA = \ + stack.desktop +@INTLTOOL_DESKTOP_RULE@ + +$(desktop_DATA).in: $(desktop_DATA).in.in + sed -e "s|\@LIBDIR\@|$(libdir)|g" $< > $@ + +EXTRA_DIST = \ + stack.desktop.in.in \ + $(schemas_in_files) === added file 'applets/stack/README' --- applets/stack/README 1970-01-01 00:00:00 +0000 +++ applets/stack/README 2007-08-01 10:44:42 +0000 @@ -0,0 +1,58 @@ +STACK APPLET for AVANT_WINDOW_NAVIGATOR +======================================= + + +Introduction +------------ +This applet can monitor a folder (of choice) for file deletions or additions. +At the same time you can drag files onto the applet, from now on called "stack". +Those files will be linked (or copied (TODO)) in the folder. You can also drag +icons out of the stack, into the trashbin or into some other application. If you +click on an icon, it will launch the default application for it. + + +Common applications +------------------- +o use a stack to monitor a "Downloads" directory +o use a stack to manage all your projects files in one place + + +Howto +----- +Q: Choose the backend folder +A: Rightclick on the stack, select PROPERTIES and select a folder in the dialog. + +Q: Add a file to the stack +A: Drop the file(s) onto the stack. They will be linked in the backend folder, + or copy/link the file(s) directly to the folder. The stack will notice them. + +Q: Remove a file from the stack +A: Drag the file from the stack and drop it in a trashbin (for example in the + trash-applet), or delete it directly from the backend folder. + +Q: Select another default icon (either for stack or filemanager-button) +A: Until it is integrated in a nice GUI, you have to launch "gconf-editor", edit + the keys in /apps/avant-window-navigator/applets/. The icon has + to be (for now) a single filename, like "folder-drag-accept", that can be + found in your gnome icon theme. Support for full path specification of icons + will come in the future. + +Q: Remove the filemanager button from the stack +A: Set the "stack_filemanager_icon" key in the gconf-editor to empty. + +Q: Disable the "paint icons over the applet-icon" feature. +A: Again, see the gconf-editor + +Q: Alter other settings of the stack +A: Like the question above; find the right keys in the gconf-editor. + + +Help +---- +Q: I do not have a clue what is going wrong +A: Launch Awn from a terminal. It gives you more information (most of the + times). Try that first, it might give you a clue already. + +Q: I only see a white line instead of an applet. +A: A white line can be caused by two things: the applet does not load, or the + specified icon cannot be found. === added file 'applets/stack/applet.c' --- applets/stack/applet.c 1970-01-01 00:00:00 +0000 +++ applets/stack/applet.c 2007-08-01 09:15:48 +0000 @@ -0,0 +1,41 @@ +/* + * Copyright (c) 2007 Timon David Ter Braak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +#include +#include + +#include "stack-applet.h" + +AwnApplet *awn_applet_factory_initp ( gchar* uid, gint orient, gint height){ + + AwnApplet *applet = AWN_APPLET (awn_applet_new (uid, orient, height)); + + gnome_vfs_init (); + + GtkWidget *stack = stack_applet_new(applet, uid); + + gtk_widget_set_size_request (GTK_WIDGET (applet), + awn_applet_get_height (applet), awn_applet_get_height (applet) * 2); + + gtk_container_add (GTK_CONTAINER (applet), stack); + + gtk_widget_show_all (GTK_WIDGET (stack)); + + return applet; +} === added file 'applets/stack/stack-applet.c' --- applets/stack/stack-applet.c 1970-01-01 00:00:00 +0000 +++ applets/stack/stack-applet.c 2007-08-01 10:41:02 +0000 @@ -0,0 +1,653 @@ +/* + * Copyright (c) 2007 Timon David Ter Braak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +#include + +#include "stack-applet.h" +#include "stack-gconf.h" +#include "stack-cairo.h" +#include "stack-defines.h" +#include "stack-container.h" +#include "stack-pixbuf-utils.h" +#include "stack-icon.h" + +G_DEFINE_TYPE(StackApplet, stack_applet, GTK_TYPE_DRAWING_AREA) + +static void stack_applet_class_init (StackAppletClass *class); +static void stack_applet_init (StackApplet *applet); + +static void stack_applet_destroy (GtkObject *object); +static void stack_applet_size_allocate (GtkWidget *widget, + GdkRectangle *allocation); +static gboolean stack_applet_expose_event (GtkWidget *widget, + GdkEventExpose *expose); +static void stack_applet_drag_leave (GtkWidget *widget, GdkDragContext *context, + guint time_); +static gboolean stack_applet_drag_motion (GtkWidget *widget, + GdkDragContext *context, gint x, gint y, guint time_); +static void stack_applet_drag_data_received (GtkWidget *widget, + GdkDragContext *context, gint x, gint y, GtkSelectionData *selectiondata, + guint info, guint time_); +static gboolean stack_applet_button_release_event (GtkWidget *widget, + GdkEventButton *event); +static void stack_applet_height_changed (AwnApplet *app, guint height, + StackApplet *applet); +static void stack_applet_orient_changed (AwnApplet *app, AwnOrientation orient, + StackApplet *applet); +static void stack_applet_applet_deleted (AwnApplet *app, const gchar *uid, + StackApplet *applet); +static void stack_applet_theme_changed (GtkIconTheme *icon_theme, + gpointer data); + +static void update_icons (StackApplet *applet, gboolean reset_icon); +static gboolean _bounce_baby (StackApplet *applet); +static gboolean stack_applet_initialize_folder_backend (StackApplet *applet); +static void stack_applet_remove_file (StackApplet *applet, GnomeVFSURI *file); +static void stack_applet_add_file (StackApplet *applet, GnomeVFSURI *file); +static void static_applet_backend_monitor_callback ( + GnomeVFSMonitorHandle *handle, const gchar *monitor_uri, + const gchar *info_uri, GnomeVFSMonitorEventType event_type, + gpointer user_data); +static GtkWidget* stack_applet_new_dialog (StackApplet *applet); +static void stack_applet_activate_dialog (GtkEntry *entry, gpointer data); + +static const GtkTargetEntry drop_types[] = { + { "text/uri-list", 0, 0 } +}; +static const gint n_drop_types = G_N_ELEMENTS (drop_types); + +/** + * Create the new applet + * -add reference to the AwnApplet + * -add awn bar height + * -update icons + * @param *applet AwnApplet + * @return StackApplet + */ +GtkWidget* stack_applet_new (AwnApplet *awn_applet, gchar* uid){ + + StackApplet *applet = g_object_new (STACK_TYPE_APPLET, NULL); + applet->awn_applet = awn_applet; + applet->uid = uid; + applet->height = awn_applet_get_height (awn_applet); + + stack_gconf_init (applet); + + applet->backend_folder = gnome_vfs_uri_new ( + stack_gconf_get_backend_folder ()); + stack_applet_initialize_folder_backend (applet); + + /* connect to external events */ + g_signal_connect (awn_applet, "height-changed", + G_CALLBACK (stack_applet_height_changed), applet); + g_signal_connect (awn_applet, "orient-changed", + G_CALLBACK (stack_applet_orient_changed), applet); + g_signal_connect (awn_applet, "applet-deleted", + G_CALLBACK (stack_applet_applet_deleted), applet); + g_signal_connect (gtk_icon_theme_get_default (), "changed", + G_CALLBACK (stack_applet_theme_changed), applet); + + gtk_widget_show (GTK_WIDGET (applet)); + + return GTK_WIDGET (applet); +} + +/** + * Initialize applet class + * Set class functions + */ +static void stack_applet_class_init (StackAppletClass *class){ + + GTK_OBJECT_CLASS (class)->destroy = stack_applet_destroy; + + GTK_WIDGET_CLASS (class)->expose_event = stack_applet_expose_event; + GTK_WIDGET_CLASS (class)->size_allocate = stack_applet_size_allocate; + GTK_WIDGET_CLASS (class)->drag_leave = stack_applet_drag_leave; + GTK_WIDGET_CLASS (class)->drag_motion = stack_applet_drag_motion; + GTK_WIDGET_CLASS (class)->drag_data_received = + stack_applet_drag_data_received; + GTK_WIDGET_CLASS (class)->button_release_event = + stack_applet_button_release_event; +} + +/** + * Initialize the new applet + */ +static void stack_applet_init (StackApplet *applet){ + + gtk_widget_add_events (GTK_WIDGET (applet), GDK_ALL_EVENTS_MASK); + + applet->size = 0; + applet->new_size = 0; + applet->y_offset = 0; + applet->orient = GTK_ORIENTATION_HORIZONTAL; + applet->drag_hover = FALSE; + applet->dir = DIR_UP; + + applet->tooltips = gtk_tooltips_new (); + g_object_ref (applet->tooltips); + gtk_object_sink (GTK_OBJECT (applet->tooltips)); + + /* set up DnD target */ + // check for move, copy or symlink + gtk_drag_dest_set (GTK_WIDGET (applet), GTK_DEST_DEFAULT_ALL, drop_types, + n_drop_types, GDK_ACTION_LINK); +} + +/** + * Destroy applet + */ +static void stack_applet_destroy (GtkObject *object){ + + StackApplet *applet = STACK_APPLET (object); + + if (applet->tooltips) + g_object_unref (applet->tooltips); + applet->tooltips = NULL; + + if (applet->icon) + g_object_unref(applet->icon); + + if (applet->reflect_icon) + g_object_unref(applet->reflect_icon); + + (* GTK_OBJECT_CLASS (stack_applet_parent_class)->destroy) (object); +} + +/** + * Expose Event - draw background + */ +static gboolean stack_applet_expose_event (GtkWidget *widget, + GdkEventExpose *expose){ + + StackApplet *applet = STACK_APPLET (widget); + cairo_t *cr = NULL; + gint width, + height, + y; + + if (!GDK_IS_DRAWABLE (widget->window)){ + g_print ("GKD_IS_DRAWABLE failed"); + return FALSE; + } + + cr = gdk_cairo_create (widget->window); + + if (!cr){ + g_print ("Could not create cairo surface"); + return FALSE; + } + + gtk_widget_get_size_request (widget, &width, &height); + + clear_background (cr); + + y = (applet->height + PADDING) - applet->y_offset; + + paint_icon (cr, applet->icon, PADDING, y, 1.0f); + + if( applet->y_offset >= 0 ){ + y = (applet->height + PADDING) + applet->height - applet->y_offset; + paint_icon (cr, applet->reflect_icon, PADDING, y, 0.33f); + } + + cairo_destroy (cr); + + return TRUE; +} + +/** + * Allocate size + */ +static void stack_applet_size_allocate (GtkWidget *widget, + GdkRectangle *allocation){ + + StackApplet *applet = STACK_APPLET (widget); + gint new_size; + + if (applet->orient == GTK_ORIENTATION_HORIZONTAL){ + new_size = allocation->height; + }else{ + new_size = allocation->width; + } + + if (new_size != applet->size){ + applet->new_size = new_size; + gtk_widget_queue_draw (GTK_WIDGET (applet)); + } + + (* GTK_WIDGET_CLASS (stack_applet_parent_class)->size_allocate) + (widget, allocation); +} + +/** + * Drag leave event + */ +static void stack_applet_drag_leave (GtkWidget *widget, GdkDragContext *context, + guint time_){ + + StackApplet *applet = STACK_APPLET (widget); + + if (applet->drag_hover){ + applet->drag_hover = FALSE; + gtk_widget_queue_draw (GTK_WIDGET (applet)); + } +} + +/** + * Drag motion event + * -bounce applet icon + */ +static gboolean stack_applet_drag_motion (GtkWidget *widget, + GdkDragContext *context, gint x, gint y, guint time_){ + + StackApplet *applet = STACK_APPLET (widget); + + if (!applet->drag_hover) { + applet->drag_hover = TRUE; + gtk_widget_queue_draw (GTK_WIDGET (applet)); + if (applet->y_offset == 0) { + g_timeout_add (25, (GSourceFunc)_bounce_baby, (gpointer)applet); + } + } + + gdk_drag_status (context, GDK_ACTION_MOVE, time_); + + return TRUE; +} + +/** + * Drag data received event + * -scan the list of (possible more) source(s) + * -extract filename, basename and get an icon for it + * -create new applet main icon + * -update icons + */ +static void stack_applet_drag_data_received (GtkWidget *widget, + GdkDragContext *context, gint x, gint y, GtkSelectionData *selectiondata, + guint info, guint time_){ + + StackApplet *applet = STACK_APPLET (widget); + GList *list, + *scan; + + list = gnome_vfs_uri_list_parse ((gchar *)selectiondata->data); + for (scan = g_list_first (list); scan; scan = g_list_next (scan)) { + GnomeVFSURI *uri = scan->data; + gchar *name = gnome_vfs_uri_extract_short_name (uri); + + // is .desktop? + if (strstr (name, ".desktop")) + continue; + + GnomeVFSURI *link = gnome_vfs_uri_append_file_name ( + applet->backend_folder, name); + GnomeVFSResult res = gnome_vfs_create_symbolic_link (link, + gnome_vfs_uri_to_string (uri, GNOME_VFS_URI_HIDE_NONE)); + + gnome_vfs_uri_unref (link); + + if(res != GNOME_VFS_OK){ + g_print ("Could not create backend folder due: %s\n", + gnome_vfs_result_to_string (res)); + return; + } + + // should not be necessary with monitor; quicker reponse though + // stack_applet_add_file (applet, link); + } + + gnome_vfs_uri_list_free(list); + + update_icons (applet, FALSE); + + gtk_drag_finish (context, TRUE, FALSE, time_); +} + +/** + * Button release event + * -create stack container if it does not exist yet + * -forward event to stack container + * -on rightclick (button 3) show context menu + */ +static gboolean stack_applet_button_release_event (GtkWidget *widget, + GdkEventButton *event){ + + StackApplet *applet = STACK_APPLET (widget); + + // toggle visibility + if (event->button == 1) { + stack_container_toggle_visiblity (applet->stack); + return TRUE; + // create and popup context menu + }else if (event->button == 3) { + if(!applet->context_menu){ + applet->context_menu = stack_applet_new_dialog (applet); + } + gtk_menu_popup (GTK_MENU (applet->context_menu), NULL, NULL, NULL, NULL, + event->button, event->time); + } + + if (GTK_WIDGET_CLASS (stack_applet_parent_class)->button_release_event){ + return (* GTK_WIDGET_CLASS (stack_applet_parent_class)-> + button_release_event) (widget, event); + }else{ + return FALSE; + } +} + +/** + * Height (of Awn bar) change event + * -update icons + */ +static void stack_applet_height_changed (AwnApplet *app, guint height, + StackApplet *applet){ + + applet->height = height; + update_icons(applet, FALSE); + gtk_widget_queue_draw (GTK_WIDGET (applet)); +} + +/** + * Orientation (of Awn bar) change event + * -update icons + */ +static void stack_applet_orient_changed (AwnApplet *app, AwnOrientation orient, + StackApplet *applet){ + + applet->orient = orient; + update_icons(applet, FALSE); + gtk_widget_queue_draw (GTK_WIDGET (applet)); +} + +/** + * Applet is deleted + * -what is the diffence between handling this and "destroy"? + */ +static void stack_applet_applet_deleted (AwnApplet *app, const gchar *uid, + StackApplet *applet){ + + return; +} + +/** + * Theme change event + * -update icons + */ +static void stack_applet_theme_changed (GtkIconTheme *icon_theme, + gpointer data){ + + StackApplet *applet = STACK_APPLET (data); + update_icons(applet, TRUE); + gtk_widget_queue_draw (GTK_WIDGET (applet)); +} + +/** + * Update the icon(s) + * -also creates the reflect icon + */ +static void update_icons (StackApplet *applet, gboolean reset_icon){ + + GdkPixbuf *old = NULL, + *reflect_old = NULL; + GtkIconTheme *theme = gtk_icon_theme_get_default(); + + if (!applet->icon || reset_icon){ + old = applet->icon; + applet->icon = gtk_icon_theme_load_icon (theme, + stack_gconf_get_applet_icon (), applet->height - PADDING, 0, NULL); + + // set the window icon + gtk_window_set_default_icon_name (stack_gconf_get_applet_icon ()); + } + + reflect_old = applet->reflect_icon; + applet->reflect_icon = gdk_pixbuf_flip(applet->icon, FALSE); + + if (old) + g_object_unref (G_OBJECT (old)); + + if (reflect_old) + g_object_unref (G_OBJECT (reflect_old)); + + if(GTK_WIDGET (applet)->window) + gdk_window_invalidate_rect (GTK_WIDGET (applet)->window, NULL, FALSE); +} + +/** + * Applet icon bounce + */ +static gboolean _bounce_baby (StackApplet *applet){ + + #define MAX_OFFSET 14 + + if (applet->y_offset == 0 && applet->dir == DIR_DOWN && + !applet->drag_hover) { + applet->dir = DIR_UP; + gtk_widget_queue_draw (GTK_WIDGET (applet)); + return FALSE; + } + + if (applet->dir == DIR_UP) { + applet->y_offset+=1; + + if (applet->y_offset == MAX_OFFSET) { + applet->dir = DIR_DOWN; + } + } else if (!applet->drag_hover){ + applet->y_offset -= 1; + } + + gtk_widget_queue_draw (GTK_WIDGET (applet)); + return TRUE; +} + +/** + * Initialize the folder backend. Called on applet startup or folder change. + * -open the backend folder + * -TODO remove all previous contents + * -read all files from the folder (except other folders) + * -get an icon for each file + * -add the file (icon) to the container + * @param *applet Stackapplet + * @return FALSE if directory opening failed, else TRUE + */ +static gboolean stack_applet_initialize_folder_backend (StackApplet *applet){ + + GnomeVFSDirectoryHandle *handle; + GnomeVFSResult result; + GnomeVFSFileInfo *info = gnome_vfs_file_info_new (); + GnomeVFSFileInfoOptions options; + + options = GNOME_VFS_FILE_INFO_GET_MIME_TYPE; + options |= GNOME_VFS_FILE_INFO_FOLLOW_LINKS; + + if (!gnome_vfs_uri_exists (applet->backend_folder)){ + result = gnome_vfs_make_directory_for_uri (applet->backend_folder, + 0766); + + if(result != GNOME_VFS_OK){ + g_print ("Could not create backend folder \"%s\" due: %s\n", + gnome_vfs_uri_to_string (applet->backend_folder, 0), + gnome_vfs_result_to_string (result)); + return FALSE; + } + } + + if(applet->monitor){ + result = gnome_vfs_monitor_cancel (applet->monitor); + if(result != GNOME_VFS_OK){ + g_print ("Canceling monitor failed due: %s\n", + gnome_vfs_result_to_string (result)); + } + } + + //StackContainer *old = applet->stack; + applet->stack = stack_container_new (GTK_WIDGET (applet)); + //if (old) + // g_object_unref (old); + + update_icons (applet, TRUE); + + gnome_vfs_directory_open_from_uri (&handle, applet->backend_folder, + options); + while (gnome_vfs_directory_read_next(handle, info) == GNOME_VFS_OK) + { + if (info->type != GNOME_VFS_FILE_TYPE_REGULAR && info->type != + GNOME_VFS_FILE_TYPE_SYMBOLIC_LINK){ + continue; + } + + GnomeVFSURI *file_uri = gnome_vfs_uri_append_file_name ( + applet->backend_folder, info->name); + stack_applet_add_file (applet, file_uri); + } + + update_icons (applet, FALSE); + + result = gnome_vfs_monitor_add (&applet->monitor, + gnome_vfs_uri_to_string (applet->backend_folder, GNOME_VFS_URI_HIDE_NONE), + GNOME_VFS_MONITOR_DIRECTORY, static_applet_backend_monitor_callback, + applet); + + return TRUE; +} + +/** + * + */ +static void stack_applet_add_file (StackApplet *applet, GnomeVFSURI *file){ + + GdkPixbuf *icon; + GtkWidget *stack_icon; + guint icon_size = stack_gconf_get_icon_size (); + const gchar *file_path = gnome_vfs_uri_get_path (file); + const gchar *name = gnome_vfs_uri_extract_short_name (file); + + icon = get_icon (file_path, icon_size); + stack_icon = stack_icon_new (icon, name, file); + stack_container_add (STACK_CONTAINER(applet->stack), stack_icon); + + if(stack_gconf_is_composite_applet_icon ()){ + applet->icon = compose_applet_icon (applet->icon, icon); + } +} + +/** + * + */ +static void stack_applet_remove_file (StackApplet *applet, GnomeVFSURI *file){ + + stack_applet_initialize_folder_backend (applet); +} + +/** + * + */ +static void static_applet_backend_monitor_callback ( + GnomeVFSMonitorHandle *handle, const gchar *monitor_uri, + const gchar *info_uri, GnomeVFSMonitorEventType event_type, + gpointer user_data){ + + StackApplet *applet = STACK_APPLET (user_data); + + switch (event_type) { + case GNOME_VFS_MONITOR_EVENT_CREATED: + stack_applet_add_file (applet, gnome_vfs_uri_new (info_uri)); + break; + + case GNOME_VFS_MONITOR_EVENT_DELETED: + stack_applet_remove_file (applet, gnome_vfs_uri_new (info_uri)); + break; + + case GNOME_VFS_MONITOR_EVENT_CHANGED: + case GNOME_VFS_MONITOR_EVENT_STARTEXECUTING: + case GNOME_VFS_MONITOR_EVENT_STOPEXECUTING: + case GNOME_VFS_MONITOR_EVENT_METADATA_CHANGED: + default: + return; + } + + g_timeout_add (25, (GSourceFunc)_bounce_baby, (gpointer)applet); +} + +/** + * Create the context menu + * -get default menu + * -add properties item + * @param *applet StackApplet + * @return the context menu + */ +static GtkWidget *stack_applet_new_dialog (StackApplet *applet){ + + GtkWidget *item; + GtkWidget *menu; + + menu = awn_applet_create_default_menu (applet->awn_applet); + item = gtk_image_menu_item_new_from_stock (GTK_STOCK_PROPERTIES, NULL); + gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), item); + + g_signal_connect (G_OBJECT (item), "activate", + G_CALLBACK (stack_applet_activate_dialog), applet); + + gtk_widget_show_all (GTK_WIDGET (menu)); + + return menu; +} + +/** + * Activate the file (folder) chooser. + * -limit to create/select folders + * -run dialog and retrieve a folder path + * @param *entry + * @param data StackApplet + * @return void + */ +static void stack_applet_activate_dialog (GtkEntry *entry, gpointer data){ + + StackApplet *applet = STACK_APPLET (data); + GtkWidget *dialog; + + dialog = gtk_file_chooser_dialog_new (STACK_TEXT_SELECT_FOLDER, NULL, + GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER, GTK_STOCK_CANCEL, + GTK_RESPONSE_CANCEL, GTK_STOCK_APPLY, GTK_RESPONSE_ACCEPT, NULL); + + gtk_window_set_skip_taskbar_hint (GTK_WINDOW (dialog), TRUE); + gtk_window_set_skip_pager_hint (GTK_WINDOW (dialog), TRUE); + + if (applet->backend_folder){ + gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), + gnome_vfs_uri_get_path (applet->backend_folder)); + } + + if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT){ + gchar *filename; + + filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog)); + gnome_vfs_uri_unref (applet->backend_folder); + applet->backend_folder = gnome_vfs_uri_new (filename); + stack_gconf_set_backend_folder (filename); + + stack_applet_initialize_folder_backend (applet); + } + + gtk_widget_destroy (dialog); +} + + === added file 'applets/stack/stack-applet.h' --- applets/stack/stack-applet.h 1970-01-01 00:00:00 +0000 +++ applets/stack/stack-applet.h 2007-08-01 09:20:55 +0000 @@ -0,0 +1,83 @@ +/* + * Copyright (c) 2007 Timon David Ter Braak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +#ifndef __STACK_APPLET_H__ +#define __STACK_APPLET_H__ + +/* + * INCLUDES + */ +#include +//#include +#include +#include + +#define STACK_TYPE_APPLET (stack_applet_get_type ()) +#define STACK_APPLET(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), STACK_TYPE_APPLET, StackApplet)) +#define STACK_APPLET_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), STACK_TYPE_APPLET, StackAppletClass)) +#define STACK_IS_APPLET(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), STACK_TYPE_APPLET)) +#define STACK_IS_APPLET_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), STACK_TYPE_APPLET)) +#define STACK_APPLET_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), STACK_TYPE_APPLET, StackAppletClass)) + +#define PADDING 1 + +enum { + DIR_DOWN = 0, + DIR_UP = 1 +}; + +typedef struct _StackApplet StackApplet; +typedef struct _StackAppletClass StackAppletClass; +struct _StackApplet +{ + GtkDrawingArea applet; + + AwnApplet *awn_applet; + GtkWidget *context_menu; + + const gchar *uid; + + guint size; + guint new_size; + GtkOrientation orient; + + GtkTooltips *tooltips; + GtkWidget *image; + GdkPixbuf *icon; + GdkPixbuf *reflect_icon; + + guint height; + gint y_offset; + gint dir; + + GtkWidget *stack; + gboolean drag_hover; + + GnomeVFSURI *backend_folder; + GnomeVFSMonitorHandle *monitor; +}; + +struct _StackAppletClass { + GtkDrawingAreaClass parent_class; +}; + +GType stack_applet_get_type (void); +GtkWidget* stack_applet_new (AwnApplet *awn_applet, gchar* uid); + +#endif /* __STACK_APPLET_H__ */ === added file 'applets/stack/stack-cairo.c' --- applets/stack/stack-cairo.c 1970-01-01 00:00:00 +0000 +++ applets/stack/stack-cairo.c 2007-08-01 10:01:53 +0000 @@ -0,0 +1,221 @@ +/* + * Copyright (c) 2007 Timon David Ter Braak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +#include +//#include +#include +//#include +//#include +//#include + +#include "stack-cairo.h" +#include "stack-applet.h" +#include "stack-gconf.h" + +/** + * Paint the (rounded) rectangle + * @cr the cairo surface + * @x the (relative) x coordinate + * @y the (relative) y coordinate + * @w the width + * @h the height + * @r the corner radius + */ +void rectangle (cairo_t *cr, int x, int y, int w, int h, int r){ + + AwnColor color; + gdouble x0 = x + r/2.0f, + y0 = y + r/2.0f, + x1 = x0 + (w - r), + y1 = y0 + (h - r); + + cairo_save (cr); + cairo_set_line_width (cr, 2.0f); + + cairo_move_to (cr, x0 + r, y0); + cairo_line_to (cr, x1 -r, y0); + cairo_curve_to (cr, x1, y0, x1, y0, x1, y0 + r); + cairo_line_to (cr, x1, y1 -r); + cairo_curve_to (cr, x1, y1, x1, y1, x1 - r, y1); + cairo_line_to (cr, x0 + r, y1); + cairo_curve_to (cr, x0, y1, x0, y1, x0, y1 - r); + cairo_line_to (cr, x0, y0 + r); + cairo_curve_to (cr, x0, y0, x0, y0, x0 + r, y0); + + stack_gconf_get_border_color (&color); + cairo_set_source_rgba (cr, color.red, color.green, color.blue, color.alpha); + cairo_stroke_preserve (cr); + + stack_gconf_get_background_color (&color); + cairo_set_source_rgba (cr, color.red, color.green, color.blue, color.alpha); + cairo_fill (cr); + + cairo_restore (cr); +} + +/* +gchar *g_str_copy_substr_index (const gchar *str, guint startpos, guint endpos){ + + gchar *result; + guint i, x = 0; + + if (str == NULL) return NULL; + if (startpos > endpos) return NULL; + + result = g_new0 (gchar, endpos - startpos + 1); + for (i = startpos; i <= endpos; i++) { + result[x] = str[i]; + x++; + } + return result; +} +*/ + +/** + * Paint the icon name + * @cr the cairo surface + * @icon_name the textual name + * @x the (relative) x coordinate + * @y the (relative) y coordinate + */ +void paint_icon_name (cairo_t *cr, const gchar *icon_name, int x, int y){ + + AwnColor color; + cairo_text_extents_t extents; + guint icon_size = stack_gconf_get_icon_size (), + num = 0; + gchar *name = g_strdup (icon_name); + + cairo_select_font_face (cr, "Sans", CAIRO_FONT_SLANT_NORMAL, + CAIRO_FONT_WEIGHT_BOLD); + cairo_set_font_size(cr, 10); + + do{ + guint len = g_utf8_strlen (name,-1), + remains = 0, + tx, + ty; + + cairo_text_extents (cr, name, &extents); + + if (extents.width > icon_size){ + guint nlen = floor((icon_size / extents.width) * len); + remains = len - nlen; + len = nlen; + } + + if (remains > 0 && remains < len){ + gboolean fixed = FALSE; + gchar *delims = G_STR_DELIMITERS; + gint i; + + for(i = len; (len - i + remains) < len; i--){ + gint j; + + for(j=0;j<7;j++){ + if(delims[j] == name[i]){ + fixed = TRUE; + break; + } + } + + + if(fixed){ + remains += (len - (i+1)); + len -= (len - (i+1)); + break; + } + } + + if(!fixed){ + len -= (STACK_ICON_TEXT_CUTOFF - remains); + remains = STACK_ICON_TEXT_CUTOFF; + } + } + + gchar *subname = g_strdup(name); + + if (remains > 0 && num == 1){ + subname[len-3] = 0x0; + gchar *cutoff = g_strconcat (subname, "...", NULL); + g_free (subname); + subname = cutoff; + }else{ + subname[len] = 0x0; + } + + cairo_text_extents (cr, subname, &extents); + tx = x + (icon_size / 2) - ((extents.width / 2) + extents.x_bearing); + ty = y + icon_size + (3 * STACK_ICON_TEXT_INNERLINE_PADDING) + + (num * (extents.height + STACK_ICON_TEXT_INNERLINE_PADDING)); + + cairo_move_to (cr, tx, ty); + cairo_text_path (cr, subname); + + g_free (subname); + + name = name + len; + num++; + }while(g_utf8_strlen(name, -1) > 0 && num < 2); + + stack_gconf_get_icontext_color (&color); + cairo_set_source_rgba (cr, color.red, color.green, color.blue, color.alpha); + cairo_fill_preserve (cr); + + stack_gconf_get_border_color (&color); + cairo_set_source_rgba (cr, color.red, color.green, color.blue, color.alpha); + cairo_set_line_width (cr, 0.05); + cairo_stroke (cr); + +// cairo_set_source_rgba (cr, 0.0f, 0.0f, 0.0f, 0.6f); +// cairo_line_to (cr, x + extents.width, y); +// cairo_set_line_width (cr, 10.0); +// cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND); +// cairo_stroke (cr); + + if(name){ + //g_free (name); + } +} + +/** + * Clear the background to transparent + */ +void clear_background (cairo_t *cr){ + + cairo_set_source_rgba (cr, 1.0f, 1.0f, 1.0f, 0.0f); + cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR); + cairo_paint (cr); +} + +/** + * Paint an icon on the cairo surface + * @cr cairo surface + * @icon the pixbuf to paint + * @x the (relative) x coordinate + * @y the (relative) y coordinate + * @a alpha value to use + */ +void paint_icon (cairo_t *cr, GdkPixbuf *icon, int x, int y, double a){ + + cairo_set_operator (cr, CAIRO_OPERATOR_OVER); + gdk_cairo_set_source_pixbuf(cr, icon, x, y); + cairo_paint_with_alpha (cr, a); +} + === added file 'applets/stack/stack-cairo.h' --- applets/stack/stack-cairo.h 1970-01-01 00:00:00 +0000 +++ applets/stack/stack-cairo.h 2007-08-01 08:46:56 +0000 @@ -0,0 +1,38 @@ +/* + * Copyright (c) 2007 Timon David Ter Braak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +#ifndef __STACK_CAIRO_H__ +#define __STACK_CAIRO_H__ + +#include + +#define STACK_ICON_TEXT_SIZE 24 +#define STACK_ICON_TEXT_CUTOFF 7 +#define STACK_ICON_TEXT_INNERLINE_PADDING 4 +#define MARGIN_X 24 +#define MARGIN_Y 24 +#define PADDING_X 6 +#define PADDING_Y 6 + +void rectangle (cairo_t *cr, int x, int y, int w, int h, int r); +void paint_icon_name (cairo_t *cr, const gchar *name, int x, int y); +void clear_background (cairo_t *cr); +void paint_icon (cairo_t *cr, GdkPixbuf *icon, int x, int y, double a); + +#endif /* __STACK_CAIRO_H__ */ === added file 'applets/stack/stack-container.c' --- applets/stack/stack-container.c 1970-01-01 00:00:00 +0000 +++ applets/stack/stack-container.c 2007-08-01 09:14:45 +0000 @@ -0,0 +1,326 @@ +/* + * Copyright (c) 2007 Timon David Ter Braak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +#include +#include +#include +#include + +#include "stack-container.h" +#include "stack-applet.h" +#include "stack-icon.h" +#include "stack-gconf.h" +#include "stack-defines.h" +#include "stack-cairo.h" +#include "stack-pixbuf-utils.h" + +G_DEFINE_TYPE(StackContainer, stack_container, GTK_TYPE_WINDOW) + +static void stack_container_class_init (StackContainerClass *class); +static void stack_container_init (StackContainer *container); + +static void stack_container_destroy (GtkObject *object); +static gboolean stack_container_expose_event (GtkWidget *widget, + GdkEventExpose *expose); +static gboolean stack_container_enter_notify_event (GtkWidget *widget, + GdkEventCrossing *event); +static gboolean stack_container_focus_out_event (GtkWidget *widget, + GdkEventFocus *event); + +static void stack_container_new_fixed_layout (StackContainer *container); +static void stack_container_get_dimension (StackContainer *container, + guint *width, guint *height); +static void stack_container_reset_position (StackContainer *container); + +/** + * Create a new container + * -if preferred, creates the initial "show in filemanager" button + */ +GtkWidget *stack_container_new (GtkWidget *applet){ + + StackContainer *container = g_object_new (STACK_TYPE_CONTAINER, NULL); + container->applet = applet; + + gchar *fileman = stack_gconf_get_filemanager_icon(); + if(fileman){ + GdkPixbuf *icon = gtk_icon_theme_load_icon ( + gtk_icon_theme_get_default(), stack_gconf_get_filemanager_icon(), + stack_gconf_get_icon_size(), 0, NULL); + container->filemanager_icon = stack_icon_new (icon, + STACK_TEXT_SHOW_IN_FILEMANAGER, STACK_APPLET(applet)->backend_folder); + stack_container_add (container, container->filemanager_icon); + } + + return GTK_WIDGET(container); +} + +/** + * Initialize container class + * Set class functions + */ +static void stack_container_class_init (StackContainerClass *class){ + + GTK_OBJECT_CLASS (class)->destroy = stack_container_destroy; + GTK_WIDGET_CLASS (class)->expose_event = stack_container_expose_event; + GTK_WIDGET_CLASS (class)->enter_notify_event = + stack_container_enter_notify_event; + GTK_WIDGET_CLASS (class)->focus_out_event = stack_container_focus_out_event; +} + +/** + * Initialize the container object + */ +static void stack_container_init (StackContainer *container){ + + container->active = FALSE; + + gtk_window_set_skip_taskbar_hint(GTK_WINDOW(container), TRUE); + gtk_window_set_skip_pager_hint(GTK_WINDOW(container), TRUE); + gtk_window_set_decorated (GTK_WINDOW(container), FALSE); + gtk_window_set_keep_above (GTK_WINDOW(container), TRUE); + + gtk_widget_set_app_paintable (GTK_WIDGET(container), TRUE); + gtk_widget_add_events(GTK_WIDGET(container), GDK_ALL_EVENTS_MASK); + + GdkScreen *screen = gtk_widget_get_screen(GTK_WIDGET(container)); + GdkColormap *colormap = gdk_screen_get_rgba_colormap(screen); + gtk_widget_set_colormap(GTK_WIDGET(container), colormap); + + stack_container_new_fixed_layout(container); +} + +/** + * Destroy event + */ +static void stack_container_destroy (GtkObject *object){ + + (* GTK_OBJECT_CLASS (stack_container_parent_class)->destroy) (object); +} + +/** + * Expose event + */ +static gboolean stack_container_expose_event (GtkWidget *widget, + GdkEventExpose *expose){ + + StackContainer *container = STACK_CONTAINER (widget); + GdkWindow *window = GDK_WINDOW(widget->window); + cairo_t *cr = NULL; + guint width, + height; + + if (!GDK_IS_DRAWABLE (window)) + return FALSE; + + cr = gdk_cairo_create(window); + + if (!cr) + return FALSE; + + stack_container_get_dimension(container, &width, &height); + + /* Clear the background to transparent */ + clear_background (cr); + + /* Create window */ + cairo_set_operator (cr, CAIRO_OPERATOR_OVER); + + /* Paint rectangle */ + rectangle (cr, 0, 0, width, height, 20); + + /* Clean up */ + cairo_destroy (cr); + + return TRUE; +} + +/** + * Enter notify (hover) event + * -create extra trigger to all icons: leave event + */ +static gboolean stack_container_enter_notify_event (GtkWidget *widget, + GdkEventCrossing *event){ + + StackContainer *container = STACK_CONTAINER (widget); + GList *tmplist = g_list_first(container->list); + GtkWidget *icon = GTK_WIDGET(tmplist->data); + + while(icon){ + stack_icon_leave_notify_event_extra (icon); + tmplist = g_list_next(tmplist); + if(tmplist) + icon = GTK_WIDGET(tmplist->data); + else + icon = NULL; + } + return TRUE; +} + +/** + * Focus out event + */ +static gboolean stack_container_focus_out_event (GtkWidget *widget, + GdkEventFocus *event){ + + StackContainer *container = STACK_CONTAINER(widget); + container->active = FALSE; + gtk_widget_hide(widget); + + return TRUE; +} + +/** + * Create a new fixed layout to position the icons + */ +static void stack_container_new_fixed_layout (StackContainer *container){ + + GtkWidget *fixed = gtk_fixed_new(); + container->layout = fixed; + gtk_container_add (GTK_CONTAINER(container), fixed); + gtk_widget_show(fixed); +} + +/** + * Get the dimensions of the container + */ +static void stack_container_get_dimension(StackContainer *container, + guint *width, guint *height){ + + guint icon_size = stack_gconf_get_icon_size (); + *width = (2 * MARGIN_X) + container->cols * + (icon_size + MARGIN_X + PADDING_X) - PADDING_X; + *height = (2 * MARGIN_Y) + container->rows * + (icon_size + STACK_ICON_TEXT_SIZE + MARGIN_Y + PADDING_Y) - PADDING_Y; +} + +/** + * Reset the position of the container to hover above the applet + */ +static void stack_container_reset_position (StackContainer *container){ + + GtkWindow *window = GTK_WINDOW (container); + StackApplet *stack_applet = STACK_APPLET (container->applet); + GtkWidget *awn_applet = GTK_WIDGET (stack_applet->awn_applet); + gint width, + height, + x, + y; + + gdk_window_get_origin( awn_applet->window, &x, &y ); + + // offest by applet height + gtk_widget_get_size_request( awn_applet, &width, &height ); + y += height/2; + x += width/2; + + // offset dialog height + gtk_window_get_size( window, &width, &height ); + y -= height; + x -= width/2; + + gtk_window_move( window, x, y-1 ); +} + +/** + * Add a new icon to the stack container + * -add widget + * -calculate new layout (and move existing items) + * -resize window + */ +void stack_container_add (StackContainer *container, GtkWidget *widget){ + + GList *tmplist; + GtkWidget *icon; + guint width, + height, + n, + rows, + cols, + item = 0, + col_item = 0, + row_item = 1, + icon_size = stack_gconf_get_icon_size(); + + container->list = g_list_append(container->list, widget); + gtk_fixed_put(GTK_FIXED(container->layout), widget, 0, 0); + gtk_widget_show(widget); + + n = g_list_length (container->list); + rows = rint (sqrt ((gdouble) n)); + cols = rows; + if((rows*rows) < n){ + cols++; + } + + container->rows = rows; + container->cols = cols; + + tmplist = g_list_first(container->list); + icon = GTK_WIDGET(tmplist->data); + + while(icon){ + guint x, + y; + + if(item > 0 && (item % cols) == 0){ + row_item++; + col_item = 1; + }else{ + col_item++; + } + + x = MARGIN_X + (col_item - 1) * (icon_size + MARGIN_X + PADDING_X); + y = MARGIN_Y + (row_item - 1) * (icon_size + STACK_ICON_TEXT_SIZE + + MARGIN_Y + PADDING_Y); + + gtk_fixed_move(GTK_FIXED(container->layout), icon, x, y); + + tmplist = g_list_next(tmplist); + if(tmplist) + icon = GTK_WIDGET(tmplist->data); + else + icon = NULL; + item++; + } + + stack_container_get_dimension(container, &width, &height); + gtk_window_resize(GTK_WINDOW(container), width, height); + gtk_widget_set_size_request(GTK_WIDGET(container->layout), width, height); +} + +/** + * Toggle the visibility of the container + */ +void stack_container_toggle_visiblity (GtkWidget *widget){ + + StackContainer *container = STACK_CONTAINER(widget); + + if(!container->list){ + return; + } + + container->active = !container->active; + if(container->active){ + stack_container_reset_position(container); + gtk_window_present (GTK_WINDOW (widget)); + }else{ + gtk_widget_hide (widget); + } +} + === added file 'applets/stack/stack-container.h' --- applets/stack/stack-container.h 1970-01-01 00:00:00 +0000 +++ applets/stack/stack-container.h 2007-08-01 09:00:21 +0000 @@ -0,0 +1,58 @@ +/* + * Copyright (c) 2007 Timon David Ter Braak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +#ifndef __STACK_CONTAINER_H__ +#define __STACK_CONTAINER_H__ + +#include + +#define STACK_TYPE_CONTAINER (stack_container_get_type ()) +#define STACK_CONTAINER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), STACK_TYPE_CONTAINER, StackContainer)) +#define STACK_CONTAINER_CLASS(class) (G_TYPE_CHECK_CLASS_CAST ((class), STACK_TYPE_CONTAINER, StackContainerClass)) +#define STACK_IS_CONTAINER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), STACK_TYPE_CONTAINER)) +#define STACK_IS_CONTAINER_CLASS(class) (G_TYPE_CHECK_CLASS_TYPE ((class), STACK_TYPE_CONTAINER)) +#define STACK_CONTAINER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), STACK_TYPE_CONTAINER, StackContainerClass)) + +typedef struct _StackContainer StackContainer; +typedef struct _StackContainerClass StackContainerClass; +struct _StackContainer +{ + GtkWindow parent; + GtkWidget *applet; + + GtkWidget *filemanager_icon; + + GtkWidget *layout; + GList *list; + gboolean active; + guint rows; + guint cols; +}; + +struct _StackContainerClass { + GtkWindowClass parent_class; +}; + +GType stack_container_get_type (void); +GtkWidget * stack_container_new (GtkWidget *applet); + +void stack_container_add (StackContainer *container, GtkWidget *widget); +void stack_container_toggle_visiblity (GtkWidget *widget); + +#endif /* __STACK_CONTAINER_H__ */ === added file 'applets/stack/stack-defines.h' --- applets/stack/stack-defines.h 1970-01-01 00:00:00 +0000 +++ applets/stack/stack-defines.h 2007-08-01 10:39:39 +0000 @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2007 Timon David Ter Braak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +#ifndef __STACK_DEFINES_H__ +#define __STACK_DEFINES_H__ + +#define STACK_TEXT_SELECT_FOLDER "Select folder as item container" +#define STACK_TEXT_SHOW_IN_FILEMANAGER "Show in filemanager" + +#define STACK_DEFAULT_USE_SYMLINKS TRUE +#define STACK_DEFAULT_COMPOSITE_APPLET_ICON TRUE +#define STACK_DEFAULT_FILEMANAGER_ICON "file-manager" +#define STACK_DEFAULT_APPLET_ICON "folder-drag-accept" +#define STACK_DEFAULT_ICON_SIZE 64 +#define STACK_DEFAULT_BORDER_COLOR "000000E6" +#define STACK_DEFAULT_BACKGROUND_COLOR "00000099" +#define STACK_DEFAULT_ICONTEXT_COLOR "FFFFFFFF" + +#define STACK_GCONFKEY_USE_SYMLINKS "stack_use_symlinks" +#define STACK_GCONFKEY_COMPOSITE_APPLET_ICON "stack_composite_applet_icon" +#define STACK_GCONFKEY_BACKEND_FOLDER "stack_backend_folder" +#define STACK_GCONFKEY_FILEMANAGER_ICON "stack_filemanager_icon" +#define STACK_GCONFKEY_APPLET_ICON "stack_applet_icon" +#define STACK_GCONFKEY_ICON_SIZE "stack_icon_size" +#define STACK_GCONFKEY_BORDER_COLOR "stack_border_color" +#define STACK_GCONFKEY_BACKGROUND_COLOR "stack_background_color" +#define STACK_GCONFKEY_ICONTEXT_COLOR "stack_icontext_color" + +#endif /* __STACK_DEFINES_H__ */ === added file 'applets/stack/stack-gconf.c' --- applets/stack/stack-gconf.c 1970-01-01 00:00:00 +0000 +++ applets/stack/stack-gconf.c 2007-08-01 10:40:06 +0000 @@ -0,0 +1,256 @@ +/* + * Copyright (c) 2007 Timon David Ter Braak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +#include +#include +#include + +#include "stack-gconf.h" +#include "stack-applet.h" +#include "stack-defines.h" + +static int getdec(char hexchar); +static void hex2float(char* HexColor, float* FloatColor); +static AwnColor* stack_gconf_get_color (AwnColor *color, const gchar *key, + const gchar *def); + +static GConfClient *client = NULL; +static StackApplet *applet = NULL; + +/** + * Initializes the GConf stuff + */ +void stack_gconf_init (StackApplet *stack_applet){ + + if (!client){ + client = gconf_client_get_default (); + } + if (!applet){ + applet = stack_applet; + } + + awn_applet_add_preferences (applet->awn_applet, + "/schemas/apps/awn-stack/prefs", NULL); +} + +/** + * Do we need to use symlinks or real file-operations + */ +gboolean stack_gconf_is_use_symlinks (){ + + gboolean issym; + GConfValue *value = awn_applet_gconf_get_value (applet->awn_applet, + STACK_GCONFKEY_USE_SYMLINKS, NULL); + + if(value){ + issym = awn_applet_gconf_get_bool (applet->awn_applet, + STACK_GCONFKEY_USE_SYMLINKS, NULL); + }else{ + issym = STACK_DEFAULT_USE_SYMLINKS; + awn_applet_gconf_set_bool (applet->awn_applet, + STACK_GCONFKEY_USE_SYMLINKS, STACK_DEFAULT_USE_SYMLINKS, NULL); + } + + return issym; +} + +/** + * Should we be creative and composite the applet icon + */ +gboolean stack_gconf_is_composite_applet_icon (){ + + gboolean iscomp; + GConfValue *value = awn_applet_gconf_get_value (applet->awn_applet, + STACK_GCONFKEY_COMPOSITE_APPLET_ICON, NULL); + + if(value){ + iscomp = awn_applet_gconf_get_bool (applet->awn_applet, + STACK_GCONFKEY_COMPOSITE_APPLET_ICON, NULL); + }else{ + iscomp = STACK_DEFAULT_COMPOSITE_APPLET_ICON; + awn_applet_gconf_set_bool (applet->awn_applet, + STACK_GCONFKEY_COMPOSITE_APPLET_ICON, + STACK_DEFAULT_COMPOSITE_APPLET_ICON, NULL); + } + + return iscomp; +} + +/** + * What is the backend folder of this applet (and is it set)? + */ +gchar *stack_gconf_get_backend_folder (){ + + gchar *folder = awn_applet_gconf_get_string (applet->awn_applet, + STACK_GCONFKEY_BACKEND_FOLDER, NULL); + + if(strlen(folder) < 1){ + folder = g_strdup_printf ("/tmp/%s", applet->uid); + stack_gconf_set_backend_folder (folder); + } + + g_print ("Using folder: %s\n", folder); + return folder; +} + +/** + * Set the backend folder of this applet + */ +void stack_gconf_set_backend_folder (gchar *folder){ + + awn_applet_gconf_set_string (applet->awn_applet, + STACK_GCONFKEY_BACKEND_FOLDER, folder, NULL); +} + +/** + * Get the icon to use for the filemanager + * -if empty, return NULL -> we do not want to use that button + */ +gchar *stack_gconf_get_filemanager_icon(){ + + gchar *icon = awn_applet_gconf_get_string (applet->awn_applet, + STACK_GCONFKEY_FILEMANAGER_ICON, NULL); + + if(!icon){ + awn_applet_gconf_set_string (applet->awn_applet, + STACK_GCONFKEY_FILEMANAGER_ICON, STACK_DEFAULT_FILEMANAGER_ICON, + NULL); + icon = STACK_DEFAULT_FILEMANAGER_ICON; + } + + if(strlen(icon) > 0){ + return icon; + }else{ + return NULL; + } +} + +/** + * Get the icon to use for the applet + */ +gchar *stack_gconf_get_applet_icon(){ + + gchar *icon = awn_applet_gconf_get_string (applet->awn_applet, + STACK_GCONFKEY_APPLET_ICON, NULL); + + if(!icon){ + awn_applet_gconf_set_string (applet->awn_applet, + STACK_GCONFKEY_APPLET_ICON, STACK_DEFAULT_APPLET_ICON, NULL); + icon = STACK_DEFAULT_APPLET_ICON; + } + + return icon; +} + +/** + * Get the preferred size of the icons in the stack + */ +guint stack_gconf_get_icon_size (){ + + guint icon_size = awn_applet_gconf_get_int (applet->awn_applet, + STACK_GCONFKEY_ICON_SIZE, NULL); + + if(!(icon_size > 0)){ + awn_applet_gconf_set_int (applet->awn_applet, + STACK_GCONFKEY_ICON_SIZE, STACK_DEFAULT_ICON_SIZE, NULL); + icon_size = STACK_DEFAULT_ICON_SIZE; + } + + return icon_size; +} + +/** + * Get the decimal value of a hex value + */ +static int getdec(char hexchar){ + + if ((hexchar >= '0') && (hexchar <= '9')) return hexchar - '0'; + if ((hexchar >= 'A') && (hexchar <= 'F')) return hexchar - 'A' + 10; + if ((hexchar >= 'a') && (hexchar <= 'f')) return hexchar - 'a' + 10; + + return -1; // Wrong character +} + +/** + * Convert a HexColor (including alpha) to a FloatColor + */ +static void hex2float(char* HexColor, float* FloatColor){ + + gchar *HexColorPtr = HexColor; + gint i; + + for (i = 0; i < 4; i++){ + + gint IntColor = (getdec(HexColorPtr[0]) * 16) + getdec(HexColorPtr[1]); + FloatColor[i] = (gfloat) IntColor / 255.0; + HexColorPtr += 2; + } +} + +/** + * Get a color from a GConf key + */ +static AwnColor *stack_gconf_get_color (AwnColor *color, const gchar *key, + const gchar *def){ + + gfloat colors[4]; + gchar *value = awn_applet_gconf_get_string(applet->awn_applet, key, NULL); + + if (value){ + hex2float (value, colors); + }else{ + awn_applet_gconf_set_string (applet->awn_applet, key, def, NULL); + hex2float ((gchar*)def, colors); + } + + color->red = colors[0]; + color->green = colors[1]; + color->blue = colors[2]; + color->alpha = colors[3]; + + return color; +} + +/** + * Get the color for the borders (lines) + */ +AwnColor *stack_gconf_get_border_color (AwnColor *color){ + + return stack_gconf_get_color (color, STACK_GCONFKEY_BORDER_COLOR, + STACK_DEFAULT_BORDER_COLOR); +} + +/** + * Get the color for the background + */ +AwnColor *stack_gconf_get_background_color (AwnColor *color){ + + return stack_gconf_get_color (color, STACK_GCONFKEY_BACKGROUND_COLOR, + STACK_DEFAULT_BACKGROUND_COLOR); +} + +/** + * Get the color for the icons text + */ +AwnColor *stack_gconf_get_icontext_color (AwnColor *color){ + + return stack_gconf_get_color (color, STACK_GCONFKEY_ICONTEXT_COLOR, + STACK_DEFAULT_ICONTEXT_COLOR); +} + === added file 'applets/stack/stack-gconf.h' --- applets/stack/stack-gconf.h 1970-01-01 00:00:00 +0000 +++ applets/stack/stack-gconf.h 2007-08-01 10:37:38 +0000 @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2007 Timon David Ter Braak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +#ifndef __STACK_GCONF_H__ +#define __STACK_GCONF_H__ + +#include "stack-applet.h" + +typedef struct { + float red; + float green; + float blue; + float alpha; + +} AwnColor; + +void stack_gconf_init (StackApplet *applet); +gboolean stack_gconf_is_use_symlinks (); +gboolean stack_gconf_is_composite_applet_icon (); +gchar *stack_gconf_get_backend_folder(); +void stack_gconf_set_backend_folder (gchar *folder); +gchar *stack_gconf_get_filemanager_icon(); +gchar *stack_gconf_get_applet_icon(); +guint stack_gconf_get_icon_size (); +AwnColor* stack_gconf_get_border_color (AwnColor *color); +AwnColor* stack_gconf_get_background_color (AwnColor *color); +AwnColor* stack_gconf_get_icontext_color (AwnColor *color); + +#endif /* __STACK_GCONF_H__ */ === added file 'applets/stack/stack-icon.c' --- applets/stack/stack-icon.c 1970-01-01 00:00:00 +0000 +++ applets/stack/stack-icon.c 2007-08-01 09:22:08 +0000 @@ -0,0 +1,317 @@ +/* + * Copyright (c) 2007 Timon David Ter Braak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +#include +#include +#include +#include + +#include "stack-icon.h" +#include "stack-applet.h" +#include "stack-cairo.h" +#include "stack-gconf.h" + +#define STACK_FRAME_RADIUS 10 + +G_DEFINE_TYPE(StackIcon, stack_icon, GTK_TYPE_DRAWING_AREA) + +static void stack_icon_class_init (StackIconClass *class); +static void stack_icon_init (StackIcon *icon); + +// Events +static void stack_icon_destroy (GtkObject *object); +static gboolean stack_icon_expose_event (GtkWidget *widget, + GdkEventExpose *expose); +static gboolean stack_icon_enter_notify_event (GtkWidget *widget, + GdkEventCrossing *event); +static gboolean stack_icon_leave_notify_event (GtkWidget *widget, + GdkEventCrossing *event); +static gboolean stack_icon_button_release_event (GtkWidget *widget, + GdkEventButton *event); + +// Drag events +static void stack_icon_drag_begin (GtkWidget *widget, + GdkDragContext *drag_context); +static void stack_icon_drag_data_delete (GtkWidget *widget, + GdkDragContext *drag_context); +static void stack_icon_drag_data_get (GtkWidget *widget, + GdkDragContext *context, GtkSelectionData *selection_data, guint info, + guint time); +static void stack_icon_drag_end (GtkWidget *widget, + GdkDragContext *drag_context); + +enum { TARGET_URILIST, }; +static GtkTargetEntry target_table[] = {{"text/uri-list", 0, TARGET_URILIST},}; +static guint n_targets = sizeof (target_table) / sizeof (target_table[0]); +static gboolean just_dragged = FALSE; + +/** + * Create a new stack icon + */ +GtkWidget *stack_icon_new (GdkPixbuf *icon, const gchar *name, + GnomeVFSURI *uri){ + + StackIcon *sti; + guint icon_size; + + sti = g_object_new (STACK_TYPE_ICON, NULL); + sti->icon = icon; + sti->name = g_strdup (name); + sti->uri = gnome_vfs_uri_dup(uri); + sti->hovering = FALSE; + + icon_size = stack_gconf_get_icon_size (); + gtk_drawing_area_size(GTK_DRAWING_AREA(sti), icon_size + MARGIN_X, + icon_size + STACK_ICON_TEXT_SIZE + MARGIN_Y); + + gtk_drag_source_set (GTK_WIDGET (sti), GDK_BUTTON1_MASK, target_table, + n_targets, GDK_ACTION_COPY | GDK_ACTION_MOVE); + + return GTK_WIDGET(sti); +} + +/** + * Initialize applet class + * Set class functions + */ +static void stack_icon_class_init (StackIconClass *class){ + + GTK_OBJECT_CLASS (class)->destroy = stack_icon_destroy; + + GTK_WIDGET_CLASS (class)->expose_event = stack_icon_expose_event; + GTK_WIDGET_CLASS (class)->enter_notify_event = stack_icon_enter_notify_event; + GTK_WIDGET_CLASS (class)->leave_notify_event = stack_icon_leave_notify_event; + GTK_WIDGET_CLASS (class)->button_release_event = stack_icon_button_release_event; + + GTK_WIDGET_CLASS (class)->drag_begin = stack_icon_drag_begin; + //GTK_WIDGET_CLASS (class)->drag_failed = stack_icon_drag_failed; + GTK_WIDGET_CLASS (class)->drag_data_delete = stack_icon_drag_data_delete; + GTK_WIDGET_CLASS (class)->drag_data_get = stack_icon_drag_data_get; + GTK_WIDGET_CLASS (class)->drag_end = stack_icon_drag_end; +} + +/** + * Initialize the new applet + */ +static void stack_icon_init (StackIcon *icon){ + + GdkScreen *screen; + GdkColormap *colormap; + + gtk_widget_set_app_paintable (GTK_WIDGET(icon), TRUE); + + screen = gtk_widget_get_screen(GTK_WIDGET(icon)); + colormap = gdk_screen_get_rgba_colormap(screen); + gtk_widget_set_colormap(GTK_WIDGET(icon), colormap); + + gtk_widget_add_events(GTK_WIDGET(icon), GDK_ALL_EVENTS_MASK); +} + +/** + * Destroy events of the applet + */ +static void stack_icon_destroy (GtkObject *object){ + + StackIcon *icon = STACK_ICON (object); + + if(icon->uri) + gnome_vfs_uri_unref (icon->uri); + icon->uri = NULL; + + if(icon->icon); + g_object_unref (G_OBJECT (icon->icon)); + icon->icon = NULL; + + (* GTK_OBJECT_CLASS (stack_icon_parent_class)->destroy) (GTK_OBJECT (icon)); +} + +/** + * Expose event of the applet + */ +static gboolean stack_icon_expose_event (GtkWidget *widget, + GdkEventExpose *expose){ + + StackIcon *icon = STACK_ICON (widget); + cairo_t *cr = NULL; + guint icon_size = stack_gconf_get_icon_size (), + x, + y, + width, + height; + + if (!GDK_IS_DRAWABLE (widget->window)){ + return FALSE; + } + + cr = gdk_cairo_create(widget->window); + + if (!cr){ + return FALSE; + } + + clear_background (cr); + cairo_set_operator (cr, CAIRO_OPERATOR_OVER); + + AwnColor color; + stack_gconf_get_background_color (&color); + cairo_set_source_rgba (cr, color.red, color.green, color.blue, color.alpha); + cairo_paint (cr); + + if(icon->hovering){ + rectangle (cr, 0, 0, icon_size + MARGIN_X, + icon_size + STACK_ICON_TEXT_SIZE + MARGIN_Y, STACK_FRAME_RADIUS); + } + + x = MARGIN_X/2; + y = MARGIN_Y/2; + width = gdk_pixbuf_get_width(icon->icon); + height = gdk_pixbuf_get_height(icon->icon); + + if(width < icon_size){ + x += (icon_size - width)/2; + } + + if(height < icon_size){ + y += (icon_size - height)/2; + } + + paint_icon (cr, icon->icon, x, y, 1.0f); + + x = MARGIN_X/2; + y = MARGIN_Y/2; + + paint_icon_name(cr, icon->name, x, y); + + cairo_destroy (cr); + + return TRUE; +} + +/** + * Enter notify (hover) event + */ +static gboolean stack_icon_enter_notify_event (GtkWidget *widget, + GdkEventCrossing *event){ + + StackIcon *icon = STACK_ICON (widget); + icon->hovering = TRUE; + gdk_window_invalidate_rect(GDK_WINDOW (widget->window), NULL, FALSE); + + return FALSE; +} + +/** + * Leave notify (hover) event + */ +static gboolean stack_icon_leave_notify_event (GtkWidget *widget, + GdkEventCrossing *event){ + + StackIcon *icon = STACK_ICON (widget); + icon->hovering = FALSE; + gdk_window_invalidate_rect(GDK_WINDOW (widget->window), NULL, FALSE); + + return FALSE; +} + +/** + * Button released event + * -shows/launched the file associated with this icon + */ +static gboolean stack_icon_button_release_event (GtkWidget *widget, + GdkEventButton *event){ + + StackIcon *icon = STACK_ICON (widget); + + if(just_dragged){ + just_dragged = FALSE; + return FALSE; + } + + if(icon->uri){ + GnomeVFSResult res = gnome_vfs_url_show ( + gnome_vfs_uri_to_string (icon->uri, GNOME_VFS_URI_HIDE_NONE)); + + if(res != GNOME_VFS_OK) + g_print ("Error launching url: %s\nError was: %s", + gnome_vfs_uri_get_path (icon->uri), + gnome_vfs_result_to_string (res)); + }else{ + g_print ("Could not launch url: url not set?"); + } + + return FALSE; +} + +/** + * Drag begin event + */ +static void stack_icon_drag_begin (GtkWidget *widget, + GdkDragContext *drag_context){ + + StackIcon *icon = STACK_ICON (widget); + gtk_drag_source_set_icon_pixbuf(widget, icon->icon); + just_dragged = TRUE; +} + +/** + * Drag delete data event + */ +static void stack_icon_drag_data_delete (GtkWidget *widget, + GdkDragContext *drag_context){ + + // remove icon from container + g_print("drag_data_delete\n"); +} + +/** + * Drag end event + */ +static void stack_icon_drag_data_get (GtkWidget *widget, + GdkDragContext *context, GtkSelectionData *selection_data, guint info, + guint time){ + + StackIcon *icon = STACK_ICON (widget); + gchar *uri; + + uri = gnome_vfs_uri_to_string(icon->uri, GNOME_VFS_URI_HIDE_NONE); + gtk_selection_data_set(selection_data, GDK_SELECTION_TYPE_STRING, 8, + (guchar *)uri, (gint)strlen(uri)); + + g_free (uri); +} + +/** + * Drag end event + */ +static void stack_icon_drag_end (GtkWidget *widget, + GdkDragContext *drag_context){ + + g_print("drag_end\n"); + just_dragged = FALSE; +} + +/** + * Extra trigger for the leave notify event + * -called by the container on loosing focus + */ +gboolean stack_icon_leave_notify_event_extra (GtkWidget *widget){ + + return stack_icon_leave_notify_event (widget, NULL); +} + === added file 'applets/stack/stack-icon.h' --- applets/stack/stack-icon.h 1970-01-01 00:00:00 +0000 +++ applets/stack/stack-icon.h 2007-08-01 08:28:28 +0000 @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2007 Timon David Ter Braak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +#ifndef __STACK_ICON_H__ +#define __STACK_ICON_H__ + +#include +#include + +#define STACK_TYPE_ICON (stack_icon_get_type ()) +#define STACK_ICON(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), STACK_TYPE_ICON, StackIcon)) +#define STACK_ICON_CLASS(class) (G_TYPE_CHECK_CLASS_CAST ((class), STACK_TYPE_ICON, StackIconClass)) +#define STACK_IS_ICON(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), STACK_TYPE_ICON)) +#define STACK_IS_ICON_CLASS(class) (G_TYPE_CHECK_CLASS_TYPE ((class), STACK_TYPE_ICON)) +#define STACK_ICON_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), STACK_TYPE_ICON, StackIconClass)) + +typedef struct _StackIcon StackIcon; +typedef struct _StackIconClass StackIconClass; +struct _StackIcon +{ + GtkDrawingArea parent; + + GdkPixbuf *icon; + const gchar *name; + GnomeVFSURI *uri; + + gboolean hovering; +}; + +struct _StackIconClass { + GtkDrawingAreaClass parent_class; +}; + +GType stack_icon_get_type (void); +GtkWidget * stack_icon_new (GdkPixbuf *icon, const gchar *name, + GnomeVFSURI *uri); +gboolean stack_icon_leave_notify_event_extra (GtkWidget *widget); + +#endif /* __STACK_ICON_H__ */ === added file 'applets/stack/stack-pixbuf-utils.c' --- applets/stack/stack-pixbuf-utils.c 1970-01-01 00:00:00 +0000 +++ applets/stack/stack-pixbuf-utils.c 2007-08-01 08:10:16 +0000 @@ -0,0 +1,140 @@ +/* + * Copyright (c) 2007 Timon David Ter Braak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +#include +#include +#include +#include +#include + +#include "stack-pixbuf-utils.h" +#include "stack-gconf.h" + +/** + * Computes scaling properties with respect to @max_width and @max_height + */ +gboolean scale_keepping_ratio (guint *width, guint *height, guint max_width, + guint max_height){ + + gdouble w = *width, + h = *height, + max_w = max_width, + max_h = max_height, + factor; + gint new_width, + new_height; + gboolean modified; + + if ((*width < max_width) && (*height < max_height)){ + return FALSE; + } + + factor = MIN (max_w / w, max_h / h); + new_width = MAX ((gint) floor (w * factor + 0.50), 1); + new_height = MAX ((gint) floor (h * factor + 0.50), 1); + + modified = (new_width != *width) || (new_height != *height); + + *width = new_width; + *height = new_height; + + return modified; +} + +/** + * Get icon from a filename + * -create thumbnails for image/video content + * -scale icon to our prefered size + */ +GdkPixbuf* get_icon(const gchar *filename, gint size){ + + GnomeThumbnailFactory *thumbnail_factory; + GdkPixbuf *pixbuf; + gchar *mime_type; + guint icon_size; + + icon_size = stack_gconf_get_icon_size (); + thumbnail_factory = gnome_thumbnail_factory_new (icon_size); + mime_type = gnome_vfs_get_mime_type (filename); + pixbuf = gnome_thumbnail_factory_generate_thumbnail (thumbnail_factory, + filename, mime_type); + + if(!pixbuf){ + GtkIconTheme *theme = gtk_icon_theme_get_default (); + gchar *icon_path = gnome_icon_lookup_sync (theme, NULL, filename, NULL, + GNOME_ICON_LOOKUP_FLAGS_NONE, GNOME_ICON_LOOKUP_RESULT_FLAGS_NONE); + pixbuf = gtk_icon_theme_load_icon (theme, icon_path, icon_size, 0, + NULL); + g_free (icon_path); + } + + if(pixbuf){ + guint width = gdk_pixbuf_get_width(pixbuf); + guint height = gdk_pixbuf_get_height(pixbuf); + + if(scale_keepping_ratio(&width, &height, icon_size, icon_size)){ + pixbuf = gdk_pixbuf_scale_simple(pixbuf, width, height, + GDK_INTERP_BILINEAR); + } + } + + g_free (mime_type); + + return pixbuf; +} + +GdkPixbuf* compose_applet_icon(GdkPixbuf *applet_icon, GdkPixbuf *icon){ + + GdkPixbuf *copy, + *scale; + guint pixel = 0x00000000, /* transparent */ + width, + height; + + copy = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8, STACK_ICON_SIZE, + STACK_ICON_SIZE); + gdk_pixbuf_fill (copy, pixel); + + width = gdk_pixbuf_get_width (applet_icon); + height = gdk_pixbuf_get_height (applet_icon); + + gdk_pixbuf_composite(applet_icon, copy, 0, 0, width, height, 0.0, 0.0, 1.0, + 1.0, GDK_INTERP_BILINEAR, 255); + + scale = gdk_pixbuf_copy (icon); + width = gdk_pixbuf_get_width(scale); + height = gdk_pixbuf_get_height(scale); + + if(scale_keepping_ratio(&width, &height, STACK_ICON_SIZE, STACK_ICON_SIZE)){ + scale = gdk_pixbuf_scale_simple(scale, width, height, + GDK_INTERP_BILINEAR); + } + + width = gdk_pixbuf_get_width (scale); + height = gdk_pixbuf_get_height (scale); + + gdk_pixbuf_composite(scale, copy, 0, 0, width, height, 0.0, 0.0, 1.0, 1.0, + GDK_INTERP_BILINEAR, 255); + + g_object_unref (G_OBJECT (applet_icon)); + g_object_unref (G_OBJECT (scale)); + + return copy; +} + === added file 'applets/stack/stack-pixbuf-utils.h' --- applets/stack/stack-pixbuf-utils.h 1970-01-01 00:00:00 +0000 +++ applets/stack/stack-pixbuf-utils.h 2007-08-01 08:08:13 +0000 @@ -0,0 +1,35 @@ +/* + * Copyright (c) 2007 Timon David Ter Braak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +#ifndef __STACK_PIXBUF_UTILS_H__ +#define __STACK_PIXBUF_UTILS_H__ + +#include + +#define STACK_ICON_SIZE 48 + +gboolean scale_keepping_ratio (guint *width, guint *height, guint max_width, guint max_height); + +GdkPixbuf* get_icon(const gchar *filename, gint size); + +GdkPixbuf* compose_applet_icon(GdkPixbuf *applet_icon, GdkPixbuf *icon); + +void pixbuf_add_transparent (GdkPixbuf *pixbuf, guint alpha); + +#endif /* __STACK_PIXBUF_UTILS_H__ */ === added file 'applets/stack/stack.desktop' --- applets/stack/stack.desktop 1970-01-01 00:00:00 +0000 +++ applets/stack/stack.desktop 2007-08-01 07:11:07 +0000 @@ -0,0 +1,9 @@ +[Desktop Entry] +Version=1.0 +Encoding=UTF-8 +Name=Stack +Type=C +Comment=Stack items on eachother +Exec=/usr/lib/awn/applets/stack/stack.so +Icon=folder-drag-accept +Name[en_US]=Stack === added file 'applets/stack/stack.desktop.in' --- applets/stack/stack.desktop.in 1970-01-01 00:00:00 +0000 +++ applets/stack/stack.desktop.in 2007-08-01 07:10:46 +0000 @@ -0,0 +1,9 @@ +[Desktop Entry] +Version=1.0 +Encoding=UTF-8 +Name=Stack +Type=C +Comment=Stack items on eachother +Exec=/usr/lib/awn/applets/stack/stack.so +Icon=folder-drag-accept +Name[en_US]=Stack === added file 'applets/stack/stack.desktop.in.in' --- applets/stack/stack.desktop.in.in 1970-01-01 00:00:00 +0000 +++ applets/stack/stack.desktop.in.in 2007-08-01 06:44:58 +0000 @@ -0,0 +1,9 @@ +[Desktop Entry] +Version=1.0 +Encoding=UTF-8 +Name=Stack +Type=C +Comment=Stack items on eachother +Exec=/usr/lib/awn/applets/stack/stack.so +Icon=folder-drag-accept +Name[en_US]=Stack === added file 'applets/stack/stack.schemas' --- applets/stack/stack.schemas 1970-01-01 00:00:00 +0000 +++ applets/stack/stack.schemas 2007-08-01 10:41:17 +0000 @@ -0,0 +1,106 @@ + + + + + + /schemas/apps/awn-stack/prefs/stack_use_symlinks + awn-stack + bool + True + + Whether the stack should use symlinks instead of real file operations. + + + + + + /schemas/apps/awn-stack/prefs/stack_composite_applet_icon + awn-stack + bool + TRUE + + If true, the icons of the stack will be drawn over the applet icon + + + + + + /schemas/apps/awn-stack/prefs/stack_backend_folder + awn-stack + string + + + Specify a full path to a folder to use as backend. + + + + + + /schemas/apps/awn-stack/prefs/stack_filemanager_icon + awn-stack + string + file-manager + + Specify an icon to use for the "Show in filemanager"-icon. + + + + + + /schemas/apps/awn-stack/prefs/stack_applet_icon + awn-stack + string + folder-drag-accept + + Specify an icon to use for the stack applet (button). + + + + + + /schemas/apps/awn-stack/prefs/stack_icon_size + awn-stack + int + 64 + + The size of the stack icons + + + + + + /schemas/apps/awn-stack/prefs/stack_border_color + awn-stack + string + 000000E6 + + RGBA color of the border + + + + + + /schemas/apps/awn-stack/prefs/stack_background_color + awn-stack + string + 00000099 + + RGBA color of the background + + + + + + /schemas/apps/awn-stack/prefs/stack_icontext_color + awn-stack + string + FFFFFFFF + + RGBA color of the icon text + + + + + + + === added file 'applets/stack/stack.schemas.in' --- applets/stack/stack.schemas.in 1970-01-01 00:00:00 +0000 +++ applets/stack/stack.schemas.in 2007-08-01 10:37:05 +0000 @@ -0,0 +1,106 @@ + + + + + + /schemas/apps/awn-stack/prefs/stack_use_symlinks + awn-stack + bool + True + + Whether the stack should use symlinks instead of real file operations. + + + + + + /schemas/apps/awn-stack/prefs/stack_composite_applet_icon + awn-stack + bool + TRUE + + If true, the icons of the stack will be drawn over the applet icon + + + + + + /schemas/apps/awn-stack/prefs/stack_backend_folder + awn-stack + string + + + Specify a full path to a folder to use as backend. + + + + + + /schemas/apps/awn-stack/prefs/stack_filemanager_icon + awn-stack + string + file-manager + + Specify an icon to use for the "Show in filemanager"-icon. + + + + + + /schemas/apps/awn-stack/prefs/stack_applet_icon + awn-stack + string + folder-drag-accept + + Specify an icon to use for the stack applet (button). + + + + + + /schemas/apps/awn-stack/prefs/stack_icon_size + awn-stack + int + 64 + + The size of the stack icons + + + + + + /schemas/apps/awn-stack/prefs/stack_border_color + awn-stack + string + 000000E6 + + RGBA color of the border + + + + + + /schemas/apps/awn-stack/prefs/stack_background_color + awn-stack + string + 00000099 + + RGBA color of the background + + + + + + /schemas/apps/awn-stack/prefs/stack_icontext_color + awn-stack + string + FFFFFFFF + + RGBA color of the icon text + + + + + + + === modified file 'applets/Makefile.am' --- applets/Makefile.am 2007-07-30 23:21:37 +0000 +++ applets/Makefile.am 2007-08-01 06:44:58 +0000 @@ -1,4 +1,4 @@ -SUBDIRS = switcher trash separator notification-area +SUBDIRS = switcher trash separator notification-area stack desktopdir = $(libdir)/awn/applets === modified file 'configure.in' --- configure.in 2007-07-30 23:21:37 +0000 +++ configure.in 2007-08-01 06:44:58 +0000 @@ -75,6 +75,7 @@ applets/switcher/Makefile applets/trash/Makefile applets/notification-area/Makefile +applets/stack/Makefile data/Makefile data/active/Makefile po/Makefile.in