src/embeddable-grid.c

   1 /*
   2  * embeddable-grid.c: An Embeddable Grid part of Gnumeric
   3  *
   4  * Contains:
   5  *    1. EmbeddableGrid Gtk object implementation.
   6  *    2. CORBA server routines for GNOME::Gnumeric::Grid
   7  *    3. GridView Gtk object implementation
   8  *
   9  * Author:
  10  *  Miguel de Icaza (miguel@gnu.org)
  11  *
  12  */
  13 #include <config.h>
  14 #include <bonobo/bonobo-embeddable.h>
  15 #include <bonobo/bonobo-embeddable-factory.h>
  16 #include "idl/Gnumeric.h"
  17 #include "sheet.h"
  18 #include "workbook.h"
  19 #include "embeddable-grid.h"
  20 #include "sheet-private.h"
  21
  22 /*
  23  * Our vectors for providing methods
  24  */
  25 POA_GNOME_Gnumeric_Grid__epv embeddable_grid_epv;
  26 POA_GNOME_Gnumeric_Grid__vepv embeddable_grid_vepv;
  27
  28 static BonoboEmbeddableFactory *bonobo_embeddable_grid_factory;
  29
  30 static inline EmbeddableGrid *
  31 embeddable_grid_from_servant (PortableServer_Servant servant)
  32 {
  33         return EMBEDDABLE_GRID (bonobo_object_from_servant (servant));
  34 }
  35
  36 static GNOME_Gnumeric_Sheet
  37 Grid_get_sheet (PortableServer_Servant servant, CORBA_Environment *ev)
  38 {
  39         EmbeddableGrid *eg = embeddable_grid_from_servant (servant);
  40
  41         return CORBA_Object_duplicate (eg->sheet->private->corba_server, ev);
  42 }
  43
  44 void
  45 embeddable_grid_set_header_visibility (EmbeddableGrid *eg,
  46                                        gboolean col_headers_visible,
  47                                        gboolean row_headers_visible)
  48 {
  49         GList *l;
  50
  51         g_return_if_fail (eg != NULL);
  52         g_return_if_fail (IS_EMBEDDABLE_GRID (eg));
  53
  54         for (l = eg->views; l; l = l->next){
  55                 GridView *grid_view = GRID_VIEW (l->data);
  56
  57                 sheet_view_set_header_visibility (
  58                         grid_view->sheet_view,
  59                         col_headers_visible,
  60                         row_headers_visible);
  61         }
  62 }
  63
  64 static void
  65 Grid_set_header_visibility (PortableServer_Servant servant,
  66                             const CORBA_boolean col_headers_visible,
  67                             const CORBA_boolean row_headers_visible,
  68                             CORBA_Environment *ev)
  69 {
  70         EmbeddableGrid *eg = embeddable_grid_from_servant (servant);
  71
  72         embeddable_grid_set_header_visibility (
  73                 eg, col_headers_visible, row_headers_visible);
  74 }
  75
  76 static void
  77 Grid_get_header_visibility (PortableServer_Servant servant,
  78                             CORBA_boolean *col_headers_visible,
  79                             CORBA_boolean *row_headers_visible,
  80                             CORBA_Environment *ev)
  81 {
  82         EmbeddableGrid *eg = embeddable_grid_from_servant (servant);
  83
  84         *col_headers_visible = eg->show_col_title;
  85         *row_headers_visible = eg->show_row_title;
  86 }
  87
  88 static BonoboView *
  89 embeddable_grid_view_factory (BonoboEmbeddable *embeddable,
  90                               const Bonobo_ViewFrame view_frame,
  91                               void *data)
  92 {
  93         BonoboView *view;
  94         EmbeddableGrid *eg = EMBEDDABLE_GRID (embeddable);
  95
  96         view = grid_view_new (eg);
  97
  98         return BONOBO_VIEW (view);
  99 }
 100
 101 static void
 102 init_embeddable_grid_corba_class (void)
 103 {
 104         /*
 105          * vepv
 106          */
 107         embeddable_grid_vepv.Bonobo_Unknown_epv = bonobo_object_get_epv ();
 108         embeddable_grid_vepv.Bonobo_Embeddable_epv = bonobo_embeddable_get_epv ();
 109         embeddable_grid_vepv.GNOME_Gnumeric_Grid_epv = &embeddable_grid_epv;
 110
 111         /*
 112          * epv
 113          */
 114         embeddable_grid_epv.get_sheet    = Grid_get_sheet;
 115         embeddable_grid_epv.set_header_visibility = Grid_set_header_visibility;
 116         embeddable_grid_epv.get_header_visibility = Grid_get_header_visibility;
 117 }
 118
 119 static void
 120 embeddable_grid_class_init (GtkObjectClass *Class)
 121 {
 122         init_embeddable_grid_corba_class ();
 123 }
 124
 125 static void
 126 embeddable_grid_init (GtkObject *object)
 127 {
 128 }
 129
 130 static CORBA_Object
 131 create_embeddable_grid (BonoboObject *object)
 132 {
 133         POA_GNOME_Gnumeric_Grid *servant;
 134         CORBA_Environment ev;
 135
 136         servant = (POA_GNOME_Gnumeric_Grid *) g_new0 (BonoboObjectServant, 1);
 137         servant->vepv = &embeddable_grid_vepv;
 138
 139         CORBA_exception_init (&ev);
 140         POA_GNOME_Gnumeric_Grid__init ((PortableServer_Servant) servant, &ev);
 141         if (ev._major != CORBA_NO_EXCEPTION){
 142                 g_free (servant);
 143                 CORBA_exception_free (&ev);
 144                 return CORBA_OBJECT_NIL;
 145         }
 146         CORBA_exception_free (&ev);
 147
 148         return bonobo_object_activate_servant (object, servant);
 149 }
 150
 151 static void
 152 embeddable_grid_init_anon (EmbeddableGrid *eg)
 153 {
 154         eg->workbook = gtk_type_new (WORKBOOK_TYPE);
 155         eg->sheet = sheet_new (eg->workbook, _("Embedded Sheet"));
 156         workbook_attach_sheet (eg->workbook, eg->sheet);
 157
 158         /*
 159          * Workaround code.  Sheets are born with a sheet_view,
 160          * but we do not need it at all.  So manually get rid of it.
 161          *
 162          * When sheet_new semantics change (see TODO), the code below
 163          * will warn about this condition to remove this piece of code
 164          */
 165         if (eg->sheet->sheet_views != NULL){
 166                 sheet_destroy_sheet_view (eg->sheet, SHEET_VIEW (eg->sheet->sheet_views->data));
 167         } else
 168                 g_error ("Remove workaround code here");
 169 }
 170
 171 EmbeddableGrid *
 172 embeddable_grid_new_anon (void)
 173 {
 174         EmbeddableGrid *embeddable_grid;
 175         GNOME_Gnumeric_Grid corba_embeddable_grid;
 176
 177         embeddable_grid = gtk_type_new (EMBEDDABLE_GRID_TYPE);
 178         embeddable_grid_init_anon (embeddable_grid);
 179         corba_embeddable_grid = create_embeddable_grid (BONOBO_OBJECT (embeddable_grid));
 180
 181         if (corba_embeddable_grid == CORBA_OBJECT_NIL){
 182                 gtk_object_destroy (GTK_OBJECT (embeddable_grid));
 183                 return NULL;
 184         }
 185
 186         bonobo_embeddable_construct (
 187                 BONOBO_EMBEDDABLE (embeddable_grid), corba_embeddable_grid,
 188                 embeddable_grid_view_factory, NULL);
 189
 190         return embeddable_grid;
 191 }
 192
 193 EmbeddableGrid *
 194 embeddable_grid_new (Workbook *wb, Sheet *sheet)
 195 {
 196         EmbeddableGrid *embeddable_grid;
 197         GNOME_Gnumeric_Grid corba_embeddable_grid;
 198
 199         embeddable_grid = gtk_type_new (EMBEDDABLE_GRID_TYPE);
 200         corba_embeddable_grid = create_embeddable_grid (BONOBO_OBJECT (embeddable_grid));
 201
 202         if (corba_embeddable_grid == CORBA_OBJECT_NIL){
 203                 gtk_object_destroy (GTK_OBJECT (embeddable_grid));
 204                 return NULL;
 205         }
 206
 207         embeddable_grid->workbook = wb;
 208         embeddable_grid->sheet = sheet;
 209
 210         /*
 211          * We keep a handle to the Workbook
 212          */
 213         bonobo_object_ref (BONOBO_OBJECT (embeddable_grid->workbook));
 214
 215         bonobo_embeddable_construct (
 216                 BONOBO_EMBEDDABLE (embeddable_grid), corba_embeddable_grid,
 217                 embeddable_grid_view_factory, NULL);
 218
 219         return embeddable_grid;
 220 }
 221
 222 static BonoboObject *
 223 embeddable_grid_factory (BonoboEmbeddableFactory *This, void *data)
 224 {
 225         EmbeddableGrid *embeddable_grid;
 226
 227         embeddable_grid = embeddable_grid_new_anon ();
 228
 229         if (embeddable_grid == NULL)
 230                 return NULL;
 231
 232         /*
 233          * Populate verb list here.
 234          */
 235
 236         return BONOBO_OBJECT (embeddable_grid);
 237 }
 238
 239 GtkType
 240 embeddable_grid_get_type (void)
 241 {
 242         static GtkType type = 0;
 243
 244         if (!type){
 245                 GtkTypeInfo info = {
 246                         "IDL:GNOME/Gnumeric/EmbeddableGrid:1.0",
 247                         sizeof (EmbeddableGrid),
 248                         sizeof (EmbeddableGridClass),
 249                         (GtkClassInitFunc) embeddable_grid_class_init,
 250                         (GtkObjectInitFunc) embeddable_grid_init,
 251                         NULL, /* reserved 1 */
 252                         NULL, /* reserved 2 */
 253                         (GtkClassInitFunc) NULL
 254                 };
 255                 type = gtk_type_unique (bonobo_embeddable_get_type (), &info);
 256         }
 257
 258         return type;
 259 }
 260
 261 void
 262 EmbeddableGridFactory_init (void)
 263 {
 264         bonobo_embeddable_grid_factory = bonobo_embeddable_factory_new (
 265                 "GNOME:Gnumeric:GridFactory:1.0",
 266                 embeddable_grid_factory, NULL);
 267 }
 268
 269 /*
 270  * GridView object
 271  */
 272 GtkType
 273 grid_view_get_type (void)
 274 {
 275         static GtkType type = 0;
 276
 277         if (!type){
 278                 GtkTypeInfo info = {
 279                         "EmbeddableGridView",
 280                         sizeof (GridView),
 281                         sizeof (GridViewClass),
 282                         NULL, NULL, NULL, NULL, NULL
 283                 };
 284                 type = gtk_type_unique (bonobo_view_get_type (), &info);
 285         }
 286
 287         return type;
 288 }
 289
 290 /*
 291  * Invoked by the "destroy" method.  We use this to keep the
 292  * EmbeddableGrid list of views up to date.
 293  */
 294 static void
 295 grid_view_destroy (GridView *grid_view)
 296 {
 297         EmbeddableGrid *eg = grid_view->embeddable;
 298
 299         eg->views = g_list_remove (eg->views, grid_view);
 300 }
 301
 302 /*
 303  * Invoked by the "view_activate" method.
 304  */
 305 static void
 306 grid_view_activate (GridView *grid_view)
 307 {
 308         /* FIXME: Do we need to do any more work here? */
 309         g_warning ("FIXME: plug is now private, can't set_focus");
 310 /*      gtk_signal_emit_by_name (GTK_OBJECT (grid_view->view.plug), "set_focus",
 311         grid_view->sheet_view->sheet_view);*/
 312
 313         bonobo_view_activate_notify (BONOBO_VIEW (grid_view), TRUE);
 314 }
 315
 316 BonoboView *
 317 grid_view_new (EmbeddableGrid *eg)
 318 {
 319         GridView *grid_view = NULL;
 320         Bonobo_View corba_grid_view;
 321
 322         grid_view = gtk_type_new (GRID_VIEW_TYPE);
 323
 324         corba_grid_view = bonobo_view_corba_object_create (BONOBO_OBJECT (grid_view));
 325         if (corba_grid_view == CORBA_OBJECT_NIL){
 326                 gtk_object_destroy (GTK_OBJECT (corba_grid_view));
 327                 return NULL;
 328         }
 329
 330         grid_view->embeddable = eg;
 331         grid_view->sheet_view = sheet_new_sheet_view (eg->sheet);
 332         gtk_widget_show (GTK_WIDGET (grid_view->sheet_view));
 333         g_warning ("FIXME: view_construct API changed");
 334 /*      bonobo_view_construct (
 335                 BONOBO_VIEW (grid_view), corba_grid_view,
 336                 GTK_WIDGET (grid_view->sheet_view));*/
 337
 338         eg->views = g_list_prepend (eg->views, grid_view);
 339
 340         gtk_signal_connect (GTK_OBJECT (grid_view), "destroy",
 341                             GTK_SIGNAL_FUNC (grid_view_destroy), NULL);
 342         gtk_signal_connect (GTK_OBJECT (grid_view), "activate",
 343                             GTK_SIGNAL_FUNC (grid_view_activate), NULL);
 344
 345         return BONOBO_VIEW (grid_view);
 346 }
 347
 348 void
 349 embeddable_grid_set_range (EmbeddableGrid *eg,
 350                            int start_col, int start_row,
 351                            int end_col, int end_row)
 352 {
 353         g_return_if_fail (eg != NULL);
 354         g_return_if_fail (IS_EMBEDDABLE_GRID (eg));
 355         g_return_if_fail (start_col <= end_col);
 356         g_return_if_fail (start_row <= end_row);
 357 }