Fixed problem when double clicking on column header
[pspp-builds.git] / lib / gtksheet / gtksheet.c
index b41840806430519c65f22524211ca32c0d2469b8..010778c7eb2cf5d65d947f0c896d54355cdd2a91 100644 (file)
@@ -421,7 +421,7 @@ static void gtk_sheet_size_allocate                  (GtkWidget *widget,
 /* Sheet queries */
 
 static gboolean gtk_sheet_range_isvisible (const GtkSheet *sheet,
-                                          GtkSheetRange range);
+                                          const GtkSheetRange *range);
 static gboolean gtk_sheet_cell_isvisible  (GtkSheet *sheet,
                                           gint row, gint column);
 /* Drawing Routines */
@@ -455,11 +455,11 @@ static void gtk_sheet_draw_border                  (GtkSheet *sheet,
 
 static void gtk_sheet_entry_changed             (GtkWidget *widget,
                                                  gpointer data);
-static void gtk_sheet_hide_active_cell          (GtkSheet *sheet);
+static void gtk_sheet_hide_entry_widget                 (GtkSheet *sheet);
 static void change_active_cell          (GtkSheet *sheet,
                                          gint row, gint col);
 static void gtk_sheet_draw_active_cell          (GtkSheet *sheet);
-static void gtk_sheet_show_active_cell          (GtkSheet *sheet);
+static void gtk_sheet_show_entry_widget                 (GtkSheet *sheet);
 static gboolean gtk_sheet_click_cell            (GtkSheet *sheet,
                                                  gint row,
                                                  gint column);
@@ -1268,7 +1268,7 @@ gtk_sheet_change_entry (GtkSheet *sheet, GtkType entry_type)
   state = sheet->state;
 
   if (sheet->state == GTK_SHEET_NORMAL)
-    gtk_sheet_hide_active_cell (sheet);
+    gtk_sheet_hide_entry_widget (sheet);
 
   sheet->entry_type = entry_type;
 
@@ -1276,7 +1276,7 @@ gtk_sheet_change_entry (GtkSheet *sheet, GtkType entry_type)
 
   if (state == GTK_SHEET_NORMAL)
     {
-      gtk_sheet_show_active_cell (sheet);
+      gtk_sheet_show_entry_widget (sheet);
     }
 
 }
