/[pspp]/psppire/gtk_sheet/gtksheet.c
ViewVC logotype

Diff of /psppire/gtk_sheet/gtksheet.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.1.1.1 by jmd, Tue Nov 2 11:18:26 2004 UTC revision 1.2 by jmd, Fri Nov 4 01:08:25 2005 UTC
# Line 19  Line 19 
19   * Free Software Foundation, Inc., 59 Temple Place - Suite 330,   * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20   * Boston, MA 02111-1307, USA.   * Boston, MA 02111-1307, USA.
21   */   */
22    /**
23     * SECTION:gtksheet
24     * @short_description: spreadsheet widget for gtk2
25     *
26     * GtkSheet is a matrix widget for GTK+. It consists of an scrollable grid of
27     * cells where you can allocate text. Cell contents can be edited interactively
28     * through a specially designed entry, GtkItemEntry. It is also a container
29     * subclass, allowing you to display buttons, curves, pixmaps and any other
30     * widgets in it.
31     *
32     * You can also set many attributes as: border, foreground and background color,
33     * text justification, and more.
34     *
35     * The testgtksheet program shows how easy is to create a spreadsheet-like GUI
36     * using this widget.
37     */
38  #include <string.h>  #include <string.h>
39  #include <stdio.h>  #include <stdio.h>
40  #include <stdlib.h>  #include <stdlib.h>
# Line 81  enum Line 96  enum
96  #define CELLOFFSET 4  #define CELLOFFSET 4
97  #define DEFAULT_COLUMN_WIDTH 80  #define DEFAULT_COLUMN_WIDTH 80
98    
99    static inline gint
100    gtk_sheet_row_height(GtkSheet *sheet, gint row)
101    {
102      return sheet->row[row].height;
103    }
104    
105    static inline gint
106    gtk_sheet_column_width(GtkSheet *sheet, gint col)
107    {
108      return sheet->column[col].width;
109    }
110    
111  static inline guint DEFAULT_ROW_HEIGHT(GtkWidget *widget)  static inline guint DEFAULT_ROW_HEIGHT(GtkWidget *widget)
112  {  {
113    if(!widget->style->font_desc) return 24;    if(!widget->style->font_desc) return 24;
# Line 350  static inline gint POSSIBLE_RESIZE(GtkSh Line 377  static inline gint POSSIBLE_RESIZE(GtkSh
377  static void gtk_sheet_class_init                (GtkSheetClass * klass);  static void gtk_sheet_class_init                (GtkSheetClass * klass);
378  static void gtk_sheet_init                      (GtkSheet * sheet);  static void gtk_sheet_init                      (GtkSheet * sheet);
379  static void gtk_sheet_destroy                   (GtkObject * object);  static void gtk_sheet_destroy                   (GtkObject * object);
380    static void gtk_sheet_finalize                  (GObject * object);
381  static void gtk_sheet_style_set                 (GtkWidget *widget,  static void gtk_sheet_style_set                 (GtkWidget *widget,
382                                                   GtkStyle  *previous_style);                                                   GtkStyle  *previous_style);
383  static void gtk_sheet_realize                   (GtkWidget * widget);  static void gtk_sheet_realize                   (GtkWidget * widget);
# Line 587  static GtkContainerClass *parent_class = Line 615  static GtkContainerClass *parent_class =
615  static guint sheet_signals[LAST_SIGNAL] = {0};  static guint sheet_signals[LAST_SIGNAL] = {0};
616    
617    
618  GtkType  GType
619  gtk_sheet_get_type ()  gtk_sheet_get_type ()
620  {  {
621    static guint sheet_type = 0;    static GType sheet_type = 0;
622    if(!sheet_type){                                                                                  
623          GtkTypeInfo sheet_info =    if (!sheet_type)
624          {      {
625                  "GtkSheet",        static const GTypeInfo sheet_info =
626                  sizeof(GtkSheet),        {
627                  sizeof(GtkSheetClass),          sizeof (GtkSheetClass),
628                  (GtkClassInitFunc) gtk_sheet_class_init,          NULL,
629                  (GtkObjectInitFunc) gtk_sheet_init,          NULL,
630                  /* reserved_1 */ NULL,          (GClassInitFunc) gtk_sheet_class_init,
631                  /* reserved_2 */ NULL,          NULL,        
632                  (GtkClassInitFunc) NULL,          NULL,      
633          };          sizeof (GtkSheet),
634          sheet_type = gtk_type_unique (GTK_TYPE_CONTAINER, &sheet_info);          0,        
635    }          (GInstanceInitFunc) gtk_sheet_init,
636            NULL,
637          };
638          sheet_type =
639            g_type_register_static (GTK_TYPE_CONTAINER, "GtkSheet",
640                                    &sheet_info, 0);
641        }
642    return sheet_type;    return sheet_type;
643  }  }
644    
# Line 633  gtk_sheet_range_free (GtkSheetRange *ran Line 667  gtk_sheet_range_free (GtkSheetRange *ran
667  GType  GType
668  gtk_sheet_range_get_type (void)  gtk_sheet_range_get_type (void)
669  {  {
670    static GType sheet_range_type;    static GType sheet_range_type=0;
671    
672    if(!sheet_range_type)    if(!sheet_range_type)
673    {    {
# Line 649  gtk_sheet_class_init (GtkSheetClass * kl Line 683  gtk_sheet_class_init (GtkSheetClass * kl
683    GtkObjectClass *object_class;    GtkObjectClass *object_class;
684    GtkWidgetClass *widget_class;    GtkWidgetClass *widget_class;
685    GtkContainerClass *container_class;    GtkContainerClass *container_class;
686      GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
687    
688    object_class = (GtkObjectClass *) klass;    object_class = (GtkObjectClass *) klass;
689    widget_class = (GtkWidgetClass *) klass;    widget_class = (GtkWidgetClass *) klass;
690    container_class = (GtkContainerClass *) klass;    container_class = (GtkContainerClass *) klass;
691    
692    parent_class = gtk_type_class (GTK_TYPE_CONTAINER);    parent_class = g_type_class_peek_parent (klass);
693    
694      /**
695       * GtkSheet::select-row
696       * @sheet: the sheet widget that emitted the signal
697       * @row: the newly selected row index
698       *
699       * A row has been selected.
700       */
701    sheet_signals[SELECT_ROW] =    sheet_signals[SELECT_ROW] =
702      gtk_signal_new ("select_row",      gtk_signal_new ("select-row",
703                      GTK_RUN_LAST,                      GTK_RUN_LAST,
704                      GTK_CLASS_TYPE(object_class),                      GTK_CLASS_TYPE(object_class),
705                      GTK_SIGNAL_OFFSET (GtkSheetClass, select_row),                      GTK_SIGNAL_OFFSET (GtkSheetClass, select_row),
706                      gtkextra_VOID__INT,                      gtkextra_VOID__INT,
707                      GTK_TYPE_NONE, 1, GTK_TYPE_INT);                      GTK_TYPE_NONE, 1, GTK_TYPE_INT);
708    
709      /**
710       * GtkSheet::select-column
711       * @sheet: the sheet widget that emitted the signal
712       * @column: the newly selected column index
713       *
714       * A column has been selected.
715       */
716    sheet_signals[SELECT_COLUMN] =    sheet_signals[SELECT_COLUMN] =
717      gtk_signal_new ("select_column",      gtk_signal_new ("select-column",
718                      GTK_RUN_LAST,                      GTK_RUN_LAST,
719                      GTK_CLASS_TYPE(object_class),                      GTK_CLASS_TYPE(object_class),
720                      GTK_SIGNAL_OFFSET (GtkSheetClass, select_column),                      GTK_SIGNAL_OFFSET (GtkSheetClass, select_column),
# Line 673  gtk_sheet_class_init (GtkSheetClass * kl Line 722  gtk_sheet_class_init (GtkSheetClass * kl
722                      GTK_TYPE_NONE, 1, GTK_TYPE_INT);                      GTK_TYPE_NONE, 1, GTK_TYPE_INT);
723    
724    sheet_signals[SELECT_RANGE] =    sheet_signals[SELECT_RANGE] =
725      gtk_signal_new ("select_range",      gtk_signal_new ("select-range",
726                      GTK_RUN_LAST,                      GTK_RUN_LAST,
727                      GTK_CLASS_TYPE(object_class),                      GTK_CLASS_TYPE(object_class),
728                      GTK_SIGNAL_OFFSET (GtkSheetClass, select_range),                      GTK_SIGNAL_OFFSET (GtkSheetClass, select_range),
# Line 681  gtk_sheet_class_init (GtkSheetClass * kl Line 730  gtk_sheet_class_init (GtkSheetClass * kl
730                      GTK_TYPE_NONE, 1, GTK_TYPE_SHEET_RANGE);                      GTK_TYPE_NONE, 1, GTK_TYPE_SHEET_RANGE);
731    
732    sheet_signals[CLIP_RANGE] =    sheet_signals[CLIP_RANGE] =
733      gtk_signal_new ("clip_range",      gtk_signal_new ("clip-range",
734                      GTK_RUN_LAST,                      GTK_RUN_LAST,
735                      GTK_CLASS_TYPE(object_class),                      GTK_CLASS_TYPE(object_class),
736                      GTK_SIGNAL_OFFSET (GtkSheetClass, clip_range),                      GTK_SIGNAL_OFFSET (GtkSheetClass, clip_range),
# Line 689  gtk_sheet_class_init (GtkSheetClass * kl Line 738  gtk_sheet_class_init (GtkSheetClass * kl
738                      GTK_TYPE_NONE, 1, GTK_TYPE_SHEET_RANGE);                      GTK_TYPE_NONE, 1, GTK_TYPE_SHEET_RANGE);
739    
740    sheet_signals[RESIZE_RANGE] =    sheet_signals[RESIZE_RANGE] =
741      gtk_signal_new ("resize_range",      gtk_signal_new ("resize-range",
742                      GTK_RUN_LAST,                      GTK_RUN_LAST,
743                      GTK_CLASS_TYPE(object_class),                      GTK_CLASS_TYPE(object_class),
744                      GTK_SIGNAL_OFFSET (GtkSheetClass, resize_range),                      GTK_SIGNAL_OFFSET (GtkSheetClass, resize_range),
745                      gtkextra_VOID__BOXED_BOXED,                      gtkextra_VOID__BOXED_BOXED,
746                      GTK_TYPE_NONE, 2, GTK_TYPE_SHEET_RANGE, GTK_TYPE_SHEET_RANGE);                      GTK_TYPE_NONE, 2, GTK_TYPE_SHEET_RANGE, GTK_TYPE_SHEET_RANGE);
747    sheet_signals[MOVE_RANGE] =    sheet_signals[MOVE_RANGE] =
748      gtk_signal_new ("move_range",      gtk_signal_new ("move-range",
749                      GTK_RUN_LAST,                      GTK_RUN_LAST,
750                      GTK_CLASS_TYPE(object_class),                      GTK_CLASS_TYPE(object_class),
751                      GTK_SIGNAL_OFFSET (GtkSheetClass, move_range),                      GTK_SIGNAL_OFFSET (GtkSheetClass, move_range),
# Line 728  gtk_sheet_class_init (GtkSheetClass * kl Line 777  gtk_sheet_class_init (GtkSheetClass * kl
777                      GTK_TYPE_BOOL, 2, GTK_TYPE_INT, GTK_TYPE_INT);                      GTK_TYPE_BOOL, 2, GTK_TYPE_INT, GTK_TYPE_INT);
778    
779    sheet_signals[SET_CELL] =    sheet_signals[SET_CELL] =
780      gtk_signal_new ("set_cell",      gtk_signal_new ("set-cell",
781                      GTK_RUN_LAST,                      GTK_RUN_LAST,
782                      GTK_CLASS_TYPE(object_class),                      GTK_CLASS_TYPE(object_class),
783                      GTK_SIGNAL_OFFSET (GtkSheetClass, set_cell),                      GTK_SIGNAL_OFFSET (GtkSheetClass, set_cell),
# Line 736  gtk_sheet_class_init (GtkSheetClass * kl Line 785  gtk_sheet_class_init (GtkSheetClass * kl
785                      GTK_TYPE_NONE, 2, GTK_TYPE_INT, GTK_TYPE_INT);                      GTK_TYPE_NONE, 2, GTK_TYPE_INT, GTK_TYPE_INT);
786    
787    sheet_signals[CLEAR_CELL] =    sheet_signals[CLEAR_CELL] =
788      gtk_signal_new ("clear_cell",      gtk_signal_new ("clear-cell",
789                      GTK_RUN_LAST,                      GTK_RUN_LAST,
790                      GTK_CLASS_TYPE(object_class),                      GTK_CLASS_TYPE(object_class),
791                      GTK_SIGNAL_OFFSET (GtkSheetClass, clear_cell),                      GTK_SIGNAL_OFFSET (GtkSheetClass, clear_cell),
# Line 752  gtk_sheet_class_init (GtkSheetClass * kl Line 801  gtk_sheet_class_init (GtkSheetClass * kl
801                      GTK_TYPE_NONE, 2, GTK_TYPE_INT, GTK_TYPE_INT);                      GTK_TYPE_NONE, 2, GTK_TYPE_INT, GTK_TYPE_INT);
802    
803    sheet_signals[NEW_COL_WIDTH] =    sheet_signals[NEW_COL_WIDTH] =
804      gtk_signal_new ("new_column_width",      gtk_signal_new ("new-column-width",
805                      GTK_RUN_LAST,                      GTK_RUN_LAST,
806                      GTK_CLASS_TYPE(object_class),                      GTK_CLASS_TYPE(object_class),
807                      GTK_SIGNAL_OFFSET (GtkSheetClass, changed),                      GTK_SIGNAL_OFFSET (GtkSheetClass, changed),
# Line 760  gtk_sheet_class_init (GtkSheetClass * kl Line 809  gtk_sheet_class_init (GtkSheetClass * kl
809                      GTK_TYPE_NONE, 2, GTK_TYPE_INT, GTK_TYPE_INT);                      GTK_TYPE_NONE, 2, GTK_TYPE_INT, GTK_TYPE_INT);
810    
811    sheet_signals[NEW_ROW_HEIGHT] =    sheet_signals[NEW_ROW_HEIGHT] =
812      gtk_signal_new ("new_row_height",      gtk_signal_new ("new-row-height",
813                      GTK_RUN_LAST,                      GTK_RUN_LAST,
814                      GTK_CLASS_TYPE(object_class),                      GTK_CLASS_TYPE(object_class),
815                      GTK_SIGNAL_OFFSET (GtkSheetClass, changed),                      GTK_SIGNAL_OFFSET (GtkSheetClass, changed),
816                      gtkextra_VOID__INT_INT,                      gtkextra_VOID__INT_INT,
817                      GTK_TYPE_NONE, 2, GTK_TYPE_INT, GTK_TYPE_INT);                      GTK_TYPE_NONE, 2, GTK_TYPE_INT, GTK_TYPE_INT);
818    
   
   
819    widget_class->set_scroll_adjustments_signal =    widget_class->set_scroll_adjustments_signal =
820      gtk_signal_new ("set_scroll_adjustments",      gtk_signal_new ("set-scroll-adjustments",
821                      GTK_RUN_LAST,                      GTK_RUN_LAST,
822                      GTK_CLASS_TYPE(object_class),                      GTK_CLASS_TYPE(object_class),
823                      GTK_SIGNAL_OFFSET (GtkSheetClass, set_scroll_adjustments),                      GTK_SIGNAL_OFFSET (GtkSheetClass, set_scroll_adjustments),
# Line 783  gtk_sheet_class_init (GtkSheetClass * kl Line 830  gtk_sheet_class_init (GtkSheetClass * kl
830    container_class->forall = gtk_sheet_forall;    container_class->forall = gtk_sheet_forall;
831    
832    object_class->destroy = gtk_sheet_destroy;    object_class->destroy = gtk_sheet_destroy;
833      gobject_class->finalize = gtk_sheet_finalize;
834    
835    widget_class->realize = gtk_sheet_realize;    widget_class->realize = gtk_sheet_realize;
836    widget_class->unrealize = gtk_sheet_unrealize;    widget_class->unrealize = gtk_sheet_unrealize;
# Line 891  gtk_sheet_init (GtkSheet *sheet) Line 939  gtk_sheet_init (GtkSheet *sheet)
939    sheet->show_grid = TRUE;    sheet->show_grid = TRUE;
940  }  }
941    
942    /**
943     * gtk_sheet_new:
944     * @rows: initial number of rows
945     * @columns: initial number of columns
946     * @title: sheet title
947     *
948     * Creates a new sheet widget with the given number of rows and columns.
949     *
950     * Returns: the new sheet widget
951     */
952  GtkWidget *  GtkWidget *
953  gtk_sheet_new (guint rows, guint columns, const gchar *title)  gtk_sheet_new (guint rows, guint columns, const gchar *title)
954  {  {
# Line 1357  gtk_sheet_show_column_titles(GtkSheet *s Line 1415  gtk_sheet_show_column_titles(GtkSheet *s
1415   gtk_sheet_recalc_left_xpixels(sheet, 0);   gtk_sheet_recalc_left_xpixels(sheet, 0);
1416   if(GTK_WIDGET_REALIZED(GTK_WIDGET(sheet))){   if(GTK_WIDGET_REALIZED(GTK_WIDGET(sheet))){
1417    gdk_window_show(sheet->column_title_window);    gdk_window_show(sheet->column_title_window);
1418      gdk_window_move_resize (sheet->column_title_window,
1419                              sheet->column_title_area.x,
1420                              sheet->column_title_area.y,
1421                              sheet->column_title_area.width,
1422                              sheet->column_title_area.height);
1423    
1424    for(col = MIN_VISIBLE_COLUMN(sheet); col <= MAX_VISIBLE_COLUMN(sheet); col++){    for(col = MIN_VISIBLE_COLUMN(sheet); col <= MAX_VISIBLE_COLUMN(sheet); col++){
1425      GtkSheetChild *child;      GtkSheetChild *child;
# Line 1387  gtk_sheet_show_row_titles(GtkSheet *shee Line 1450  gtk_sheet_show_row_titles(GtkSheet *shee
1450   gtk_sheet_recalc_left_xpixels(sheet, 0);   gtk_sheet_recalc_left_xpixels(sheet, 0);
1451   if(GTK_WIDGET_REALIZED(GTK_WIDGET(sheet))){   if(GTK_WIDGET_REALIZED(GTK_WIDGET(sheet))){
1452    gdk_window_show(sheet->row_title_window);    gdk_window_show(sheet->row_title_window);
1453      gdk_window_move_resize (sheet->row_title_window,
1454                              sheet->row_title_area.x,
1455                              sheet->row_title_area.y,
1456                              sheet->row_title_area.width,
1457                              sheet->row_title_area.height);
1458    
1459    for(row = MIN_VISIBLE_ROW(sheet); row <= MAX_VISIBLE_ROW(sheet); row++){    for(row = MIN_VISIBLE_ROW(sheet); row <= MAX_VISIBLE_ROW(sheet); row++){
1460      GtkSheetChild *child;      GtkSheetChild *child;
# Line 2382  gtk_sheet_set_scroll_adjustments (GtkShe Line 2450  gtk_sheet_set_scroll_adjustments (GtkShe
2450  }  }
2451    
2452  static void  static void
2453  gtk_sheet_destroy (GtkObject * object)  gtk_sheet_finalize (GObject * object)
2454  {  {
2455    GtkSheet *sheet;    GtkSheet *sheet;
2456    
# Line 2393  gtk_sheet_destroy (GtkObject * object) Line 2461  gtk_sheet_destroy (GtkObject * object)
2461    
2462    /* get rid of all the cells */    /* get rid of all the cells */
2463    gtk_sheet_range_clear (sheet, NULL);    gtk_sheet_range_clear (sheet, NULL);
2464      gtk_sheet_range_delete(sheet, NULL);
2465    
2466      gtk_sheet_delete_rows (sheet, 0, sheet->maxrow + 1);
2467      gtk_sheet_delete_columns (sheet, 0, sheet->maxcol + 1);
2468    
2469      DeleteRow (sheet, 0, sheet->maxrow + 1);
2470      DeleteColumn (sheet, 0, sheet->maxcol + 1);
2471    
2472      g_free(sheet->row);
2473      sheet->row = NULL;
2474      g_free(sheet->column);
2475      sheet->column = NULL;
2476      g_free(sheet->data);
2477      sheet->data = NULL;
2478    
2479      if(sheet->name){
2480          g_free(sheet->name);
2481          sheet->name = NULL;
2482      }
2483    
2484      if (G_OBJECT_CLASS (parent_class)->finalize)
2485        (*G_OBJECT_CLASS (parent_class)->finalize) (object);
2486    }
2487    
2488    static void
2489    gtk_sheet_destroy (GtkObject * object)
2490    {
2491      GtkSheet *sheet;
2492      GList *children;
2493    
2494      g_return_if_fail (object != NULL);
2495      g_return_if_fail (GTK_IS_SHEET (object));
2496    
2497      sheet = GTK_SHEET (object);
2498    
2499    /* destroy the entry */    /* destroy the entry */
2500    if(sheet->sheet_entry && GTK_IS_WIDGET(sheet->sheet_entry)){    if(sheet->sheet_entry && GTK_IS_WIDGET(sheet->sheet_entry)){
# Line 2430  gtk_sheet_destroy (GtkObject * object) Line 2532  gtk_sheet_destroy (GtkObject * object)
2532        sheet->vadjustment = NULL;        sheet->vadjustment = NULL;
2533      }      }
2534    
2535      children = sheet->children;
2536    gtk_sheet_range_delete(sheet, NULL);    while(children){
2537        GtkSheetChild *child = (GtkSheetChild *)children->data;
2538    gtk_sheet_delete_rows (sheet, 0, sheet->maxrow + 1);      if(child && child->widget)
2539    gtk_sheet_delete_columns (sheet, 0, sheet->maxcol + 1);        gtk_sheet_remove(GTK_CONTAINER(sheet), child->widget);
2540        children = sheet->children;
2541    g_free(sheet->row);    }  
2542    sheet->row = NULL;    sheet->children = NULL;
   g_free(sheet->column);  
   sheet->column = NULL;  
   g_free(sheet->data);  
   sheet->data = NULL;  
   
   if(sheet->name){  
       g_free(sheet->name);  
       sheet->name = NULL;  
   }  
2543    
2544    if (GTK_OBJECT_CLASS (parent_class)->destroy)    if (GTK_OBJECT_CLASS (parent_class)->destroy)
2545      (*GTK_OBJECT_CLASS (parent_class)->destroy) (object);      (*GTK_OBJECT_CLASS (parent_class)->destroy) (object);
   
   if(sheet->children) g_list_free(sheet->children);  
   sheet->children = NULL;  
   
2546  }  }
2547    
2548  static void  static void
# Line 2594  gtk_sheet_realize (GtkWidget * widget) Line 2683  gtk_sheet_realize (GtkWidget * widget)
2683                                            GDK_GC_FUNCTION |                                            GDK_GC_FUNCTION |
2684                                            GDK_GC_SUBWINDOW);                                            GDK_GC_SUBWINDOW);
2685    
 /* create sheet_entry_window */  
   
   if(GTK_WIDGET_NO_WINDOW(sheet->sheet_entry)){  
   
     attributes.window_type = GDK_WINDOW_CHILD;  
     attributes.x = 0;  
     attributes.y = 0;  
     attributes.width = sheet->sheet_entry->requisition.width;  
     attributes.height = sheet->sheet_entry->requisition.height;  
     attributes.wclass = GDK_INPUT_OUTPUT;  
     attributes.visual = gtk_widget_get_visual (widget);  
     attributes.colormap = gtk_widget_get_colormap (widget);  
     attributes.event_mask = GDK_EXPOSURE_MASK;  
   
     attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;  
     sheet->sheet_entry_window =  gdk_window_new (sheet->sheet_window,  
                                                  &attributes, attributes_mask);  
     gdk_window_set_user_data (sheet->sheet_entry_window, widget);  
   }  
   
2686    if(sheet->sheet_entry->parent){    if(sheet->sheet_entry->parent){
2687            gtk_widget_ref(sheet->sheet_entry);            gtk_widget_ref(sheet->sheet_entry);
2688            gtk_widget_unparent(sheet->sheet_entry);            gtk_widget_unparent(sheet->sheet_entry);
2689    }    }
2690    gtk_widget_set_parent_window (sheet->sheet_entry,    gtk_widget_set_parent_window (sheet->sheet_entry, sheet->sheet_window);
                                 sheet->sheet_entry_window ?  
                                 sheet->sheet_entry_window :  
                                 sheet->sheet_window);  
2691    gtk_widget_set_parent(sheet->sheet_entry, GTK_WIDGET(sheet));    gtk_widget_set_parent(sheet->sheet_entry, GTK_WIDGET(sheet));
2692    
2693    if(sheet->button && sheet->button->parent){    if(sheet->button && sheet->button->parent){
# Line 2704  static void Line 2770  static void
2770  gtk_sheet_unrealize (GtkWidget * widget)  gtk_sheet_unrealize (GtkWidget * widget)
2771  {  {
2772    GtkSheet *sheet;    GtkSheet *sheet;
   GtkSheetChild *child;  
   GList *children;  
2773    
2774    g_return_if_fail (widget != NULL);    g_return_if_fail (widget != NULL);
2775    g_return_if_fail (GTK_IS_SHEET (widget));    g_return_if_fail (GTK_IS_SHEET (widget));
2776    
2777    sheet = GTK_SHEET (widget);    sheet = GTK_SHEET (widget);
   GTK_WIDGET_UNSET_FLAGS (widget, GTK_REALIZED | GTK_MAPPED);  
2778    
2779    gdk_cursor_destroy (sheet->cursor_drag);    gdk_cursor_destroy (sheet->cursor_drag);
2780    
# Line 2719  gtk_sheet_unrealize (GtkWidget * widget) Line 2782  gtk_sheet_unrealize (GtkWidget * widget)
2782    gdk_gc_destroy (sheet->fg_gc);    gdk_gc_destroy (sheet->fg_gc);
2783    gdk_gc_destroy (sheet->bg_gc);    gdk_gc_destroy (sheet->bg_gc);
2784    
   gtk_style_detach (widget->style);  
   
2785    gdk_window_destroy (sheet->sheet_window);    gdk_window_destroy (sheet->sheet_window);
2786    gdk_window_destroy (sheet->column_title_window);    gdk_window_destroy (sheet->column_title_window);
2787    gdk_window_destroy (sheet->row_title_window);    gdk_window_destroy (sheet->row_title_window);
   gdk_window_set_user_data (widget->window, NULL);  
   gdk_window_destroy (widget->window);  
2788    
2789    if (sheet->pixmap){    if (sheet->pixmap){
2790      g_free (sheet->pixmap);      g_free (sheet->pixmap);
2791      sheet->pixmap = NULL;      sheet->pixmap = NULL;
2792    }    }
2793    
   widget->window = NULL;  
2794    sheet->column_title_window=NULL;    sheet->column_title_window=NULL;
2795    sheet->sheet_window = NULL;    sheet->sheet_window = NULL;
   sheet->sheet_entry_window = NULL;  
2796    sheet->cursor_drag = NULL;    sheet->cursor_drag = NULL;
2797    sheet->xor_gc = NULL;    sheet->xor_gc = NULL;
2798    sheet->fg_gc = NULL;    sheet->fg_gc = NULL;
2799    sheet->bg_gc = NULL;    sheet->bg_gc = NULL;
2800    
2801    children = sheet->children;    if (GTK_WIDGET_CLASS (parent_class)->unrealize)
2802    while (children)      (* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
    {  
      child = children->data;  
      children = children->next;  
   
      if(child->window)  
         {  
             gdk_window_set_user_data(child->window, NULL);  
             gdk_window_destroy(child->window);  
             child->window = NULL;  
         }  
   
    }  
   
2803  }  }
2804    
2805  static void  static void
# Line 2780  gtk_sheet_map (GtkWidget * widget) Line 2824  gtk_sheet_map (GtkWidget * widget)
2824    
2825        gdk_window_show (sheet->sheet_window);        gdk_window_show (sheet->sheet_window);
2826    
       if(sheet->sheet_entry_window)  
           gdk_window_show(sheet->sheet_entry_window);  
   
2827        if(sheet->column_titles_visible){        if(sheet->column_titles_visible){
2828               size_allocate_column_title_buttons(sheet);
2829             gdk_window_show (sheet->column_title_window);             gdk_window_show (sheet->column_title_window);
2830        }        }
2831        if(sheet->row_titles_visible){        if(sheet->row_titles_visible){
2832               size_allocate_row_title_buttons(sheet);
2833             gdk_window_show (sheet->row_title_window);             gdk_window_show (sheet->row_title_window);
2834        }        }
2835    
# Line 2821  gtk_sheet_map (GtkWidget * widget) Line 2864  gtk_sheet_map (GtkWidget * widget)
2864              !GTK_WIDGET_MAPPED (child->widget)){              !GTK_WIDGET_MAPPED (child->widget)){
2865            gtk_widget_map (child->widget);            gtk_widget_map (child->widget);
2866            gtk_sheet_position_child(sheet, child);            gtk_sheet_position_child(sheet, child);
           if (GTK_WIDGET_NO_WINDOW(child->widget) && child->window)  
                          gdk_window_show(child->window);  
2867          }          }
2868        }        }
2869    
# Line 2852  gtk_sheet_unmap (GtkWidget * widget) Line 2893  gtk_sheet_unmap (GtkWidget * widget)
2893            gdk_window_hide (sheet->row_title_window);            gdk_window_hide (sheet->row_title_window);
2894        gdk_window_hide (widget->window);        gdk_window_hide (widget->window);
2895    
       if(sheet->sheet_entry_window)  
           gdk_window_hide (sheet->sheet_entry_window);  
   
2896        if (GTK_WIDGET_MAPPED (sheet->sheet_entry))        if (GTK_WIDGET_MAPPED (sheet->sheet_entry))
2897          gtk_widget_unmap (sheet->sheet_entry);          gtk_widget_unmap (sheet->sheet_entry);
2898    
# Line 2871  gtk_sheet_unmap (GtkWidget * widget) Line 2909  gtk_sheet_unmap (GtkWidget * widget)
2909                GTK_WIDGET_MAPPED (child->widget))                GTK_WIDGET_MAPPED (child->widget))
2910                  {                  {
2911                       gtk_widget_unmap (child->widget);                       gtk_widget_unmap (child->widget);
                      if(child->window) gdk_window_hide(child->window);  
2912                  }                  }
2913          }          }
2914    
# Line 3576  gtk_sheet_real_cell_clear (GtkSheet *she Line 3613  gtk_sheet_real_cell_clear (GtkSheet *she
3613    link = gtk_sheet_get_link(sheet, row, column);    link = gtk_sheet_get_link(sheet, row, column);
3614    
3615    if(text){    if(text){
3616        g_free(sheet->data[row][column]->text);      g_free(sheet->data[row][column]->text);
3617        sheet->data[row][column]->text = NULL;      sheet->data[row][column]->text = NULL;
3618    
3619        if(GTK_IS_OBJECT(sheet) && G_OBJECT(sheet)->ref_count > 0)
3620        gtk_signal_emit(GTK_OBJECT(sheet),sheet_signals[CLEAR_CELL], row, column);        gtk_signal_emit(GTK_OBJECT(sheet),sheet_signals[CLEAR_CELL], row, column);
3621    }      }  
3622    
# Line 3879  gtk_sheet_entry_changed(GtkWidget *widge Line 3917  gtk_sheet_entry_changed(GtkWidget *widge
3917   else   else
3918   {   {
3919   /* Added by Matias Mutchinick */   /* Added by Matias Mutchinick */
3920        gtk_sheet_cell_clear(sheet, row, col);        if(row < sheet->maxallocrow && col < sheet->maxalloccol && sheet->data[row] && sheet->data[row][col] && sheet->data[row][col]->text) {
3921            g_free(sheet->data[row][col]->text);
3922            sheet->data[row][col]->text = NULL;
3923          }
3924   }   }
3925    
3926   if(sheet->freeze_count == 0)   if(sheet->freeze_count == 0)
# Line 3962  gtk_sheet_hide_active_cell(GtkSheet *she Line 4003  gtk_sheet_hide_active_cell(GtkSheet *she
4003   column_button_release(sheet, col);   column_button_release(sheet, col);
4004   row_button_release(sheet, row);   row_button_release(sheet, row);
4005    
4006   if(sheet->sheet_entry_window)   gtk_widget_unmap(sheet->sheet_entry);
       gdk_window_hide(sheet->sheet_entry_window);  
  else  
       gdk_window_hide(sheet->sheet_entry->window);  
4007    
4008   if(row != -1 && col != -1)   if(row != -1 && col != -1)
4009     gdk_draw_pixmap(sheet->sheet_window,     gdk_draw_pixmap(sheet->sheet_window,
# Line 4038  gtk_sheet_show_active_cell(GtkSheet *she Line 4076  gtk_sheet_show_active_cell(GtkSheet *she
4076   GtkEntry *sheet_entry;   GtkEntry *sheet_entry;
4077   GtkSheetCellAttr attributes;   GtkSheetCellAttr attributes;
4078   gchar *text = NULL;   gchar *text = NULL;
4079     const gchar *old_text;
4080   GtkJustification justification;   GtkJustification justification;
4081   gint row, col;   gint row, col;
4082    
# Line 4086  gtk_sheet_show_active_cell(GtkSheet *she Line 4125  gtk_sheet_show_active_cell(GtkSheet *she
4125              gtk_entry_set_editable(GTK_ENTRY(sheet_entry), TRUE);              gtk_entry_set_editable(GTK_ENTRY(sheet_entry), TRUE);
4126   }   }
4127    
4128   if(!GTK_IS_ITEM_ENTRY(sheet_entry))  /*** Added by John Gotts. Mar 25, 2005 *********/
4129      gtk_entry_set_text(GTK_ENTRY(sheet_entry), text);   old_text = gtk_entry_get_text(GTK_ENTRY(sheet_entry));
4130   else   if (strcmp(old_text, text) != 0) {
4131      gtk_item_entry_set_text(GTK_ITEM_ENTRY(sheet_entry), text, justification);    if(!GTK_IS_ITEM_ENTRY(sheet_entry))
4132         gtk_entry_set_text(GTK_ENTRY(sheet_entry), text);
4133      else
4134         gtk_item_entry_set_text(GTK_ITEM_ENTRY(sheet_entry), text, justification);
4135     }
4136    
4137   gtk_sheet_entry_set_max_size(sheet);   gtk_sheet_entry_set_max_size(sheet);
4138   gtk_sheet_size_allocate_entry(sheet);   gtk_sheet_size_allocate_entry(sheet);
4139    
4140   if(GTK_WIDGET_REALIZED(sheet->sheet_entry)){   gtk_widget_map(sheet->sheet_entry);
      if(sheet->sheet_entry_window)            
             gdk_window_show(sheet->sheet_entry_window);  
      else  
             gdk_window_show(sheet->sheet_entry->window);  
      gtk_widget_queue_draw(sheet->sheet_entry);  
  }  
4141   gtk_sheet_draw_active_cell(sheet);   gtk_sheet_draw_active_cell(sheet);
4142    
4143   gtk_widget_grab_focus(GTK_WIDGET(sheet_entry));   gtk_widget_grab_focus(GTK_WIDGET(sheet_entry));
# Line 4703  gtk_sheet_real_unselect_range (GtkSheet Line 4740  gtk_sheet_real_unselect_range (GtkSheet
4740       row_button_release(sheet, i);       row_button_release(sheet, i);
4741    }    }
4742    
4743      gtk_sheet_position_children(sheet);
4744  }  }
4745    
4746    
# Line 4729  gtk_sheet_expose (GtkWidget * widget, Line 4767  gtk_sheet_expose (GtkWidget * widget,
4767        /* exposure events on the sheet */        /* exposure events on the sheet */
4768    
4769        if(event->window == sheet->row_title_window && sheet->row_titles_visible){        if(event->window == sheet->row_title_window && sheet->row_titles_visible){
4770                       size_allocate_row_title_buttons(sheet);           gint i;
4771                       gdk_window_show(sheet->row_title_window);           for(i = MIN_VISIBLE_ROW(sheet); i <= MAX_VISIBLE_ROW(sheet); i++)
4772               gtk_sheet_button_draw(sheet,i,-1);
4773        }        }
4774    
4775        if(event->window == sheet->column_title_window && sheet->column_titles_visible){        if(event->window == sheet->column_title_window && sheet->column_titles_visible){
4776                       size_allocate_column_title_buttons(sheet);           gint i;
4777                       gdk_window_show(sheet->column_title_window);           for(i = MIN_VISIBLE_COLUMN(sheet); i <= MAX_VISIBLE_COLUMN(sheet); i++)
4778               gtk_sheet_button_draw(sheet,-1,i);
4779        }        }
4780    
4781        if (event->window == sheet->sheet_window){        if (event->window == sheet->sheet_window){
# Line 5176  gtk_sheet_motion (GtkWidget * widget, Line 5216  gtk_sheet_motion (GtkWidget * widget,
5216    
5217    sheet = GTK_SHEET (widget);    sheet = GTK_SHEET (widget);
5218    
   
5219    /* selections on the sheet */    /* selections on the sheet */
5220    x = event->x;    x = event->x;
5221    y = event->y;    y = event->y;
# Line 5311  gtk_sheet_motion (GtkWidget * widget, Line 5350  gtk_sheet_motion (GtkWidget * widget,
5350    
5351    if (GTK_SHEET_IN_RESIZE(sheet)){    if (GTK_SHEET_IN_RESIZE(sheet)){
5352         GtkSheetRange aux;         GtkSheetRange aux;
5353         gint v_h;         gint v_h, current_col, current_row, col_threshold, row_threshold;
5354         v_h=1;         v_h=1;
5355    
5356         if(abs(x-COLUMN_LEFT_XPIXEL(sheet,sheet->drag_cell.col)) >         if(abs(x-COLUMN_LEFT_XPIXEL(sheet,sheet->drag_cell.col)) >
5357            abs(y-ROW_TOP_YPIXEL(sheet,sheet->drag_cell.row))) v_h=2;            abs(y-ROW_TOP_YPIXEL(sheet,sheet->drag_cell.row))) v_h=2;
5358            
5359           current_col = COLUMN_FROM_XPIXEL(sheet,x);
5360           current_row = ROW_FROM_YPIXEL(sheet,y);
5361           column = current_col-sheet->drag_cell.col;
5362           row    = current_row-sheet->drag_cell.row;
5363    
5364           /*use half of column width resp. row height as threshold to expand selection*/
5365           col_threshold = COLUMN_LEFT_XPIXEL(sheet,current_col)+gtk_sheet_column_width (sheet,current_col)/2;
5366           if (column > 0){
5367             if (x < col_threshold)
5368               column-=1;
5369           }
5370           else if (column < 0){
5371             if (x > col_threshold)
5372               column+=1;
5373           }
5374           row_threshold = ROW_TOP_YPIXEL(sheet,current_row)+gtk_sheet_row_height (sheet, current_row)/2;
5375           if (row > 0){
5376             if(y < row_threshold)
5377               row-=1;
5378           }
5379           else if (row < 0){
5380             if(y > row_threshold)
5381               row+=1;      
5382           }
5383    
        column=COLUMN_FROM_XPIXEL(sheet,x)-sheet->drag_cell.col;  
        row=ROW_FROM_YPIXEL(sheet,y)-sheet->drag_cell.row;  
5384         if(sheet->state==GTK_SHEET_COLUMN_SELECTED) row=0;         if(sheet->state==GTK_SHEET_COLUMN_SELECTED) row=0;
5385         if(sheet->state==GTK_SHEET_ROW_SELECTED) column=0;         if(sheet->state==GTK_SHEET_ROW_SELECTED) column=0;
5386         sheet->x_drag=x;         sheet->x_drag=x;
5387         sheet->y_drag=y;         sheet->y_drag=y;
5388         aux=sheet->range;         aux=sheet->range;
5389    
        if(row < sheet->range.row0 - sheet->range.rowi - 1)  
           row=row+(sheet->range.rowi-sheet->range.row0 + 1);  
        else if(row<0) row=0;  
   
        if(column < sheet->range.col0 - sheet->range.coli - 1)  
           column=column+(sheet->range.coli-sheet->range.col0 + 1);  
        else if(column<0) column=0;  
   
5390         if(v_h==1)         if(v_h==1)
5391             column=0;             column=0;
5392         else         else
# Line 5734  gtk_sheet_key_press(GtkWidget *widget, Line 5789  gtk_sheet_key_press(GtkWidget *widget,
5789        extend_selection = FALSE;        extend_selection = FALSE;
5790        break;        break;
5791      default:      default:
5792        if(in_selection) GTK_SHEET_SET_FLAGS(sheet, GTK_SHEET_IN_SELECTION);        if(in_selection) {
5793        if(extend_selection) return TRUE;          GTK_SHEET_SET_FLAGS(sheet, GTK_SHEET_IN_SELECTION);
5794            if(extend_selection) return TRUE;
5795          }
5796        if(state == GTK_SHEET_ROW_SELECTED)        if(state == GTK_SHEET_ROW_SELECTED)
5797          sheet->active_cell.col=MIN_VISIBLE_COLUMN(sheet);          sheet->active_cell.col=MIN_VISIBLE_COLUMN(sheet);
5798        if(state == GTK_SHEET_COLUMN_SELECTED)        if(state == GTK_SHEET_COLUMN_SELECTED)
# Line 6124  gtk_sheet_size_allocate_entry(GtkSheet * Line 6181  gtk_sheet_size_allocate_entry(GtkSheet *
6181     shentry_allocation.height -= MIN(shentry_allocation.height, 3);     shentry_allocation.height -= MIN(shentry_allocation.height, 3);
6182   }   }
6183    
6184   if(sheet->sheet_entry_window){   gtk_widget_size_allocate(sheet->sheet_entry, &shentry_allocation);
    gdk_window_move_resize(sheet->sheet_entry_window,  
                           shentry_allocation.x,  
                           shentry_allocation.y,  
                           shentry_allocation.width,  
                           shentry_allocation.height);  
    shentry_allocation.x = 0;  
    shentry_allocation.y = 0;  
    gtk_widget_size_allocate(sheet->sheet_entry, &shentry_allocation);  
  } else {  
    gtk_widget_size_allocate(sheet->sheet_entry, &shentry_allocation);  
  }  
6185    
6186   if(previous_style == style) gtk_style_unref(previous_style);   if(previous_style == style) gtk_style_unref(previous_style);
6187  }  }
# Line 6204  create_sheet_entry(GtkSheet *sheet) Line 6250  create_sheet_entry(GtkSheet *sheet)
6250   style = gtk_style_copy(GTK_WIDGET(sheet)->style);   style = gtk_style_copy(GTK_WIDGET(sheet)->style);
6251    
6252   if(sheet->sheet_entry){   if(sheet->sheet_entry){
     if(sheet->sheet_entry_window){  
         gdk_window_set_user_data(sheet->sheet_entry_window, NULL);  
         gdk_window_destroy(sheet->sheet_entry_window);  
         sheet->sheet_entry_window = NULL;  
     }  
6253      /* avoids warnings */      /* avoids warnings */
6254      gtk_widget_ref(sheet->sheet_entry);      gtk_widget_ref(sheet->sheet_entry);
6255      gtk_widget_unparent(sheet->sheet_entry);      gtk_widget_unparent(sheet->sheet_entry);
# Line 6217  create_sheet_entry(GtkSheet *sheet) Line 6258  create_sheet_entry(GtkSheet *sheet)
6258    
6259   if(sheet->entry_type){   if(sheet->entry_type){
6260    
6261     if(!gtk_type_is_a (sheet->entry_type, GTK_TYPE_ENTRY)){     if(!g_type_is_a (sheet->entry_type, GTK_TYPE_ENTRY)){
6262    
6263       parent = GTK_WIDGET(gtk_type_new(sheet->entry_type));       parent = GTK_WIDGET(gtk_type_new(sheet->entry_type));
6264    
# Line 6255  create_sheet_entry(GtkSheet *sheet) Line 6296  create_sheet_entry(GtkSheet *sheet)
6296   }   }
6297    
6298   gtk_widget_size_request(sheet->sheet_entry, NULL);   gtk_widget_size_request(sheet->sheet_entry, NULL);
6299      
  if (GTK_WIDGET_REALIZED(sheet) && GTK_WIDGET_NO_WINDOW (sheet->sheet_entry))  
     {  
       GdkWindowAttr attributes;  
       gint attributes_mask;  
         
       attributes.window_type = GDK_WINDOW_CHILD;  
       attributes.x = 0;  
       attributes.y = 0;  
       attributes.width = sheet->sheet_entry->requisition.width;  
       attributes.height = sheet->sheet_entry->requisition.height;  
       attributes.wclass = GDK_INPUT_OUTPUT;  
       attributes.visual = gtk_widget_get_visual (widget);  
       attributes.colormap = gtk_widget_get_colormap (widget);  
       attributes.event_mask = GDK_EXPOSURE_MASK;  
   
       attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;  
       sheet->sheet_entry_window =  gdk_window_new (sheet->sheet_window,  
                                                &attributes, attributes_mask);  
       gdk_window_set_user_data (sheet->sheet_entry_window, widget);  
   
      }  
   
6300   if(GTK_WIDGET_REALIZED(sheet))   if(GTK_WIDGET_REALIZED(sheet))
6301     {     {
6302        gtk_widget_set_parent_window (sheet->sheet_entry,        gtk_widget_set_parent_window (sheet->sheet_entry, sheet->sheet_window);
                                     sheet->sheet_entry_window ?  
                                     sheet->sheet_entry_window :  
                                     sheet->sheet_window);  
6303        gtk_widget_set_parent(sheet->sheet_entry, GTK_WIDGET(sheet));        gtk_widget_set_parent(sheet->sheet_entry, GTK_WIDGET(sheet));
6304        gtk_widget_realize(sheet->sheet_entry);        gtk_widget_realize(sheet->sheet_entry);
6305     }     }
# Line 6407  gtk_sheet_button_draw (GtkSheet *sheet, Line 6423  gtk_sheet_button_draw (GtkSheet *sheet,
6423    gchar *line = 0;    gchar *line = 0;
6424    gchar *words = 0;    gchar *words = 0;
6425    gchar label[10];    gchar label[10];
6426      PangoAlignment align = PANGO_ALIGN_LEFT;
6427      gboolean rtl;
6428    
6429      rtl = gtk_widget_get_direction(GTK_WIDGET(sheet)) == GTK_TEXT_DIR_RTL;
6430    
6431    if(!GTK_WIDGET_REALIZED(GTK_WIDGET(sheet))) return;    if(!GTK_WIDGET_REALIZED(GTK_WIDGET(sheet))) return;
6432    
# Line 6454  gtk_sheet_button_draw (GtkSheet *sheet, Line 6474  gtk_sheet_button_draw (GtkSheet *sheet,
6474    
6475    gtk_paint_box (sheet->button->style, window,    gtk_paint_box (sheet->button->style, window,
6476                   GTK_STATE_NORMAL, GTK_SHADOW_OUT,                   GTK_STATE_NORMAL, GTK_SHADOW_OUT,
6477                   &allocation, GTK_WIDGET(sheet),                   &allocation, GTK_WIDGET(sheet->button),
6478                   "buttondefault", x, y, width, height);                   "buttondefault", x, y, width, height);
6479    
6480    state = button->state;    state = button->state;
# Line 6468  gtk_sheet_button_draw (GtkSheet *sheet, Line 6488  gtk_sheet_button_draw (GtkSheet *sheet,
6488    if(state != GTK_STATE_NORMAL && state != GTK_STATE_INSENSITIVE)    if(state != GTK_STATE_NORMAL && state != GTK_STATE_INSENSITIVE)
6489    gtk_paint_box (sheet->button->style, window,    gtk_paint_box (sheet->button->style, window,
6490                   button->state, shadow_type,                   button->state, shadow_type,
6491                   &allocation, GTK_WIDGET(sheet),                   &allocation, GTK_WIDGET(sheet->button),
6492                   "button", x, y, width, height);                   "button", x, y, width, height);
6493    
6494    if(button->label_visible){    if(button->label_visible){
# Line 6479  gtk_sheet_button_draw (GtkSheet *sheet, Line 6499  gtk_sheet_button_draw (GtkSheet *sheet,
6499                                &allocation);                                &allocation);
6500      gdk_gc_set_clip_rectangle(GTK_WIDGET(sheet)->style->white_gc, &allocation);      gdk_gc_set_clip_rectangle(GTK_WIDGET(sheet)->style->white_gc, &allocation);
6501    
6502    /*
6503      y += DEFAULT_ROW_HEIGHT(GTK_WIDGET(sheet))/2 + sheet->button->style->ythickness + DEFAULT_FONT_DESCENT(GTK_WIDGET(sheet));      y += DEFAULT_ROW_HEIGHT(GTK_WIDGET(sheet))/2 + sheet->button->style->ythickness + DEFAULT_FONT_DESCENT(GTK_WIDGET(sheet));
6504    */
6505        y += 2*sheet->button->style->ythickness;
6506    
6507      if(button->label && strlen(button->label)>0){      if(button->label && strlen(button->label)>0){
6508               PangoLayout *layout = NULL;
6509               gint real_x = x, real_y = y;
6510    
6511             words=button->label;             words=button->label;
6512             line = g_new(gchar, 1);             line = g_new(gchar, 1);
# Line 6497  gtk_sheet_button_draw (GtkSheet *sheet, Line 6522  gtk_sheet_button_draw (GtkSheet *sheet,
6522               if(*words == '\n' || *(words+1) == '\0'){               if(*words == '\n' || *(words+1) == '\0'){
6523                 text_width = STRING_WIDTH(GTK_WIDGET(sheet), GTK_WIDGET(sheet)->style->font_desc, line);                 text_width = STRING_WIDTH(GTK_WIDGET(sheet), GTK_WIDGET(sheet)->style->font_desc, line);
6524    
6525                   layout = gtk_widget_create_pango_layout (GTK_WIDGET(sheet), line);
6526                 switch(button->justification){                 switch(button->justification){
6527                   case GTK_JUSTIFY_LEFT:                   case GTK_JUSTIFY_LEFT:
6528                     gtk_paint_string (GTK_WIDGET(sheet)->style, window, state,                     real_x = x + CELLOFFSET;
6529                                       &allocation, GTK_WIDGET(sheet), "label",                     align = rtl ? PANGO_ALIGN_RIGHT : PANGO_ALIGN_LEFT;
                                      x + CELLOFFSET, y,  
                                      line);  
6530                     break;                     break;
6531                   case GTK_JUSTIFY_RIGHT:                   case GTK_JUSTIFY_RIGHT:
6532                     gtk_paint_string (GTK_WIDGET(sheet)->style, window, state,                     real_x = x + width - text_width - CELLOFFSET;
6533                                       &allocation, GTK_WIDGET(sheet), "label",                     align = rtl ? PANGO_ALIGN_LEFT : PANGO_ALIGN_RIGHT;
                                      x + width - text_width - CELLOFFSET, y,  
                                      line);  
6534                     break;                     break;
6535                   case GTK_JUSTIFY_CENTER:                   case GTK_JUSTIFY_CENTER:
6536                   default:                   default:
6537                     gtk_paint_string (GTK_WIDGET(sheet)->style, window, state,                     real_x = x + (width - text_width)/2;
6538                                       &allocation, GTK_WIDGET(sheet), "label",                     align = rtl ? PANGO_ALIGN_RIGHT : PANGO_ALIGN_LEFT;
6539                                       x + (width - text_width) /2, y,                     pango_layout_set_justify (layout, TRUE);
                                      line);  
6540                 }                 }
6541                   pango_layout_set_alignment (layout, align);
6542                   gtk_paint_layout (GTK_WIDGET(sheet)->style,
6543                                     window,
6544                                     state,
6545                                     FALSE,
6546                                     &allocation,
6547                                     GTK_WIDGET(sheet),
6548                                     "label",
6549                                     real_x, real_y,
6550                                     layout);
6551                   g_object_unref(G_OBJECT(layout));
6552    
6553                 y += text_height + 2;                 real_y += text_height + 2;
6554    
6555                 g_free(line);                 g_free(line);
6556                 line = g_new(gchar, 1);                 line = g_new(gchar, 1);
# Line 6528  gtk_sheet_button_draw (GtkSheet *sheet, Line 6560  gtk_sheet_button_draw (GtkSheet *sheet,
6560             }             }
6561             g_free(line);             g_free(line);
6562      }else{      }else{
6563               PangoLayout *layout = NULL;
6564               gint real_x = x, real_y = y;
6565    
6566             sprintf(label,"%d",index);             sprintf(label,"%d",index);
6567             text_width = STRING_WIDTH(GTK_WIDGET(sheet), GTK_WIDGET(sheet)->style->font_desc, label);             text_width = STRING_WIDTH(GTK_WIDGET(sheet), GTK_WIDGET(sheet)->style->font_desc, label);
6568    
6569               layout = gtk_widget_create_pango_layout (GTK_WIDGET(sheet), label);
6570             switch(button->justification){             switch(button->justification){
6571               case GTK_JUSTIFY_LEFT:               case GTK_JUSTIFY_LEFT:
6572                 gtk_paint_string (GTK_WIDGET(sheet)->style, window, state,                 real_x = x + CELLOFFSET;
6573                                   &allocation, GTK_WIDGET(sheet), "label",                 align = rtl ? PANGO_ALIGN_RIGHT : PANGO_ALIGN_LEFT;
                                  x + CELLOFFSET, y,  
                                  label);  
6574                 break;                 break;
6575               case GTK_JUSTIFY_RIGHT:               case GTK_JUSTIFY_RIGHT:
6576                 gtk_paint_string (GTK_WIDGET(sheet)->style, window, state,                 real_x = x + width - text_width - CELLOFFSET;
6577                                   &allocation, GTK_WIDGET(sheet), "label",                 align = rtl ? PANGO_ALIGN_LEFT : PANGO_ALIGN_RIGHT;
                                  x + width - text_width - CELLOFFSET, y,  
                                  label);  
6578                 break;                 break;
6579               case GTK_JUSTIFY_CENTER:               case GTK_JUSTIFY_CENTER:
6580               default:               default:
6581                 gtk_paint_string (GTK_WIDGET(sheet)->style, window, state,                 real_x = x + (width - text_width)/2;
6582                                   &allocation, GTK_WIDGET(sheet), "label",                 align = rtl ? PANGO_ALIGN_RIGHT : PANGO_ALIGN_LEFT;
6583                                   x + (width - text_width) /2, y,                 pango_layout_set_justify (layout, TRUE);
                                  label);  
6584             }             }
6585               pango_layout_set_alignment (layout, align);
6586               gtk_paint_layout (GTK_WIDGET(sheet)->style,
6587                                 window,
6588                                 state,
6589                                 FALSE,
6590                                 &allocation,
6591                                 GTK_WIDGET(sheet),
6592                                 "label",
6593                                 real_x, real_y,
6594                                 layout);
6595               g_object_unref(G_OBJECT(layout));
6596      }      }
6597    
6598      gdk_gc_set_clip_rectangle(GTK_WIDGET(sheet)->style->fg_gc[button->state],      gdk_gc_set_clip_rectangle(GTK_WIDGET(sheet)->style->fg_gc[button->state],
# Line 6559  gtk_sheet_button_draw (GtkSheet *sheet, Line 6600  gtk_sheet_button_draw (GtkSheet *sheet,
6600      gdk_gc_set_clip_rectangle(GTK_WIDGET(sheet)->style->white_gc, NULL);      gdk_gc_set_clip_rectangle(GTK_WIDGET(sheet)->style->white_gc, NULL);
6601    
6602    }    }
6603      
6604    if((child = button->child) && (child->widget)){    if((child = button->child) && (child->widget)){
6605        child->x = allocation.x;        child->x = allocation.x;
6606        child->y = allocation.y;        child->y = allocation.y;
6607    
6608        child->x += (width - child->widget->requisition.width) / 2;        child->x += (width - child->widget->requisition.width) / 2;
6609        child->y += (height - child->widget->requisition.height) / 2;        child->y += (height - child->widget->requisition.height) / 2;
6610        child->widget->allocation.width = child->widget->requisition.width;        allocation.x = child->x;
6611        child->widget->allocation.height = child->widget->requisition.height;        allocation.y = child->y;
6612          allocation.width = child->widget->requisition.width;
6613          allocation.height = child->widget->requisition.height;
6614    
6615        x = child->x;        x = child->x;
6616        y = child->y;        y = child->y;
6617    
6618        gtk_widget_set_state(child->widget, button->state);        gtk_widget_set_state(child->widget, button->state);
       if(GTK_WIDGET_NO_WINDOW(child->widget))  
         {  
            child->widget->allocation.x = 0;  
            child->widget->allocation.y = 0;  
         }  
6619    
6620        if(GTK_WIDGET_REALIZED(GTK_WIDGET(sheet)) &&        if(GTK_WIDGET_REALIZED(GTK_WIDGET(sheet)) &&
6621           GTK_WIDGET_MAPPED(child->widget))           GTK_WIDGET_MAPPED(child->widget))
6622              {              {
6623                gtk_widget_size_allocate(child->widget,                gtk_widget_size_allocate(child->widget,
6624                                         &child->widget->allocation);                                         &allocation);
6625                if(GTK_WIDGET_NO_WINDOW(child->widget) && child->window)                gtk_widget_queue_draw(child->widget);
                  {  
                     gdk_window_move_resize(child->window,  
                                            x, y,  
                                            child->widget->allocation.width,  
                                            child->widget->allocation.height);  
                     gtk_widget_draw(child->widget, NULL);  
                  }  
6626              }              }
   
6627    }    }
6628        
6629  }  }
# Line 6792  vadjustment_value_changed (GtkAdjustment Line 6822  vadjustment_value_changed (GtkAdjustment
6822               gtk_sheet_cell_clear(sheet,               gtk_sheet_cell_clear(sheet,
6823                                    sheet->active_cell.row,                                    sheet->active_cell.row,
6824                                    sheet->active_cell.col);                                    sheet->active_cell.col);
6825           gtk_widget_unmap(sheet->sheet_entry);
       if(sheet->sheet_entry_window)  
             gdk_window_hide(sheet->sheet_entry_window);  
       else  
             gdk_window_hide(sheet->sheet_entry->window);  
6826      }      }
6827    
6828    gtk_sheet_position_children(sheet);    gtk_sheet_position_children(sheet);
# Line 6902  hadjustment_value_changed (GtkAdjustment Line 6928  hadjustment_value_changed (GtkAdjustment
6928                                    sheet->active_cell.row,                                    sheet->active_cell.row,
6929                                    sheet->active_cell.col);                                    sheet->active_cell.col);
6930    
6931        if(sheet->sheet_entry_window)        gtk_widget_unmap(sheet->sheet_entry);
             gdk_window_hide(sheet->sheet_entry_window);  
       else  
             gdk_window_hide(sheet->sheet_entry->window);  
6932      }      }
6933    
6934    gtk_sheet_position_children(sheet);    gtk_sheet_position_children(sheet);
# Line 7297  gtk_sheet_delete_rows(GtkSheet *sheet, g Line 7320  gtk_sheet_delete_rows(GtkSheet *sheet, g
7320     {     {
7321       child = (GtkSheetChild *)children->data;       child = (GtkSheetChild *)children->data;
7322    
7323       if(child->attached_to_cell){       if(child->attached_to_cell &&
7324          if(child->row >= row && child->row < row+nrows){            child->row >= row && child->row < row+nrows){  
7325                gtk_container_remove(GTK_CONTAINER(sheet), child->widget);                gtk_container_remove(GTK_CONTAINER(sheet), child->widget);
7326                children = sheet->children;                children = sheet->children;
7327          }       } else
         else  
         {  
               if(child->row >= row) child->row -= nrows;  
               children = children->next;  
         }  
      }  
      else  
7328          children = children->next;          children = children->next;
7329     }     }
7330    
7331     children = sheet->children;
7332     while(children)
7333       {
7334         child = (GtkSheetChild *)children->data;
7335    
7336         if(child->attached_to_cell && child->row > row) child->row -= nrows;
7337         children = children->next;
7338       }
7339    
7340   if(!GTK_WIDGET_REALIZED(sheet)) return;   if(!GTK_WIDGET_REALIZED(sheet)) return;
7341    
# Line 7363  gtk_sheet_delete_columns(GtkSheet *sheet Line 7387  gtk_sheet_delete_columns(GtkSheet *sheet
7387     {     {
7388       child = (GtkSheetChild *)children->data;       child = (GtkSheetChild *)children->data;
7389    
7390       if(child->attached_to_cell){       if(child->attached_to_cell &&
7391          if(child->col >= col && child->col < col+ncols){            child->col >= col && child->col < col+ncols){  
7392                gtk_container_remove(GTK_CONTAINER(sheet), child->widget);                gtk_container_remove(GTK_CONTAINER(sheet), child->widget);
7393                children = sheet->children;                children = sheet->children;
7394          }       } else
         else  
         {  
               if(child->col >= col) child->col -= ncols;  
               children = children->next;  
         }  
      }  
      else  
7395          children = children->next;          children = children->next;
7396     }     }
7397    
7398     children = sheet->children;
7399     while(children)
7400       {
7401         child = (GtkSheetChild *)children->data;
7402    
7403         if(child->attached_to_cell && child->col > col) child->col -= ncols;
7404         children = children->next;
7405       }
7406    
7407   if(!GTK_WIDGET_REALIZED(sheet)) return;   if(!GTK_WIDGET_REALIZED(sheet)) return;
7408    
# Line 8135  gtk_sheet_put(GtkSheet *sheet, GtkWidget Line 8160  gtk_sheet_put(GtkSheet *sheet, GtkWidget
8160    child_info->widget = child;    child_info->widget = child;
8161    child_info->x = x;      child_info->x = x;  
8162    child_info->y = y;    child_info->y = y;
   child_info->window = NULL;    
