src/position.c

   1 /* vim: set sw=8: -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  * position.c: Utility routines for various types of positional
   4  *         coordinates.
   5  *
   6  * Copyright (C) 2000-2005 Jody Goldberg (jody@gnome.org)
   7  * Copyright (C) 2006-2009 Morten Welinder (terra@gnome.org)
   8  *
   9  * This program is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU General Public License as
  11  * published by the Free Software Foundation; either version 2 of the
  12  * License, or (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301
  22  * USA
  23  */
  24 #include <gnumeric-config.h>
  25 #include "gnumeric.h"
  26 #include "libgnumeric.h"
  27 #include "position.h"
  28
  29 #include "sheet.h"
  30 #include "sheet-view.h"
  31 #include "cell.h"
  32 #include "value.h"
  33 #include "ranges.h"
  34 #include <string.h>
  35 #include "workbook.h"
  36
  37 /* GnmCellPos made a boxed type */
  38 static GnmCellPos *
  39 gnm_cell_pos_dup (GnmCellPos *pos)
  40 {
  41         GnmCellPos *res = g_new (GnmCellPos, 1);
  42         *res = *pos;
  43         return res;
  44 }
  45
  46 GType
  47 gnm_cell_pos_get_type (void)
  48 {
  49         static GType t = 0;
  50
  51         if (t == 0) {
  52                 t = g_boxed_type_register_static ("GnmCellPos",
  53                          (GBoxedCopyFunc)gnm_cell_pos_dup,
  54                          (GBoxedFreeFunc)g_free);
  55         }
  56         return t;
  57 }
  58
  59 /* GnmEvalPos made a boxed type */
  60 static GnmEvalPos *
  61 gnm_eval_pos_dup (GnmEvalPos *ep)
  62 {
  63         GnmEvalPos *res = g_new0 (GnmEvalPos, 1);
  64         memcpy (res, ep, sizeof (GnmEvalPos)); /* is this safe? */
  65         return res;
  66 }
  67
  68 GType
  69 gnm_eval_pos_get_type (void)
  70 {
  71         static GType t = 0;
  72
  73         if (t == 0) {
  74                 t = g_boxed_type_register_static ("GnmEvalPos",
  75                          (GBoxedCopyFunc)gnm_eval_pos_dup,
  76                          (GBoxedFreeFunc)g_free);
  77         }
  78         return t;
  79 }
  80
  81 /**
  82  * eval_pos_init:
  83  * @ep: The position to init.
  84  * @s: #Sheet
  85  * @col: column.
  86  * @row: row
  87  *
  88  * Returns: (transfer none): the initialized #GnmEvalPos (@ep).
  89  **/
  90 GnmEvalPos *
  91 eval_pos_init (GnmEvalPos *ep, Sheet *sheet, int col, int row)
  92 {
  93         g_return_val_if_fail (ep != NULL, NULL);
  94         g_return_val_if_fail (sheet != NULL, NULL);
  95
  96         ep->eval.col = col;
  97         ep->eval.row = row;
  98         ep->sheet = sheet;
  99         ep->dep = NULL;
 100         ep->array_texpr = NULL;
 101
 102         return ep;
 103 }
 104
 105 /**
 106  * eval_pos_init_pos:
 107  * @ep: The position to init.
 108  * @s: #Sheet
 109  * @pos: #GnmCellPos
 110  *
 111  * Returns: (transfer none): the initialized #GnmEvalPos (@ep).
 112  **/
 113 GnmEvalPos *
 114 eval_pos_init_pos (GnmEvalPos *ep, Sheet *sheet, GnmCellPos const *pos)
 115 {
 116         g_return_val_if_fail (ep != NULL, NULL);
 117         g_return_val_if_fail (sheet != NULL, NULL);
 118         g_return_val_if_fail (pos != NULL, NULL);
 119
 120         ep->eval = *pos;
 121         ep->sheet = sheet;
 122         ep->dep = NULL;
 123         ep->array_texpr = NULL;
 124
 125         return ep;
 126 }
 127
 128 /**
 129  * eval_pos_init_dep:
 130  * @ep: The position to init.
 131  * @dep:
 132  *
 133  * Returns: (transfer none): the initialized #GnmEvalPos (@ep).
 134  **/
 135 GnmEvalPos *
 136 eval_pos_init_dep (GnmEvalPos *ep, GnmDependent const *dep)
 137 {
 138         g_return_val_if_fail (ep != NULL, NULL);
 139         g_return_val_if_fail (dep != NULL, NULL);
 140
 141         ep->eval = *dependent_pos (dep);
 142         ep->sheet = dep->sheet;
 143         ep->dep = (GnmDependent *)dep;
 144         ep->array_texpr = NULL;
 145
 146         return ep;
 147 }
 148
 149 /**
 150  * eval_pos_init_editpos:
 151  * @ep: The position to init.
 152  * @sv: @Sheetview
 153  *
 154  * The function initializes an evalpos with the edit position from the
 155  * given sheetview.
 156  * Returns: (transfer none): the initialized #GnmEvalPos (@ep).
 157  **/
 158 GnmEvalPos *
 159 eval_pos_init_editpos (GnmEvalPos *ep, SheetView const *sv)
 160 {
 161         g_return_val_if_fail (ep != NULL, NULL);
 162         g_return_val_if_fail (GNM_IS_SV (sv), NULL);
 163
 164         return eval_pos_init (ep, sv_sheet (sv),
 165                 sv->edit_pos.col, sv->edit_pos.row);
 166 }
 167
 168 /**
 169  * eval_pos_init_cell:
 170  * @ep: The position to init.
 171  * @cell: A cell
 172  *
 173  * The function initializes an evalpos with the given cell
 174  *
 175  * Returns: (transfer none): the initialized #GnmEvalPos (@ep).
 176  */
 177 GnmEvalPos *
 178 eval_pos_init_cell (GnmEvalPos *ep, GnmCell const *cell)
 179 {
 180         g_return_val_if_fail (ep != NULL, NULL);
 181         g_return_val_if_fail (cell != NULL, NULL);
 182
 183         ep->eval = cell->pos;
 184         ep->sheet = cell->base.sheet;
 185         ep->dep = (GnmDependent *)GNM_CELL_TO_DEP (cell);
 186         ep->array_texpr = NULL;
 187
 188         return ep;
 189 }
 190
 191 /**
 192  * eval_pos_init_sheet:
 193  * @ep: The position to init.
 194  * @sheet: A sheet
 195  *
 196  * The function initializes an evalpos with the given sheet.
 197  *
 198  * Returns: (transfer none): the initialized #GnmEvalPos (@ep).
 199  */
 200 GnmEvalPos *
 201 eval_pos_init_sheet (GnmEvalPos *ep, Sheet const *sheet)
 202 {
 203         g_return_val_if_fail (ep != NULL, NULL);
 204         g_return_val_if_fail (IS_SHEET (sheet), NULL);
 205
 206         ep->eval.col = ep->eval.row = 0;
 207         ep->sheet = (Sheet *)sheet;
 208         ep->dep = NULL;
 209         ep->array_texpr = NULL;
 210
 211         return ep;
 212 }
 213
 214 gboolean
 215 eval_pos_is_array_context (GnmEvalPos const *ep)
 216 {
 217         return ep->array_texpr != NULL;
 218 }
 219
 220
 221 static GnmParsePos *
 222 gnm_parse_pos_dup (GnmParsePos *ep)
 223 {
 224         GnmParsePos *res = g_new0 (GnmParsePos, 1);
 225         memcpy (res, ep, sizeof (GnmParsePos)); /* is this safe? */
 226         return res;
 227 }
 228
 229 GType
 230 gnm_parse_pos_get_type (void)
 231 {
 232         static GType t = 0;
 233
 234         if (t == 0) {
 235                 t = g_boxed_type_register_static ("GnmParsePos",
 236                          (GBoxedCopyFunc)gnm_parse_pos_dup,
 237                          (GBoxedFreeFunc)g_free);
 238         }
 239         return t;
 240 }
 241
 242 /*
 243  * parse_pos_init:
 244  *
 245  * @pp: The position to init.
 246  * @sheet: The sheet being selected
 247  * @wb: The workbook being selected.
 248  * @row:
 249  * @col:
 250  *
 251  * Use either a sheet (preferred) or a workbook to initialize the supplied
 252  * ParsePosition.
 253  * Returns: (transfer none): the initialized #GnmParsePos (@pp).
 254  */
 255 GnmParsePos *
 256 parse_pos_init (GnmParsePos *pp, Workbook *wb, Sheet const *sheet,
 257                 int col, int row)
 258 {
 259         /* Global */
 260         if (wb == NULL && sheet == NULL)
 261                 return NULL;
 262
 263         g_return_val_if_fail (pp != NULL, NULL);
 264
 265         pp->sheet = (Sheet *)sheet;
 266         pp->wb = sheet ? sheet->workbook : wb;
 267         pp->eval.col = col;
 268         pp->eval.row = row;
 269
 270         return pp;
 271 }
 272
 273 /*
 274  * parse_pos_init_dep:
 275  * @pp: The position to init.
 276  * @dep: The dependent
 277  *
 278  * Returns: (transfer none): the initialized #GnmParsePos (@pp).
 279  */
 280 GnmParsePos *
 281 parse_pos_init_dep (GnmParsePos *pp, GnmDependent const *dep)
 282 {
 283         g_return_val_if_fail (pp != NULL, NULL);
 284
 285         pp->sheet = dep->sheet;
 286         pp->wb = dep->sheet ? dep->sheet->workbook : NULL;
 287         pp->eval = *dependent_pos (dep);
 288
 289         return pp;
 290 }
 291
 292 /*
 293  * parse_pos_init_cell:
 294  * @pp: The position to init.
 295  * @cell: The cell
 296  *
 297  * Returns: (transfer none): the initialized #GnmParsePos (@pp).
 298  */
 299 GnmParsePos *
 300 parse_pos_init_cell (GnmParsePos *pp, GnmCell const *cell)
 301 {
 302         g_return_val_if_fail (cell != NULL, NULL);
 303         g_return_val_if_fail (IS_SHEET (cell->base.sheet), NULL);
 304         g_return_val_if_fail (cell->base.sheet->workbook != NULL, NULL);
 305
 306         return parse_pos_init (pp, NULL, cell->base.sheet,
 307                                cell->pos.col, cell->pos.row);
 308 }
 309
 310 /*
 311  * parse_pos_init_evalpos:
 312  * @pp: The position to init.
 313  * @ep: #GnmEvalPos
 314  *
 315  * Returns: (transfer none): the initialized #GnmParsePos (@pp).
 316  */
 317 GnmParsePos *
 318 parse_pos_init_evalpos (GnmParsePos *pp, GnmEvalPos const *ep)
 319 {
 320         g_return_val_if_fail (ep != NULL, NULL);
 321
 322         return parse_pos_init (pp, NULL, ep->sheet, ep->eval.col, ep->eval.row);
 323 }
 324
 325 /*
 326  * parse_pos_init_editpos:
 327  * @pp: The position to init.
 328  * @sv: sheet view
 329  *
 330  * Returns: (transfer none): the initialized #GnmParsePos (@pp).
 331  */
 332 GnmParsePos *
 333 parse_pos_init_editpos (GnmParsePos *pp, SheetView const *sv)
 334 {
 335         g_return_val_if_fail (GNM_IS_SV (sv), NULL);
 336
 337         return parse_pos_init (pp, NULL, sv_sheet (sv),
 338                 sv->edit_pos.col, sv->edit_pos.row);
 339 }
 340
 341 /*
 342  * parse_pos_init_sheet:
 343  * @pp: The position to init.
 344  * @sheet: The sheet
 345  *
 346  * Returns: (transfer none): the initialized #GnmParsePos (@pp).
 347  */
 348 GnmParsePos *
 349 parse_pos_init_sheet (GnmParsePos *pp, Sheet const *sheet)
 350 {
 351         g_return_val_if_fail (pp != NULL, NULL);
 352         g_return_val_if_fail (IS_SHEET (sheet), NULL);
 353         return parse_pos_init (pp, NULL, sheet, 0, 0);
 354 }
 355
 356 /********************************************************************************/
 357
 358
 359 static GnmCellRef *
 360 gnm_cellref_dup (GnmCellRef *ep)
 361 {
 362         GnmCellRef *res = g_new0 (GnmCellRef, 1);
 363         memcpy (res, ep, sizeof (GnmCellRef)); /* is this safe? */
 364         return res;
 365 }
 366
 367 GType
 368 gnm_cellref_get_type (void)
 369 {
 370         static GType t = 0;
 371
 372         if (t == 0) {
 373                 t = g_boxed_type_register_static ("GnmCellRef",
 374                          (GBoxedCopyFunc)gnm_cellref_dup,
 375                          (GBoxedFreeFunc)g_free);
 376         }
 377         return t;
 378 }
 379 GnmCellRef *
 380 gnm_cellref_init (GnmCellRef *ref, Sheet *sheet, int col, int row, gboolean relative)
 381 {
 382         ref->sheet = sheet;
 383         ref->col   = col;
 384         ref->row   = row;
 385         ref->col_relative = ref->row_relative = relative;
 386
 387         return ref;
 388 }
 389
 390 gboolean
 391 gnm_cellref_equal (GnmCellRef const *a, GnmCellRef const *b)
 392 {
 393         return (a->col == b->col) &&
 394                (a->col_relative == b->col_relative) &&
 395                (a->row == b->row) &&
 396                (a->row_relative == b->row_relative) &&
 397                (a->sheet == b->sheet);
 398 }
 399
 400 guint
 401 gnm_cellref_hash (GnmCellRef const *cr)
 402 {
 403         guint h = cr->row;
 404         h = (h << 16) | (h >> 16);
 405         h ^= ((guint)cr->col << 2);
 406         if (cr->col_relative) h ^= 1;
 407         if (cr->row_relative) h ^= 2;
 408         return h;
 409 }
 410
 411 int
 412 gnm_cellref_get_col (GnmCellRef const *ref, GnmEvalPos const *ep)
 413 {
 414         g_return_val_if_fail (ref != NULL, 0);
 415         g_return_val_if_fail (ep != NULL, 0);
 416
 417         if (ref->col_relative) {
 418                 Sheet const *sheet = eval_sheet (ref->sheet, ep->sheet);
 419                 int res = (ep->eval.col + ref->col) % gnm_sheet_get_max_cols (sheet);
 420                 if (res < 0)
 421                         return res + gnm_sheet_get_max_cols (sheet);
 422                 return res;
 423         }
 424         return ref->col;
 425 }
 426
 427 int
 428 gnm_cellref_get_row (GnmCellRef const *ref, GnmEvalPos const *ep)
 429 {
 430         g_return_val_if_fail (ref != NULL, 0);
 431         g_return_val_if_fail (ep != NULL, 0);
 432
 433         if (ref->row_relative) {
 434                 Sheet const *sheet = eval_sheet (ref->sheet, ep->sheet);
 435                 int res = (ep->eval.row + ref->row) % gnm_sheet_get_max_rows (sheet);
 436                 if (res < 0)
 437                         return res + gnm_sheet_get_max_rows (sheet);
 438                 return res;
 439         }
 440         return ref->row;
 441 }
 442
 443 static int
 444 modulo (int i, int max)
 445 {
 446         if (i < 0) {
 447                 i %= max;
 448                 if (i < 0)
 449                         i += max;
 450         } else if (i >= max)
 451                 i %= max;
 452
 453         return i;
 454 }
 455
 456
 457 void
 458 gnm_cellpos_init_cellref_ss (GnmCellPos *res, GnmCellRef const *cell_ref,
 459                              GnmCellPos const *pos, GnmSheetSize const *ss)
 460 {
 461         g_return_if_fail (cell_ref != NULL);
 462         g_return_if_fail (res != NULL);
 463
 464         if (cell_ref->col_relative) {
 465                 int col = cell_ref->col + pos->col;
 466                 res->col = modulo (col, ss->max_cols);
 467         } else
 468                 res->col = cell_ref->col;
 469
 470         if (cell_ref->row_relative) {
 471                 int row = cell_ref->row + pos->row;
 472                 res->row = modulo (row, ss->max_rows);
 473         } else
 474                 res->row = cell_ref->row;
 475 }
 476
 477 void
 478 gnm_cellpos_init_cellref (GnmCellPos *res, GnmCellRef const *cell_ref,
 479                           GnmCellPos const *pos, Sheet const *base_sheet)
 480 {
 481         Sheet const *sheet = eval_sheet (cell_ref->sheet, base_sheet);
 482         gnm_cellpos_init_cellref_ss (res, cell_ref, pos,
 483                                      gnm_sheet_get_size (sheet));
 484 }
 485
 486 void
 487 gnm_cellref_make_abs (GnmCellRef *dest, GnmCellRef const *src, GnmEvalPos const *ep)
 488 {
 489         GnmCellPos pos;
 490
 491         g_return_if_fail (dest != NULL);
 492         g_return_if_fail (src != NULL);
 493         g_return_if_fail (ep != NULL);
 494
 495         gnm_cellpos_init_cellref (&pos, src, &ep->eval, ep->sheet);
 496
 497         dest->sheet = src->sheet;
 498         dest->col = pos.col;
 499         dest->row = pos.row;
 500         dest->col_relative = FALSE;
 501         dest->row_relative = FALSE;
 502 }
 503
 504 void
 505 gnm_cellref_set_col_ar (GnmCellRef *cr, GnmParsePos const *pp, gboolean abs_rel)
 506 {
 507         if (cr->col_relative ^ abs_rel) {
 508                 if (cr->col_relative)
 509                         cr->col += pp->eval.col;
 510                 else
 511                         cr->col -= pp->eval.col;
 512                 cr->col_relative = abs_rel;
 513         }
 514 }
 515
 516 void
 517 gnm_cellref_set_row_ar (GnmCellRef *cr, GnmParsePos const *pp, gboolean abs_rel)
 518 {
 519         if (cr->row_relative ^ abs_rel) {
 520                 if (cr->row_relative)
 521                         cr->row += pp->eval.row;
 522                 else
 523                         cr->row -= pp->eval.row;
 524                 cr->row_relative = abs_rel;
 525         }
 526 }
 527
 528 gboolean
 529 gnm_rangeref_equal (GnmRangeRef const *a, GnmRangeRef const *b)
 530 {
 531         return  gnm_cellref_equal (&a->a, &b->a) &&
 532                 gnm_cellref_equal (&a->b, &b->b);
 533 }
 534
 535 guint
 536 gnm_rangeref_hash (GnmRangeRef const *rr)
 537 {
 538         guint h = gnm_cellref_hash (&rr->a);
 539         h = (h << 16) | (h >> 16);
 540         h ^= gnm_cellref_hash (&rr->b);
 541         return h;
 542 }
 543
 544 GnmRangeRef *
 545 gnm_rangeref_dup (GnmRangeRef const *rr)
 546 {
 547         GnmRangeRef *res;
 548
 549         g_return_val_if_fail (rr != NULL, NULL);
 550
 551         res = g_new (GnmRangeRef, 1);
 552         *res = *rr;
 553         return res;
 554 }
 555
 556 GType
 557 gnm_rangeref_get_type (void)
 558 {
 559         static GType t = 0;
 560
 561         if (t == 0) {
 562                 t = g_boxed_type_register_static ("GnmRangeRef",
 563                          (GBoxedCopyFunc)gnm_rangeref_dup,
 564                          (GBoxedFreeFunc)g_free);
 565         }
 566         return t;
 567 }
 568
 569 void
 570 gnm_rangeref_normalize_pp (GnmRangeRef const *ref, GnmParsePos const *pp,
 571                            Sheet **start_sheet, Sheet **end_sheet,
 572                            GnmRange *dest)
 573 {
 574         GnmSheetSize const *ss;
 575
 576         g_return_if_fail (ref != NULL);
 577         g_return_if_fail (pp != NULL);
 578
 579         *start_sheet = eval_sheet (ref->a.sheet, pp->sheet);
 580         *end_sheet   = eval_sheet (ref->b.sheet, *start_sheet);
 581
 582         ss = gnm_sheet_get_size2 (*start_sheet, pp->wb);
 583         gnm_cellpos_init_cellref_ss (&dest->start, &ref->a, &pp->eval, ss);
 584
 585         ss = *end_sheet
 586                 ? gnm_sheet_get_size (*end_sheet)
 587                 : ss;
 588         gnm_cellpos_init_cellref_ss (&dest->end, &ref->b, &pp->eval, ss);
 589
 590         range_normalize (dest);
 591 }
 592
 593 /**
 594  * gnm_rangeref_normalize:
 595  *
 596  * Take a range_ref and normalize it by converting to absolute coords and
 597  * handling inversions.
 598  */
 599 void
 600 gnm_rangeref_normalize (GnmRangeRef const *ref, GnmEvalPos const *ep,
 601                         Sheet **start_sheet, Sheet **end_sheet, GnmRange *dest)
 602 {
 603         GnmParsePos pp;
 604
 605         parse_pos_init_evalpos (&pp, ep);
 606         gnm_rangeref_normalize_pp (ref, &pp, start_sheet, end_sheet, dest);
 607 }
 608
 609 guint
 610 gnm_cellpos_hash (GnmCellPos const *key)
 611 {
 612         guint h = key->row;
 613         h = (h << 16) | (h >> 16);
 614         h ^= key->col;
 615         return h;
 616 }
 617
 618 gint
 619 gnm_cellpos_equal (GnmCellPos const *a, GnmCellPos const *b)
 620 {
 621         return (a->row == b->row && a->col == b->col);
 622 }
 623