@@ -1537,32 +1537,32 @@ gtk_sheet_select_column (GtkSheet *sheet, gint column)
 
 static gboolean
 gtk_sheet_range_isvisible (const GtkSheet *sheet,
-                          GtkSheetRange range)
+                          const GtkSheetRange *range)
 {
   g_return_val_if_fail (sheet != NULL, FALSE);
 
-  if (range.row0 < 0 || range.row0 >= psppire_axis_unit_count (sheet->vaxis))
+  if (range->row0 < 0 || range->row0 >= psppire_axis_unit_count (sheet->vaxis))
     return FALSE;
 
-  if (range.rowi < 0 || range.rowi >= psppire_axis_unit_count (sheet->vaxis))
+  if (range->rowi < 0 || range->rowi >= psppire_axis_unit_count (sheet->vaxis))
     return FALSE;
 
-  if (range.col0 < 0 || range.col0 >= psppire_axis_unit_count (sheet->haxis))
+  if (range->col0 < 0 || range->col0 >= psppire_axis_unit_count (sheet->haxis))
     return FALSE;
 
-  if (range.coli < 0 || range.coli >= psppire_axis_unit_count (sheet->haxis))
+  if (range->coli < 0 || range->coli >= psppire_axis_unit_count (sheet->haxis))
     return FALSE;
 
-  if (range.rowi < min_visible_row (sheet))
+  if (range->rowi < min_visible_row (sheet))
     return FALSE;
 
-  if (range.row0 > max_visible_row (sheet))
+  if (range->row0 > max_visible_row (sheet))
     return FALSE;
 
-  if (range.coli < min_visible_column (sheet))
+  if (range->coli < min_visible_column (sheet))
     return FALSE;
 
-  if (range.col0 > max_visible_column (sheet))
+  if (range->col0 > max_visible_column (sheet))
     return FALSE;
 
   return TRUE;
@@ -1579,7 +1579,7 @@ gtk_sheet_cell_isvisible (GtkSheet *sheet,
   range.rowi = row;
   range.coli = column;
 
-  return gtk_sheet_range_isvisible (sheet, range);
+  return gtk_sheet_range_isvisible (sheet, &range);
 }
 
 void
@@ -1709,6 +1709,8 @@ gtk_sheet_style_set (GtkWidget *widget,
 
 }
 
+#define BORDER_WIDTH 2
+
 static void
 gtk_sheet_realize (GtkWidget *widget)
 {
@@ -1717,7 +1719,7 @@ gtk_sheet_realize (GtkWidget *widget)
   const gint attributes_mask =
     GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP | GDK_WA_CURSOR;
 
-  GdkGCValues values, auxvalues;
+  GdkGCValues values;
   GdkColormap *colormap;
   GdkDisplay *display;
 
@@ -1814,12 +1816,10 @@ gtk_sheet_realize (GtkWidget *widget)
   sheet->fg_gc = gdk_gc_new (widget->window);
   sheet->bg_gc = gdk_gc_new (widget->window);
 
-  gdk_gc_get_values (sheet->fg_gc, &auxvalues);
-
   values.foreground = widget->style->white;
   values.function = GDK_INVERT;
   values.subwindow_mode = GDK_INCLUDE_INFERIORS;
-  values.line_width = 3;
+  values.line_width = BORDER_WIDTH;
 
   sheet->xor_gc = gdk_gc_new_with_values (widget->window,
                                          &values,
@@ -2132,10 +2132,11 @@ gtk_sheet_range_draw (GtkSheet *sheet, const GtkSheetRange *range)
       drawing_range.rowi = MIN (range->rowi, max_visible_row (sheet));
       drawing_range.coli = MIN (range->coli, max_visible_column (sheet));
 
-
       rectangle_from_range (sheet, &drawing_range, &area);
     }
 
+  g_return_if_fail (drawing_range.rowi >= drawing_range.row0);
+  g_return_if_fail (drawing_range.coli >= drawing_range.col0);
 
   gdk_draw_rectangle (sheet->sheet_window,
                      GTK_WIDGET (sheet)->style->white_gc,
@@ -2150,7 +2151,7 @@ gtk_sheet_range_draw (GtkSheet *sheet, const GtkSheetRange *range)
       }
 
   if (sheet->state != GTK_SHEET_NORMAL &&
-      gtk_sheet_range_isvisible (sheet, sheet->range))
+      gtk_sheet_range_isvisible (sheet, &sheet->range))
     gtk_sheet_range_draw_selection (sheet, drawing_range);
 
   if (sheet->state == GTK_STATE_NORMAL &&
@@ -2158,7 +2159,7 @@ gtk_sheet_range_draw (GtkSheet *sheet, const GtkSheetRange *range)
       sheet->active_cell.row <= drawing_range.rowi &&
       sheet->active_cell.col >= drawing_range.col0 &&
       sheet->active_cell.col <= drawing_range.coli)
-    gtk_sheet_show_active_cell (sheet);
+    gtk_sheet_show_entry_widget (sheet);
 }
 
 static void
@@ -2172,7 +2173,7 @@ gtk_sheet_range_draw_selection (GtkSheet *sheet, GtkSheetRange range)
       range.row0 > sheet->range.rowi || range.rowi < sheet->range.row0)
     return;
 
-  if (!gtk_sheet_range_isvisible (sheet, range)) return;
+  if (!gtk_sheet_range_isvisible (sheet, &range)) return;
   if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return;
 
   aux = range;
@@ -2465,7 +2466,7 @@ gtk_sheet_set_active_cell (GtkSheet *sheet, gint row, gint col)
 
   if ( row == -1 || col == -1)
     {
-      gtk_sheet_hide_active_cell (sheet);
+      gtk_sheet_hide_entry_widget (sheet);
       return;
     }
 
@@ -2522,10 +2523,8 @@ gtk_sheet_entry_changed (GtkWidget *widget, gpointer data)
 
 
 static void
-gtk_sheet_hide_active_cell (GtkSheet *sheet)
+gtk_sheet_hide_entry_widget (GtkSheet *sheet)
 {
-  GdkRectangle area;
-
   if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)))
     return;
 
@@ -2535,19 +2534,6 @@ gtk_sheet_hide_active_cell (GtkSheet *sheet)
   gtk_widget_hide (sheet->entry_widget);
   gtk_widget_unmap (sheet->entry_widget);
 
