mirror/transmission
1
0
Fork 0
mirror of https://github.com/transmission/transmission synced 2024-12-27 01:57:52 +00:00
Code Issues Releases Wiki Activity
transmission/gtk/sexy-icon-entry.c

1015 lines
29 KiB
C
Raw Blame History

/*
* @file libsexy/sexy-icon-entry.c Entry widget
*
* @Copyright (C) 2004-2006 Christian Hammond.
*
* 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 <string.h>
#include <gtk/gtk.h>
#include "sexy-icon-entry.h"
#define ICON_MARGIN 2
#define MAX_ICONS 2
#define IS_VALID_ICON_ENTRY_POSITION( pos ) \
( ( pos ) == SEXY_ICON_ENTRY_PRIMARY \
|| ( pos ) == SEXY_ICON_ENTRY_SECONDARY )
typedef struct
{
GtkImage * icon;
gboolean highlight;
gboolean hovered;
GdkWindow * window;
} SexyIconInfo;
struct _SexyIconEntryPriv
{
SexyIconInfo icons[MAX_ICONS];
gulong icon_released_id;
};
enum
{
ICON_PRESSED,
ICON_RELEASED,
LAST_SIGNAL
};
static void sexy_icon_entry_class_init( SexyIconEntryClass *klass );
static void sexy_icon_entry_editable_init(
GtkEditableClass *iface );
static void sexy_icon_entry_init( SexyIconEntry *entry );
static void sexy_icon_entry_finalize( GObject *obj );
static void sexy_icon_entry_destroy( GtkObject *obj );
static void sexy_icon_entry_map( GtkWidget *widget );
static void sexy_icon_entry_unmap( GtkWidget *widget );
static void sexy_icon_entry_realize( GtkWidget *widget );
static void sexy_icon_entry_unrealize( GtkWidget *widget );
static void sexy_icon_entry_size_request(
GtkWidget *widget,
GtkRequisition *
requisition );
static void sexy_icon_entry_size_allocate(
GtkWidget *widget,
GtkAllocation *
allocation );
static gint sexy_icon_entry_expose( GtkWidget * widget,
GdkEventExpose *event );
static gint sexy_icon_entry_enter_notify(
GtkWidget * widget,
GdkEventCrossing *event );
static gint sexy_icon_entry_leave_notify(
GtkWidget * widget,
GdkEventCrossing *event );
static gint sexy_icon_entry_button_press( GtkWidget * widget,
GdkEventButton *event );
static gint sexy_icon_entry_button_release(
GtkWidget * widget,
GdkEventButton *event );
static GtkEntryClass *parent_class = NULL;
static guint signals[LAST_SIGNAL] = {0};
G_DEFINE_TYPE_EXTENDED( SexyIconEntry, sexy_icon_entry, GTK_TYPE_ENTRY,
0,
G_IMPLEMENT_INTERFACE( GTK_TYPE_EDITABLE,
sexy_icon_entry_editable_init ) );
static void
sexy_icon_entry_class_init( SexyIconEntryClass *klass )
{
GObjectClass * gobject_class;
GtkObjectClass *object_class;
GtkWidgetClass *widget_class;
parent_class = g_type_class_peek_parent( klass );
gobject_class = G_OBJECT_CLASS( klass );
object_class = GTK_OBJECT_CLASS( klass );
widget_class = GTK_WIDGET_CLASS( klass );
gobject_class->finalize = sexy_icon_entry_finalize;
object_class->destroy = sexy_icon_entry_destroy;
widget_class->map = sexy_icon_entry_map;
widget_class->unmap = sexy_icon_entry_unmap;
widget_class->realize = sexy_icon_entry_realize;
widget_class->unrealize = sexy_icon_entry_unrealize;
widget_class->size_request = sexy_icon_entry_size_request;
widget_class->size_allocate = sexy_icon_entry_size_allocate;
widget_class->expose_event = sexy_icon_entry_expose;
widget_class->enter_notify_event = sexy_icon_entry_enter_notify;
widget_class->leave_notify_event = sexy_icon_entry_leave_notify;
widget_class->button_press_event = sexy_icon_entry_button_press;
widget_class->button_release_event = sexy_icon_entry_button_release;
/**
* SexyIconEntry::icon-pressed:
* @entry: The entry on which the signal is emitted.
* @icon_pos: The position of the clicked icon.
* @button: The mouse button clicked.
*
* The ::icon-pressed signal is emitted when an icon is clicked.
*/
signals[ICON_PRESSED] =
g_signal_new( "icon_pressed",
G_TYPE_FROM_CLASS( gobject_class ),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET( SexyIconEntryClass, icon_pressed ),
NULL, NULL,
gtk_marshal_VOID__INT_INT,
G_TYPE_NONE, 2,
G_TYPE_INT,
G_TYPE_INT );
/**
* SexyIconEntry::icon-released:
* @entry: The entry on which the signal is emitted.
* @icon_pos: The position of the clicked icon.
* @button: The mouse button clicked.
*
* The ::icon-released signal is emitted on the button release from a
* mouse click.
*/
signals[ICON_RELEASED] =
g_signal_new( "icon_released",
G_TYPE_FROM_CLASS( gobject_class ),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET( SexyIconEntryClass, icon_released ),
NULL, NULL,
gtk_marshal_VOID__INT_INT,
G_TYPE_NONE, 2,
G_TYPE_INT,
G_TYPE_INT );
}
static void
sexy_icon_entry_editable_init( GtkEditableClass *iface G_GNUC_UNUSED )
{}
static void
sexy_icon_entry_init( SexyIconEntry *entry )
{
entry->priv = g_new0( SexyIconEntryPriv, 1 );
}
static void
sexy_icon_entry_finalize( GObject *obj )
{
SexyIconEntry *entry;
g_return_if_fail( obj != NULL );
g_return_if_fail( SEXY_IS_ICON_ENTRY( obj ) );
entry = SEXY_ICON_ENTRY( obj );
g_free( entry->priv );
if( G_OBJECT_CLASS( parent_class )->finalize )
G_OBJECT_CLASS( parent_class )->finalize( obj );
}
static void
sexy_icon_entry_destroy( GtkObject *obj )
{
SexyIconEntry *entry;
entry = SEXY_ICON_ENTRY( obj );
sexy_icon_entry_set_icon( entry, SEXY_ICON_ENTRY_PRIMARY, NULL );
sexy_icon_entry_set_icon( entry, SEXY_ICON_ENTRY_SECONDARY, NULL );
if( GTK_OBJECT_CLASS( parent_class )->destroy )
GTK_OBJECT_CLASS( parent_class )->destroy( obj );
}
static void
sexy_icon_entry_map( GtkWidget *widget )
{
if( GTK_WIDGET_REALIZED( widget ) && !GTK_WIDGET_MAPPED( widget ) )
{
SexyIconEntry *entry = SEXY_ICON_ENTRY( widget );
int i;
GTK_WIDGET_CLASS( parent_class )->map( widget );
for( i = 0; i < MAX_ICONS; i++ )
{
if( entry->priv->icons[i].icon != NULL )
gdk_window_show( entry->priv->icons[i].window );
}
}
}
static void
sexy_icon_entry_unmap( GtkWidget *widget )
{
if( GTK_WIDGET_MAPPED( widget ) )
{
SexyIconEntry *entry = SEXY_ICON_ENTRY( widget );
int i;
for( i = 0; i < MAX_ICONS; i++ )
{
if( entry->priv->icons[i].icon != NULL )
gdk_window_hide( entry->priv->icons[i].window );
}
GTK_WIDGET_CLASS( parent_class )->unmap( widget );
}
}
static gint
get_icon_width( SexyIconEntry * entry,
SexyIconEntryPosition icon_pos )
{
GtkRequisition requisition;
gint menu_icon_width;
gint width;
SexyIconInfo * icon_info = &entry->priv->icons[icon_pos];
if( icon_info->icon == NULL )
return 0;
gtk_widget_size_request( GTK_WIDGET( icon_info->icon ), &requisition );
gtk_icon_size_lookup( GTK_ICON_SIZE_MENU, &menu_icon_width, NULL );
width = MAX( requisition.width, menu_icon_width );
return width;
}
static void
get_borders( SexyIconEntry *entry,
gint * xborder,
gint * yborder )
{
GtkWidget *widget = GTK_WIDGET( entry );
gint focus_width;
gboolean interior_focus;
gtk_widget_style_get( widget,
"interior-focus", &interior_focus,
"focus-line-width", &focus_width,
NULL );
if( gtk_entry_get_has_frame( GTK_ENTRY( entry ) ) )
{
*xborder = widget->style->xthickness;
*yborder = widget->style->ythickness;
}
else
{
*xborder = 0;
*yborder = 0;
}
if( !interior_focus )
{
*xborder += focus_width;
*yborder += focus_width;
}
}
static void
get_text_area_size( SexyIconEntry *entry,
GtkAllocation *alloc )
{
GtkWidget * widget = GTK_WIDGET( entry );
GtkRequisition requisition;
gint xborder, yborder;
gtk_widget_get_child_requisition( widget, &requisition );
get_borders( entry, &xborder, &yborder );
alloc->x = xborder;
alloc->y = yborder;
alloc->width = widget->allocation.width - xborder * 2;
alloc->height = requisition.height - yborder * 2;
}
static void
get_icon_allocation( SexyIconEntry * icon_entry,
gboolean left,
GtkAllocation *widget_alloc G_GNUC_UNUSED,
GtkAllocation * text_area_alloc,
GtkAllocation * allocation,
SexyIconEntryPosition * icon_pos )
{
gboolean rtl;
rtl = ( gtk_widget_get_direction( GTK_WIDGET( icon_entry ) ) ==
GTK_TEXT_DIR_RTL );
if( left )
*icon_pos =
( rtl ? SEXY_ICON_ENTRY_SECONDARY : SEXY_ICON_ENTRY_PRIMARY );
else
*icon_pos =
( rtl ? SEXY_ICON_ENTRY_PRIMARY : SEXY_ICON_ENTRY_SECONDARY );
allocation->y = text_area_alloc->y;
allocation->width = get_icon_width( icon_entry, *icon_pos );
allocation->height = text_area_alloc->height;
if( left )
allocation->x = text_area_alloc->x + ICON_MARGIN;
else
{
allocation->x = text_area_alloc->x + text_area_alloc->width -
allocation->width - ICON_MARGIN;
}
}
static void
sexy_icon_entry_realize( GtkWidget *widget )
{
SexyIconEntry *entry = SEXY_ICON_ENTRY( widget );
GdkWindowAttr attributes;
gint attributes_mask;
int i;
GTK_WIDGET_CLASS( parent_class )->realize( widget );
attributes.x = 0;
attributes.y = 0;
attributes.width = 1;
attributes.height = 1;
attributes.window_type = GDK_WINDOW_CHILD;
attributes.wclass = GDK_INPUT_OUTPUT;
attributes.visual = gtk_widget_get_visual( widget );
attributes.colormap = gtk_widget_get_colormap( widget );
attributes.event_mask = gtk_widget_get_events( widget );
attributes.event_mask |=
( GDK_EXPOSURE_MASK
| GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK
| GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK );
attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
for( i = 0; i < MAX_ICONS; i++ )
{
SexyIconInfo *icon_info;
icon_info = &entry->priv->icons[i];
icon_info->window = gdk_window_new( widget->window, &attributes,
attributes_mask );
gdk_window_set_user_data( icon_info->window, widget );
gdk_window_set_background( icon_info->window,
&widget->style->base[GTK_WIDGET_STATE(
widget )] );
}
gtk_widget_queue_resize( widget );
}
static void
sexy_icon_entry_unrealize( GtkWidget *widget )
{
SexyIconEntry *entry = SEXY_ICON_ENTRY( widget );
int i;
GTK_WIDGET_CLASS( parent_class )->unrealize( widget );
for( i = 0; i < MAX_ICONS; i++ )
{
SexyIconInfo *icon_info = &entry->priv->icons[i];
gdk_window_destroy( icon_info->window );
icon_info->window = NULL;
}
}
static void
sexy_icon_entry_size_request( GtkWidget * widget,
GtkRequisition *requisition )
{
SexyIconEntry *entry;
gint icon_widths = 0;
int i;
entry = SEXY_ICON_ENTRY( widget );
for( i = 0; i < MAX_ICONS; i++ )
{
int icon_width = get_icon_width( entry, i );
if( icon_width > 0 )
icon_widths += icon_width + ICON_MARGIN;
}
GTK_WIDGET_CLASS( parent_class )->size_request( widget, requisition );
if( icon_widths > requisition->width )
requisition->width += icon_widths;
}
static void
place_windows( SexyIconEntry *icon_entry,
GtkAllocation *widget_alloc )
{
SexyIconEntryPosition left_icon_pos;
SexyIconEntryPosition right_icon_pos;
GtkAllocation left_icon_alloc;
GtkAllocation right_icon_alloc;
GtkAllocation text_area_alloc;
get_text_area_size( icon_entry, &text_area_alloc );
get_icon_allocation( icon_entry, TRUE, widget_alloc, &text_area_alloc,
&left_icon_alloc, &left_icon_pos );
get_icon_allocation( icon_entry, FALSE, widget_alloc, &text_area_alloc,
&right_icon_alloc, &right_icon_pos );
if( left_icon_alloc.width > 0 )
{
text_area_alloc.x = left_icon_alloc.x + left_icon_alloc.width +
ICON_MARGIN;
}
if( right_icon_alloc.width > 0 )
text_area_alloc.width -= right_icon_alloc.width + ICON_MARGIN;
text_area_alloc.width -= text_area_alloc.x;
gdk_window_move_resize( icon_entry->priv->icons[left_icon_pos].window,
left_icon_alloc.x, left_icon_alloc.y,
left_icon_alloc.width, left_icon_alloc.height );
gdk_window_move_resize( icon_entry->priv->icons[right_icon_pos].window,
right_icon_alloc.x, right_icon_alloc.y,
right_icon_alloc.width, right_icon_alloc.height );
gdk_window_move_resize( GTK_ENTRY( icon_entry )->text_area,
text_area_alloc.x, text_area_alloc.y,
text_area_alloc.width, text_area_alloc.height );
}
static void
sexy_icon_entry_size_allocate( GtkWidget * widget,
GtkAllocation *allocation )
{
g_return_if_fail( SEXY_IS_ICON_ENTRY( widget ) );
g_return_if_fail( allocation != NULL );
widget->allocation = *allocation;
GTK_WIDGET_CLASS( parent_class )->size_allocate( widget, allocation );
if( GTK_WIDGET_REALIZED( widget ) )
place_windows( SEXY_ICON_ENTRY( widget ), allocation );
}
static GdkPixbuf *
get_pixbuf_from_icon( SexyIconEntry * entry,
SexyIconEntryPosition icon_pos )
{
GdkPixbuf * pixbuf = NULL;
gchar * stock_id;
SexyIconInfo *icon_info = &entry->priv->icons[icon_pos];
GtkIconSize size;
switch( gtk_image_get_storage_type( GTK_IMAGE( icon_info->icon ) ) )
{
case GTK_IMAGE_PIXBUF:
pixbuf = gtk_image_get_pixbuf( GTK_IMAGE( icon_info->icon ) );
g_object_ref( pixbuf );
break;
case GTK_IMAGE_STOCK:
gtk_image_get_stock( GTK_IMAGE(
icon_info->icon ), &stock_id, &size );
pixbuf = gtk_widget_render_icon( GTK_WIDGET( entry ),
stock_id, size, NULL );
break;
default:
return NULL;
}
return pixbuf;
}
/* Kudos to the gnome-panel guys. */
static void
colorshift_pixbuf( GdkPixbuf *dest,
GdkPixbuf *src,
int shift )
{
gint i, j;
gint width, height, has_alpha, src_rowstride, dest_rowstride;
guchar *target_pixels;
guchar *original_pixels;
guchar *pix_src;
guchar *pix_dest;
int val;
guchar r, g, b;
has_alpha = gdk_pixbuf_get_has_alpha( src );
width = gdk_pixbuf_get_width( src );
height = gdk_pixbuf_get_height( src );
src_rowstride = gdk_pixbuf_get_rowstride( src );
dest_rowstride = gdk_pixbuf_get_rowstride( dest );
original_pixels = gdk_pixbuf_get_pixels( src );
target_pixels = gdk_pixbuf_get_pixels( dest );
for( i = 0; i < height; i++ )
{
pix_dest = target_pixels + i * dest_rowstride;
pix_src = original_pixels + i * src_rowstride;
for( j = 0; j < width; j++ )
{
r = *( pix_src++ );
g = *( pix_src++ );
b = *( pix_src++ );
val = r + shift;
*( pix_dest++ ) = CLAMP( val, 0, 255 );
val = g + shift;
*( pix_dest++ ) = CLAMP( val, 0, 255 );
val = b + shift;
*( pix_dest++ ) = CLAMP( val, 0, 255 );
if( has_alpha )
*( pix_dest++ ) = *( pix_src++ );
}
}
}
static void
draw_icon( GtkWidget * widget,
SexyIconEntryPosition icon_pos )
{
SexyIconEntry *entry = SEXY_ICON_ENTRY( widget );
SexyIconInfo * icon_info = &entry->priv->icons[icon_pos];
GdkPixbuf * pixbuf;
gint x, y, width, height;
if( icon_info->icon == NULL || !GTK_WIDGET_REALIZED( widget ) )
return;
if( ( pixbuf = get_pixbuf_from_icon( entry, icon_pos ) ) == NULL )
return;
gdk_drawable_get_size( icon_info->window, &width, &height );
if( width == 1 || height == 1 )
{
/*
* size_allocate hasn't been called yet. These are the default values.
*/
return;
}
if( gdk_pixbuf_get_height( pixbuf ) > height )
{
GdkPixbuf *temp_pixbuf;
int scale;
scale = height - ( 2 * ICON_MARGIN );
temp_pixbuf = gdk_pixbuf_scale_simple( pixbuf, scale, scale,
GDK_INTERP_BILINEAR );
g_object_unref( pixbuf );
pixbuf = temp_pixbuf;
}
x = ( width - gdk_pixbuf_get_width( pixbuf ) ) / 2;
y = ( height - gdk_pixbuf_get_height( pixbuf ) ) / 2;
if( icon_info->hovered )
{
GdkPixbuf *temp_pixbuf;
temp_pixbuf = gdk_pixbuf_copy( pixbuf );
colorshift_pixbuf( temp_pixbuf, pixbuf, 30 );
g_object_unref( pixbuf );
pixbuf = temp_pixbuf;
}
gdk_draw_pixbuf( icon_info->window, widget->style->black_gc, pixbuf,
0, 0, x, y, -1, -1,
GDK_RGB_DITHER_NORMAL, 0, 0 );
g_object_unref( pixbuf );
}
static gint
sexy_icon_entry_expose( GtkWidget * widget,
GdkEventExpose *event )
{
SexyIconEntry *entry;
g_return_val_if_fail( SEXY_IS_ICON_ENTRY( widget ), FALSE );
g_return_val_if_fail( event != NULL, FALSE );
entry = SEXY_ICON_ENTRY( widget );
if( GTK_WIDGET_DRAWABLE( widget ) )
{
gboolean found = FALSE;
int i;
for( i = 0; i < MAX_ICONS && !found; i++ )
{
SexyIconInfo *icon_info = &entry->priv->icons[i];
if( event->window == icon_info->window )
{
gint width;
GtkAllocation text_area_alloc;
get_text_area_size( entry, &text_area_alloc );
gdk_drawable_get_size( icon_info->window, &width, NULL );
gtk_paint_flat_box( widget->style, icon_info->window,
GTK_WIDGET_STATE(
widget ), GTK_SHADOW_NONE,
NULL, widget, "entry_bg",
0, 0, width, text_area_alloc.height );
draw_icon( widget, i );
found = TRUE;
}
}
if( !found )
GTK_WIDGET_CLASS( parent_class )->expose_event( widget, event );
}
return FALSE;
}
static void
update_icon( GObject *obj G_GNUC_UNUSED,
GParamSpec * param,
SexyIconEntry *entry )
{
if( param != NULL )
{
const char *name = g_param_spec_get_name( param );
if( strcmp( name, "pixbuf" ) && strcmp( name, "stock" )
&& strcmp( name, "image" ) && strcmp( name, "pixmap" )
&& strcmp( name, "icon_set" ) && strcmp( name, "pixbuf_animation" ) )
{
return;
}
}
gtk_widget_queue_resize( GTK_WIDGET( entry ) );
}
static gint
sexy_icon_entry_enter_notify( GtkWidget * widget,
GdkEventCrossing *event )
{
SexyIconEntry *entry = SEXY_ICON_ENTRY( widget );
int i;
for( i = 0; i < MAX_ICONS; i++ )
{
if( event->window == entry->priv->icons[i].window )
{
if( sexy_icon_entry_get_icon_highlight( entry, i ) )
{
entry->priv->icons[i].hovered = TRUE;
update_icon( NULL, NULL, entry );
break;
}
}
}
return FALSE;
}
static gint
sexy_icon_entry_leave_notify( GtkWidget * widget,
GdkEventCrossing *event )
{
SexyIconEntry *entry = SEXY_ICON_ENTRY( widget );
int i;
for( i = 0; i < MAX_ICONS; i++ )
{
if( event->window == entry->priv->icons[i].window )
{
if( sexy_icon_entry_get_icon_highlight( entry, i ) )
{
entry->priv->icons[i].hovered = FALSE;
update_icon( NULL, NULL, entry );
break;
}
}
}
return FALSE;
}
static gint
sexy_icon_entry_button_press( GtkWidget * widget,
GdkEventButton *event )
{
SexyIconEntry *entry = SEXY_ICON_ENTRY( widget );
int i;
for( i = 0; i < MAX_ICONS; i++ )
{
if( event->window == entry->priv->icons[i].window )
{
if( event->button == 1
&& sexy_icon_entry_get_icon_highlight( entry, i ) )
{
entry->priv->icons[i].hovered = FALSE;
update_icon( NULL, NULL, entry );
}
g_signal_emit( entry, signals[ICON_PRESSED], 0, i,
event->button );
return TRUE;
}
}
if( GTK_WIDGET_CLASS( parent_class )->button_press_event )
return GTK_WIDGET_CLASS( parent_class )->button_press_event( widget,
event );
return FALSE;
}
static gint
sexy_icon_entry_button_release( GtkWidget * widget,
GdkEventButton *event )
{
SexyIconEntry *entry = SEXY_ICON_ENTRY( widget );
int i;
for( i = 0; i < MAX_ICONS; i++ )
{
GdkWindow *icon_window = entry->priv->icons[i].window;
if( event->window == icon_window )
{
int width, height;
gdk_drawable_get_size( icon_window, &width, &height );
if( event->button == 1
&& sexy_icon_entry_get_icon_highlight( entry, i )
&& event->x >= 0 && event->y >= 0
&& event->x <= width && event->y <= height )
{
entry->priv->icons[i].hovered = TRUE;
update_icon( NULL, NULL, entry );
}
g_signal_emit( entry, signals[ICON_RELEASED], 0, i,
event->button );
return TRUE;
}
}
if( GTK_WIDGET_CLASS( parent_class )->button_release_event )
return GTK_WIDGET_CLASS( parent_class )->button_release_event(
widget,
event );
return FALSE;
}
/**
* sexy_icon_entry_new
*
* Creates a new SexyIconEntry widget.
*
* Returns a new #SexyIconEntry.
*/
GtkWidget *
sexy_icon_entry_new( void )
{
return GTK_WIDGET( g_object_new( SEXY_TYPE_ICON_ENTRY, NULL ) );
}
/**
* sexy_icon_entry_set_icon
* @entry: A #SexyIconEntry.
* @position: Icon position.
* @icon: A #GtkImage to set as the icon.
*
* Sets the icon shown in the entry
*/
void
sexy_icon_entry_set_icon( SexyIconEntry * entry,
SexyIconEntryPosition icon_pos,
GtkImage * icon )
{
SexyIconInfo *icon_info;
g_return_if_fail( entry != NULL );
g_return_if_fail( SEXY_IS_ICON_ENTRY( entry ) );
g_return_if_fail( IS_VALID_ICON_ENTRY_POSITION( icon_pos ) );
g_return_if_fail( icon == NULL || GTK_IS_IMAGE( icon ) );
icon_info = &entry->priv->icons[icon_pos];
if( icon == icon_info->icon )
return;
if( icon_pos == SEXY_ICON_ENTRY_SECONDARY
&& entry->priv->icon_released_id != 0 )
{
g_signal_handler_disconnect( entry, entry->priv->icon_released_id );
entry->priv->icon_released_id = 0;
}
if( icon == NULL )
{
if( icon_info->icon != NULL )
{
gtk_widget_destroy( GTK_WIDGET( icon_info->icon ) );
icon_info->icon = NULL;
/*
* Explicitly check, as the pointer may become invalidated
* during destruction.
*/
if( icon_info->window != NULL
&& GDK_IS_WINDOW( icon_info->window ) )
gdk_window_hide( icon_info->window );
}
}
else
{
if( icon_info->window != NULL && icon_info->icon == NULL )
gdk_window_show( icon_info->window );
g_signal_connect( G_OBJECT( icon ), "notify",
G_CALLBACK( update_icon ), entry );
icon_info->icon = icon;
g_object_ref( icon );
}
update_icon( NULL, NULL, entry );
}
/**
* sexy_icon_entry_set_icon_highlight
* @entry: A #SexyIconEntry;
* @position: Icon position.
* @highlight: TRUE if the icon should highlight on mouse-over
*
* Determines whether the icon will highlight on mouse-over.
*/
void
sexy_icon_entry_set_icon_highlight( SexyIconEntry * entry,
SexyIconEntryPosition icon_pos,
gboolean highlight )
{
SexyIconInfo *icon_info;
g_return_if_fail( entry != NULL );
g_return_if_fail( SEXY_IS_ICON_ENTRY( entry ) );
g_return_if_fail( IS_VALID_ICON_ENTRY_POSITION( icon_pos ) );
icon_info = &entry->priv->icons[icon_pos];
if( icon_info->highlight == highlight )
return;
icon_info->highlight = highlight;
}
/**
* sexy_icon_entry_get_icon
* @entry: A #SexyIconEntry.
* @position: Icon position.
*
* Retrieves the image used for the icon
*
* Returns: A #GtkImage.
*/
GtkImage *
sexy_icon_entry_get_icon( const SexyIconEntry * entry,
SexyIconEntryPosition icon_pos )
{
g_return_val_if_fail( entry != NULL, NULL );
g_return_val_if_fail( SEXY_IS_ICON_ENTRY( entry ), NULL );
g_return_val_if_fail( IS_VALID_ICON_ENTRY_POSITION( icon_pos ), NULL );
return entry->priv->icons[icon_pos].icon;
}
/**
* sexy_icon_entry_get_icon_highlight
* @entry: A #SexyIconEntry.
* @position: Icon position.
*
* Retrieves whether entry will highlight the icon on mouseover.
*
* Returns: TRUE if icon highlights.
*/
gboolean
sexy_icon_entry_get_icon_highlight( const SexyIconEntry * entry,
SexyIconEntryPosition icon_pos )
{
g_return_val_if_fail( entry != NULL, FALSE );
g_return_val_if_fail( SEXY_IS_ICON_ENTRY( entry ), FALSE );
g_return_val_if_fail( IS_VALID_ICON_ENTRY_POSITION( icon_pos ), FALSE );
return entry->priv->icons[icon_pos].highlight;
}
static void
clear_button_clicked_cb( SexyIconEntry * icon_entry,
SexyIconEntryPosition icon_pos,
int button )
{
if( icon_pos != SEXY_ICON_ENTRY_SECONDARY || button != 1 )
return;
gtk_entry_set_text( GTK_ENTRY( icon_entry ), "" );
}
/**
* sexy_icon_entry_add_clear_button
* @icon_entry: A #SexyIconEntry.
*
* A convenience function to add a clear button to the end of the entry.
* This is useful for search boxes.
*/
void
sexy_icon_entry_add_clear_button( SexyIconEntry *icon_entry )
{
GtkWidget *icon;
g_return_if_fail( icon_entry != NULL );
g_return_if_fail( SEXY_IS_ICON_ENTRY( icon_entry ) );
icon = gtk_image_new_from_stock( GTK_STOCK_CLEAR, GTK_ICON_SIZE_MENU );
gtk_widget_show( icon );
sexy_icon_entry_set_icon( SEXY_ICON_ENTRY( icon_entry ),
SEXY_ICON_ENTRY_SECONDARY,
GTK_IMAGE( icon ) );
sexy_icon_entry_set_icon_highlight( SEXY_ICON_ENTRY( icon_entry ),
SEXY_ICON_ENTRY_SECONDARY, TRUE );
if( icon_entry->priv->icon_released_id != 0 )
{
g_signal_handler_disconnect( icon_entry,
icon_entry->priv->icon_released_id );
}
icon_entry->priv->icon_released_id =
g_signal_connect( G_OBJECT( icon_entry ), "icon_released",
G_CALLBACK( clear_button_clicked_cb ), NULL );
}
Reference in a new issue View git blame Copy permalink