From 97c4e57dc0d5f3c3e9582aaea1602c415f66e9fa Mon Sep 17 00:00:00 2001 From: Scott Fritzinger Date: Thu, 13 Jul 2000 01:55:48 +0000 Subject: [PATCH] added icon list from gtkiconlist and some beginning index code (not much) git-svn-id: https://svn.code.sf.net/p/gphoto/code/trunk/libgphoto2@661 67ed7778-7388-44ab-90cf-0a291f65f57c --- frontends/gtk-old/src/callbacks.c | 19 +- frontends/gtk-old/src/gtkiconlist.c | 1515 ++++++++++++++++++++ frontends/gtk-old/src/gtkiconlist.h | 173 +++ frontends/gtk-old/src/gtkiconlist.lo | Bin 0 -> 171920 bytes frontends/gtk-old/src/gtkitementry.c | 1964 ++++++++++++++++++++++++++ frontends/gtk-old/src/gtkitementry.h | 73 + frontends/gtk-old/src/interface.c | 2 +- 7 files changed, 3742 insertions(+), 4 deletions(-) create mode 100644 frontends/gtk-old/src/gtkiconlist.c create mode 100644 frontends/gtk-old/src/gtkiconlist.h create mode 100644 frontends/gtk-old/src/gtkiconlist.lo create mode 100644 frontends/gtk-old/src/gtkitementry.c create mode 100644 frontends/gtk-old/src/gtkitementry.h diff --git a/frontends/gtk-old/src/callbacks.c b/frontends/gtk-old/src/callbacks.c index 1a075649d..a8935c412 100644 --- a/frontends/gtk-old/src/callbacks.c +++ b/frontends/gtk-old/src/callbacks.c @@ -427,11 +427,14 @@ camera_select_again: gtk_widget_destroy(window); } +int resize=0; + void camera_index_thumbnails() { GtkWidget *icon_list, *icon, *pixmap; GtkIconListItem *item; char buf[1024]; + int x; debug_print("camera index thumbnails"); @@ -440,9 +443,19 @@ void camera_index_thumbnails() { icon_list = (GtkWidget*) lookup_widget(gp_gtk_main_window, "icons"); - strcpy(buf,"A Thumbnail"); - item = gtk_icon_list_add_from_data(GTK_ICON_LIST(icon_list),nothumbnail_xpm,buf,NULL); - gtk_entry_set_editable(GTK_ENTRY(item->entry), FALSE); + if (resize) { + gtk_widget_hide(icon_list); + gtk_widget_show(icon_list); + return; + } + + GTK_ICON_LIST(icon_list)->is_editable = FALSE; + for (x=0; x<10; x++) { + sprintf(buf,"Photo #%i", x); + item = gtk_icon_list_add_from_data(GTK_ICON_LIST(icon_list), + nothumbnail_xpm,buf,NULL); + } + resize=1; } void camera_index_no_thumbnails() { diff --git a/frontends/gtk-old/src/gtkiconlist.c b/frontends/gtk-old/src/gtkiconlist.c new file mode 100644 index 000000000..32d8a86f6 --- /dev/null +++ b/frontends/gtk-old/src/gtkiconlist.c @@ -0,0 +1,1515 @@ +/* gtkiconlist - gtkiconlist widget for gtk+ + * Copyright 1999-2001 Adrian E. Feiguin + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +#include +#include +#include +#include +#include +#include "gtkitementry.h" +#include "gtkiconlist.h" +#include + +#define DEFAULT_ROW_SPACING 4 +#define DEFAULT_COL_SPACING 10 +#define DEFAULT_TEXT_SPACE 60 +#define DEFAULT_ICON_BORDER 2 +#define DEFAULT_WIDTH 150 +#define DEFAULT_HEIGHT 120 + +#define GRAPH_MASK (GDK_EXPOSURE_MASK | \ + GDK_POINTER_MOTION_MASK | \ + GDK_POINTER_MOTION_HINT_MASK | \ + GDK_BUTTON_PRESS_MASK | \ + GDK_BUTTON_RELEASE_MASK) + +/* Signals */ +enum{ + SELECT_ICON, + UNSELECT_ICON, + TEXT_CHANGED, + ACTIVATE_ICON, + DEACTIVATE_ICON, + CLICK_EVENT, + LAST_SIGNAL, +}; + +static void +gtk_iconlist_marshal_BOOL__POINTER_POINTER (GtkObject *object, + GtkSignalFunc func, + gpointer func_data, + GtkArg * args); + +typedef gboolean (*GtkIconListSignal1) (GtkObject *object, + GtkIconListItem *arg1, gchar *arg2, + gpointer user_data); + + +static guint signals[LAST_SIGNAL] = {0}; + +static void gtk_icon_list_class_init (GtkIconListClass *class); +static void gtk_icon_list_init (GtkIconList *icon_list); +static void gtk_icon_list_finalize (GtkObject *object); +static void gtk_icon_list_destroy (GtkObject *object); +static void gtk_icon_list_realize (GtkWidget *widget); +static void gtk_icon_list_map (GtkWidget *widget); +static void gtk_icon_list_draw (GtkWidget *widget, + GdkRectangle *area); +static void gtk_icon_list_paint (GtkWidget *widget, + GdkRectangle *area); +static gint gtk_icon_list_expose (GtkWidget *widget, + GdkEventExpose *event); +static gint gtk_icon_list_button_press (GtkWidget *widget, + GdkEventButton *event); +static gint deactivate_entry (GtkIconList *iconlist); +static gint entry_in (GtkWidget *widget, + GdkEventButton *event, + gpointer data); +static gint entry_changed (GtkWidget *widget, + gpointer data); +static void select_icon (GtkIconList *iconlist, + GtkIconListItem *item, + GdkEvent *event); +static void unselect_icon (GtkIconList *iconlist, + GtkIconListItem *item, + GdkEvent *event); +static void unselect_all (GtkIconList *iconlist); +static void set_labels (GtkIconList *iconlist, + GtkIconListItem *item, + const gchar *label); +static GtkIconListItem *get_icon_from_entry (GtkIconList *iconlist, + GtkWidget *widget); +static void reorder_icons (GtkIconList *iconlist); +static void item_size_request (GtkIconList *iconlist, + GtkIconListItem *item, + GtkRequisition *requisition); +static void gtk_icon_list_move (GtkIconList *iconlist, + GtkIconListItem *icon, + guint x, guint y); +static GtkIconListItem *gtk_icon_list_real_add (GtkIconList *iconualist, + GdkPixmap *pixmap, + GdkBitmap *mask, + const gchar *label, + gpointer data); +static GtkIconListItem *gtk_icon_list_put (GtkIconList *iconlist, + guint x, guint y, + GdkPixmap *pixmap, + GdkBitmap *mask, + const gchar *label, + gpointer data); +static gint icon_key_press (GtkWidget *widget, + GdkEventKey *key, + gpointer data); +static gint sort_list (gpointer a, gpointer b); +/* +static void my_strconcat (gchar **str, const gchar *add); +*/ + +static GtkFixedClass *parent_class = NULL; + +GtkType +gtk_icon_list_get_type (void) +{ + static GtkType icon_list_type = 0; + + if (!icon_list_type) + { + GtkTypeInfo icon_list_info = + { + "GtkIconList", + sizeof (GtkIconList), + sizeof (GtkIconListClass), + (GtkClassInitFunc) gtk_icon_list_class_init, + (GtkObjectInitFunc) gtk_icon_list_init, + /* reserved 1*/ NULL, + /* reserved 2 */ NULL, + (GtkClassInitFunc) NULL, + }; + + icon_list_type = gtk_type_unique (GTK_TYPE_FIXED, &icon_list_info); + } + return icon_list_type; +} + +GtkType +gtk_icon_list_item_get_type (void) +{ + static GtkType icon_list_item_type = 0; + + if (!icon_list_item_type) + { + GtkTypeInfo icon_list_item_info = + { + "GtkIconListItem", + 0, + 0, + (GtkClassInitFunc) NULL, + (GtkObjectInitFunc) NULL, + /* reserved 1*/ NULL, + /* reserved 2 */ NULL, + (GtkClassInitFunc) NULL, + }; + + icon_list_item_type = gtk_type_unique (GTK_TYPE_BOXED, + &icon_list_item_info); + } + return icon_list_item_type; +} + + +static void +gtk_icon_list_class_init (GtkIconListClass *klass) +{ + GtkObjectClass *object_class; + GtkWidgetClass *widget_class; + + parent_class = gtk_type_class (gtk_fixed_get_type ()); + + object_class = (GtkObjectClass *) klass; + widget_class = (GtkWidgetClass *) klass; + + object_class->finalize = gtk_icon_list_finalize; + object_class->destroy = gtk_icon_list_destroy; + + widget_class->realize = gtk_icon_list_realize; + widget_class->draw = gtk_icon_list_draw; + widget_class->map = gtk_icon_list_map; + widget_class->expose_event = gtk_icon_list_expose; + widget_class->button_press_event = gtk_icon_list_button_press; + + signals[SELECT_ICON] = + gtk_signal_new("select_icon", + GTK_RUN_LAST, + object_class->type, + GTK_SIGNAL_OFFSET(GtkIconListClass, select_icon), + gtk_iconlist_marshal_BOOL__POINTER_POINTER, + GTK_TYPE_BOOL, 2, + GTK_TYPE_ICON_LIST_ITEM, GTK_TYPE_GDK_EVENT); + + signals[UNSELECT_ICON] = + gtk_signal_new("unselect_icon", + GTK_RUN_FIRST, + object_class->type, + GTK_SIGNAL_OFFSET(GtkIconListClass, unselect_icon), + gtk_marshal_NONE__POINTER_POINTER, + GTK_TYPE_NONE, 2, + GTK_TYPE_ICON_LIST_ITEM, GTK_TYPE_GDK_EVENT); + + signals[TEXT_CHANGED] = + gtk_signal_new("text_changed", + GTK_RUN_LAST, + object_class->type, + GTK_SIGNAL_OFFSET(GtkIconListClass, text_changed), + gtk_iconlist_marshal_BOOL__POINTER_POINTER, + GTK_TYPE_BOOL, 2, + GTK_TYPE_ICON_LIST_ITEM, GTK_TYPE_STRING); + + signals[ACTIVATE_ICON] = + gtk_signal_new("activate_icon", + GTK_RUN_LAST, + object_class->type, + GTK_SIGNAL_OFFSET(GtkIconListClass, activate_icon), + gtk_marshal_BOOL__POINTER, + GTK_TYPE_BOOL, 1, + GTK_TYPE_ICON_LIST_ITEM); + + signals[DEACTIVATE_ICON] = + gtk_signal_new("deactivate_icon", + GTK_RUN_LAST, + object_class->type, + GTK_SIGNAL_OFFSET(GtkIconListClass, deactivate_icon), + gtk_marshal_BOOL__POINTER, + GTK_TYPE_BOOL, 1, + GTK_TYPE_ICON_LIST_ITEM); + + signals[CLICK_EVENT] = + gtk_signal_new("click_event", + GTK_RUN_LAST, + object_class->type, + GTK_SIGNAL_OFFSET(GtkIconListClass, click_event), + gtk_marshal_NONE__POINTER, + GTK_TYPE_NONE, 1, + GTK_TYPE_GDK_EVENT); + + gtk_object_class_add_signals (object_class, signals, LAST_SIGNAL); + + +} + +static void +gtk_iconlist_marshal_BOOL__POINTER_POINTER (GtkObject *object, + GtkSignalFunc func, + gpointer func_data, + GtkArg * args) +{ + GtkIconListSignal1 rfunc; + gboolean *veto; + + veto = GTK_RETLOC_BOOL (args[2]); + + rfunc = (GtkIconListSignal1) func; + + *veto = (*rfunc) (object, + GTK_VALUE_POINTER (args[0]), + GTK_VALUE_POINTER (args[1]), + func_data); + +} + +void +gtk_icon_list_freeze(GtkIconList *iconlist) +{ + iconlist->freeze_count++; +} + +void +gtk_icon_list_thaw(GtkIconList *iconlist) +{ + if(iconlist->freeze_count == 0) return; + iconlist->freeze_count--; + if(iconlist->freeze_count == 0) + reorder_icons(iconlist); +} + +static void +reorder_icons(GtkIconList *iconlist) +{ + GtkWidget *widget; + GtkIconListItem *item; + GtkRequisition req; + GList *icons; + gint hspace = 0; + gint vspace = 0; + gint x = 0; + gint y = 0; + gint old_width, old_height; + + widget = GTK_WIDGET(iconlist); + + if(iconlist->freeze_count > 0) return; + + old_width = widget->allocation.width; + old_height = widget->allocation.height; + + y = iconlist->row_spacing; + x = iconlist->col_spacing; + + icons = iconlist->icons; + while(icons){ + item = (GtkIconListItem *) icons->data; + + gtk_icon_list_move(iconlist, item, x, y); + + item_size_request(iconlist, item, &req); + + vspace = req.height + iconlist->row_spacing; + hspace = req.width + iconlist->col_spacing; + + switch(iconlist->mode){ + case GTK_ICON_LIST_TEXT_RIGHT: + y += vspace; + if(y + vspace > old_height){ + x += hspace; + y = iconlist->row_spacing; + } + break; + case GTK_ICON_LIST_TEXT_BELOW: + case GTK_ICON_LIST_ICON: + default: + x += hspace; + if(x + hspace > old_width){ + x = iconlist->col_spacing; + y += vspace; + } + break; + } + + icons = icons->next; + + } + +} + + +static void +gtk_icon_list_move(GtkIconList *iconlist, GtkIconListItem *icon, + guint x, guint y) +{ + GtkRequisition req1, req2; + GtkRequisition req; + gint old_width, old_height, width, height; + gint old_x, old_y; + + old_x = icon->x; + old_y = icon->y; + + icon->x = x; + icon->y = y; + + item_size_request(iconlist, icon, &req); + req1 = icon->pixmap->requisition; + req2 = icon->entry->requisition; + + req1.width = MAX(iconlist->icon_width, req1.width); + if(iconlist->mode == GTK_ICON_LIST_TEXT_BELOW){ + req1.width = MAX(req2.width, req1.width); + } + req1.width += 2*iconlist->icon_border; + req1.height += 2*iconlist->icon_border; + + if(iconlist->mode == GTK_ICON_LIST_ICON) + req2.width = req2.height = 0; + + old_width = width = GTK_WIDGET(iconlist)->allocation.width; + old_height = height = GTK_WIDGET(iconlist)->allocation.height; + + gtk_fixed_move(GTK_FIXED(iconlist), icon->pixmap, + x + req1.width/2 - icon->pixmap->requisition.width/2, + y + iconlist->icon_border); + + icon->pixmap->allocation.x += (x - old_x); + icon->pixmap->allocation.y += (y - old_y); + icon->entry->allocation.x += (x - old_x); + icon->entry->allocation.y += (y - old_y); + + switch(iconlist->mode){ + case GTK_ICON_LIST_TEXT_BELOW: + gtk_fixed_move(GTK_FIXED(iconlist), icon->entry, + x - req2.width/2 + req1.width/2, + y + req1.height + iconlist->icon_border); + if(y + req.height > height) + height += req.height; + break; + case GTK_ICON_LIST_TEXT_RIGHT: + gtk_fixed_move(GTK_FIXED(iconlist), icon->entry, + x + req1.width + iconlist->icon_border, + y + req1.height/2 - req2.height/2); + if(x + req.width > width) + width += req.width; + break; + case GTK_ICON_LIST_ICON: + default: ; + } + + gtk_widget_size_allocate(icon->pixmap, &icon->pixmap->allocation); + if(icon->entry){ + gtk_widget_size_allocate(icon->entry, &icon->entry->allocation); + gtk_widget_draw(icon->entry, NULL); + } + +} + +static void +gtk_icon_list_realize(GtkWidget *widget) +{ + GList *icons; + GtkIconList *iconlist; + GtkIconListItem *item; + GtkStyle *style; + + GTK_WIDGET_CLASS(parent_class)->realize (widget); + + iconlist = GTK_ICON_LIST(widget); + + gtk_widget_ensure_style(widget); + + style = gtk_style_copy(widget->style); + style->bg[0] = iconlist->background; + gtk_widget_set_style(widget, style); + gtk_style_set_background(widget->style, widget->window, GTK_STATE_NORMAL); + gtk_style_unref(style); + + icons = iconlist->icons; + while(icons){ + item = (GtkIconListItem *) icons->data; + gtk_widget_draw(item->pixmap, NULL); + if(iconlist->mode != GTK_ICON_LIST_ICON){ + gtk_widget_realize(item->entry); + gdk_gc_set_foreground(GTK_ITEM_ENTRY(item->entry)->bg_gc, + &iconlist->background); + gdk_gc_set_foreground(GTK_ITEM_ENTRY(item->entry)->fg_gc, + &widget->style->fg[GTK_STATE_NORMAL]); + gtk_widget_show(item->entry); + } + if(item->entry) gtk_widget_draw(item->entry, NULL); + icons = icons->next; + } + + reorder_icons(iconlist); +} + + +static void +gtk_icon_list_init (GtkIconList *icon_list) +{ + GtkWidget *widget; + widget = GTK_WIDGET(icon_list); + + gtk_widget_ensure_style(widget); + gdk_color_black(gtk_widget_get_colormap(widget), &widget->style->black); + gdk_color_white(gtk_widget_get_colormap(widget), &widget->style->white); + + gtk_widget_set_events (widget, gtk_widget_get_events(widget)| + GRAPH_MASK); + + icon_list->selection = NULL; + icon_list->is_editable = TRUE; + + icon_list->num_icons = 0; + icon_list->background = widget->style->white; + + icon_list->row_spacing = DEFAULT_ROW_SPACING; + icon_list->col_spacing = DEFAULT_COL_SPACING; + icon_list->text_space = DEFAULT_TEXT_SPACE; + icon_list->icon_border = DEFAULT_ICON_BORDER; + + icon_list->active_icon = NULL; + icon_list->compare_func = (GCompareFunc)sort_list; +} + +static gint +sort_list(gpointer a, gpointer b) +{ + GtkIconListItem *itema; + GtkIconListItem *itemb; + + itema = (GtkIconListItem *)a; + itemb = (GtkIconListItem *)b; + + return (strcmp(itema->label, itemb->label)); +} + +static void +gtk_icon_list_paint (GtkWidget *widget, GdkRectangle *area) +{ + GtkIconList *icon_list; + + icon_list = GTK_ICON_LIST(widget); + + if(!GTK_WIDGET_DRAWABLE(widget)) return; + + GTK_WIDGET_CLASS(parent_class)->draw(widget, area); + + if(icon_list->active_icon && icon_list->active_icon->entry){ + gdk_draw_rectangle(widget->window, + widget->style->fg_gc[GTK_STATE_NORMAL], + FALSE, + icon_list->active_icon->entry->allocation.x+2, + icon_list->active_icon->entry->allocation.y+2, + icon_list->active_icon->entry->allocation.width-4, + icon_list->active_icon->entry->allocation.height-4); + } + +} + +static void +gtk_icon_list_draw (GtkWidget *widget, GdkRectangle *darea) +{ + GdkRectangle area; + if(darea) + area = *darea; + else + { + area.x = 0; + area.y = 0; + area.width = widget->allocation.width; + area.height = widget->allocation.height; + } + +/* GTK_WIDGET_CLASS(parent_class)->draw (widget, &area); +*/ + gtk_icon_list_paint(widget, &area); + +} + + +static gint +gtk_icon_list_expose(GtkWidget *widget, GdkEventExpose *event) +{ + gtk_icon_list_paint(widget, &event->area); + return FALSE; +} + +static void +gtk_icon_list_map (GtkWidget *widget) +{ + if(!GTK_WIDGET_MAPPED(widget)){ + GTK_WIDGET_CLASS(parent_class)->map (widget); + GTK_WIDGET_SET_FLAGS(widget, GTK_MAPPED); + +/* + set_adjustments(widget, NULL); +*/ + } +} + +static gint +gtk_icon_list_button_press(GtkWidget *widget, GdkEventButton *event) +{ + GtkIconList *iconlist; + GtkIconListItem *item; + gint x, y; + GtkAllocation *allocation; + + if(!GTK_IS_ICON_LIST(widget)) return FALSE; + + iconlist = GTK_ICON_LIST(widget); + + gtk_widget_get_pointer(widget, &x, &y); + item = gtk_icon_list_get_icon_at(iconlist, x , y ); + + if(!item){ + gtk_signal_emit(GTK_OBJECT(iconlist), signals[CLICK_EVENT], + event); + return FALSE; + } + + if(item->entry){ + allocation = &item->entry->allocation; + if(x >= allocation->x && + x <= allocation->x + allocation->width && + y >= allocation->y && + y <= allocation->y + allocation->height) return FALSE; + } + + if(item) + switch(iconlist->selection_mode){ + case GTK_SELECTION_SINGLE: + case GTK_SELECTION_BROWSE: + unselect_all(iconlist); + case GTK_SELECTION_MULTIPLE: + case GTK_SELECTION_EXTENDED: + select_icon(iconlist, item, (GdkEvent *)event); + } + + return FALSE; +} + + +static gint +deactivate_entry(GtkIconList *iconlist) +{ + GdkGC *gc; + GtkEntry *entry; + gboolean veto; + + if(iconlist->active_icon) { + gtk_signal_emit(GTK_OBJECT(iconlist), signals[DEACTIVATE_ICON], + iconlist->active_icon, &veto); + if(!veto) return FALSE; + + entry = GTK_ENTRY(iconlist->active_icon->entry); + gtk_entry_set_editable(entry, FALSE); + gtk_entry_set_text(entry, iconlist->active_icon->entry_label); + gtk_entry_select_region(entry, 0, 0); + gtk_entry_set_position(entry, 0); + + + if(GTK_WIDGET_REALIZED(iconlist->active_icon->entry)){ + gc = gdk_gc_new(GTK_WIDGET(iconlist)->window); + gdk_gc_set_foreground(gc, &iconlist->background); + gdk_draw_rectangle(GTK_WIDGET(iconlist)->window, + gc, + FALSE, + GTK_WIDGET(entry)->allocation.x+2, + GTK_WIDGET(entry)->allocation.y+2, + GTK_WIDGET(entry)->allocation.width-4, + GTK_WIDGET(entry)->allocation.height-4); + gdk_gc_unref(gc); + } + + iconlist->active_icon->state = GTK_STATE_NORMAL; + iconlist->active_icon = NULL; + } + + return TRUE; +} + + +static void +select_icon(GtkIconList *iconlist, GtkIconListItem *item, GdkEvent *event) +{ + gboolean veto = TRUE; + + if(iconlist->mode != GTK_ICON_LIST_ICON){ + if(!deactivate_entry(iconlist)) return; + + if(GTK_WIDGET_REALIZED(item->entry)){ + gdk_gc_set_foreground(GTK_ITEM_ENTRY(item->entry)->fg_gc, + &item->entry->style->fg[GTK_STATE_SELECTED]); + gdk_gc_set_foreground(GTK_ITEM_ENTRY(item->entry)->bg_gc, + &item->entry->style->bg[GTK_STATE_SELECTED]); + } + gtk_entry_set_text(GTK_ENTRY(item->entry), item->label); + gtk_entry_set_position(GTK_ENTRY(item->entry), 0); + gtk_widget_draw(item->entry, NULL); + } + + gtk_signal_emit(GTK_OBJECT(iconlist), signals[SELECT_ICON], item, + event, &veto); + + if(!veto) return; + + if(item->state == GTK_STATE_SELECTED) return; + iconlist->selection = g_list_append(iconlist->selection, item); + + item->state = GTK_STATE_SELECTED; + if(item->entry) gtk_widget_grab_focus(item->entry); + +} + +static void +unselect_icon(GtkIconList *iconlist, GtkIconListItem *item, GdkEvent *event) +{ + GList *selection; + GtkIconListItem *icon; + if(item->state == GTK_STATE_NORMAL) return; + + selection = iconlist->selection; + while(selection){ + icon = (GtkIconListItem *)selection->data; + if(item == icon) break; + selection = selection->next; + } + + if(selection){ + selection = g_list_remove_link(iconlist->selection, selection); + g_list_free_1(selection); + } + + item->state = GTK_STATE_NORMAL; + + if(iconlist->mode != GTK_ICON_LIST_ICON){ + if(GTK_WIDGET_REALIZED(item->entry)){ + gdk_gc_set_foreground(GTK_ITEM_ENTRY(item->entry)->bg_gc, + &iconlist->background); + gdk_gc_set_foreground(GTK_ITEM_ENTRY(item->entry)->fg_gc, + &item->entry->style->fg[GTK_STATE_NORMAL]); + } + gtk_entry_select_region(GTK_ENTRY(item->entry), 0, 0); + gtk_entry_set_text(GTK_ENTRY(item->entry), item->entry_label); + gtk_entry_set_editable(GTK_ENTRY(item->entry), FALSE); + gtk_widget_draw(item->entry, NULL); + } + + gtk_signal_emit(GTK_OBJECT(iconlist), signals[UNSELECT_ICON], item, event); +} + +static void +unselect_all(GtkIconList *iconlist) +{ + GList *selection; + GtkIconListItem *item; + + selection = iconlist->selection; + while(selection){ + item = (GtkIconListItem *)selection->data; + unselect_icon(iconlist, item, NULL); + selection = selection->next; + } + + g_list_free(iconlist->selection); + iconlist->selection = NULL; +} + +GtkWidget* +gtk_icon_list_new (guint icon_width, guint mode) +{ + GtkIconList *icon_list; + + icon_list = gtk_type_new (gtk_icon_list_get_type ()); + icon_list->icon_width = icon_width; + icon_list->mode = mode; + icon_list->icons = NULL; + icon_list->selection = NULL; + icon_list->selection_mode = GTK_SELECTION_SINGLE; + return GTK_WIDGET (icon_list); +} + + +static void +gtk_icon_list_destroy (GtkObject *object) +{ + GtkIconList *icon_list; + + g_return_if_fail (object != NULL); + g_return_if_fail (GTK_IS_ICON_LIST (object)); + + icon_list = GTK_ICON_LIST (object); + + gtk_icon_list_clear(icon_list); + + if (GTK_OBJECT_CLASS (parent_class)->destroy) + (*GTK_OBJECT_CLASS (parent_class)->destroy) (object); +} + + +static void +gtk_icon_list_finalize (GtkObject *object) +{ + GtkIconList *icon_list; + + g_return_if_fail (object != NULL); + g_return_if_fail (GTK_IS_ICON_LIST (object)); + + icon_list = GTK_ICON_LIST (object); + + if (GTK_OBJECT_CLASS (parent_class)->finalize) + (*GTK_OBJECT_CLASS (parent_class)->finalize) (object); +} + +void +gtk_icon_list_set_background (GtkIconList *iconlist, GdkColor *color) +{ + GtkWidget *widget; + GtkStyle *style; + + g_return_if_fail (iconlist != NULL); + g_return_if_fail (GTK_IS_ICON_LIST (iconlist)); + + widget = GTK_WIDGET(iconlist); + + iconlist->background = *color; + style = gtk_style_copy(widget->style); + style->bg[0] = iconlist->background; + gtk_widget_set_style(widget, style); + gtk_style_set_background(widget->style, widget->window, GTK_STATE_NORMAL); + gtk_style_unref(style); + +} + +static gint +entry_changed (GtkWidget *widget, gpointer data) +{ + GtkIconList *iconlist; + GtkIconListItem *item; + gboolean veto = TRUE; + gchar *text; + + iconlist = GTK_ICON_LIST(data); + item = get_icon_from_entry(iconlist, widget); + text = gtk_entry_get_text(GTK_ENTRY(widget)); + + gtk_signal_emit(GTK_OBJECT(data), signals[TEXT_CHANGED], + item, text, &veto); + + if(!veto) return veto; + + if(GTK_EDITABLE(item->entry)->editable){ + g_free(item->label); + item->label = g_strdup(text); + g_free(item->entry_label); + set_labels(iconlist, item, text); + } + + return veto; +} + +static gint +entry_in (GtkWidget *widget, GdkEventButton *event, gpointer data) +{ + GtkIconList *iconlist; + GtkIconListItem *item; + gboolean veto = TRUE; + + iconlist = GTK_ICON_LIST(data); + + item = get_icon_from_entry(iconlist, widget); + + if(iconlist->active_icon && iconlist->active_icon->entry == widget) + return FALSE; + + gtk_signal_emit(GTK_OBJECT(iconlist), signals[ACTIVATE_ICON], &item, &veto); + + if(!veto) return FALSE; + if(!deactivate_entry(iconlist)) return FALSE; + + if(item->state == GTK_STATE_SELECTED){ + if(iconlist->is_editable && !GTK_EDITABLE(widget)->editable){ + unselect_all(iconlist); + gtk_entry_set_editable(GTK_ENTRY(widget), TRUE); + if(item->label) gtk_entry_set_text(GTK_ENTRY(widget), item->label); + gtk_widget_draw(widget, NULL); + iconlist->active_icon = item; + item->state = GTK_STATE_NORMAL; + if(GTK_WIDGET_DRAWABLE(widget)) + gdk_draw_rectangle(GTK_WIDGET(iconlist)->window, + widget->style->fg_gc[GTK_STATE_NORMAL], + FALSE, + iconlist->active_icon->entry->allocation.x+2, + iconlist->active_icon->entry->allocation.y+2, + iconlist->active_icon->entry->allocation.width-4, + iconlist->active_icon->entry->allocation.height-4); + } + }else{ + if(iconlist->selection_mode == GTK_SELECTION_SINGLE || + iconlist->selection_mode == GTK_SELECTION_BROWSE) + unselect_all(iconlist); + select_icon(iconlist, item, (GdkEvent *)event); + } + + return FALSE; +} + +GtkIconListItem * +gtk_icon_list_get_active_icon(GtkIconList *iconlist) +{ + return iconlist->active_icon; +} + +static GtkIconListItem * +get_icon_from_entry(GtkIconList *iconlist, GtkWidget *widget) +{ + GList *icons; + GtkIconListItem *item; + + icons = iconlist->icons; + while(icons){ + item = (GtkIconListItem *) icons->data; + if(widget == item->entry) return item; + icons = icons->next; + } + + return NULL; +} + +GtkIconListItem * +gtk_icon_list_get_icon_at(GtkIconList *iconlist, gint x, gint y) +{ + GList *icons; + GtkIconListItem *item; + GtkRequisition req; + + icons = iconlist->icons; + while(icons){ + item = (GtkIconListItem *) icons->data; + item_size_request(iconlist, item, &req); + if(x >= item->x && x <= item->x + req.width && + y >= item->y && y <= item->y + req.height) return item; + icons = icons->next; + } + + return NULL; +} + +GtkIconListItem * +gtk_icon_list_add (GtkIconList *iconlist, + const gchar *file, + const gchar *label, + gpointer link) +{ + GtkIconListItem *item; + GdkColormap *colormap; + GdkPixmap *pixmap; + GdkBitmap *mask; + + colormap = gdk_colormap_get_system(); + pixmap = gdk_pixmap_colormap_create_from_xpm(NULL, colormap, &mask, NULL, + file); + item = gtk_icon_list_real_add(iconlist, pixmap, mask, label, link); + return item; +} + +GtkIconListItem * +gtk_icon_list_add_from_data (GtkIconList *iconlist, + gchar **data, + const gchar *label, + gpointer link) +{ + GtkIconListItem *item; + GdkColormap *colormap; + GdkPixmap *pixmap; + GdkBitmap *mask; + + colormap = gdk_colormap_get_system(); + pixmap = gdk_pixmap_colormap_create_from_xpm_d(NULL, colormap, &mask, NULL, + data); + item = gtk_icon_list_real_add(iconlist, pixmap, mask, label, link); + return item; +} + +static GtkIconListItem* +gtk_icon_list_real_add (GtkIconList *iconlist, + GdkPixmap *pixmap, + GdkBitmap *mask, + const gchar *label, + gpointer data) +{ + GtkIconListItem *item; + GtkRequisition requisition; + gint hspace = 0; + gint vspace = 0; + gint x = 0; + gint y = 0; + gint width, height; + + width = GTK_WIDGET(iconlist)->allocation.width; + height = GTK_WIDGET(iconlist)->allocation.height; + + if(iconlist->num_icons > 0){ + item = gtk_icon_list_get_nth(iconlist, iconlist->num_icons-1); + x = item->x; + y = item->y; + item_size_request(iconlist, item, &requisition); + + vspace = requisition.height + iconlist->row_spacing; + hspace = requisition.width + iconlist->col_spacing; + + switch(iconlist->mode){ + case GTK_ICON_LIST_TEXT_RIGHT: + y += vspace; + if(y >= height){ + x += hspace; + y = iconlist->row_spacing; + } + break; + case GTK_ICON_LIST_TEXT_BELOW: + case GTK_ICON_LIST_ICON: + default: + x += hspace; + if(x >= width){ + x = iconlist->col_spacing; + y += vspace ; + } + break; + } + } else { + y = iconlist->row_spacing; + x = iconlist->col_spacing; + } + + item = gtk_icon_list_put(iconlist, x, y, pixmap, mask, label, data); + return item; +} + +static GtkIconListItem * +gtk_icon_list_put (GtkIconList *iconlist, + guint x, guint y, + GdkPixmap *pixmap, + GdkBitmap *mask, + const gchar *label, + gpointer data) +{ + GtkIconListItem *icon; + GtkIconListItem *active_icon; + GtkWidget *widget; + GtkRequisition req1, req2; + gint text_width; + gint width, height, old_width, old_height; + GtkAllocation alloc; + + widget = GTK_WIDGET(iconlist); + + old_width = width = GTK_WIDGET(iconlist)->allocation.width; + old_height = height = GTK_WIDGET(iconlist)->allocation.height; + + active_icon = iconlist->active_icon; + gtk_icon_list_set_active_icon(iconlist, NULL); + + icon = g_new(GtkIconListItem, 1); + icon->x = x; + icon->y = y; + icon->state = GTK_STATE_NORMAL; + icon->label = NULL; + icon->entry_label = NULL; + if(label) icon->label = g_strdup(label); + icon->entry = gtk_item_entry_new(); + icon->pixmap = gtk_pixmap_new(pixmap, mask); + icon->link = data; + + GTK_ITEM_ENTRY(icon->entry)->text_max_size = DEFAULT_TEXT_SPACE; + gtk_widget_size_request(icon->entry, &req2); + if(iconlist->mode == GTK_ICON_LIST_TEXT_RIGHT){ + req2.width = MAX(iconlist->text_space, req2.width); + gtk_widget_set_usize(icon->entry, req2.width, req2.height); + } + + gtk_widget_size_request(icon->pixmap, &req1); + req1.width = MAX(iconlist->icon_width, req1.width); + if(iconlist->mode == GTK_ICON_LIST_TEXT_BELOW){ + req1.width = MAX(req2.width, req1.width); + } + req1.width += 2*iconlist->icon_border; + req1.height += 2*iconlist->icon_border; + + if(iconlist->mode == GTK_ICON_LIST_ICON) + req2.width = req2.height = 0; + else + set_labels(iconlist, icon, label); + + text_width = gdk_string_width(icon->entry->style->font, label); + + gtk_fixed_put(GTK_FIXED(iconlist), icon->pixmap, + x + req1.width/2 - icon->pixmap->requisition.width/2, + y + iconlist->icon_border); + + alloc.x = x + req1.width/2 - icon->pixmap->requisition.width/2; + alloc.y = y + iconlist->icon_border; + alloc.width = req1.width; + alloc.height = req1.height; + gtk_widget_size_allocate(icon->pixmap, &alloc); + + switch(iconlist->mode){ + case GTK_ICON_LIST_TEXT_BELOW: + gtk_item_entry_set_text(GTK_ITEM_ENTRY(icon->entry), icon->entry_label, + GTK_JUSTIFY_CENTER); + gtk_fixed_put(GTK_FIXED(iconlist), icon->entry, + x - req2.width/2 + req1.width/2, + y + req1.height + iconlist->icon_border); + alloc.x = x - req2.width/2 + req1.width/2; + alloc.y = y + req1.height + iconlist->icon_border; + alloc.width = req2.width; + alloc.height = req2.height; + gtk_widget_size_allocate(icon->entry, &alloc); + + if(y + req1.height + iconlist->icon_border + req2.height > height) + height += req1.height + iconlist->icon_border + req2.height; + break; + case GTK_ICON_LIST_TEXT_RIGHT: + gtk_item_entry_set_text(GTK_ITEM_ENTRY(icon->entry), icon->entry_label, + GTK_JUSTIFY_LEFT); + gtk_fixed_put(GTK_FIXED(iconlist), icon->entry, + x + req1.width + iconlist->icon_border, + y + req1.height/2 - req2.height/2); + alloc.x = x + req1.width + iconlist->icon_border; + alloc.y = y + req1.height/2 - req2.height/2; + alloc.width = req2.width; + alloc.height = req2.height; + gtk_widget_size_allocate(icon->entry, &alloc); + + if(x + req1.width + iconlist->icon_border + text_width > width) + width += req1.width + iconlist->icon_border + text_width; + break; + case GTK_ICON_LIST_ICON: + default: ; + } + + if(GTK_WIDGET_REALIZED(iconlist)) + if(iconlist->mode != GTK_ICON_LIST_ICON){ + gdk_gc_set_foreground(GTK_ITEM_ENTRY(icon->entry)->bg_gc, + &iconlist->background); + gdk_gc_set_foreground(GTK_ITEM_ENTRY(icon->entry)->fg_gc, + &widget->style->fg[GTK_STATE_NORMAL]); + gtk_widget_show(icon->entry); + } + + gtk_widget_show(icon->pixmap); + + iconlist->icons = g_list_insert_sorted(iconlist->icons, icon, iconlist->compare_func); + iconlist->num_icons++; + + if(GTK_WIDGET_REALIZED(iconlist)) + reorder_icons(iconlist); + + gtk_entry_set_editable(GTK_ENTRY(icon->entry), FALSE); + gtk_signal_connect(GTK_OBJECT(icon->entry), "key_press_event", + (GtkSignalFunc)icon_key_press, iconlist); + gtk_signal_connect(GTK_OBJECT(icon->entry), "button_press_event", + (GtkSignalFunc)entry_in, iconlist); + gtk_signal_connect(GTK_OBJECT(icon->entry), "changed", + (GtkSignalFunc)entry_changed, iconlist); + + gtk_icon_list_set_active_icon(iconlist, active_icon); + return icon; +} + +static void +set_labels(GtkIconList *iconlist, GtkIconListItem *icon, const gchar *label) +{ + gint text_width; + gint point_width; + gint max_width; + gchar letter[2]; + gchar *entry_label; + gint n, space; + + text_width = gdk_string_width(icon->entry->style->font, label); + point_width = gdk_string_width(icon->entry->style->font, "X"); + + max_width = icon->entry->requisition.width; + max_width = MAX(max_width, iconlist->text_space); + + entry_label = g_strdup(""); + + for(n = 0; n < strlen(label); n++){ + space = strlen(label) - n + 1; + if(space > 3 && + gdk_string_width(icon->entry->style->font, entry_label) + + 3 * point_width > max_width) + break; + letter[0] = label[n]; + letter[1] = '\0'; + entry_label = g_strconcat(entry_label, letter, NULL); + } + + if(strlen(entry_label) < strlen(label)) + entry_label = g_strconcat(entry_label, "...", NULL); + else + entry_label = g_strdup(entry_label); + + icon->entry_label = entry_label; +} + +/* +static void +my_strconcat(gchar **str, const gchar *add) +{ + gint n, m; + + if(!*str || !add) return; + m = strlen(add); + n = strlen(*str); + *str = g_realloc(*str, n+m+1); + if(!str) + strcat(*str, add); + else + g_warning("Couldn't reallocate label string"); + +} +*/ + +static gint +icon_key_press(GtkWidget *widget, GdkEventKey *key, gpointer data) +{ + GtkIconList *iconlist; + + iconlist = GTK_ICON_LIST(data); + if(key->keyval != GDK_Return) return FALSE; + + if(iconlist->active_icon) + select_icon(iconlist, iconlist->active_icon, NULL); + + return FALSE; +} + +static void +item_size_request(GtkIconList *iconlist, + GtkIconListItem *item, + GtkRequisition *requisition) +{ + GtkRequisition req2; + + gtk_widget_size_request(item->entry, &req2); + req2.width = MAX(req2.width, iconlist->text_space); + + gtk_widget_size_request(item->pixmap, requisition); + requisition->width = MAX(iconlist->icon_width, requisition->width); + requisition->width += 2*iconlist->icon_border; + requisition->height += 2*iconlist->icon_border; + + switch(iconlist->mode){ + case GTK_ICON_LIST_TEXT_BELOW: + requisition->height += req2.height; + requisition->width = MAX(requisition->width, req2.width); + break; + case GTK_ICON_LIST_TEXT_RIGHT: + requisition->width += req2.width; + break; + case GTK_ICON_LIST_ICON: + default: ; + } + +} + + +void +gtk_icon_list_set_editable (GtkIconList *iconlist, gboolean editable) +{ + GList *icons; + GtkIconListItem *item; + + icons = iconlist->icons; + while(icons){ + item = (GtkIconListItem *) icons->data; + gtk_entry_set_editable(GTK_ENTRY(item->entry), editable); + icons = icons->next; + } + + iconlist->is_editable = editable; +} + +GtkIconListItem * +gtk_icon_list_get_nth(GtkIconList *iconlist, guint n) +{ + return (GtkIconListItem *)g_list_nth_data(iconlist->icons, n); +} + +gint +gtk_icon_list_get_index(GtkIconList *iconlist, GtkIconListItem *item) +{ + GList *icons; + GtkIconListItem *icon; + gint n = 0; + + if(item == NULL) return -1; + + icons = iconlist->icons; + while(icons){ + n++; + icon = (GtkIconListItem *) icons->data; + if(item == icon) break; + icons = icons->next; + } + + if(icons) return n; + + return -1; +} + + +void +gtk_icon_list_remove (GtkIconList *iconlist, GtkIconListItem *item) +{ + GList *icons; + GtkIconListItem *icon; + + if(item == NULL) return; + + icons = iconlist->icons; + while(icons){ + icon = (GtkIconListItem *) icons->data; + if(item == icon) break; + icons = icons->next; + } + + if(icons){ + if(icon->state == GTK_STATE_SELECTED) unselect_icon(iconlist, icon, NULL); + gtk_container_remove(GTK_CONTAINER(iconlist), icon->entry); + gtk_container_remove(GTK_CONTAINER(iconlist), icon->pixmap); + if(icon->label){ + g_free(icon->label); + icon->label = NULL; + } + if(icon->entry_label){ + g_free(icon->entry_label); + icon->entry_label = NULL; + } + + g_free(icon); + iconlist->icons = g_list_remove_link(iconlist->icons, icons); + g_list_free_1(icons); + iconlist->num_icons--; + } + + if(iconlist->num_icons == 0){ + iconlist->icons = NULL; + iconlist->selection = NULL; + } +} + +void +gtk_icon_list_remove_nth (GtkIconList *iconlist, guint n) +{ + GtkIconListItem *item; + + item = gtk_icon_list_get_nth(iconlist, n); + gtk_icon_list_remove(iconlist, item); +} + +void +gtk_icon_list_clear(GtkIconList *iconlist) +{ + GList *icons; + GtkIconListItem *icon; + + if(!deactivate_entry(iconlist)) return; + unselect_all(iconlist); + + icons = iconlist->icons; + + while(icons){ + icon = (GtkIconListItem *) icons->data; + gtk_container_remove(GTK_CONTAINER(iconlist), icon->entry); + gtk_container_remove(GTK_CONTAINER(iconlist), icon->pixmap); + if(icon->label){ + g_free(icon->label); + icon->label = NULL; + } + if(icon->entry_label){ + g_free(icon->entry_label); + icon->entry_label = NULL; + } + + g_free(icon); + iconlist->icons = g_list_remove_link(iconlist->icons, icons); + g_list_free_1(icons); + icons = iconlist->icons; + } + + iconlist->icons = NULL; + iconlist->num_icons = 0; + +} + +void +gtk_icon_list_link(GtkIconListItem *item, gpointer data) +{ + item->link = data; +} + +gpointer +gtk_icon_list_get_link(GtkIconListItem *item) +{ + return item->link; +} + +GtkIconListItem * +gtk_icon_list_get_icon_from_link(GtkIconList *iconlist, gpointer data) +{ + GList *icons; + GtkIconListItem *item; + + icons = iconlist->icons; + while(icons){ + item = (GtkIconListItem *) icons->data; + if(data == item->link) return item; + icons = icons->next; + } + + return NULL; +} + +GtkWidget * +gtk_icon_list_get_entry(GtkIconListItem *item) +{ + return item->entry; +} + +GtkWidget * +gtk_icon_list_get_pixmap(GtkIconListItem *item) +{ + return item->pixmap; +} + +void +gtk_icon_list_set_pixmap(GtkIconListItem *item, + GdkPixmap *pixmap, + GdkBitmap *mask) +{ + + if(item->pixmap) gtk_widget_destroy(item->pixmap); + item->pixmap = gtk_pixmap_new(pixmap, mask); + +} + +void +gtk_icon_list_set_label(GtkIconList *iconlist, GtkIconListItem *item, const gchar *label) +{ + if(item->label){ + g_free(item->label); + item->label = NULL; + } + if(item->entry_label){ + g_free(item->entry_label); + item->entry_label = NULL; + } + item->label = g_strdup(label); + gtk_entry_set_text(GTK_ENTRY(item->entry), label); + set_labels(iconlist, item, label); +} + +/********************************** + * gtk_icon_list_set_icon_width + * gtk_icon_list_set_row_spacing + * gtk_icon_list_set_col_spacing + * gtk_icon_list_set_text_space + * gtk_icon_list_icon_border + **********************************/ + +void +gtk_icon_list_set_icon_width(GtkIconList *iconlist, guint width) +{ + iconlist->icon_width = width; + reorder_icons(iconlist); +} + +void +gtk_icon_list_set_icon_border(GtkIconList *iconlist, guint border) +{ + iconlist->icon_border = border; + reorder_icons(iconlist); +} + +void +gtk_icon_list_set_row_spacing(GtkIconList *iconlist, guint spacing) +{ + iconlist->row_spacing = spacing; + reorder_icons(iconlist); +} + +void +gtk_icon_list_set_col_spacing(GtkIconList *iconlist, guint spacing) +{ + iconlist->col_spacing = spacing; + reorder_icons(iconlist); +} + +void +gtk_icon_list_set_text_space(GtkIconList *iconlist, guint spacing) +{ + iconlist->text_space = spacing; + reorder_icons(iconlist); +} + +/********************************** + * gtk_icon_list_set_selection_mode + * gtk_icon_list_select_icon + * gtk_icon_list_unselect_icon + * gtk_icon_list_unselect_all + **********************************/ + +void +gtk_icon_list_set_selection_mode(GtkIconList *iconlist, gint mode) +{ + iconlist->selection_mode = mode; +} + +void +gtk_icon_list_select_icon(GtkIconList *iconlist, GtkIconListItem *item) +{ + select_icon(iconlist, item, NULL); +} + +void +gtk_icon_list_unselect_icon(GtkIconList *iconlist, GtkIconListItem *item) +{ + unselect_icon(iconlist, item, NULL); +} + +void +gtk_icon_list_unselect_all(GtkIconList *iconlist) +{ + unselect_all(iconlist); +} + +void +gtk_icon_list_set_active_icon(GtkIconList *iconlist, GtkIconListItem *icon) +{ + if(!icon){ + deactivate_entry(iconlist); + unselect_all(iconlist); + return; + } + + if(icon->entry){ + icon->state = GTK_STATE_SELECTED; + entry_in(icon->entry, NULL, iconlist); + gtk_widget_grab_focus(icon->entry); + } +} diff --git a/frontends/gtk-old/src/gtkiconlist.h b/frontends/gtk-old/src/gtkiconlist.h new file mode 100644 index 000000000..b8598b7a6 --- /dev/null +++ b/frontends/gtk-old/src/gtkiconlist.h @@ -0,0 +1,173 @@ +/* gtkiconlist - gtkiconlist widget for gtk+ + * Copyright 1999-2001 Adrian E. Feiguin + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +#ifndef __GTK_ICON_LIST_H__ +#define __GTK_ICON_LIST_H__ + + +#include + +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ + +enum +{ + GTK_ICON_LIST_ICON, + GTK_ICON_LIST_TEXT_RIGHT, + GTK_ICON_LIST_TEXT_BELOW, +}; + +#define GTK_ICON_LIST(obj) GTK_CHECK_CAST (obj, gtk_icon_list_get_type (), GtkIconList) +#define GTK_ICON_LIST_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, gtk_icon_list_get_type, GtkIconListClass) +#define GTK_IS_ICON_LIST(obj) GTK_CHECK_TYPE (obj, gtk_icon_list_get_type ()) +#define GTK_TYPE_ICON_LIST (gtk_icon_list_get_type ()) +#define GTK_TYPE_ICON_LIST_ITEM (gtk_icon_list_item_get_type ()) + + +typedef struct _GtkIconList GtkIconList; +typedef struct _GtkIconListClass GtkIconListClass; +typedef struct _GtkIconListItem GtkIconListItem; + +struct _GtkIconListItem +{ + guint x, y; + + gint state; + + gchar *entry_label; + gchar *label; + + GtkWidget *pixmap; + GtkWidget *entry; + + gpointer link; +}; + +struct _GtkIconList +{ + GtkFixed fixed; + + guint8 flags; + + guint mode; + GtkSelectionMode selection_mode; + + guint freeze_count; + + guint icon_width; + + guint text_space; /* entry width */ + guint row_spacing; /* space between rows */ + guint col_spacing; /* space between columns */ + guint icon_border; /* space between icon and entry */ + + gboolean is_editable; + + GtkIconListItem *active_icon; + + GdkColor background; + + gint num_icons; + GList *icons; + + GList *selection; + + GCompareFunc compare_func; +}; + +struct _GtkIconListClass +{ + GtkFixedClass parent_class; + + gboolean (*select_icon) (GtkIconList *iconlist, + GtkIconListItem *icon, + GdkEvent *event); + void (*unselect_icon) (GtkIconList *iconlist, + GtkIconListItem *icon, + GdkEvent *event); + gboolean (*text_changed) (GtkIconList *iconlist, + GtkIconListItem *icon, + gchar *new_text); + gboolean (*activate_icon) (GtkIconList *iconlist, + GtkIconListItem *icon); + gboolean (*deactivate_icon) (GtkIconList *iconlist, + GtkIconListItem *icon); + void (*click_event) (GtkIconList *iconlist, + GdkEvent *event); +}; + + +GtkType gtk_icon_list_get_type (void); +GtkType gtk_icon_list_item_get_type (void); +GtkWidget* gtk_icon_list_new (guint icon_width, + guint mode); +void gtk_icon_list_freeze (GtkIconList *icon_list); +void gtk_icon_list_thaw (GtkIconList *icon_list); +void gtk_icon_list_set_background (GtkIconList *icon_list, + GdkColor *color); +GtkIconListItem *gtk_icon_list_add_from_data (GtkIconList *icon_list, + gchar **data, + const gchar *label, + gpointer link); +GtkIconListItem *gtk_icon_list_add (GtkIconList *icon_list, + const gchar *pixmap_file, + const gchar *label, + gpointer link); +GtkIconListItem *gtk_icon_list_get_nth (GtkIconList *iconlist, + guint n); +gint gtk_icon_list_get_index (GtkIconList *iconlist, + GtkIconListItem *item); +void gtk_icon_list_remove (GtkIconList *iconlist, + GtkIconListItem *item); +void gtk_icon_list_set_active_icon (GtkIconList *iconlist, + GtkIconListItem *icon); +void gtk_icon_list_remove_nth (GtkIconList *iconlist, + guint n); +void gtk_icon_list_clear (GtkIconList *iconlist); +void gtk_icon_list_link (GtkIconListItem *item, + gpointer data); +gpointer gtk_icon_list_get_link (GtkIconListItem *item); +GtkIconListItem *gtk_icon_list_get_icon_from_link(GtkIconList *iconlist, + gpointer data); +GtkIconListItem *gtk_icon_list_get_icon_at (GtkIconList *iconlist, + gint x, gint y); +GtkIconListItem *gtk_icon_list_get_active_icon (GtkIconList *iconlist); +GtkWidget *gtk_icon_list_get_entry (GtkIconListItem *item); +GtkWidget *gtk_icon_list_get_pixmap (GtkIconListItem *item); +void gtk_icon_list_set_pixmap (GtkIconListItem *item, + GdkPixmap *pixmap, + GdkBitmap *bitmap); +void gtk_icon_list_set_label (GtkIconList *iconlist, + GtkIconListItem *item, + const gchar *label); +void gtk_icon_list_set_selection_mode(GtkIconList *iconlist, + gint mode); +void gtk_icon_list_select_icon (GtkIconList *iconlist, + GtkIconListItem *item); +void gtk_icon_list_unselect_icon (GtkIconList *iconlist, + GtkIconListItem *item); +void gtk_icon_list_unselect_all (GtkIconList *iconlist); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + + +#endif /* __GTK_ICON_LIST_H__ */ diff --git a/frontends/gtk-old/src/gtkiconlist.lo b/frontends/gtk-old/src/gtkiconlist.lo new file mode 100644 index 0000000000000000000000000000000000000000..4ba66b1f7d653b87c235e4a4864ff968019218d1 GIT binary patch literal 171920 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 literal 0 HcmV?d00001 diff --git a/frontends/gtk-old/src/gtkitementry.c b/frontends/gtk-old/src/gtkitementry.c new file mode 100644 index 000000000..37b9562fd --- /dev/null +++ b/frontends/gtk-old/src/gtkitementry.c @@ -0,0 +1,1964 @@ +/* GtkItemEntry - widget for gtk+ + * Copyright (C) 1999-2001 Adrian E. Feiguin + * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald + * + * GtkItemEntry widget by Adrian E. Feiguin + * Based on GtkEntry widget + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free + * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include "gtkitementry.h" + +#define MIN_ENTRY_WIDTH 150 +#define DRAW_TIMEOUT 20 +#define INNER_BORDER 4 + +enum { + ARG_0, + ARG_MAX_LENGTH, + ARG_VISIBILITY +}; + + +static void gtk_entry_class_init (GtkItemEntryClass *klass); +static void gtk_entry_init (GtkItemEntry *entry); +static void gtk_entry_set_position_from_editable + (GtkEditable *editable, + gint position); +static void gtk_entry_realize (GtkWidget *widget); +static void gtk_entry_unrealize (GtkWidget *widget); +static void gtk_entry_draw_focus (GtkWidget *widget); +static void gtk_entry_size_allocate (GtkWidget *widget, + GtkAllocation *allocation); +static void gtk_entry_size_request (GtkWidget *widget, + GtkRequisition *requisition); +static void gtk_entry_make_backing_pixmap (GtkEntry *entry, + gint width, gint height); +static void gtk_entry_draw (GtkWidget *widget, + GdkRectangle *area); +static gint gtk_entry_expose (GtkWidget *widget, + GdkEventExpose *event); +static gint gtk_entry_button_press (GtkWidget *widget, + GdkEventButton *event); +static gint gtk_entry_button_release (GtkWidget *widget, + GdkEventButton *event); +static gint gtk_entry_motion_notify (GtkWidget *widget, + GdkEventMotion *event); +static gint gtk_entry_key_press (GtkWidget *widget, + GdkEventKey *event); +static void gtk_entry_draw_text (GtkEntry *entry); +static void gtk_entry_draw_cursor (GtkEntry *entry); +static void gtk_entry_draw_cursor_on_drawable + (GtkEntry *entry, + GdkDrawable *drawable); +#ifdef USE_XIM +static void gtk_entry_update_ic_attr (GtkWidget *widget); +#endif +static void gtk_entry_queue_draw (GtkEntry *entry); +static gint gtk_entry_timer (gpointer data); +static gint gtk_entry_position (GtkEntry *entry, + gint x); +static void entry_adjust_scroll (GtkEntry *entry); +static void gtk_entry_grow_text (GtkEntry *entry); +static void gtk_entry_insert_text (GtkEditable *editable, + const gchar *new_text, + gint new_text_length, + gint *position); +static void gtk_entry_delete_text (GtkEditable *editable, + gint start_pos, + gint end_pos); +static void gtk_entry_update_text (GtkEditable *editable, + gint start_pos, + gint end_pos); +static gchar *gtk_entry_get_chars (GtkEditable *editable, + gint start_pos, + gint end_pos); + +/* Binding actions */ +static void gtk_entry_move_cursor (GtkEditable *editable, + gint x, + gint y); +static void gtk_entry_move_word (GtkEditable *editable, + gint n); +static void gtk_entry_move_to_column (GtkEditable *editable, + gint row); +static void gtk_entry_kill_char (GtkEditable *editable, + gint direction); +static void gtk_entry_kill_word (GtkEditable *editable, + gint direction); +static void gtk_entry_kill_line (GtkEditable *editable, + gint direction); + +/* To be removed */ +static void gtk_move_forward_character (GtkEntry *entry); +static void gtk_move_backward_character (GtkEntry *entry); +static void gtk_move_forward_word (GtkEntry *entry); +static void gtk_move_backward_word (GtkEntry *entry); +static void gtk_move_beginning_of_line (GtkEntry *entry); +static void gtk_move_end_of_line (GtkEntry *entry); +static void gtk_delete_forward_character (GtkEntry *entry); +static void gtk_delete_backward_character (GtkEntry *entry); +static void gtk_delete_forward_word (GtkEntry *entry); +static void gtk_delete_backward_word (GtkEntry *entry); +static void gtk_delete_line (GtkEntry *entry); +static void gtk_delete_to_line_end (GtkEntry *entry); +static void gtk_select_word (GtkEntry *entry, + guint32 time); +static void gtk_select_line (GtkEntry *entry, + guint32 time); + + +static void gtk_entry_set_selection (GtkEditable *editable, + gint start, + gint end); + +static gint gtk_entry_find_position (GtkEntry *entry, + gint position); +static void gtk_entry_set_position_from_editable (GtkEditable *editable, + gint position); + +static GtkWidgetClass *parent_class = NULL; +static GdkAtom ctext_atom = GDK_NONE; + +static const GtkTextFunction control_keys[26] = +{ + (GtkTextFunction)gtk_move_beginning_of_line, /* a */ + (GtkTextFunction)gtk_move_backward_character, /* b */ + (GtkTextFunction)gtk_editable_copy_clipboard, /* c */ + (GtkTextFunction)gtk_delete_forward_character, /* d */ + (GtkTextFunction)gtk_move_end_of_line, /* e */ + (GtkTextFunction)gtk_move_forward_character, /* f */ + NULL, /* g */ + (GtkTextFunction)gtk_delete_backward_character, /* h */ + NULL, /* i */ + NULL, /* j */ + (GtkTextFunction)gtk_delete_to_line_end, /* k */ + NULL, /* l */ + NULL, /* m */ + NULL, /* n */ + NULL, /* o */ + NULL, /* p */ + NULL, /* q */ + NULL, /* r */ + NULL, /* s */ + NULL, /* t */ + (GtkTextFunction)gtk_delete_line, /* u */ + (GtkTextFunction)gtk_editable_paste_clipboard, /* v */ + (GtkTextFunction)gtk_delete_backward_word, /* w */ + (GtkTextFunction)gtk_editable_cut_clipboard, /* x */ + NULL, /* y */ + NULL, /* z */ +}; + +static const GtkTextFunction alt_keys[26] = +{ + NULL, /* a */ + (GtkTextFunction)gtk_move_backward_word, /* b */ + NULL, /* c */ + (GtkTextFunction)gtk_delete_forward_word, /* d */ + NULL, /* e */ + (GtkTextFunction)gtk_move_forward_word, /* f */ + NULL, /* g */ + NULL, /* h */ + NULL, /* i */ + NULL, /* j */ + NULL, /* k */ + NULL, /* l */ + NULL, /* m */ + NULL, /* n */ + NULL, /* o */ + NULL, /* p */ + NULL, /* q */ + NULL, /* r */ + NULL, /* s */ + NULL, /* t */ + NULL, /* u */ + NULL, /* v */ + NULL, /* w */ + NULL, /* x */ + NULL, /* y */ + NULL, /* z */ +}; + + +GtkType +gtk_item_entry_get_type (void) +{ + static GtkType entry_type = 0; + + if (!entry_type) + { + static const GtkTypeInfo entry_info = + { + "GtkItemEntry", + sizeof (GtkItemEntry), + sizeof (GtkItemEntryClass), + (GtkClassInitFunc) gtk_entry_class_init, + (GtkObjectInitFunc) gtk_entry_init, + /* reserved_1 */ NULL, + /* reserved_2 */ NULL, + (GtkClassInitFunc) NULL, + }; + + entry_type = gtk_type_unique (GTK_TYPE_ENTRY, &entry_info); + } + + return entry_type; +} + +static void +gtk_entry_class_init (GtkItemEntryClass *klass) +{ + GtkObjectClass *object_class; + GtkWidgetClass *widget_class; + GtkEditableClass *editable_class; + + object_class = (GtkObjectClass*) klass; + widget_class = (GtkWidgetClass*) klass; + editable_class = (GtkEditableClass*) klass; + parent_class = gtk_type_class (GTK_TYPE_ENTRY); + + widget_class->realize = gtk_entry_realize; + widget_class->unrealize = gtk_entry_unrealize; + widget_class->draw_focus = gtk_entry_draw_focus; + widget_class->size_allocate = gtk_entry_size_allocate; + widget_class->size_request = gtk_entry_size_request; + widget_class->draw = gtk_entry_draw; + widget_class->expose_event = gtk_entry_expose; + widget_class->button_press_event = gtk_entry_button_press; + widget_class->button_release_event = gtk_entry_button_release; + widget_class->motion_notify_event = gtk_entry_motion_notify; + widget_class->key_press_event = gtk_entry_key_press; + + editable_class->insert_text = gtk_entry_insert_text; + editable_class->delete_text = gtk_entry_delete_text; + editable_class->changed = (void (*)(GtkEditable *)) entry_adjust_scroll; + + editable_class->move_cursor = gtk_entry_move_cursor; + editable_class->move_word = gtk_entry_move_word; + editable_class->move_to_column = gtk_entry_move_to_column; + + editable_class->kill_char = gtk_entry_kill_char; + editable_class->kill_word = gtk_entry_kill_word; + editable_class->kill_line = gtk_entry_kill_line; + + editable_class->update_text = gtk_entry_update_text; + editable_class->get_chars = gtk_entry_get_chars; + editable_class->set_selection = gtk_entry_set_selection; + editable_class->set_position = gtk_entry_set_position_from_editable; + +} + + +static void +gtk_entry_init (GtkItemEntry *entry) +{ +} + +GtkWidget* +gtk_item_entry_new () +{ + GtkWidget *item_entry; + + item_entry = GTK_WIDGET (gtk_type_new (gtk_item_entry_get_type ())); + + return item_entry; +} + +GtkWidget* +gtk_item_entry_new_with_max_length (guint16 max) +{ + GtkItemEntry *item_entry; + item_entry = gtk_type_new (gtk_item_entry_get_type ()); + GTK_ENTRY (item_entry)->text_max_length = max; + return GTK_WIDGET (item_entry); +} + +void +gtk_item_entry_set_text (GtkItemEntry *item_entry, + const gchar *text, + GtkJustification justification ) +{ + gint tmp_pos; + + GtkEditable *editable; + GtkEntry *entry; + + g_return_if_fail (item_entry != NULL); + g_return_if_fail (GTK_IS_ITEM_ENTRY (item_entry)); + g_return_if_fail (text != NULL); + + editable = GTK_EDITABLE (item_entry); + entry = GTK_ENTRY(item_entry); + + item_entry->justification = justification; + + gtk_entry_delete_text (GTK_EDITABLE(entry), 0, entry->text_length); + + tmp_pos = 0; + gtk_editable_insert_text (editable, text, strlen (text), &tmp_pos); + editable->current_pos = tmp_pos; + + editable->selection_start_pos = 0; + editable->selection_end_pos = 0; + + if (GTK_WIDGET_DRAWABLE (entry)) + gtk_entry_draw_text (entry); +} + +static void +gtk_entry_set_position_from_editable (GtkEditable *editable, + gint position) +{ + GtkEntry *entry; + + g_return_if_fail (editable != NULL); + g_return_if_fail (GTK_IS_EDITABLE (editable)); + + entry = GTK_ENTRY(editable); + + if ((position == -1) || (position > entry->text_length)) + GTK_EDITABLE(entry)->current_pos = entry->text_length; + else + GTK_EDITABLE(entry)->current_pos = position; + entry_adjust_scroll (entry); +} + +void +gtk_item_entry_set_justification (GtkItemEntry *item_entry, GtkJustification justification) +{ + g_return_if_fail (item_entry != NULL); + g_return_if_fail (GTK_IS_ITEM_ENTRY (item_entry)); + + item_entry->justification = justification; + entry_adjust_scroll (GTK_ENTRY(item_entry)); + gtk_widget_draw(GTK_WIDGET(item_entry), NULL); +} + + +static void +gtk_entry_realize (GtkWidget *widget) +{ + GtkItemEntry *item_entry; + + g_return_if_fail (widget != NULL); + g_return_if_fail (GTK_IS_ITEM_ENTRY (widget)); + + if (GTK_WIDGET_CLASS (parent_class)->realize) + (* GTK_WIDGET_CLASS (parent_class)->realize) (widget); + + item_entry = GTK_ITEM_ENTRY (widget); + + item_entry->fg_gc = gdk_gc_new (widget->window); + item_entry->bg_gc = gdk_gc_new (widget->window); + + gdk_gc_set_foreground (item_entry->fg_gc, &widget->style->white); + gdk_gc_set_foreground (item_entry->bg_gc, &widget->style->black); +} + +static void +gtk_entry_unrealize (GtkWidget *widget) +{ + GtkItemEntry *item_entry; + + g_return_if_fail (widget != NULL); + g_return_if_fail (GTK_IS_ITEM_ENTRY (widget)); + + item_entry = GTK_ITEM_ENTRY (widget); + + gdk_gc_destroy (item_entry->fg_gc); + gdk_gc_destroy (item_entry->bg_gc); + + if (GTK_WIDGET_CLASS (parent_class)->unrealize) + (* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget); +} + +static void +gtk_entry_draw_focus (GtkWidget *widget) +{ + g_return_if_fail (widget != NULL); + g_return_if_fail (GTK_IS_ITEM_ENTRY (widget)); + + if (GTK_WIDGET_DRAWABLE (widget)) + { + gtk_entry_draw_cursor (GTK_ENTRY (widget)); + } +} + + +static void +gtk_entry_size_allocate (GtkWidget *widget, + GtkAllocation *allocation) +{ + GtkEntry *entry; + GtkEditable *editable; + gint width = 0, nwidth = 0, height = 0, nheight = 0; + + + g_return_if_fail (widget != NULL); + g_return_if_fail (GTK_IS_ITEM_ENTRY (widget)); + g_return_if_fail (allocation != NULL); + + widget->allocation = *allocation; + entry = GTK_ENTRY (widget); + editable = GTK_EDITABLE (widget); + + if (GTK_WIDGET_REALIZED (widget)) + { + gdk_window_get_size (entry->text_area, &width, &height); + gdk_window_move_resize (widget->window, + allocation->x + INNER_BORDER, + allocation->y + INNER_BORDER, + allocation->width - 2 * INNER_BORDER, + allocation->height - 2 * INNER_BORDER); + gdk_window_move_resize (entry->text_area, + 0, + 0, + allocation->width - 2 * INNER_BORDER, + allocation->height - 2 * INNER_BORDER); + + + gdk_window_get_size (entry->text_area, &nwidth, &nheight); + if(nwidth != width || nheight != height){ + entry->scroll_offset = 0; + entry_adjust_scroll (entry); + } + +#ifdef USE_XIM + if (editable->ic && + (gdk_ic_get_style (editable->ic) & GDK_IM_PREEDIT_POSITION)) + { + editable->ic_attr->preedit_area.width = nwidth; + editable->ic_attr->preedit_area.height = nheight; + gdk_ic_set_attr (editable->ic, editable->ic_attr, + GDK_IC_PREEDIT_AREA); + } +#endif + + } +} + +static void +gtk_entry_size_request (GtkWidget *widget, + GtkRequisition *requisition) +{ + GtkItemEntry *entry; + + g_return_if_fail (widget != NULL); + g_return_if_fail (GTK_IS_ITEM_ENTRY (widget)); + g_return_if_fail (requisition != NULL); + + requisition->width = MIN_ENTRY_WIDTH + (widget->style->klass->xthickness + INNER_BORDER) * 2; + requisition->height = (widget->style->font->ascent + + widget->style->font->descent + + (widget->style->klass->ythickness + INNER_BORDER) * 2); + + entry = GTK_ITEM_ENTRY(widget); + + if(entry->text_max_size > 0 && + requisition->width > entry->text_max_size) + requisition->width = entry->text_max_size; +} + +static void +gtk_entry_draw (GtkWidget *widget, + GdkRectangle *area) +{ + g_return_if_fail (widget != NULL); + g_return_if_fail (GTK_IS_ENTRY (widget)); + g_return_if_fail (area != NULL); + + if (GTK_WIDGET_DRAWABLE (widget)) + { + gtk_widget_draw_focus (widget); + gtk_entry_draw_text (GTK_ENTRY (widget)); + } +} + +static gint +gtk_entry_expose (GtkWidget *widget, + GdkEventExpose *event) +{ + GtkEntry *entry; + + g_return_val_if_fail (widget != NULL, FALSE); + g_return_val_if_fail (GTK_IS_ENTRY (widget), FALSE); + g_return_val_if_fail (event != NULL, FALSE); + + entry = GTK_ENTRY (widget); + + if (widget->window == event->window) + gtk_widget_draw_focus (widget); + else if (entry->text_area == event->window) + gtk_entry_draw_text (GTK_ENTRY (widget)); + + return FALSE; +} + +static gint +gtk_entry_button_press (GtkWidget *widget, + GdkEventButton *event) +{ + GtkEntry *entry; + GtkEditable *editable; + GdkModifierType mods; + gint tmp_pos; + + g_return_val_if_fail (widget != NULL, FALSE); + g_return_val_if_fail (GTK_IS_ENTRY (widget), FALSE); + g_return_val_if_fail (event != NULL, FALSE); + + if (ctext_atom == GDK_NONE) + ctext_atom = gdk_atom_intern ("COMPOUND_TEXT", FALSE); + + entry = GTK_ENTRY (widget); + editable = GTK_EDITABLE (widget); + + if (entry->button && (event->button != entry->button)) + return FALSE; + + gdk_window_get_pointer(widget->window, NULL, NULL, &mods); + if (mods & GDK_BUTTON3_MASK) + return FALSE; + + entry->button = event->button; + + if (!GTK_WIDGET_HAS_FOCUS (widget)) + gtk_widget_grab_focus (widget); + + if (event->button == 1) + { + switch (event->type) + { + case GDK_BUTTON_PRESS: + gtk_grab_add (widget); + + tmp_pos = gtk_entry_position (entry, event->x + entry->scroll_offset); + /* Set it now, so we display things right. We'll unset it + * later if things don't work out */ + editable->has_selection = TRUE; + gtk_entry_set_selection (editable, tmp_pos, tmp_pos); + editable->current_pos = editable->selection_start_pos; + break; + + case GDK_2BUTTON_PRESS: + gtk_select_word (entry, event->time); + break; + + case GDK_3BUTTON_PRESS: + gtk_select_line (entry, event->time); + break; + + default: + break; + } + } + else if (event->type == GDK_BUTTON_PRESS) + { + if ((event->button == 2) && editable->editable) + { + if (editable->selection_start_pos == editable->selection_end_pos || + editable->has_selection) + editable->current_pos = gtk_entry_position (entry, event->x + entry->scroll_offset); + gtk_selection_convert (widget, GDK_SELECTION_PRIMARY, + ctext_atom, event->time); + } + else + { + gtk_grab_add (widget); + + tmp_pos = gtk_entry_position (entry, event->x + entry->scroll_offset); + gtk_entry_set_selection (editable, tmp_pos, tmp_pos); + editable->has_selection = FALSE; + editable->current_pos = editable->selection_start_pos; + + if (gdk_selection_owner_get (GDK_SELECTION_PRIMARY) == widget->window) + gtk_selection_owner_set (NULL, GDK_SELECTION_PRIMARY, event->time); + } + } + + return FALSE; +} + +static gint +gtk_entry_button_release (GtkWidget *widget, + GdkEventButton *event) +{ + GtkEntry *entry; + GtkEditable *editable; + + g_return_val_if_fail (widget != NULL, FALSE); + g_return_val_if_fail (GTK_IS_ENTRY (widget), FALSE); + g_return_val_if_fail (event != NULL, FALSE); + + entry = GTK_ENTRY (widget); + editable = GTK_EDITABLE (widget); + + if (entry->button != event->button) + return FALSE; + + entry->button = 0; + + if (event->button == 1) + { + gtk_grab_remove (widget); + + editable->has_selection = FALSE; + if (editable->selection_start_pos != editable->selection_end_pos) + { + if (gtk_selection_owner_set (widget, + GDK_SELECTION_PRIMARY, + event->time)) + editable->has_selection = TRUE; + else + gtk_entry_queue_draw (entry); + } + else + { + if (gdk_selection_owner_get (GDK_SELECTION_PRIMARY) == widget->window) + gtk_selection_owner_set (NULL, GDK_SELECTION_PRIMARY, event->time); + } + } + else if (event->button == 3) + { + gtk_grab_remove (widget); + } + + return FALSE; +} + +static gint +gtk_entry_motion_notify (GtkWidget *widget, + GdkEventMotion *event) +{ + GtkEntry *entry; + gint x; + + g_return_val_if_fail (widget != NULL, FALSE); + g_return_val_if_fail (GTK_IS_ENTRY (widget), FALSE); + g_return_val_if_fail (event != NULL, FALSE); + + entry = GTK_ENTRY (widget); + + if (entry->button == 0) + return FALSE; + + x = event->x; + if (event->is_hint || (entry->text_area != event->window)) + gdk_window_get_pointer (entry->text_area, &x, NULL, NULL); + + GTK_EDITABLE(entry)->selection_end_pos = gtk_entry_position (entry, x + entry->scroll_offset); + GTK_EDITABLE(entry)->current_pos = GTK_EDITABLE(entry)->selection_end_pos; + entry_adjust_scroll (entry); + gtk_entry_queue_draw (entry); + + return FALSE; +} + +static gint +gtk_entry_key_press (GtkWidget *widget, + GdkEventKey *event) +{ + GtkEntry *entry; + GtkEditable *editable; + + gint return_val; + gint key; + guint initial_pos; + gint extend_selection; + gint extend_start; + + g_return_val_if_fail (widget != NULL, FALSE); + g_return_val_if_fail (GTK_IS_ENTRY (widget), FALSE); + g_return_val_if_fail (event != NULL, FALSE); + + entry = GTK_ENTRY (widget); + editable = GTK_EDITABLE (widget); + return_val = FALSE; + + if(!GTK_WIDGET_HAS_FOCUS(widget)) return FALSE; + + if(editable->editable == FALSE) + switch(event->keyval){ + case GDK_Left: case GDK_Right: case GDK_Up: case GDK_Down: + case GDK_Tab: case GDK_Return: + break; + default: + return TRUE; + } + + initial_pos = editable->current_pos; + + extend_selection = event->state & GDK_SHIFT_MASK; + extend_start = FALSE; + + if (extend_selection) + { + if (editable->selection_start_pos == editable->selection_end_pos) + { + editable->selection_start_pos = editable->current_pos; + editable->selection_end_pos = editable->current_pos; + } + + extend_start = (editable->current_pos == editable->selection_start_pos); + } + + switch (event->keyval) + { + case GDK_BackSpace: + return_val = TRUE; + if (event->state & GDK_CONTROL_MASK) + gtk_delete_backward_word (entry); + else + gtk_delete_backward_character (entry); + break; + case GDK_Clear: + return_val = TRUE; + gtk_delete_line (entry); + break; + case GDK_Insert: + return_val = TRUE; + if (event->state & GDK_SHIFT_MASK) + { + extend_selection = FALSE; + gtk_editable_paste_clipboard (editable); + } + else if (event->state & GDK_CONTROL_MASK) + { + gtk_editable_copy_clipboard (editable); + } + else + { + /* gtk_toggle_insert(entry) -- IMPLEMENT */ + } + break; + case GDK_Delete: + return_val = TRUE; + if (event->state & GDK_CONTROL_MASK) + gtk_delete_forward_word (entry); + else if (event->state & GDK_SHIFT_MASK) + { + extend_selection = FALSE; + gtk_editable_cut_clipboard (editable); + } + else + gtk_delete_forward_character (entry); + break; + case GDK_Home: + return_val = TRUE; + gtk_move_beginning_of_line (entry); + break; + case GDK_End: + return_val = TRUE; + gtk_move_end_of_line (entry); + break; + case GDK_Left: + return_val = TRUE; + if (event->state & GDK_CONTROL_MASK) + gtk_move_backward_word (entry); + else + gtk_move_backward_character (entry); + break; + case GDK_Right: + return_val = TRUE; + if (event->state & GDK_CONTROL_MASK) + gtk_move_forward_word (entry); + else + gtk_move_forward_character (entry); + break; + case GDK_Shift_L: + case GDK_Shift_R: + case GDK_Tab: + case GDK_Escape: + case GDK_Up: + case GDK_Down: + case GDK_Return: + return_val = TRUE; + gtk_signal_emit_by_name (GTK_OBJECT (entry), "activate"); + break; + default: + if ((event->keyval >= 0x20) && (event->keyval <= 0xFF)) + { + key = event->keyval; + + if (event->state & GDK_CONTROL_MASK) + { + if ((key >= 'A') && (key <= 'Z')) + key -= 'A' - 'a'; + + if ((key >= 'a') && (key <= 'z') && control_keys[key - 'a']) + { + (* control_keys[key - 'a']) (editable, event->time); + return_val = TRUE; + } + break; + } + else if (event->state & GDK_MOD1_MASK) + { + if ((key >= 'A') && (key <= 'Z')) + key -= 'A' - 'a'; + + if ((key >= 'a') && (key <= 'z') && alt_keys[key - 'a']) + { + (* alt_keys[key - 'a']) (editable, event->time); + return_val = TRUE; + } + break; + } + } + if (event->length > 0) + { + gint tmp_pos; + + extend_selection = FALSE; + gtk_editable_delete_selection (editable); + + tmp_pos = editable->current_pos; + gtk_editable_insert_text (editable, event->string, event->length, &tmp_pos); + editable->current_pos = tmp_pos; + + return_val = TRUE; + } + break; + } + + /* since we emit signals from within the above code, + * the widget might already be destroyed or at least + * unrealized. + */ + if (GTK_WIDGET_REALIZED (editable) && + return_val && (editable->current_pos != initial_pos)) + { + if (extend_selection) + { + if (editable->current_pos < editable->selection_start_pos) + editable->selection_start_pos = editable->current_pos; + else if (editable->current_pos > editable->selection_end_pos) + editable->selection_end_pos = editable->current_pos; + else + { + if (extend_start) + editable->selection_start_pos = editable->current_pos; + else + editable->selection_end_pos = editable->current_pos; + } + } + else + { + editable->selection_start_pos = 0; + editable->selection_end_pos = 0; + } + + gtk_editable_claim_selection (editable, + editable->selection_start_pos != editable->selection_end_pos, + event->time); + + entry_adjust_scroll (entry); + gtk_entry_queue_draw (entry); + } + + return return_val; +} + + +static void +gtk_entry_make_backing_pixmap (GtkEntry *entry, gint width, gint height) +{ + gint pixmap_width, pixmap_height; + + if (!entry->backing_pixmap) + { + /* allocate */ + entry->backing_pixmap = gdk_pixmap_new (entry->text_area, + width, height, + -1); + } + else + { + /* reallocate if sizes don't match */ + gdk_window_get_size (entry->backing_pixmap, + &pixmap_width, &pixmap_height); + if ((pixmap_width != width) || (pixmap_height != height)) + { + gdk_pixmap_unref (entry->backing_pixmap); + entry->backing_pixmap = gdk_pixmap_new (entry->text_area, + width, height, + -1); + } + } +} + +static void +gtk_entry_draw_text (GtkEntry *entry) +{ + GtkWidget *widget; + GtkItemEntry *item_entry; + GtkEditable *editable; + GtkStateType selected_state; + gint start_pos; + gint end_pos; + gint start_xoffset; + gint selection_start_pos; + gint selection_end_pos; + gint selection_start_xoffset; + gint selection_end_xoffset; + gint width, height; + gint y; + GdkDrawable *drawable; + gint use_backing_pixmap; + GdkWChar *stars; + GdkWChar *toprint; + + g_return_if_fail (entry != NULL); + g_return_if_fail (GTK_IS_ENTRY (entry)); + g_return_if_fail (GTK_IS_ITEM_ENTRY (entry)); + + item_entry = GTK_ITEM_ENTRY (entry); + + if (entry->timer) + { + gtk_timeout_remove (entry->timer); + entry->timer = 0; + } + + if (GTK_WIDGET_DRAWABLE (entry)) + { + widget = GTK_WIDGET (entry); + editable = GTK_EDITABLE (entry); + + gdk_window_get_size (entry->text_area, &width, &height); + + if (!entry->text) + { + gdk_draw_rectangle (entry->text_area, + item_entry->bg_gc, + TRUE, + 0, 0, + width, + height); + + if (editable->editable) + gtk_entry_draw_cursor (entry); + return; + } + + + /* + If the widget has focus, draw on a backing pixmap to avoid flickering + and copy it to the text_area. + Otherwise draw to text_area directly for better speed. + */ + use_backing_pixmap = GTK_WIDGET_HAS_FOCUS (widget) && (entry->text != NULL); + + if (use_backing_pixmap) + { + gtk_entry_make_backing_pixmap (entry, width, height); + drawable = entry->backing_pixmap; + gdk_draw_rectangle (drawable, + item_entry->bg_gc, + TRUE, + 0, 0, + width, + height); + } + else + { + drawable = entry->text_area; + gdk_draw_rectangle (entry->text_area, + item_entry->bg_gc, + TRUE, + 0, 0, + width, + height); + + } + + +/* CENTER */ +/* y = height; + y = (height - (widget->style->font->ascent + widget->style->font->descent)) / 2; + y += widget->style->font->ascent; +*/ +/* BOTTOM */ + y = height; + y = (y - widget->style->font->ascent - widget->style->font->descent); + y += widget->style->font->ascent; + + start_pos = gtk_entry_find_position (entry, entry->scroll_offset); + start_xoffset = entry->char_offset[start_pos] - entry->scroll_offset; + + end_pos = gtk_entry_find_position (entry, entry->scroll_offset + width); + if (end_pos < entry->text_length) + end_pos += 1; + + selected_state = GTK_STATE_SELECTED; + if (!editable->has_selection) + selected_state = GTK_STATE_ACTIVE; + + selection_start_pos = MIN (editable->selection_start_pos, editable->selection_end_pos); + selection_end_pos = MAX (editable->selection_start_pos, editable->selection_end_pos); + + selection_start_pos = CLAMP (selection_start_pos, start_pos, end_pos); + selection_end_pos = CLAMP (selection_end_pos, start_pos, end_pos); + + selection_start_xoffset = + entry->char_offset[selection_start_pos] - entry->scroll_offset; + selection_end_xoffset = + entry->char_offset[selection_end_pos] -entry->scroll_offset; + + /* if entry->visible, print a bunch of stars. If not, print the standard text. */ + if (entry->visible) + { + toprint = entry->text + start_pos; + } + else + { + gint i; + + stars = g_new (GdkWChar, end_pos - start_pos); + for (i = 0; i < end_pos - start_pos; i++) + stars[i] = '*'; + toprint = stars; + } + + if (selection_start_pos > start_pos) + gdk_draw_text_wc (drawable, widget->style->font, + item_entry->fg_gc, + start_xoffset, y, + toprint, + selection_start_pos - start_pos); + + if ((selection_end_pos >= start_pos) && + (selection_start_pos < end_pos) && + (selection_start_pos != selection_end_pos)) + { + gint yoffset = + (height - + (widget->style->font->ascent + widget->style->font->descent)); + gtk_paint_flat_box (widget->style, drawable, + selected_state, GTK_SHADOW_NONE, + NULL, widget, "text", + selection_start_xoffset, + yoffset, + selection_end_xoffset - selection_start_xoffset, + widget->style->font->ascent + widget->style->font->descent); + gdk_draw_text_wc (drawable, widget->style->font, + widget->style->fg_gc[selected_state], + selection_start_xoffset, y, + toprint + selection_start_pos - start_pos, + selection_end_pos - selection_start_pos); + } + + if (selection_end_pos < end_pos) + gdk_draw_text_wc (drawable, widget->style->font, + item_entry->fg_gc, + selection_end_xoffset, y, + toprint + selection_end_pos - start_pos, + end_pos - selection_end_pos); + /* free the space allocated for the stars if it's neccessary. */ + if (!entry->visible) + g_free (toprint); + + if (editable->editable) + gtk_entry_draw_cursor_on_drawable (entry, drawable); + + if (use_backing_pixmap) + gdk_draw_pixmap(entry->text_area, + item_entry->fg_gc, + entry->backing_pixmap, + 0, 0, 0, 0, width, height); + } + + +} + +static void +gtk_entry_draw_cursor (GtkEntry *entry) +{ + g_return_if_fail (entry != NULL); + g_return_if_fail (GTK_IS_ENTRY (entry)); + + gtk_entry_draw_cursor_on_drawable (entry, entry->text_area); +} + +static void +gtk_entry_draw_cursor_on_drawable (GtkEntry *entry, GdkDrawable *drawable) +{ + GtkWidget *widget; + GtkEditable *editable; + gint xoffset; + gint text_area_height; + + g_return_if_fail (entry != NULL); + g_return_if_fail (GTK_IS_ENTRY (entry)); + g_return_if_fail (GTK_IS_ITEM_ENTRY (entry)); + + if (GTK_WIDGET_DRAWABLE (entry)) + { + widget = GTK_WIDGET (entry); + editable = GTK_EDITABLE (entry); + + xoffset = entry->char_offset[editable->current_pos]; + xoffset -= entry->scroll_offset; + + gdk_window_get_size (entry->text_area, NULL, &text_area_height); + + if (GTK_WIDGET_HAS_FOCUS (widget) && + (editable->selection_start_pos == editable->selection_end_pos)) + { + gint yoffset = + (text_area_height - + (widget->style->font->ascent + widget->style->font->descent)); + + gdk_draw_line (drawable, widget->style->fg_gc[GTK_STATE_NORMAL], + xoffset, yoffset, + xoffset, text_area_height); + } + else + { + gint yoffset = + (text_area_height - + (widget->style->font->ascent + widget->style->font->descent)); + + gtk_paint_flat_box (widget->style, drawable, + GTK_WIDGET_STATE(widget), GTK_SHADOW_NONE, + NULL, widget, "entry_bg", + xoffset, yoffset, + 1, text_area_height); + /* Draw the character under the cursor again */ +/* + gdk_draw_text_wc (drawable, widget->style->font, + widget->style->fg_gc[GTK_WIDGET_STATE (widget)], + xoffset, yoffset, + entry->text + editable->current_pos, 1); +*/ + } + + +#ifdef USE_XIM + if (GTK_WIDGET_HAS_FOCUS(widget) && gdk_im_ready() && editable->ic && + (gdk_ic_get_style (editable->ic) & GDK_IM_PREEDIT_POSITION)) + { + editable->ic_attr->spot_location.x = xoffset; + editable->ic_attr->spot_location.y = + (text_area_height + (widget->style->font->ascent + - widget->style->font->descent) + 1) / 2; + + gdk_ic_set_attr (editable->ic, + editable->ic_attr, GDK_IC_SPOT_LOCATION); + } +#endif + } +} + +static void +gtk_entry_queue_draw (GtkEntry *entry) +{ + g_return_if_fail (entry != NULL); + g_return_if_fail (GTK_IS_ENTRY (entry)); + g_return_if_fail (GTK_IS_ITEM_ENTRY (entry)); + + if (!entry->timer) + entry->timer = gtk_timeout_add (DRAW_TIMEOUT, gtk_entry_timer, entry); +} + +static gint +gtk_entry_timer (gpointer data) +{ + GtkEntry *entry; + + GDK_THREADS_ENTER (); + + entry = GTK_ENTRY (data); + entry->timer = 0; + gtk_entry_draw_text (entry); + + GDK_THREADS_LEAVE (); + + return FALSE; +} + +static gint +gtk_entry_find_position (GtkEntry *entry, + gint x) +{ + gint start = 0; + gint end = entry->text_length; + gint half; + + if (x <= 0) + return 0; + if (x >= entry->char_offset[end]) + return end; + + /* invariant - char_offset[start] <= x < char_offset[end] */ + + while (start != end) + { + half = (start+end)/2; + if (half == start) + return half; + else if (entry->char_offset[half] <= x) + start = half; + else + end = half; + } + + return start; +} + +static gint +gtk_entry_position (GtkEntry *entry, + gint x) +{ + return gtk_entry_find_position(entry, x); +} + + +static void +entry_adjust_scroll (GtkEntry *entry) +{ + GtkItemEntry *item_entry; + gint xoffset; + gint text_area_width, text_area_height; + gint char_width, text_width; + + g_return_if_fail (entry != NULL); + g_return_if_fail (GTK_IS_ENTRY (entry)); + g_return_if_fail (GTK_IS_ITEM_ENTRY (entry)); + + item_entry = GTK_ITEM_ENTRY (entry); + + if (!entry->text_area) + return; + + gdk_window_get_size (entry->text_area, &text_area_width, &text_area_height); + + char_width = gdk_char_width (GTK_WIDGET(item_entry)->style->font,(gchar)'X'); + + entry->scroll_offset = 0 ; + + switch(item_entry->justification){ + + case GTK_JUSTIFY_FILL: + case GTK_JUSTIFY_LEFT: + +/* LEFT JUSTIFICATION */ + + if (GTK_EDITABLE(entry)->current_pos > 0) + xoffset = gdk_text_width (GTK_WIDGET (entry)->style->font, gtk_entry_get_text(entry), GTK_EDITABLE(entry)->current_pos); + else + xoffset = 0; + + xoffset -= entry->scroll_offset; + if (xoffset < 0) + entry->scroll_offset += xoffset; + else if (xoffset > text_area_width){ + if(item_entry->text_max_size != 0 && + text_area_width + char_width <= item_entry->text_max_size){ + + text_width = gdk_text_width (GTK_WIDGET (item_entry)->style->font, + gtk_entry_get_text(entry), strlen(gtk_entry_get_text(entry))); + GTK_WIDGET(item_entry)->allocation.width = text_width + + 2 * INNER_BORDER + 1; + gtk_entry_size_allocate(GTK_WIDGET(item_entry), + (GtkAllocation *)(>K_WIDGET(item_entry)->allocation)); + gtk_widget_queue_draw(GTK_WIDGET(item_entry)); + }else{ + entry->scroll_offset += (xoffset - text_area_width) + 1; + } + } + + break; + + case GTK_JUSTIFY_RIGHT: + +/* RIGHT JUSTIFICATION FOR NUMBERS */ + if(entry->text){ + + text_width = gdk_text_width (GTK_WIDGET (item_entry)->style->font, gtk_entry_get_text(entry), strlen(gtk_entry_get_text(entry))); + + entry->scroll_offset= -(text_area_width - text_width) + 1; + if(entry->scroll_offset > 0){ + if(item_entry->text_max_size != 0 && + text_area_width + char_width <= item_entry->text_max_size){ + GTK_WIDGET(item_entry)->allocation.x = + GTK_WIDGET(item_entry)->allocation.x+ + GTK_WIDGET(item_entry)->allocation.width- + (text_area_width+char_width); + GTK_WIDGET(item_entry)->allocation.width = text_area_width + char_width; + gtk_entry_size_allocate(GTK_WIDGET(item_entry), + (GtkAllocation *)(>K_WIDGET(item_entry)->allocation)); + gtk_widget_queue_draw(GTK_WIDGET(item_entry)); + } + else + { + entry->scroll_offset= -(text_area_width + - gdk_text_width (GTK_WIDGET (item_entry)->style->font, gtk_entry_get_text(entry), GTK_EDITABLE(entry)->current_pos)) + 1; + if(entry->scroll_offset < 0) entry->scroll_offset = 0; + } + } + } + else + entry->scroll_offset=0; + + break; + case GTK_JUSTIFY_CENTER: + + if(entry->text){ + + text_width = gdk_text_width (GTK_WIDGET (item_entry)->style->font, gtk_entry_get_text(entry), strlen(gtk_entry_get_text(entry))); + + entry->scroll_offset= -(text_area_width - text_width)/2; + if(entry->scroll_offset > 0){ + if(item_entry->text_max_size != 0 && + text_area_width+char_width<=item_entry->text_max_size){ + GTK_WIDGET(item_entry)->allocation.x=GTK_WIDGET(item_entry)->allocation.x+ + GTK_WIDGET(item_entry)->allocation.width/2- + (text_area_width+char_width)/2; + GTK_WIDGET(item_entry)->allocation.width=text_area_width+char_width; + gtk_entry_size_allocate(GTK_WIDGET(item_entry), + (GtkAllocation *)(>K_WIDGET(item_entry)->allocation)); + gtk_widget_queue_draw(GTK_WIDGET(item_entry)); + } + else + { + entry->scroll_offset= -(text_area_width + - gdk_text_width (GTK_WIDGET (item_entry)->style->font, gtk_entry_get_text(entry), GTK_EDITABLE(entry)->current_pos)) + 1; + if(entry->scroll_offset < 0) entry->scroll_offset = 0; + } + } + } + else + entry->scroll_offset=0; + + break; + + } + +} + +static void +gtk_entry_grow_text (GtkEntry *entry) +{ + gint previous_size; + gint i; + + g_return_if_fail (entry != NULL); + g_return_if_fail (GTK_IS_ENTRY (entry)); + g_return_if_fail (GTK_IS_ITEM_ENTRY (entry)); + + previous_size = entry->text_size; + if (!entry->text_size) + entry->text_size = 128; + else + entry->text_size *= 2; + entry->text = g_realloc (entry->text, entry->text_size * sizeof(GdkWChar)); + entry->char_offset = g_realloc (entry->char_offset, + entry->text_size * sizeof(guint)); + + if (entry->text_length == 0) /* initial allocation */ + { + entry->char_offset[0] = 0; + } + + for (i = previous_size; i < entry->text_size; i++) + entry->text[i] = '\0'; +} + +static void +gtk_entry_insert_text (GtkEditable *editable, + const gchar *new_text, + gint new_text_length, + gint *position) +{ + GdkWChar *text; + gint start_pos; + gint end_pos; + gint last_pos; + gint max_length; + gint i; + + guchar *new_text_nt; + gint insertion_length; + GdkWChar *insertion_text; + + GtkEntry *entry; + GtkWidget *widget; + + g_return_if_fail (editable != NULL); + g_return_if_fail (GTK_IS_ENTRY (editable)); + + entry = GTK_ENTRY (editable); + widget = GTK_WIDGET (editable); + + if ((entry->text_length == 0) && (entry->use_wchar == FALSE)) + { + if (!GTK_WIDGET_REALIZED (widget)) + gtk_widget_ensure_style (widget); + if ((widget->style) && (widget->style->font->type == GDK_FONT_FONTSET)) + entry->use_wchar = TRUE; + } + + if (new_text_length < 0) + { + new_text_nt = (gchar *)new_text; + new_text_length = strlen (new_text); + if (new_text_length <= 0) return; + } + else if (new_text_length == 0) + { + return; + } + else + { + /* make a null-terminated copy of new_text */ + new_text_nt = g_new (gchar, new_text_length + 1); + memcpy (new_text_nt, new_text, new_text_length); + new_text_nt[new_text_length] = 0; + } + + /* The algorithms here will work as long as, the text size (a + * multiple of 2), fits into a guint16 but we specify a shorter + * maximum length so that if the user pastes a very long text, there + * is not a long hang from the slow X_LOCALE functions. */ + + if (entry->text_max_length == 0) + max_length = 2047; + else + max_length = MIN (2047, entry->text_max_length); + + /* Convert to wide characters */ + insertion_text = g_new (GdkWChar, new_text_length); + if (entry->use_wchar) + insertion_length = gdk_mbstowcs (insertion_text, new_text_nt, + new_text_length); + else + for (insertion_length=0; new_text_nt[insertion_length]; insertion_length++) + insertion_text[insertion_length] = new_text_nt[insertion_length]; + if (new_text_nt != (guchar *)new_text) + g_free (new_text_nt); + + /* Make sure we do not exceed the maximum size of the entry. */ + if (insertion_length + entry->text_length > max_length) + insertion_length = max_length - entry->text_length; + + /* Don't insert anything, if there was nothing to insert. */ + if (insertion_length <= 0) + { + g_free(insertion_text); + return; + } + + /* Make sure we are inserting at integral character position */ + start_pos = *position; + if (start_pos < 0) + start_pos = 0; + else if (start_pos > entry->text_length) + start_pos = entry->text_length; + + end_pos = start_pos + insertion_length; + last_pos = insertion_length + entry->text_length; + + if (editable->selection_start_pos >= *position) + editable->selection_start_pos += insertion_length; + if (editable->selection_end_pos >= *position) + editable->selection_end_pos += insertion_length; + + while (last_pos >= entry->text_size) + gtk_entry_grow_text (entry); + + text = entry->text; + for (i = last_pos - 1; i >= end_pos; i--) + text[i] = text[i- (end_pos - start_pos)]; + for (i = start_pos; i < end_pos; i++) + text[i] = insertion_text[i - start_pos]; + g_free (insertion_text); + + /* Fix up the the character offsets */ + + if (GTK_WIDGET_REALIZED (entry)) + { + gint offset = 0; + + for (i = last_pos; i >= end_pos; i--) + entry->char_offset[i] + = entry->char_offset[i - insertion_length]; + + for (i=start_pos; ichar_offset[i] = entry->char_offset[start_pos] + offset; + if (entry->visible) + { + offset += gdk_char_width_wc (GTK_WIDGET (entry)->style->font, + entry->text[i]); + } + else + { + offset += gdk_char_width (GTK_WIDGET (entry)->style->font, '*'); + } + } + for (i = end_pos; i <= last_pos; i++) + entry->char_offset[i] += offset; + } + + entry->text_length += insertion_length; + *position = end_pos; + + entry->text_mb_dirty = 1; + gtk_entry_queue_draw (entry); +} + +static void +gtk_entry_delete_text (GtkEditable *editable, + gint start_pos, + gint end_pos) +{ + GdkWChar *text; + gint deletion_length; + gint i; + + GtkEntry *entry; + + g_return_if_fail (editable != NULL); + g_return_if_fail (GTK_IS_ENTRY (editable)); + + entry = GTK_ENTRY (editable); + + if (end_pos < 0) + end_pos = entry->text_length; + + if (editable->selection_start_pos > start_pos) + editable->selection_start_pos -= MIN(end_pos, editable->selection_start_pos) - start_pos; + if (editable->selection_end_pos > start_pos) + editable->selection_end_pos -= MIN(end_pos, editable->selection_end_pos) - start_pos; + + if ((start_pos < end_pos) && + (start_pos >= 0) && + (end_pos <= entry->text_length)) + { + text = entry->text; + deletion_length = end_pos - start_pos; + + /* Fix up the character offsets */ + if (GTK_WIDGET_REALIZED (entry)) + { + gint deletion_width = + entry->char_offset[end_pos] - entry->char_offset[start_pos]; + + for (i = 0 ; i <= entry->text_length - end_pos; i++) + entry->char_offset[start_pos+i] = entry->char_offset[end_pos+i] - deletion_width; + } + + for (i = end_pos; i < entry->text_length; i++) + text[i - deletion_length] = text[i]; + + for (i = entry->text_length - deletion_length; i < entry->text_length; i++) + text[i] = '\0'; + + entry->text_length -= deletion_length; + editable->current_pos = start_pos; + } + + entry->text_mb_dirty = 1; + gtk_entry_queue_draw (entry); +} + +static void +gtk_entry_update_text (GtkEditable *editable, + gint start_pos, + gint end_pos) +{ + gtk_entry_queue_draw (GTK_ENTRY(editable)); +} + +static gchar * +gtk_entry_get_chars (GtkEditable *editable, + gint start_pos, + gint end_pos) +{ + GtkEntry *entry; + + g_return_val_if_fail (editable != NULL, NULL); + g_return_val_if_fail (GTK_IS_ENTRY (editable), NULL); + + entry = GTK_ENTRY (editable); + + if (end_pos < 0) + end_pos = entry->text_length; + + start_pos = MIN(entry->text_length, start_pos); + end_pos = MIN(entry->text_length, end_pos); + + if (start_pos <= end_pos) + { + guchar *mbstr; + if (entry->use_wchar) + { + GdkWChar ch; + if (end_pos >= entry->text_size) + gtk_entry_grow_text(entry); + ch = entry->text[end_pos]; + entry->text[end_pos] = 0; + mbstr = gdk_wcstombs (entry->text + start_pos); + entry->text[end_pos] = ch; + return (gchar *)mbstr; + } + else + { + gint i; + mbstr = g_new (gchar, end_pos - start_pos + 1); + for (i=0; itext[start_pos + i]; + mbstr[i] = 0; + return (gchar *)mbstr; + } + } + else + return NULL; +} + +static void +gtk_entry_move_cursor (GtkEditable *editable, + gint x, + gint y) +{ + GtkEntry *entry; + entry = GTK_ENTRY (editable); + + /* Horizontal motion */ + if ((gint)editable->current_pos < -x) + editable->current_pos = 0; + else if (editable->current_pos + x > entry->text_length) + editable->current_pos = entry->text_length; + else + editable->current_pos += x; + + /* Ignore vertical motion */ +} + +static void +gtk_move_forward_character (GtkEntry *entry) +{ + gtk_entry_move_cursor (GTK_EDITABLE (entry), 1, 0); +} + +static void +gtk_move_backward_character (GtkEntry *entry) +{ + gtk_entry_move_cursor (GTK_EDITABLE (entry), -1, 0); +} + +static void +gtk_entry_move_word (GtkEditable *editable, + gint n) +{ + while (n-- > 0) + gtk_move_forward_word (GTK_ENTRY (editable)); + while (n++ < 0) + gtk_move_backward_word (GTK_ENTRY (editable)); +} + +static void +gtk_move_forward_word (GtkEntry *entry) +{ + GtkEditable *editable; + GdkWChar *text; + gint i; + + editable = GTK_EDITABLE (entry); + + if (entry->text && (editable->current_pos < entry->text_length)) + { + text = entry->text; + i = editable->current_pos; + + if ((entry->use_wchar) ? (!gdk_iswalnum (text[i])) : (!isalnum (text[i]))) + for (; i < entry->text_length; i++) + { + if ((entry->use_wchar) ? gdk_iswalnum (text[i]) : isalnum (text[i])) + break; + } + + for (; i < entry->text_length; i++) + { + if ((entry->use_wchar) ? (!gdk_iswalnum (text[i])) : (!isalnum (text[i]))) + break; + } + + editable->current_pos = i; + } +} + +static void +gtk_move_backward_word (GtkEntry *entry) +{ + GtkEditable *editable; + GdkWChar *text; + gint i; + + editable = GTK_EDITABLE (entry); + + if (entry->text && editable->current_pos > 0) + { + text = entry->text; + i = editable->current_pos - 1; + if ((entry->use_wchar) ? (!gdk_iswalnum (text[i])) : (!isalnum (text[i]))) + for (; i >= 0; i--) + { + if ((entry->use_wchar) ? gdk_iswalnum (text[i]) : isalnum (text[i])) + break; + } + for (; i >= 0; i--) + { + if ((entry->use_wchar) ? (!gdk_iswalnum (text[i])) : (!isalnum (text[i]))) + { + i++; + break; + } + } + + if (i < 0) + i = 0; + + editable->current_pos = i; + } +} + +static void +gtk_entry_move_to_column (GtkEditable *editable, gint column) +{ + GtkEntry *entry; + + entry = GTK_ENTRY (editable); + + if (column < 0 || column > entry->text_length) + editable->current_pos = entry->text_length; + else + editable->current_pos = column; +} + +static void +gtk_move_beginning_of_line (GtkEntry *entry) +{ + gtk_entry_move_to_column (GTK_EDITABLE (entry), 0); +} + +static void +gtk_move_end_of_line (GtkEntry *entry) +{ + gtk_entry_move_to_column (GTK_EDITABLE (entry), -1); +} + +static void +gtk_entry_kill_char (GtkEditable *editable, + gint direction) +{ + if (editable->selection_start_pos != editable->selection_end_pos) + gtk_editable_delete_selection (editable); + else + { + gint old_pos = editable->current_pos; + if (direction >= 0) + { + gtk_entry_move_cursor (editable, 1, 0); + gtk_editable_delete_text (editable, old_pos, editable->current_pos); + } + else + { + gtk_entry_move_cursor (editable, -1, 0); + gtk_editable_delete_text (editable, editable->current_pos, old_pos); + } + } +} + +static void +gtk_delete_forward_character (GtkEntry *entry) +{ + gtk_entry_kill_char (GTK_EDITABLE (entry), 1); +} + +static void +gtk_delete_backward_character (GtkEntry *entry) +{ + gtk_entry_kill_char (GTK_EDITABLE (entry), -1); +} + +static void +gtk_entry_kill_word (GtkEditable *editable, + gint direction) +{ + if (editable->selection_start_pos != editable->selection_end_pos) + gtk_editable_delete_selection (editable); + else + { + gint old_pos = editable->current_pos; + if (direction >= 0) + { + gtk_entry_move_word (editable, 1); + gtk_editable_delete_text (editable, old_pos, editable->current_pos); + } + else + { + gtk_entry_move_word (editable, -1); + gtk_editable_delete_text (editable, editable->current_pos, old_pos); + } + } +} + +static void +gtk_delete_forward_word (GtkEntry *entry) +{ + gtk_entry_kill_word (GTK_EDITABLE (entry), 1); +} + +static void +gtk_delete_backward_word (GtkEntry *entry) +{ + gtk_entry_kill_word (GTK_EDITABLE (entry), -1); +} + +static void +gtk_entry_kill_line (GtkEditable *editable, + gint direction) +{ + gint old_pos = editable->current_pos; + if (direction >= 0) + { + gtk_entry_move_to_column (editable, -1); + gtk_editable_delete_text (editable, old_pos, editable->current_pos); + } + else + { + gtk_entry_move_to_column (editable, 0); + gtk_editable_delete_text (editable, editable->current_pos, old_pos); + } +} + +static void +gtk_delete_line (GtkEntry *entry) +{ + gtk_entry_move_to_column (GTK_EDITABLE (entry), 0); + gtk_entry_kill_line (GTK_EDITABLE (entry), 1); +} + +static void +gtk_delete_to_line_end (GtkEntry *entry) +{ + gtk_editable_delete_text (GTK_EDITABLE(entry), GTK_EDITABLE(entry)->current_pos, entry->text_length); +} + +static void +gtk_select_word (GtkEntry *entry, + guint32 time) +{ + GtkEditable *editable; + gint start_pos; + gint end_pos; + + editable = GTK_EDITABLE (entry); + + gtk_move_backward_word (entry); + start_pos = editable->current_pos; + + gtk_move_forward_word (entry); + end_pos = editable->current_pos; + + editable->has_selection = TRUE; + gtk_entry_set_selection (editable, start_pos, end_pos); + gtk_editable_claim_selection (editable, start_pos != end_pos, time); +} + +static void +gtk_select_line (GtkEntry *entry, + guint32 time) +{ + GtkEditable *editable; + + editable = GTK_EDITABLE (entry); + + editable->has_selection = TRUE; + gtk_entry_set_selection (editable, 0, entry->text_length); + gtk_editable_claim_selection (editable, entry->text_length != 0, time); + + editable->current_pos = editable->selection_end_pos; +} + +static void +gtk_entry_set_selection (GtkEditable *editable, + gint start, + gint end) +{ + g_return_if_fail (editable != NULL); + g_return_if_fail (GTK_IS_ENTRY (editable)); + + if (end < 0) + end = GTK_ENTRY (editable)->text_length; + + editable->selection_start_pos = start; + editable->selection_end_pos = end; + + gtk_entry_queue_draw (GTK_ENTRY (editable)); +} + +#ifdef USE_XIM +static void +gtk_entry_update_ic_attr (GtkWidget *widget) +{ + GtkEditable *editable = (GtkEditable *) widget; + GdkICAttributesType mask = 0; + + gdk_ic_get_attr (editable->ic, editable->ic_attr, + GDK_IC_PREEDIT_FOREGROUND | + GDK_IC_PREEDIT_BACKGROUND | + GDK_IC_PREEDIT_FONTSET); + + if (editable->ic_attr->preedit_foreground.pixel != + widget->style->fg[GTK_STATE_NORMAL].pixel) + { + mask |= GDK_IC_PREEDIT_FOREGROUND; + editable->ic_attr->preedit_foreground + = widget->style->fg[GTK_STATE_NORMAL]; + } + if (editable->ic_attr->preedit_background.pixel != + widget->style->base[GTK_STATE_NORMAL].pixel) + { + mask |= GDK_IC_PREEDIT_BACKGROUND; + editable->ic_attr->preedit_background + = widget->style->base[GTK_STATE_NORMAL]; + } + if ((gdk_ic_get_style (editable->ic) & GDK_IM_PREEDIT_POSITION) && + !gdk_font_equal (editable->ic_attr->preedit_fontset, + widget->style->font)) + { + mask |= GDK_IC_PREEDIT_FONTSET; + editable->ic_attr->preedit_fontset = widget->style->font; + } + + if (mask) + gdk_ic_set_attr (editable->ic, editable->ic_attr, mask); +} +#endif /* USE_XIM */ + + diff --git a/frontends/gtk-old/src/gtkitementry.h b/frontends/gtk-old/src/gtkitementry.h new file mode 100644 index 000000000..f5969d178 --- /dev/null +++ b/frontends/gtk-old/src/gtkitementry.h @@ -0,0 +1,73 @@ +/* GtkItemEntry - widget for gtk+ + * Copyright (C) 1999-2001 Adrian E. Feiguin + * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald + * + * GtkItemEntry widget by Adrian E. Feiguin + * Based on GtkEntry widget + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free + * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ +#ifndef __GTK_ITEM_ENTRY_H__ +#define __GTK_ITEM_ENTRY_H__ + + +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ + + +#define GTK_TYPE_ITEM_ENTRY (gtk_item_entry_get_type ()) +#define GTK_ITEM_ENTRY(obj) (GTK_CHECK_CAST (obj, gtk_item_entry_get_type (), GtkItemEntry)) +#define GTK_ITEM_ENTRY_CLASS(klass) (GTK_CHECK_CLASS_CAST (klass, gtk_item_entry_get_type (), GtkItemEntryClass)) +#define GTK_IS_ITEM_ENTRY(obj) (GTK_CHECK_TYPE (obj, gtk_item_entry_get_type ())) +#define GTK_IS_ITEM_ENTRY_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_ENTRY)) + + +typedef struct _GtkItemEntry GtkItemEntry; +typedef struct _GtkItemEntryClass GtkItemEntryClass; + +struct _GtkItemEntry +{ + GtkEntry parent; + + gint text_max_size; + + GdkGC *fg_gc; + GdkGC *bg_gc; + + GtkJustification justification; +}; + +struct _GtkItemEntryClass +{ + GtkEntryClass parent_class; +}; + +GtkType gtk_item_entry_get_type (void); +GtkWidget* gtk_item_entry_new (void); +GtkWidget* gtk_item_entry_new_with_max_length (guint16 max); +void gtk_item_entry_set_text (GtkItemEntry *item_entry, + const gchar *text, + GtkJustification justification); +void gtk_item_entry_set_justification (GtkItemEntry *item_entry, + GtkJustification justification); + + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + + +#endif /* __GTK_ITEM_ENTRY_H__ */ diff --git a/frontends/gtk-old/src/interface.c b/frontends/gtk-old/src/interface.c index 3c9368f70..e008cc80b 100644 --- a/frontends/gtk-old/src/interface.c +++ b/frontends/gtk-old/src/interface.c @@ -1229,7 +1229,7 @@ create_main_window (void) gtk_object_set_data_full (GTK_OBJECT (main_window), "icons", icons, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (icons); - gtk_icon_list_set_selection_mode(GTK_ICON_LIST(icons), GTK_SELECTION_MULTIPLE); + gtk_icon_list_set_selection_mode(GTK_ICON_LIST(icons), GTK_SELECTION_BROWSE); gtk_container_add (GTK_CONTAINER (viewport2), icons); /*