-  rectangle_from_cell (sheet,
-                      sheet->active_cell.row, sheet->active_cell.col,
-                      &area);
-
-  gdk_draw_rectangle (sheet->sheet_window,
-                     GTK_WIDGET (sheet)->style->white_gc,
-                     TRUE,
-                     area.x, area.y,
-                     area.width, area.height);
-
-  gtk_sheet_cell_draw (sheet, sheet->active_cell.row,
-                              sheet->active_cell.col);
-
   GTK_WIDGET_UNSET_FLAGS (GTK_WIDGET (sheet->entry_widget), GTK_VISIBLE);
 }
 
@@ -2572,11 +2558,30 @@ change_active_cell (GtkSheet *sheet, gint row, gint col)
       gtk_sheet_real_unselect_range (sheet, NULL);
     }
 
+
   g_signal_handler_block   (sheet->entry_widget, sheet->entry_handler_id);
 
   old_row = sheet->active_cell.row;
   old_col = sheet->active_cell.col;
 
+  {
+    /* Redraw the neighbourhood of the old active cell */
+    GtkSheetRange r;
+    r.col0 = old_col - 1;
+    r.coli = old_col + 1;
+    r.row0 = old_row - 1;
+    r.rowi = old_row + 1;
+
+    maximize_int (&r.row0, 0);
+    maximize_int (&r.col0, 0);
+    minimize_int (&r.rowi, psppire_axis_unit_count (sheet->vaxis) - 1);
+    minimize_int (&r.coli, psppire_axis_unit_count (sheet->haxis) - 1);
+
+
+    if (  gtk_sheet_range_isvisible (sheet, &r))
+      gtk_sheet_range_draw (sheet, &r);
+  }
+
   sheet->range.row0 = row;
   sheet->range.col0 = col;
   sheet->range.rowi = row;
@@ -2588,7 +2593,8 @@ change_active_cell (GtkSheet *sheet, gint row, gint col)
 
   GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IN_SELECTION);
 
-  gtk_sheet_show_active_cell (sheet);
+  gtk_sheet_draw_active_cell (sheet);
+  gtk_sheet_show_entry_widget (sheet);
 
 
   g_signal_emit (sheet, sheet_signals [ACTIVATE], 0,
@@ -2599,7 +2605,7 @@ change_active_cell (GtkSheet *sheet, gint row, gint col)
 }
 
 static void
-gtk_sheet_show_active_cell (GtkSheet *sheet)
+gtk_sheet_show_entry_widget (GtkSheet *sheet)
 {
   GtkEntry *sheet_entry;
   GtkSheetCellAttr attributes;
@@ -2631,9 +2637,6 @@ gtk_sheet_show_active_cell (GtkSheet *sheet)
   if ( ! text )
     text = g_strdup ("");
 
-  gtk_entry_set_visibility (sheet_entry, attributes.is_visible);
-
-
   if ( GTK_IS_ENTRY (sheet_entry))
     {
       const gchar *old_text = gtk_entry_get_text (GTK_ENTRY (sheet_entry));
@@ -2934,6 +2937,8 @@ gtk_sheet_new_selection (GtkSheet *sheet, GtkSheetRange *range)
   *range = new_range;
 }
 
+
+
 static void
 gtk_sheet_draw_border (GtkSheet *sheet, GtkSheetRange new_range)
 {
@@ -2944,10 +2949,10 @@ gtk_sheet_draw_border (GtkSheet *sheet, GtkSheetRange new_range)
   gdk_draw_rectangle (sheet->sheet_window,
                      sheet->xor_gc,
                      FALSE,
-                     area.x + 1,
-                     area.y + 1,
-                     area.width - 2,
-                     area.height - 2);
+                     area.x,
+                     area.y,
+                     area.width + 1,
+                     area.height + 1);
 }
 
 