8163    child_info->attached_to_cell = FALSE;    child_info->attached_to_cell = FALSE;
8164    child_info->floating = TRUE;    child_info->floating = TRUE;
8165    child_info->xpadding = child_info->ypadding = 0;    child_info->xpadding = child_info->ypadding = 0;
# Line 8152  gtk_sheet_put(GtkSheet *sheet, GtkWidget Line 8176  gtk_sheet_put(GtkSheet *sheet, GtkWidget
8176    if (GTK_WIDGET_VISIBLE(GTK_WIDGET(sheet)))    if (GTK_WIDGET_VISIBLE(GTK_WIDGET(sheet)))
8177      {      {
8178         if(GTK_WIDGET_REALIZED(GTK_WIDGET(sheet)) &&         if(GTK_WIDGET_REALIZED(GTK_WIDGET(sheet)) &&
8179            !GTK_WIDGET_REALIZED(child))            (!GTK_WIDGET_REALIZED(child) || GTK_WIDGET_NO_WINDOW(child)))
8180          gtk_sheet_realize_child(sheet, child_info);          gtk_sheet_realize_child(sheet, child_info);
8181    
8182         if(GTK_WIDGET_MAPPED(GTK_WIDGET(sheet)) &&         if(GTK_WIDGET_MAPPED(GTK_WIDGET(sheet)) &&
# Line 8247  gtk_sheet_attach        (GtkSheet *sheet Line 8271  gtk_sheet_attach        (GtkSheet *sheet
8271    child->x = area.x + child->xpadding;    child->x = area.x + child->xpadding;
8272    child->y = area.y + child->ypadding;    child->y = area.y + child->ypadding;
8273    
   gtk_widget_set_parent (widget, GTK_WIDGET(sheet));  
   
8274    if (GTK_WIDGET_VISIBLE(GTK_WIDGET(sheet)))    if (GTK_WIDGET_VISIBLE(GTK_WIDGET(sheet)))
8275      {      {
8276         if(GTK_WIDGET_REALIZED(GTK_WIDGET(sheet)) &&         if(GTK_WIDGET_REALIZED(GTK_WIDGET(sheet)) &&
8277            !GTK_WIDGET_REALIZED(widget))            (!GTK_WIDGET_REALIZED(widget) || GTK_WIDGET_NO_WINDOW(widget)))
8278          gtk_sheet_realize_child(sheet, child);          gtk_sheet_realize_child(sheet, child);
8279    
8280         if(GTK_WIDGET_MAPPED(GTK_WIDGET(sheet)) &&         if(GTK_WIDGET_MAPPED(GTK_WIDGET(sheet)) &&
# Line 8290  gtk_sheet_button_attach                (GtkSheet *shee Line 8312  gtk_sheet_button_attach                (GtkSheet *shee
8312    child->widget = widget;    child->widget = widget;
8313    child->x = 0;      child->x = 0;  
8314    child->y = 0;      child->y = 0;  
   child->window = NULL;    
8315    child->attached_to_cell = TRUE;    child->attached_to_cell = TRUE;
8316    child->floating = FALSE;    child->floating = FALSE;
8317    child->row = row;    child->row = row;
# Line 8311  gtk_sheet_button_attach                (GtkSheet *shee Line 8332  gtk_sheet_button_attach                (GtkSheet *shee
8332    
8333    sheet->children = g_list_append(sheet->children, child);    sheet->children = g_list_append(sheet->children, child);
8334    
   gtk_widget_set_parent (widget, GTK_WIDGET(sheet));  
8335    gtk_sheet_button_size_request(sheet, button, &button_requisition);    gtk_sheet_button_size_request(sheet, button, &button_requisition);
8336    
8337    if(row == -1){    if(row == -1){
# Line 8331  gtk_sheet_button_attach                (GtkSheet *shee Line 8351  gtk_sheet_button_attach                (GtkSheet *shee
8351    if (GTK_WIDGET_VISIBLE(GTK_WIDGET(sheet)))    if (GTK_WIDGET_VISIBLE(GTK_WIDGET(sheet)))
8352      {      {
8353         if(GTK_WIDGET_REALIZED(GTK_WIDGET(sheet)) &&         if(GTK_WIDGET_REALIZED(GTK_WIDGET(sheet)) &&
8354            !GTK_WIDGET_REALIZED(widget))            (!GTK_WIDGET_REALIZED(widget) || GTK_WIDGET_NO_WINDOW(widget)))
8355          gtk_sheet_realize_child(sheet, child);          gtk_sheet_realize_child(sheet, child);
8356    
8357         if(GTK_WIDGET_MAPPED(GTK_WIDGET(sheet)) &&         if(GTK_WIDGET_MAPPED(GTK_WIDGET(sheet)) &&
# Line 8585  gtk_sheet_position_child(GtkSheet *sheet Line 8605  gtk_sheet_position_child(GtkSheet *sheet
8605        child_allocation.height = child_requisition.height;        child_allocation.height = child_requisition.height;
8606     }     }
8607    
8608       gtk_widget_size_allocate(child->widget, &child_allocation);
8609     if(GTK_WIDGET_NO_WINDOW(child->widget))     gtk_widget_queue_draw(child->widget);
      {  
         child_allocation.x = 0;  
         child_allocation.y = 0;  
      }  
   
    if(GTK_WIDGET_REALIZED(GTK_WIDGET(sheet)) &&  
       GTK_WIDGET_MAPPED(child->widget))  
          {  
               gtk_widget_size_allocate(child->widget,  
                                        &child_allocation);  
               if(GTK_WIDGET_NO_WINDOW(child->widget) && child->window)  
                  {  
                     gdk_window_move_resize(child->window,  
                                            x, y,  
                                            child_allocation.width,  
                                            child_allocation.height);  
                     gtk_widget_draw(child->widget, NULL);  
                  }  
          }  
   
8610  }  }
8611    
8612  static void  static void
# Line 8623  gtk_sheet_forall (GtkContainer *containe Line 8623  gtk_sheet_forall (GtkContainer *containe
8623    g_return_if_fail (callback != NULL);    g_return_if_fail (callback != NULL);
8624    
8625    sheet = GTK_SHEET (container);    sheet = GTK_SHEET (container);
   
8626    children = sheet->children;    children = sheet->children;
8627    while (children)    while (children)
8628      {      {
# Line 8634  gtk_sheet_forall (GtkContainer *containe Line 8633  gtk_sheet_forall (GtkContainer *containe
8633      }      }
8634    if(sheet->button)    if(sheet->button)
8635       (* callback) (sheet->button, callback_data);       (* callback) (sheet->button, callback_data);
8636      if(sheet->sheet_entry)
8637         (* callback) (sheet->sheet_entry, callback_data);
8638  }  }
8639    
8640    
# Line 8703  gtk_sheet_remove (GtkContainer *containe Line 8704  gtk_sheet_remove (GtkContainer *containe
8704       if(child->col == -1)       if(child->col == -1)
8705          sheet->column[child->row].button.child = NULL;          sheet->column[child->row].button.child = NULL;
8706    
      if(child->window) {  
         gdk_window_hide(child->window);  
         gdk_window_unref(child->window);  
      }  
   
8707       gtk_widget_unparent (widget);       gtk_widget_unparent (widget);
8708       child->widget = NULL;       child->widget = NULL;
8709    
8710       sheet->children = g_list_remove_link (sheet->children, children);       sheet->children = g_list_remove_link (sheet->children, children);
8711       g_list_free_1 (children);       g_list_free_1 (children);
8712         g_free(child);
8713     }     }
8714    
8715  }  }
# Line 8720  gtk_sheet_remove (GtkContainer *containe Line 8717  gtk_sheet_remove (GtkContainer *containe
8717  static void  static void
8718  gtk_sheet_realize_child(GtkSheet *sheet, GtkSheetChild *child)  gtk_sheet_realize_child(GtkSheet *sheet, GtkSheetChild *child)
8719  {  {
   gint attributes_mask;  
8720    GtkWidget *widget;    GtkWidget *widget;
8721    
8722    widget = GTK_WIDGET(sheet);    widget = GTK_WIDGET(sheet);
8723    
8724    if (GTK_WIDGET_NO_WINDOW (child->widget))    if(GTK_WIDGET_REALIZED(widget)){
8725      {      if(child->row == -1)
8726        GdkWindowAttr attributes;        gtk_widget_set_parent_window(child->widget, sheet->column_title_window);
8727              else if(child->col == -1)
8728        gint x = child->x - sheet->hoffset;        gtk_widget_set_parent_window(child->widget, sheet->row_title_window);
8729        gint y = child->y - sheet->voffset;      else
   
       gtk_widget_size_request(child->widget, NULL);  
   
       attributes.window_type = GDK_WINDOW_CHILD;  
       attributes.x = x;  
       attributes.y = y;  
       attributes.width = child->widget->requisition.width;  
       attributes.height = child->widget->requisition.height;  
       attributes.wclass = GDK_INPUT_OUTPUT;  
       attributes.visual = gtk_widget_get_visual (widget);  
       attributes.colormap = gtk_widget_get_colormap (widget);  
       attributes.event_mask = GDK_EXPOSURE_MASK;  
   
       attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;  
   
       if(child->row == -1)  
         child->window =  gdk_window_new (sheet->column_title_window,  
                                          &attributes, attributes_mask);  
       else if(child->col == -1)  
         child->window =  gdk_window_new (sheet->row_title_window,  
                                          &attributes, attributes_mask);  
       else  
         child->window =  gdk_window_new (widget->window,  
                                          &attributes, attributes_mask);  
   
       if(GTK_IS_PIXMAP(child->widget)){  
             gdk_window_shape_combine_mask(child->window,  
                                           GTK_PIXMAP(child->widget)->mask,  
                                           0, 0);  
       }  
   
       gdk_window_set_user_data (child->window, widget);  
   
       if (child->window)  
         gtk_style_set_background (widget->style,  
                                   child->window,  
                                   GTK_STATE_NORMAL);  
   
       gtk_widget_set_parent_window(child->widget, child->window);  
       gdk_window_show(child->window);  
     }  
   else  
8730        gtk_widget_set_parent_window(child->widget, sheet->sheet_window);        gtk_widget_set_parent_window(child->widget, sheet->sheet_window);
8731      }
8732    
8733      gtk_widget_realize(child->widget);    gtk_widget_set_parent(child->widget, widget);
8734  }  }
8735    
8736    
# Line 8811  gtk_sheet_child_hide(GtkSheetChild *chil Line 8766  gtk_sheet_child_hide(GtkSheetChild *chil
8766  {  {
8767    g_return_if_fail(child != NULL);    g_return_if_fail(child != NULL);
8768    gtk_widget_hide(child->widget);    gtk_widget_hide(child->widget);
   if(child->window)    
       gdk_window_hide(child->window);  
8769  }  }
8770    
8771  static void  static void
# Line 8821  gtk_sheet_child_show(GtkSheetChild *chil Line 8774  gtk_sheet_child_show(GtkSheetChild *chil
8774    g_return_if_fail(child != NULL);    g_return_if_fail(child != NULL);
8775    
8776    gtk_widget_show(child->widget);    gtk_widget_show(child->widget);
   if(child->window)    
       gdk_window_show(child->window);  
8777  }  }

Legend:
Removed from v.1.1.1.1  
changed lines
  Added in v.1.2

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26