src/corba-sheet.c

   1 /*
   2  * corba-sheet.c: The implementation of the Sheet CORBA interfaces
   3  * defined by Gnumeric
   4  *
   5  * Author:
   6  *    Miguel de Icaza (miguel@gnu.org)
   7  *
   8  * Notes:
   9  *
  10  * Strings representing ranges, when parsed ignore relative strings.
  11  */
  12 #include <config.h>
  13 #include <libgnorba/gnome-factory.h>
  14 #include <gnome.h>
  15 #include "sheet.h"
  16 #include "selection.h"
  17 #include "gnumeric.h"
  18 #include "idl/Gnumeric.h"
  19 #include "corba.h"
  20 #include "utils.h"
  21 #include "ranges.h"
  22 #include "selection.h"
  23 #include "commands.h"
  24 #include "command-context-corba.h"
  25 #include "cell.h"
  26 #include "colrow.h"
  27 #include "value.h"
  28 #include "sheet-private.h"
  29
  30 #define verify(cond)          if (!(cond)){ out_of_range (ev); return; }
  31 #define verify_val(cond,val)  if (!(cond)){ out_of_range (ev); return (val); }
  32 #define verify_col(c)         verify (((c) >= 0 && (c < SHEET_MAX_COLS)))
  33 #define verify_col_val(c,val) verify_val (((c) >= 0 && (c < SHEET_MAX_COLS)),val)
  34 #define verify_row(c)         verify (((c) >= 0 && (c < SHEET_MAX_ROWS)))
  35 #define verify_row_val(c,val) verify_val (((c) >= 0 && (c < SHEET_MAX_ROWS)),val)
  36 #define verify_region(c1,r1,c2,r2) \
  37         verify_col(c1); verify_col(c2); verify_row(r1); verify_row(r2); \
  38         verify(c1 <= c2);\
  39         verify (r1 <= r2);
  40
  41 #define verify_range(sheet,range,l) \
  42         if (!corba_range_parse (sheet,range,l)) \
  43         { out_of_range (ev); return; }
  44
  45 #define verify_range_val(sheet,range,l,val) \
  46         if (!corba_range_parse (sheet,range,l)) \
  47         { out_of_range (ev); return (val); }
  48
  49 static POA_GNOME_Gnumeric_Sheet__vepv gnome_gnumeric_sheet_vepv;
  50 static POA_GNOME_Gnumeric_Sheet__epv gnome_gnumeric_sheet_epv;
  51
  52 typedef struct {
  53         POA_GNOME_Gnumeric_Sheet servant;
  54         Sheet *sheet;
  55 } SheetServant;
  56
  57 static inline void
  58 out_of_range (CORBA_Environment *ev)
  59 {
  60         CORBA_exception_set (ev, CORBA_USER_EXCEPTION, ex_GNOME_Gnumeric_Sheet_OutOfRange, NULL);
  61 }
  62
  63 /*
  64  * Parses a list of ranges, returns a GList containing pointers to
  65  * Value structures.  Sets the return_list pointer to point to a
  66  * a list of those values.
  67  *
  68  * Returns TRUE on successfully parsing the string, FALSE otherwise
  69  */
  70 static gboolean
  71 corba_range_parse (Sheet *sheet, const char *range_spec, GSList **return_list)
  72 {
  73         GSList *list;
  74
  75         list = range_list_parse (sheet, range_spec, TRUE);
  76         if (list) {
  77                 *return_list = list;
  78                 return TRUE;
  79         } else {
  80                 *return_list = NULL;
  81                 return FALSE;
  82         }
  83 }
  84
  85 static inline Sheet *
  86 sheet_from_servant (PortableServer_Servant servant)
  87 {
  88         SheetServant *ss = (SheetServant *) servant;
  89
  90         return ss->sheet;
  91 }
  92
  93 static void
  94 Sheet_cursor_set (PortableServer_Servant servant,
  95                   const CORBA_long base_col,
  96                   const CORBA_long base_row,
  97                   const CORBA_long start_col,
  98                   const CORBA_long start_row,
  99                   const CORBA_long end_col,
 100                   const CORBA_long end_row,
 101                   CORBA_Environment *ev)
 102 {
 103         Sheet *sheet = sheet_from_servant (servant);
 104
 105         verify_region (start_col, start_row, end_col, end_row);
 106         verify ((base_col > 0)  && (base_row > 0));
 107         verify ((base_row >= start_row) && (base_row <= end_row) &&
 108                 (base_col >= start_col) && (base_col <= end_col));
 109
 110         sheet_cursor_set (sheet, base_col, base_row, start_col, start_row, end_col, end_row);
 111 }
 112
 113 static void
 114 Sheet_cursor_move (PortableServer_Servant servant, const CORBA_long col, const CORBA_long row, CORBA_Environment *ev)
 115 {
 116         Sheet *sheet = sheet_from_servant (servant);
 117
 118         verify_col (col);
 119         verify_row (row);
 120
 121         sheet_cursor_set (sheet, col, row, col, row, col, row);
 122 }
 123
 124 static void
 125 Sheet_make_cell_visible (PortableServer_Servant servant, const CORBA_long col, const CORBA_long row, CORBA_Environment *ev)
 126 {
 127         Sheet *sheet = sheet_from_servant (servant);
 128
 129         verify_col (col);
 130         verify_row (row);
 131
 132         sheet_make_cell_visible (sheet, col, row);
 133 }
 134
 135 static void
 136 Sheet_select_all (PortableServer_Servant servant, CORBA_Environment *ev)
 137 {
 138         Sheet *sheet = sheet_from_servant (servant);
 139
 140         sheet_select_all (sheet);
 141 }
 142
 143 static CORBA_boolean
 144 Sheet_is_all_selected (PortableServer_Servant servant, CORBA_Environment *ev)
 145 {
 146         Sheet *sheet = sheet_from_servant (servant);
 147
 148         return sheet_is_all_selected (sheet);
 149 }
 150
 151 static void
 152 Sheet_selection_reset (PortableServer_Servant servant, CORBA_Environment *ev)
 153 {
 154         Sheet *sheet = sheet_from_servant (servant);
 155
 156         sheet_selection_reset (sheet);
 157 }
 158
 159 static void
 160 Sheet_selection_append (PortableServer_Servant servant,
 161                         const CORBA_long col, const CORBA_long row,
 162                         CORBA_Environment *ev)
 163 {
 164         Sheet *sheet = sheet_from_servant (servant);
 165
 166         verify_col (col);
 167         verify_row (row);
 168
 169         sheet_selection_add (sheet, col, row);
 170 }
 171
 172 static void
 173 Sheet_selection_append_range (PortableServer_Servant servant,
 174                               const CORBA_long start_col, const CORBA_long start_row,
 175                               const CORBA_long end_col, const CORBA_long end_row,
 176                               CORBA_Environment *ev)
 177 {
 178         Sheet *sheet = sheet_from_servant (servant);
 179
 180         verify_region (start_col, start_row, end_col, end_row);
 181
 182         sheet_selection_add_range (sheet,
 183                                    start_col, start_row,
 184                                    start_col, start_row,
 185                                    end_col, end_row);
 186 }
 187
 188 static void
 189 Sheet_selection_copy (PortableServer_Servant servant, CORBA_Environment *ev)
 190 {
 191         Sheet *sheet = sheet_from_servant (servant);
 192
 193         sheet_selection_copy (command_context_corba (sheet->workbook), sheet);
 194 }
 195
 196 static void
 197 Sheet_selection_cut (PortableServer_Servant servant, CORBA_Environment *ev)
 198 {
 199         Sheet *sheet = sheet_from_servant (servant);
 200
 201         sheet_selection_cut (command_context_corba (sheet->workbook), sheet);
 202 }
 203
 204 static void
 205 Sheet_selection_paste (PortableServer_Servant servant,
 206                        const CORBA_long dest_col, const CORBA_long dest_row,
 207                        const CORBA_long paste_flags, CORBA_Environment *ev)
 208 {
 209         Sheet *sheet = sheet_from_servant (servant);
 210
 211         verify_col (dest_col);
 212         verify_row (dest_row);
 213
 214         sheet_selection_paste (
 215                 command_context_corba (sheet->workbook), sheet,
 216                 dest_col, dest_row, paste_flags, 0);
 217 }
 218
 219 static void
 220 Sheet_clear_region (PortableServer_Servant servant,
 221                     const CORBA_long start_col, const CORBA_long start_row,
 222                     const CORBA_long end_col, const CORBA_long end_row,
 223                     CORBA_Environment *ev)
 224 {
 225         Sheet *sheet = sheet_from_servant (servant);
 226
 227         verify_region (start_col, start_row, end_col, end_row);
 228
 229         sheet_clear_region (
 230                 command_context_corba (sheet->workbook),
 231                 sheet, start_col, start_row,
 232                 end_col, end_row, CLEAR_VALUES|CLEAR_FORMATS|CLEAR_COMMENTS);
 233 }
 234
 235 static void
 236 Sheet_clear_region_content (PortableServer_Servant servant,
 237                             const CORBA_long start_col, const CORBA_long start_row,
 238                             const CORBA_long end_col, const CORBA_long end_row,
 239                             CORBA_Environment *ev)
 240 {
 241         Sheet *sheet = sheet_from_servant (servant);
 242
 243         verify_region (start_col, start_row, end_col, end_row);
 244
 245         sheet_clear_region (
 246                 command_context_corba (sheet->workbook),
 247                 sheet, start_col, start_row,
 248                 end_col, end_row, CLEAR_VALUES|CLEAR_COMMENTS);
 249 }
 250
 251 static void
 252 Sheet_clear_region_comments (PortableServer_Servant servant,
 253                              const CORBA_long start_col, const CORBA_long start_row,
 254                              const CORBA_long end_col, const CORBA_long end_row,
 255                              CORBA_Environment *ev)
 256 {
 257         Sheet *sheet = sheet_from_servant (servant);
 258
 259         verify_region (start_col, start_row, end_col, end_row);
 260
 261         sheet_clear_region (
 262                 command_context_corba (sheet->workbook),
 263                 sheet, start_col, start_row,
 264                 end_col, end_row, CLEAR_COMMENTS);
 265 }
 266
 267 static void
 268 Sheet_clear_region_formats (PortableServer_Servant servant,
 269                             const CORBA_long start_col, const CORBA_long start_row,
 270                             const CORBA_long end_col, const CORBA_long end_row,
 271                             CORBA_Environment *ev)
 272 {
 273         Sheet *sheet = sheet_from_servant (servant);
 274
 275         verify_region (start_col, start_row, end_col, end_row);
 276
 277         sheet_clear_region (
 278                 command_context_corba (sheet->workbook),
 279                 sheet, start_col, start_row,
 280                 end_col, end_row, CLEAR_FORMATS);
 281 }
 282
 283 static void
 284 Sheet_cell_set_value (PortableServer_Servant servant,
 285                       const CORBA_long col, const CORBA_long row,
 286                       const GNOME_Gnumeric_Value *value,
 287                       CORBA_Environment *ev)
 288 {
 289         Sheet *sheet = sheet_from_servant (servant);
 290         Cell *cell;
 291         Value *v;
 292
 293         verify_col (col);
 294         verify_row (row);
 295
 296         cell = sheet_cell_fetch (sheet, col, row);
 297
 298         switch (value->_d){
 299         case GNOME_Gnumeric_VALUE_EMPTY:
 300                 v = value_new_empty ();
 301                 break;
 302
 303         case GNOME_Gnumeric_VALUE_BOOLEAN:
 304                 v = value_new_bool (value->_u.v_bool);
 305                 break;
 306
 307         case GNOME_Gnumeric_VALUE_ERROR:
 308                 v = value_new_error (NULL, value->_u.error);
 309                 break;
 310
 311         case GNOME_Gnumeric_VALUE_STRING:
 312                 v = value_new_string (value->_u.str);
 313                 break;
 314
 315         case GNOME_Gnumeric_VALUE_INTEGER:
 316                 v = value_new_int (value->_u.v_int);
 317                 break;
 318
 319         case GNOME_Gnumeric_VALUE_FLOAT:
 320                 v = value_new_float (value->_u.v_float);
 321                 break;
 322
 323         case GNOME_Gnumeric_VALUE_CELLRANGE: {
 324                 CellRef a, b;
 325
 326                 parse_cell_name (value->_u.cell_range.cell_a, &a.col, &a.row, TRUE, NULL);
 327                 parse_cell_name (value->_u.cell_range.cell_b, &b.col, &b.row, TRUE, NULL);
 328                 a.sheet = sheet;
 329                 b.sheet = sheet;
 330                 a.col_relative = 0;
 331                 b.col_relative = 0;
 332                 a.row_relative = 0;
 333                 b.row_relative = 0;
 334                 v = value_new_cellrange (&a, &b);
 335                 break;
 336         }
 337
 338         case GNOME_Gnumeric_VALUE_ARRAY:
 339                 v = NULL;
 340                 g_error ("FIXME: Implement me");
 341                 break;
 342
 343         default:
 344                 CORBA_exception_set (ev, CORBA_USER_EXCEPTION, ex_GNOME_Gnumeric_Sheet_InvalidValue, NULL);
 345                 return;
 346         }
 347
 348         cell_set_value (cell, v);
 349 }
 350
 351 static void
 352 fill_corba_value (GNOME_Gnumeric_Value *value, Sheet *sheet, CORBA_long col, CORBA_long row)
 353 {
 354         Cell *cell;
 355         ParsePosition pp;
 356
 357         g_assert (value != NULL);
 358         g_assert (sheet != NULL);
 359
 360         parse_pos_init (&pp, sheet->workbook, col, row);
 361         cell = sheet_cell_get (sheet, col, row);
 362         if (cell && cell->value) {
 363                 switch (cell->value->type) {
 364                 case VALUE_EMPTY:
 365                         value->_d = GNOME_Gnumeric_VALUE_EMPTY;
 366                         break;
 367
 368                 case VALUE_BOOLEAN:
 369                         value->_d = GNOME_Gnumeric_VALUE_BOOLEAN;
 370                         value->_u.v_bool = cell->value->v.v_bool;
 371                         break;
 372
 373                 case VALUE_ERROR:
 374                         value->_d = GNOME_Gnumeric_VALUE_ERROR;
 375                         value->_u.error = CORBA_string_dup (cell->value->v.error.mesg->str);
 376                         break;
 377
 378                 case VALUE_STRING:
 379                         value->_d = GNOME_Gnumeric_VALUE_STRING;
 380                         value->_u.str = CORBA_string_dup (cell->value->v.str->str);
 381                         break;
 382
 383                 case VALUE_INTEGER:
 384                         value->_d = GNOME_Gnumeric_VALUE_INTEGER;
 385                         value->_u.v_int = cell->value->v.v_int;
 386                         break;
 387
 388                 case VALUE_FLOAT:
 389                         value->_d = GNOME_Gnumeric_VALUE_FLOAT;
 390                         value->_u.v_float = cell->value->v.v_float;
 391                         break;
 392
 393                 case VALUE_CELLRANGE: {
 394                         char *a, *b;
 395
 396                         a = cellref_name (&cell->value->v.cell_range.cell_a, &pp);
 397                         b = cellref_name (&cell->value->v.cell_range.cell_b, &pp);
 398
 399                         value->_d = GNOME_Gnumeric_VALUE_CELLRANGE;
 400                         value->_u.cell_range.cell_a = CORBA_string_dup (a);
 401                         value->_u.cell_range.cell_b = CORBA_string_dup (b);
 402                         g_free (a);
 403                         g_free (b);
 404                         break;
 405                 }
 406
 407                 case VALUE_ARRAY:
 408                         g_error ("FIXME: Implement me");
 409                         break;
 410                 }
 411         } else {
 412                 value->_d = GNOME_Gnumeric_VALUE_INTEGER;
 413                 value->_u.v_int = 0;
 414         }
 415
 416 }
 417
 418 static GNOME_Gnumeric_Value *
 419 Sheet_cell_get_value (PortableServer_Servant servant,
 420                       const CORBA_long col, const CORBA_long row,
 421                       CORBA_Environment *ev)
 422 {
 423         Sheet *sheet = sheet_from_servant (servant);
 424         GNOME_Gnumeric_Value *value;
 425
 426         verify_col_val (col, NULL);
 427         verify_row_val (row, NULL);
 428
 429         value = GNOME_Gnumeric_Value__alloc ();
 430
 431         fill_corba_value (value, sheet, col, row);
 432         return value;
 433 }
 434
 435 static void
 436 Sheet_cell_set_text (PortableServer_Servant servant,
 437                      const CORBA_long col, const CORBA_long row,
 438                      const CORBA_char * text, CORBA_Environment *ev)
 439 {
 440         Sheet *sheet = sheet_from_servant (servant);
 441         Cell *cell;
 442
 443         verify_col (col);
 444         verify_row (row);
 445
 446         cell = sheet_cell_fetch (sheet, col, row);
 447         cell_set_text (cell, text);
 448 }
 449
 450 static CORBA_char *
 451 Sheet_cell_get_text (PortableServer_Servant servant,
 452                      const CORBA_long col,
 453                      const CORBA_long row,
 454                      CORBA_Environment *ev)
 455 {
 456         Sheet *sheet = sheet_from_servant (servant);
 457         Cell  *cell;
 458
 459         verify_col_val (col, NULL);
 460         verify_row_val (row, NULL);
 461
 462         cell = sheet_cell_get (sheet, col, row);
 463         if (cell) {
 464                 char *str;
 465
 466                 str = cell_get_text (cell);
 467                 return CORBA_string_dup (str);
 468         } else {
 469                 return CORBA_string_dup ("");
 470         }
 471 }
 472
 473 static void
 474 Sheet_cell_set_formula (PortableServer_Servant servant,
 475                         const CORBA_long col,
 476                         const CORBA_long row,
 477                         const CORBA_char * formula,
 478                         CORBA_Environment *ev)
 479 {
 480         Sheet *sheet = sheet_from_servant (servant);
 481         Cell *cell;
 482
 483         verify_col (col);
 484         verify_row (row);
 485
 486         cell = sheet_cell_fetch (sheet, col, row);
 487         cell_set_formula (cell, formula);
 488 }
 489
 490 static void
 491 Sheet_cell_set_format (PortableServer_Servant servant,
 492                        const CORBA_long col,
 493                        const CORBA_long row,
 494                        const CORBA_char * format,
 495                        CORBA_Environment *ev)
 496 {
 497         Sheet *sheet = sheet_from_servant (servant);
 498         Cell *cell;
 499
 500         verify_col (col);
 501         verify_row (row);
 502
 503         cell = sheet_cell_fetch (sheet, col, row);
 504         cell_set_format (cell, format);
 505 }
 506
 507 static CORBA_char *
 508 Sheet_cell_get_format (PortableServer_Servant servant,
 509                        const CORBA_long col,
 510                        const CORBA_long row,
 511                        CORBA_Environment *ev)
 512 {
 513         CORBA_char *ans;
 514         Sheet *sheet = sheet_from_servant (servant);
 515         MStyle *mstyle;
 516
 517         verify_col_val (col, NULL);
 518         verify_row_val (row, NULL);
 519
 520         mstyle = sheet_style_compute (sheet, col, row);
 521         ans = CORBA_string_dup (mstyle_get_format (mstyle)->format);
 522         mstyle_unref (mstyle);
 523
 524         return ans;
 525 }
 526
 527 static void
 528 Sheet_cell_set_font (PortableServer_Servant servant,
 529                      const CORBA_long col,
 530                      const CORBA_long row,
 531                      const CORBA_char * font,
 532                      const CORBA_double points,
 533                      CORBA_Environment *ev)
 534 {
 535         MStyle *mstyle = mstyle_new ();
 536         mstyle_set_font_name (mstyle, font);
 537         mstyle_set_font_size (mstyle, points);
 538         sheet_style_attach_single (sheet_from_servant (servant),
 539                                    col, row, mstyle);
 540 }
 541
 542 static CORBA_char *
 543 Sheet_cell_get_font (PortableServer_Servant servant, const CORBA_long col, const CORBA_long row, CORBA_Environment *ev)
 544 {
 545         CORBA_char *ans;
 546         Sheet *sheet = sheet_from_servant (servant);
 547         MStyle *mstyle;
 548
 549         verify_col_val (col, NULL);
 550         verify_row_val (row, NULL);
 551
 552         mstyle = sheet_style_compute (sheet, col, row);
 553         ans = CORBA_string_dup (mstyle_get_font_name (mstyle));
 554         mstyle_unref (mstyle);
 555
 556         return ans;
 557 }
 558
 559 static void
 560 Sheet_cell_set_comment (PortableServer_Servant servant,
 561                         const CORBA_long col, const CORBA_long row,
 562                         const CORBA_char * comment, CORBA_Environment *ev)
 563 {
 564         Sheet *sheet = sheet_from_servant (servant);
 565         Cell *cell;
 566
 567         verify_col (col);
 568         verify_row (row);
 569
 570         cell = sheet_cell_fetch (sheet, col, row);
 571         cell_set_comment (cell, comment);
 572 }
 573
 574 static CORBA_char *
 575 Sheet_cell_get_comment (PortableServer_Servant servant,
 576                         const CORBA_long col, const CORBA_long row,
 577                         CORBA_Environment *ev)
 578 {
 579         Sheet *sheet = sheet_from_servant (servant);
 580         Cell *cell;
 581
 582         verify_col_val (col, NULL);
 583         verify_row_val (row, NULL);
 584
 585         cell = sheet_cell_get (sheet, col, row);
 586         if (cell)
 587                 return CORBA_string_dup (cell->comment->comment->str);
 588         else
 589                 return CORBA_string_dup ("");
 590 }
 591
 592 static void
 593 Sheet_cell_set_foreground (PortableServer_Servant servant,
 594                            const CORBA_long col, const CORBA_long row,
 595                            const CORBA_char * color, CORBA_Environment *ev)
 596 {
 597         GdkColor c;
 598         MStyle *mstyle = mstyle_new ();
 599
 600         verify_col (col);
 601         verify_row (row);
 602
 603         gdk_color_parse (color, &c);
 604         mstyle_set_color (mstyle, MSTYLE_COLOR_FORE,
 605                           style_color_new (c.red, c.green, c.blue));
 606         sheet_style_attach_single (sheet_from_servant (servant),
 607                                    col, row, mstyle);
 608 }
 609
 610 static CORBA_char *
 611 Sheet_cell_get_foreground (PortableServer_Servant servant,
 612                            const CORBA_long col, const CORBA_long row,
 613                            CORBA_Environment *ev)
 614 {
 615         g_warning ("cell get foreground deprecated");
 616
 617         return NULL;
 618 }
 619
 620 static void
 621 Sheet_cell_set_background (PortableServer_Servant servant,
 622                            const CORBA_long col, const CORBA_long row,
 623                            const CORBA_char * color, CORBA_Environment *ev)
 624 {
 625         GdkColor c;
 626         MStyle *mstyle = mstyle_new ();
 627
 628         verify_col (col);
 629         verify_row (row);
 630
 631         gdk_color_parse (color, &c);
 632         mstyle_set_color (mstyle, MSTYLE_COLOR_BACK,
 633                           style_color_new (c.red, c.green, c.blue));
 634         sheet_style_attach_single (sheet_from_servant (servant),
 635                                    col, row, mstyle);
 636 }
 637
 638 static CORBA_char *
 639 Sheet_cell_get_background (PortableServer_Servant servant,
 640                            const CORBA_long col, const CORBA_long row,
 641                            CORBA_Environment *ev)
 642 {
 643         g_warning ("Deprecated cell get background");
 644         return NULL;
 645 }
 646
 647 static void
 648 Sheet_cell_set_pattern (PortableServer_Servant servant,
 649                         const CORBA_long col, const CORBA_long row,
 650                         const CORBA_long pattern, CORBA_Environment *ev)
 651 {
 652         MStyle *mstyle = mstyle_new ();
 653
 654         verify_col (col);
 655         verify_row (row);
 656
 657         mstyle_set_pattern (mstyle, pattern);
 658         sheet_style_attach_single (sheet_from_servant (servant),
 659                                    col, row, mstyle);
 660 }
 661
 662 static CORBA_long
 663 Sheet_cell_get_pattern (PortableServer_Servant servant,
 664                         const CORBA_long col, const CORBA_long row,
 665                         CORBA_Environment *ev)
 666 {
 667         CORBA_long ans;
 668         Sheet *sheet = sheet_from_servant (servant);
 669         MStyle *mstyle;
 670
 671         verify_col_val (col, 0);
 672         verify_row_val (row, 0);
 673
 674         mstyle = sheet_style_compute (sheet, col, row);
 675         ans = mstyle_get_pattern (mstyle);
 676         mstyle_unref (mstyle);
 677
 678         return ans;
 679 }
 680
 681 static void
 682 Sheet_cell_set_alignment (PortableServer_Servant servant,
 683                           const CORBA_long col, const CORBA_long row,
 684                           const CORBA_long halign, const CORBA_long valign,
 685                           const CORBA_long orientation, const CORBA_boolean auto_return,
 686                           CORBA_Environment *ev)
 687 {
 688         int v, h;
 689         MStyle *mstyle = mstyle_new ();
 690
 691         verify_col (col);
 692         verify_row (row);
 693
 694         switch (halign) {
 695         case GNOME_Gnumeric_Sheet_HALIGN_GENERAL:
 696                 h = HALIGN_GENERAL;
 697                 break;
 698
 699         case GNOME_Gnumeric_Sheet_HALIGN_LEFT:
 700                 h = HALIGN_LEFT;
 701                 break;
 702
 703         case GNOME_Gnumeric_Sheet_HALIGN_RIGHT:
 704                 h = HALIGN_RIGHT;
 705                 break;
 706
 707         case GNOME_Gnumeric_Sheet_HALIGN_CENTER:
 708                 h = HALIGN_CENTER;
 709                 break;
 710
 711         case GNOME_Gnumeric_Sheet_HALIGN_FILL:
 712                 h = HALIGN_FILL;
 713                 break;
 714
 715         case GNOME_Gnumeric_Sheet_HALIGN_JUSTIFY:
 716                 h = HALIGN_JUSTIFY;
 717                 break;
 718
 719         case GNOME_Gnumeric_Sheet_HALIGN_CENTER_ACROSS_SELECTION:
 720                 h = HALIGN_CENTER_ACROSS_SELECTION;
 721                 break;
 722
 723         default:
 724                 h = HALIGN_GENERAL;
 725         }
 726
 727         switch (valign) {
 728         case GNOME_Gnumeric_Sheet_VALIGN_TOP:
 729                 v = VALIGN_TOP;
 730                 break;
 731
 732         case GNOME_Gnumeric_Sheet_VALIGN_BOTTOM:
 733                 v = VALIGN_BOTTOM;
 734                 break;
 735
 736         case GNOME_Gnumeric_Sheet_VALIGN_CENTER:
 737                 v = VALIGN_CENTER;
 738                 break;
 739
 740         case GNOME_Gnumeric_Sheet_VALIGN_JUSTIFY:
 741                 v = VALIGN_JUSTIFY;
 742                 break;
 743
 744         default:
 745                 v = VALIGN_TOP;
 746                 break;
 747         }
 748
 749         mstyle_set_align_v (mstyle, v);
 750         mstyle_set_align_h (mstyle, h);
 751         sheet_style_attach_single (sheet_from_servant (servant),
 752                                    col, row, mstyle);
 753 }
 754
 755 static void
 756 Sheet_cell_get_alignment (PortableServer_Servant servant,
 757                           const CORBA_long col, const CORBA_long row,
 758                           CORBA_long * halign, CORBA_long * valign,
 759                           CORBA_long * orientation, CORBA_boolean * auto_return,
 760                           CORBA_Environment *ev)
 761 {
 762         MStyle *mstyle;
 763
 764         verify_col (col);
 765         verify_row (row);
 766
 767         mstyle = sheet_style_compute (sheet_from_servant (servant), col, row);
 768
 769         switch (mstyle_get_align_h (mstyle)) {
 770         case HALIGN_GENERAL:
 771                 *halign = GNOME_Gnumeric_Sheet_HALIGN_GENERAL;
 772                 break;
 773
 774         case HALIGN_LEFT:
 775                 *halign = GNOME_Gnumeric_Sheet_HALIGN_LEFT;
 776                 break;
 777
 778         case HALIGN_RIGHT:
 779                 *halign = GNOME_Gnumeric_Sheet_HALIGN_RIGHT;
 780                 break;
 781
 782         case HALIGN_CENTER:
 783                 *halign = GNOME_Gnumeric_Sheet_HALIGN_CENTER;
 784                 break;
 785
 786         case HALIGN_FILL:
 787                 *halign = GNOME_Gnumeric_Sheet_HALIGN_FILL;
 788                 break;
 789
 790         case HALIGN_JUSTIFY:
 791                 *halign = GNOME_Gnumeric_Sheet_HALIGN_JUSTIFY;
 792                 break;
 793
 794         case HALIGN_CENTER_ACROSS_SELECTION:
 795                 *halign = GNOME_Gnumeric_Sheet_HALIGN_CENTER_ACROSS_SELECTION;
 796                 break;
 797
 798         default:
 799                 g_assert_not_reached ();
 800         }
 801
 802         switch (mstyle_get_align_v (mstyle)) {
 803         case VALIGN_TOP:
 804                 *valign = GNOME_Gnumeric_Sheet_VALIGN_TOP;
 805                 break;
 806
 807         case VALIGN_BOTTOM:
 808                 *valign = GNOME_Gnumeric_Sheet_VALIGN_BOTTOM;
 809                 break;
 810
 811         case VALIGN_CENTER:
 812                 *valign = GNOME_Gnumeric_Sheet_VALIGN_CENTER;
 813                 break;
 814
 815         case VALIGN_JUSTIFY:
 816                 *valign = GNOME_Gnumeric_Sheet_VALIGN_JUSTIFY;
 817                 break;
 818         }
 819         *orientation = mstyle_get_orientation (mstyle);
 820         *auto_return = mstyle_get_fit_in_cell (mstyle);
 821
 822         mstyle_unref (mstyle);
 823 }
 824
 825 static void
 826 Sheet_set_dirty (PortableServer_Servant servant, const CORBA_boolean is_dirty, CORBA_Environment *ev)
 827 {
 828         Sheet *sheet = sheet_from_servant (servant);
 829
 830         sheet->modified = is_dirty;
 831 }
 832
 833 static void
 834 Sheet_insert_col (PortableServer_Servant servant,
 835                   const CORBA_long col, const CORBA_long count,
 836                   CORBA_Environment *ev)
 837 {
 838         Sheet *sheet = sheet_from_servant (servant);
 839
 840         verify_col (col);
 841         cmd_insert_cols (
 842                 command_context_corba (sheet->workbook), sheet,
 843                 col, count);
 844 }
 845
 846 static void
 847 Sheet_delete_col (PortableServer_Servant servant,
 848                   const CORBA_long col, const CORBA_long count,
 849                   CORBA_Environment *ev)
 850 {
 851         Sheet *sheet = sheet_from_servant (servant);
 852
 853         verify_col (col);
 854         cmd_delete_cols (
 855                 command_context_corba (sheet->workbook), sheet,
 856                 col, count);
 857 }
 858
 859 static void
 860 Sheet_insert_row (PortableServer_Servant servant,
 861                   const CORBA_long row, const CORBA_long count,
 862                   CORBA_Environment *ev)
 863 {
 864         Sheet *sheet = sheet_from_servant (servant);
 865
 866         verify_row (row);
 867         cmd_insert_rows (
 868                 command_context_corba (sheet->workbook), sheet,
 869                 row, count);
 870 }
 871
 872 static void
 873 Sheet_delete_row (PortableServer_Servant servant,
 874                   const CORBA_long row, const CORBA_long count,
 875                   CORBA_Environment *ev)
 876 {
 877         Sheet *sheet = sheet_from_servant (servant);
 878
 879         verify_row (row);
 880         cmd_delete_rows (
 881                 command_context_corba (sheet->workbook), sheet,
 882                 row, count);
 883 }
 884
 885 static void
 886 Sheet_shift_rows (PortableServer_Servant servant,
 887                   const CORBA_long col, const CORBA_long start_row,
 888                   const CORBA_long end_row, const CORBA_long count,
 889                   CORBA_Environment *ev)
 890 {
 891         Sheet *sheet = sheet_from_servant (servant);
 892
 893         verify_row (start_row);
 894         verify_row (end_row);
 895         verify_col (col);
 896
 897         sheet_shift_rows (
 898                 command_context_corba (sheet->workbook), sheet,
 899                 col, start_row, end_row, count);
 900 }
 901
 902 static void
 903 Sheet_shift_cols (PortableServer_Servant servant,
 904                   const CORBA_long col,
 905                   const CORBA_long start_row, const CORBA_long end_row,
 906                   const CORBA_long count, CORBA_Environment *ev)
 907 {
 908         Sheet *sheet = sheet_from_servant (servant);
 909
 910         verify_col (col);
 911         verify_row (start_row);
 912         verify_row (end_row);
 913
 914         sheet_shift_cols (
 915                 command_context_corba (sheet->workbook), sheet,
 916                 col, start_row, end_row, count);
 917 }
 918
 919 static GNOME_Gnumeric_Sheet_ValueVector *
 920 Sheet_range_get_values (PortableServer_Servant servant, const CORBA_char *range, CORBA_Environment *ev)
 921 {
 922         GNOME_Gnumeric_Sheet_ValueVector *vector;
 923         Sheet *sheet = sheet_from_servant (servant);
 924         GSList *ranges, *l;
 925         int size, i;
 926
 927         verify_range_val (sheet, range, &ranges, NULL);
 928
 929         /*
 930          * Find out how big is the array we need to return
 931          */
 932         size = 0;
 933         for (l = ranges; l; l = l->next){
 934                 Value *value = l->data;
 935                 CellRef a, b;
 936                 int cols, rows;
 937
 938                 g_assert (value->type == VALUE_CELLRANGE);
 939
 940                 a = value->v.cell_range.cell_a;
 941                 b = value->v.cell_range.cell_b;
 942
 943                 cols = abs (b.col - a.col) + 1;
 944                 rows = abs (b.row - a.row) + 1;
 945
 946                 size += cols * rows;
 947         }
 948
 949         vector = GNOME_Gnumeric_Sheet_ValueVector__alloc ();
 950         vector->_buffer = CORBA_sequence_GNOME_Gnumeric_Value_allocbuf (size);
 951
 952         /* No memory, return an empty vector */
 953         if (vector->_buffer == NULL) {
 954                 vector->_length = 0;
 955                 vector->_maximum = 0;
 956
 957                 return vector;
 958         }
 959
 960         /*
 961          * Fill in the vector
 962          */
 963         for (i = 0, l = ranges; l; l = l->next, i++) {
 964                 Value *value = l->data;
 965                 CellRef a, b;
 966                 int col, row;
 967
 968                 a = value->v.cell_range.cell_a;
 969                 b = value->v.cell_range.cell_b;
 970
 971                 for (col = a.col; col <= b.col; col++)
 972                         for (row = a.row; row < b.row; row++)
 973                                 fill_corba_value (&vector->_buffer [i], sheet, col, row);
 974         }
 975
 976         range_list_destroy (ranges);
 977         return vector;
 978 }
 979
 980 static void
 981 cb_range_set_text (Cell *cell, void *data)
 982 {
 983         cell_set_text (cell, data);
 984 }
 985
 986 static void
 987 Sheet_range_set_text (PortableServer_Servant servant,
 988                       const CORBA_char *range,
 989                       const CORBA_char *text,
 990                       CORBA_Environment *ev)
 991 {
 992         Sheet *sheet = sheet_from_servant (servant);
 993         GSList *ranges;
 994
 995         verify_range (sheet, range, &ranges);
 996
 997         range_list_foreach_all (ranges, cb_range_set_text, (char *) text);
 998
 999         range_list_destroy (ranges);
1000 }
1001
1002 static void
1003 cb_range_set_formula (Cell *cell, void *data)
1004 {
1005         cell_set_formula (cell, data);
1006 }
1007
1008 static void
1009 Sheet_range_set_formula (PortableServer_Servant servant,
1010                          const CORBA_char *range,
1011                          const CORBA_char *formula,
1012                          CORBA_Environment *ev)
1013 {
1014         Sheet *sheet = sheet_from_servant (servant);
1015         GSList *ranges;
1016
1017         verify_range (sheet, range, &ranges);
1018
1019         range_list_foreach_all (ranges, cb_range_set_formula, (char *)formula);
1020
1021         range_list_destroy (ranges);
1022 }
1023
1024 static void
1025 Sheet_range_set_format (PortableServer_Servant servant,
1026                         const CORBA_char *range,
1027                         const CORBA_char *format,
1028                         CORBA_Environment *ev)
1029 {
1030         Sheet *sheet = sheet_from_servant (servant);
1031         GSList *ranges;
1032         MStyle *mstyle;
1033
1034         verify_range (sheet, range, &ranges);
1035
1036         cell_freeze_redraws ();
1037
1038         mstyle = mstyle_new ();
1039         mstyle_set_format (mstyle, format);
1040         ranges_set_style (sheet, ranges, mstyle);
1041
1042         cell_thaw_redraws ();
1043
1044         range_list_destroy (ranges);
1045 }
1046
1047 static void
1048 Sheet_range_set_font (PortableServer_Servant servant,
1049                       const CORBA_char *range,
1050                       const CORBA_char *font,
1051                       CORBA_short points,
1052                       CORBA_Environment *ev)
1053 {
1054         Sheet *sheet = sheet_from_servant (servant);
1055         GSList *ranges;
1056         MStyle *mstyle;
1057
1058         verify_range (sheet, range, &ranges);
1059
1060         cell_freeze_redraws ();
1061
1062         mstyle = mstyle_new ();
1063         mstyle_set_font_name (mstyle, font);
1064         mstyle_set_font_size (mstyle, points);
1065         ranges_set_style (sheet, ranges, mstyle);
1066
1067         cell_thaw_redraws ();
1068
1069         range_list_destroy (ranges);
1070 }
1071
1072 static void
1073 Sheet_range_set_foreground (PortableServer_Servant servant,
1074                             const CORBA_char *range,
1075                             const CORBA_char *color,
1076                             CORBA_Environment *ev)
1077 {
1078         Sheet   *sheet = sheet_from_servant (servant);
1079         GSList  *ranges;
1080         MStyle  *mstyle;
1081         GdkColor c;
1082
1083         verify_range (sheet, range, &ranges);
1084
1085         gdk_color_parse (color, &c);
1086         cell_freeze_redraws ();
1087
1088         mstyle = mstyle_new ();
1089         mstyle_set_color (mstyle, MSTYLE_COLOR_FORE,
1090                           style_color_new (c.red, c.green, c.blue));
1091         ranges_set_style (sheet, ranges, mstyle);
1092
1093         cell_thaw_redraws ();
1094
1095         range_list_destroy (ranges);
1096 }
1097
1098 static void
1099 Sheet_range_set_background (PortableServer_Servant servant,
1100                             const CORBA_char *range,
1101                             const CORBA_char *color,
1102                             CORBA_Environment *ev)
1103 {
1104         Sheet   *sheet = sheet_from_servant (servant);
1105         GSList  *ranges;
1106         MStyle  *mstyle;
1107         GdkColor c;
1108
1109         verify_range (sheet, range, &ranges);
1110
1111         gdk_color_parse (color, &c);
1112         cell_freeze_redraws ();
1113
1114         mstyle = mstyle_new ();
1115         mstyle_set_color (mstyle, MSTYLE_COLOR_BACK,
1116                           style_color_new (c.red, c.green, c.blue));
1117         ranges_set_style (sheet, ranges, mstyle);
1118
1119         cell_thaw_redraws ();
1120
1121         range_list_destroy (ranges);
1122 }
1123
1124 static void
1125 Sheet_range_set_pattern (PortableServer_Servant servant,
1126                          const CORBA_char      *range,
1127                          CORBA_long             pattern,
1128                          CORBA_Environment     *ev)
1129 {
1130         Sheet   *sheet = sheet_from_servant (servant);
1131         GSList  *ranges;
1132         MStyle  *mstyle;
1133
1134         verify_range (sheet, range, &ranges);
1135
1136         cell_freeze_redraws ();
1137
1138         mstyle = mstyle_new ();
1139         mstyle_set_pattern (mstyle, pattern);
1140         ranges_set_style (sheet, ranges, mstyle);
1141
1142         cell_thaw_redraws ();
1143
1144         range_list_destroy (ranges);
1145 }
1146
1147 static void
1148 Sheet_range_set_alignment (PortableServer_Servant servant,
1149                            const CORBA_char      *range,
1150                            CORBA_long             halign,
1151                            CORBA_long             valign,
1152                            CORBA_long             orientation,
1153                            CORBA_boolean          auto_return,
1154                            CORBA_Environment     *ev)
1155 {
1156         Sheet   *sheet = sheet_from_servant (servant);
1157         GSList  *ranges;
1158         MStyle  *mstyle;
1159
1160         verify_range (sheet, range, &ranges);
1161
1162         mstyle = mstyle_new ();
1163         mstyle_set_align_h (mstyle, halign);
1164         mstyle_set_align_v (mstyle, valign);
1165         mstyle_set_orientation (mstyle, orientation);
1166         mstyle_set_fit_in_cell (mstyle, (gboolean) auto_return);
1167         ranges_set_style (sheet, ranges, mstyle);
1168
1169         cell_thaw_redraws ();
1170
1171         range_list_destroy (ranges);
1172 }
1173
1174 static CORBA_long
1175 Sheet_max_cols_used (PortableServer_Servant servant, CORBA_Environment *ev)
1176 {
1177         Sheet *sheet  = sheet_from_servant (servant);
1178         Range  extent = sheet_get_extent (sheet);
1179
1180         return extent.end.col;
1181 }
1182
1183 static CORBA_long
1184 Sheet_max_rows_used (PortableServer_Servant servant, CORBA_Environment *ev)
1185 {
1186         Sheet *sheet = sheet_from_servant (servant);
1187         Range  extent = sheet_get_extent (sheet);
1188
1189         return extent.end.row;
1190 }
1191
1192 static CORBA_double
1193 Sheet_col_width (PortableServer_Servant servant, CORBA_long col, CORBA_Environment *ev)
1194 {
1195         Sheet *sheet = sheet_from_servant (servant);
1196         ColRowInfo *ci;
1197
1198         verify_col_val (col, 0.0);
1199
1200         ci = sheet_col_get_info (sheet, col);
1201         return ci->size_pts;
1202 }
1203
1204 static CORBA_double
1205 Sheet_row_height (PortableServer_Servant servant, CORBA_long row, CORBA_Environment *ev)
1206 {
1207         Sheet *sheet = sheet_from_servant (servant);
1208         ColRowInfo *ri;
1209
1210         verify_row_val (row, 0.0);
1211
1212         ri = sheet_row_get_info (sheet, row);
1213         return ri->size_pts;
1214 }
1215
1216 static void
1217 Sheet_corba_class_init (void)
1218 {
1219         static int inited;
1220
1221         if (inited)
1222                 return;
1223         inited = TRUE;
1224
1225         gnome_gnumeric_sheet_vepv.GNOME_Gnumeric_Sheet_epv =
1226                 &gnome_gnumeric_sheet_epv;
1227
1228         gnome_gnumeric_sheet_epv.cursor_set = Sheet_cursor_set;
1229         gnome_gnumeric_sheet_epv.cursor_move = Sheet_cursor_move;
1230         gnome_gnumeric_sheet_epv.make_cell_visible = Sheet_make_cell_visible;
1231         gnome_gnumeric_sheet_epv.select_all = Sheet_select_all;
1232         gnome_gnumeric_sheet_epv.is_all_selected = Sheet_is_all_selected;
1233         gnome_gnumeric_sheet_epv.selection_reset = Sheet_selection_reset;
1234         gnome_gnumeric_sheet_epv.selection_append = Sheet_selection_append;
1235         gnome_gnumeric_sheet_epv.selection_append_range = Sheet_selection_append_range;
1236         gnome_gnumeric_sheet_epv.selection_copy = Sheet_selection_copy;
1237         gnome_gnumeric_sheet_epv.selection_cut = Sheet_selection_cut;
1238         gnome_gnumeric_sheet_epv.selection_paste = Sheet_selection_paste;
1239         gnome_gnumeric_sheet_epv.clear_region = Sheet_clear_region;
1240         gnome_gnumeric_sheet_epv.clear_region_content = Sheet_clear_region_content;
1241         gnome_gnumeric_sheet_epv.clear_region_comments = Sheet_clear_region_comments;
1242         gnome_gnumeric_sheet_epv.clear_region_formats = Sheet_clear_region_formats;
1243
1244         /*
1245          * Cell based routines
1246          */
1247         gnome_gnumeric_sheet_epv.cell_set_value = Sheet_cell_set_value;
1248         gnome_gnumeric_sheet_epv.cell_get_value = Sheet_cell_get_value;
1249         gnome_gnumeric_sheet_epv.cell_set_text = Sheet_cell_set_text;
1250         gnome_gnumeric_sheet_epv.cell_get_text = Sheet_cell_get_text;
1251         gnome_gnumeric_sheet_epv.cell_set_formula = Sheet_cell_set_formula;
1252         gnome_gnumeric_sheet_epv.cell_set_format = Sheet_cell_set_format;
1253         gnome_gnumeric_sheet_epv.cell_get_format = Sheet_cell_get_format;
1254         gnome_gnumeric_sheet_epv.cell_set_font = Sheet_cell_set_font;
1255         gnome_gnumeric_sheet_epv.cell_get_font = Sheet_cell_get_font;
1256         gnome_gnumeric_sheet_epv.cell_set_foreground = Sheet_cell_set_foreground;
1257         gnome_gnumeric_sheet_epv.cell_get_foreground = Sheet_cell_get_foreground;
1258         gnome_gnumeric_sheet_epv.cell_set_background = Sheet_cell_set_background;
1259         gnome_gnumeric_sheet_epv.cell_get_background = Sheet_cell_get_background;
1260         gnome_gnumeric_sheet_epv.cell_set_pattern = Sheet_cell_set_pattern;
1261         gnome_gnumeric_sheet_epv.cell_get_pattern = Sheet_cell_get_pattern;
1262         gnome_gnumeric_sheet_epv.cell_set_alignment = Sheet_cell_set_alignment;
1263         gnome_gnumeric_sheet_epv.cell_get_alignment = Sheet_cell_get_alignment;
1264         gnome_gnumeric_sheet_epv.cell_set_comment = Sheet_cell_set_comment;
1265         gnome_gnumeric_sheet_epv.cell_get_comment = Sheet_cell_get_comment;
1266
1267         /*
1268          * Column manipulation
1269          */
1270         gnome_gnumeric_sheet_epv.insert_col = Sheet_insert_col;
1271         gnome_gnumeric_sheet_epv.delete_col = Sheet_delete_col;
1272         gnome_gnumeric_sheet_epv.insert_row = Sheet_insert_row;
1273         gnome_gnumeric_sheet_epv.delete_row = Sheet_delete_row;
1274         gnome_gnumeric_sheet_epv.shift_cols = Sheet_shift_cols;
1275         gnome_gnumeric_sheet_epv.shift_rows = Sheet_shift_rows;
1276
1277         /*
1278          * Region based routines
1279          */
1280         gnome_gnumeric_sheet_epv.range_get_values  = Sheet_range_get_values;
1281         gnome_gnumeric_sheet_epv.range_set_text    = Sheet_range_set_text;
1282         gnome_gnumeric_sheet_epv.range_set_formula = Sheet_range_set_formula;
1283         gnome_gnumeric_sheet_epv.range_set_format  = Sheet_range_set_format;
1284         gnome_gnumeric_sheet_epv.range_set_font    = Sheet_range_set_font;
1285         gnome_gnumeric_sheet_epv.range_set_foreground = Sheet_range_set_foreground;
1286         gnome_gnumeric_sheet_epv.range_set_background = Sheet_range_set_background;
1287         gnome_gnumeric_sheet_epv.range_set_pattern    = Sheet_range_set_pattern;
1288         gnome_gnumeric_sheet_epv.range_set_alignment  = Sheet_range_set_alignment;
1289
1290         gnome_gnumeric_sheet_epv.set_dirty = Sheet_set_dirty;
1291
1292         /*
1293          * Information
1294          */
1295         gnome_gnumeric_sheet_epv.max_cols_used = Sheet_max_cols_used;
1296         gnome_gnumeric_sheet_epv.max_rows_used = Sheet_max_rows_used;
1297         gnome_gnumeric_sheet_epv.row_height    = Sheet_row_height;
1298         gnome_gnumeric_sheet_epv.col_width     = Sheet_col_width;
1299 }
1300
1301 void
1302 sheet_corba_setup (Sheet *sheet)
1303 {
1304         SheetServant *ss;
1305         CORBA_Environment ev;
1306         PortableServer_ObjectId *objid;
1307
1308         Sheet_corba_class_init ();
1309
1310         ss = g_new0 (SheetServant, 1);
1311         ss->servant.vepv = &gnome_gnumeric_sheet_vepv;
1312         ss->sheet = sheet;
1313
1314         CORBA_exception_init (&ev);
1315         POA_GNOME_Gnumeric_Sheet__init ((PortableServer_Servant) ss, &ev);
1316         objid = PortableServer_POA_activate_object (gnumeric_poa, ss, &ev);
1317         CORBA_free (objid);
1318
1319         sheet->private->corba_server = PortableServer_POA_servant_to_reference (gnumeric_poa, ss, &ev);
1320
1321         CORBA_exception_free (&ev);
1322 }
1323
1324 void
1325 sheet_corba_shutdown (Sheet *sheet)
1326 {
1327         CORBA_Environment ev;
1328
1329         g_return_if_fail (sheet != NULL);
1330         g_return_if_fail (IS_SHEET (sheet));
1331         g_return_if_fail (sheet->private->corba_server != NULL);
1332
1333         g_warning ("Should release all the corba resources here");
1334
1335         CORBA_exception_init (&ev);
1336         PortableServer_POA_deactivate_object (gnumeric_poa, sheet->private->corba_server, &ev);
1337         CORBA_exception_free (&ev);
1338 }
1339