@@ -3051,11 +3056,6 @@ gtk_sheet_real_unselect_range (GtkSheet *sheet,
   g_signal_emit (sheet, sheet_signals[SELECT_COLUMN], 0, -1);
   g_signal_emit (sheet, sheet_signals[SELECT_ROW], 0, -1);
 
-#if 0
-  if (gtk_sheet_range_isvisible (sheet, *range))
-    gtk_sheet_draw_backing_pixmap (sheet, *range);
-#endif
-
   sheet->range.row0 = -1;
   sheet->range.rowi = -1;
   sheet->range.col0 = -1;
@@ -3119,19 +3119,20 @@ gtk_sheet_expose (GtkWidget *widget,
                        sheet->hadjustment->value);
   range.coli++;
 
+
   if (event->window == sheet->sheet_window)
     {
       gtk_sheet_range_draw (sheet, &range);
 
       if (sheet->state != GTK_SHEET_NORMAL)
        {
-         if (gtk_sheet_range_isvisible (sheet, sheet->range))
+         if (gtk_sheet_range_isvisible (sheet, &sheet->range))
            gtk_sheet_range_draw (sheet, &sheet->range);
 
          if (GTK_SHEET_IN_RESIZE (sheet) || GTK_SHEET_IN_DRAG (sheet))
            gtk_sheet_range_draw (sheet, &sheet->drag_range);
 
-         if (gtk_sheet_range_isvisible (sheet, sheet->range))
+         if (gtk_sheet_range_isvisible (sheet, &sheet->range))
            gtk_sheet_range_draw_selection (sheet, sheet->range);
          if (GTK_SHEET_IN_RESIZE (sheet) || GTK_SHEET_IN_DRAG (sheet))
            draw_xor_rectangle (sheet, sheet->drag_range);
@@ -3144,9 +3145,6 @@ gtk_sheet_expose (GtkWidget *widget,
        }
     }
 
-  if (sheet->state != GTK_SHEET_NORMAL && GTK_SHEET_IN_SELECTION (sheet))
-    gtk_widget_grab_focus (GTK_WIDGET (sheet));
-
   (* GTK_WIDGET_CLASS (parent_class)->expose_event) (widget, event);
 
   return FALSE;
@@ -4343,14 +4341,6 @@ gtk_sheet_size_allocate (GtkWidget *widget,
                            allocation->width - 2 * border_width,
                            allocation->height - 2 * border_width);
 
-  /* use internal allocation structure for all the math
-   * because it's easier than always subtracting the container
-   * border width */
-  sheet->internal_allocation.x = 0;
-  sheet->internal_allocation.y = 0;
-  sheet->internal_allocation.width = allocation->width - 2 * border_width;
-  sheet->internal_allocation.height = allocation->height - 2 * border_width;
-
   sheet_allocation.x = 0;
   sheet_allocation.y = 0;
   sheet_allocation.width = allocation->width - 2 * border_width;
@@ -4545,6 +4535,12 @@ gtk_sheet_size_allocate_entry (GtkSheet *sheet)
   rectangle_from_cell (sheet, sheet->active_cell.row,
                       sheet->active_cell.col, &entry_alloc);
 
+  entry_alloc.width -= BORDER_WIDTH;
+  entry_alloc.height -= BORDER_WIDTH;
+  entry_alloc.x += BORDER_WIDTH / 2;
+  entry_alloc.y += BORDER_WIDTH / 2;
+
+
   gtk_widget_set_size_request (sheet->entry_widget, entry_alloc.width,
                               entry_alloc.height);
   gtk_widget_size_allocate (sheet->entry_widget, &entry_alloc);
@@ -4564,6 +4560,13 @@ create_sheet_entry (GtkSheet *sheet)
 
   gtk_widget_size_request (sheet->entry_widget, NULL);
 
+  if ( GTK_IS_ENTRY (sheet->entry_widget))
+    {
+      g_object_set (sheet->entry_widget,
+                   "has-frame", FALSE,
+                   NULL);
+    }
+
   if (GTK_WIDGET_REALIZED (sheet))
     {
       gtk_widget_set_parent_window (sheet->entry_widget, sheet->sheet_window);
@@ -4739,7 +4742,7 @@ draw_button (GtkSheet *sheet, GdkWindow *window,
 static void
 draw_column_title_buttons_range (GtkSheet *sheet, gint first, gint last)
 {
-  GdkRegion *region;
+  GdkRectangle rect;
   gint col;
   if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return;
 
@@ -4748,10 +4751,18 @@ draw_column_title_buttons_range (GtkSheet *sheet, gint first, gint last)
   g_return_if_fail (first >= min_visible_column (sheet));
   g_return_if_fail (last <= max_visible_column (sheet));
 
-  region =
-    gdk_drawable_get_visible_region (GDK_DRAWABLE (sheet->column_title_window));
+  rect.y = 0;
+  rect.height = sheet->column_title_area.height;
+  rect.x = psppire_axis_pixel_start (sheet->haxis, first) + CELL_SPACING;
+  rect.width = psppire_axis_pixel_start (sheet->haxis, last) + CELL_SPACING
+    + psppire_axis_unit_size (sheet->haxis, last);
 
-  gdk_window_begin_paint_region (sheet->column_title_window, region);
+  rect.x -= sheet->hadjustment->value;
+
+  minimize_int (&rect.width, sheet->column_title_area.width);
+  maximize_int (&rect.x, 0);
+
+  gdk_window_begin_paint_rect (sheet->column_title_window, &rect);
 
   for (col = first ; col <= last ; ++col)
     {
@@ -4780,7 +4791,7 @@ draw_column_title_buttons_range (GtkSheet *sheet, gint first, gint last)
 static void
 draw_row_title_buttons_range (GtkSheet *sheet, gint first, gint last)
 {
-  GdkRegion *region;
+  GdkRectangle rect;
   gint row;
   if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return;
 
@@ -4789,13 +4800,18 @@ draw_row_title_buttons_range (GtkSheet *sheet, gint first, gint last)
   g_return_if_fail (first >= min_visible_row (sheet));
   g_return_if_fail (last <= max_visible_row (sheet));
 
+  rect.x = 0;
+  rect.width = sheet->row_title_area.width;
+  rect.y = psppire_axis_pixel_start (sheet->vaxis, first) + CELL_SPACING;
+  rect.height = psppire_axis_pixel_start (sheet->vaxis, last) + CELL_SPACING
+    + psppire_axis_unit_size (sheet->vaxis, last);
 
-  region =
-    gdk_drawable_get_visible_region (GDK_DRAWABLE (sheet->row_title_window));
-
-  gdk_window_begin_paint_region (sheet->row_title_window, region);
+  rect.y -= sheet->vadjustment->value;
 
+  minimize_int (&rect.height, sheet->row_title_area.height);
+  maximize_int (&rect.y, 0);
 
+  gdk_window_begin_paint_rect (sheet->row_title_window, &rect);
   for (row = first; row <= last; ++row)
     {
       GdkRectangle allocation;
@@ -4915,6 +4931,7 @@ vadjustment_value_changed (GtkAdjustment *adjustment,
   gtk_sheet_range_draw (sheet, NULL);
   draw_row_title_buttons (sheet);
   //  size_allocate_global_button (sheet);
+  gtk_sheet_draw_active_cell (sheet);
 
   gdk_window_end_paint (sheet->sheet_window);
 }
@@ -4943,6 +4960,8 @@ hadjustment_value_changed (GtkAdjustment *adjustment,
   draw_column_title_buttons (sheet);
   //  size_allocate_global_button (sheet);
 
+  gtk_sheet_draw_active_cell (sheet);
+
   gdk_window_end_paint (sheet->sheet_window);
 }
 
@@ -5195,8 +5214,6 @@ gtk_sheet_get_attributes (const GtkSheet *sheet, gint row, gint col,
   attr->font_desc = GTK_WIDGET (sheet)->style->font_desc;
 
   attr->is_editable = g_sheet_model_is_editable (sheet->model, row, col);
-  attr->is_visible = g_sheet_model_is_visible (sheet->model, row, col);
-
 
   colormap = gtk_widget_get_colormap (GTK_WIDGET (sheet));
   fg = g_sheet_model_get_foreground (sheet->model, row, col);
@@ -5357,7 +5374,7 @@ range_to_text (const GtkSheet *sheet)
   gint r, c;
   GString *string;
 
-  if ( !gtk_sheet_range_isvisible (sheet, sheet->range))
+  if ( !gtk_sheet_range_isvisible (sheet, &sheet->range))
     return NULL;
 
   string = g_string_sized_new (80);
@@ -5383,7 +5400,7 @@ range_to_html (const GtkSheet *sheet)
   gint r, c;
   GString *string;
 
-  if ( !gtk_sheet_range_isvisible (sheet, sheet->range))
+  if ( !gtk_sheet_range_isvisible (sheet, &sheet->range))
     return NULL;
 
   string = g_string_sized_new (480);
@@ -5474,7 +5491,7 @@ gtk_sheet_update_primary_selection (GtkSheet *sheet)
   clipboard = gtk_widget_get_clipboard (GTK_WIDGET (sheet),
                                        GDK_SELECTION_PRIMARY);
 
-  if (gtk_sheet_range_isvisible (sheet, sheet->range))
+  if (gtk_sheet_range_isvisible (sheet, &sheet->range))
     {
       if (!gtk_clipboard_set_with_owner (clipboard, targets,
                                         G_N_ELEMENTS (targets),