src/sheet-autofill.c

   1 /* vim: set sw=8: -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  * sheet-autofill.c: Provides the autofill features
   4  *
   5  * Author:
   6  *   Miguel de Icaza (miguel@kernel.org), 1998
   7  *   Jody Goldberg (jody@gnome.org), 1999-2006
   8  *   Copyright (C) 1999-2009 Morten Welinder (terra@gnome.org)
   9  */
  10 #include <gnumeric-config.h>
  11 #include <glib/gi18n-lib.h>
  12 #include "gnumeric.h"
  13 #include "sheet-autofill.h"
  14
  15 #include "sheet.h"
  16 #include "cell.h"
  17 #include "value.h"
  18 #include "workbook.h"
  19 #include "sheet-style.h"
  20 #include "expr.h"
  21 #include "gnm-datetime.h"
  22 #include "mstyle.h"
  23 #include "ranges.h"
  24 #include "sheet-merge.h"
  25 #include "gnm-format.h"
  26 #include <goffice/goffice.h>
  27
  28 #include <string.h>
  29 #include <errno.h>
  30 #include <stdlib.h>
  31
  32 /* ------------------------------------------------------------------------- */
  33
  34 static char *month_names_long[12 + 1];
  35 static char *month_names_short[12 + 1];
  36 static char *weekday_names_long[7 + 1];
  37 static char *weekday_names_short[7 + 1];
  38 static char *quarters[4 + 1];
  39 static gboolean has_quarters;
  40
  41 /**
  42  * gnm_autofill_init: (skip)
  43  */
  44 void
  45 gnm_autofill_init (void)
  46 {
  47         GDateMonth m;
  48         GDateWeekday wd;
  49         char const *qtemplate;
  50
  51         for (m = 1; m <= 12; m++) {
  52                 month_names_long[m - 1] = go_date_month_name (m, FALSE);
  53                 month_names_short[m - 1] = go_date_month_name (m, TRUE);
  54         }
  55         for (wd = 1; wd <= 7; wd++) {
  56                 weekday_names_long[wd - 1] = go_date_weekday_name (wd, FALSE);
  57                 weekday_names_short[wd - 1] = go_date_weekday_name (wd, TRUE);
  58         }
  59
  60         /* xgettext: This is a C format string where %d will be replaced
  61            by 1, 2, 3, or 4.  A year will then be appended and we'll get
  62            something like 3Q2005.  If that makes no sense in your language,
  63            translate to the empty string.  */
  64         qtemplate = _("%dQ");
  65         has_quarters = (qtemplate[0] != 0);
  66         if (has_quarters) {
  67                 int q;
  68                 for (q = 1; q <= 4; q++)
  69                         quarters[q - 1] = g_strdup_printf (qtemplate, q);
  70         }
  71 }
  72
  73 /**
  74  * gnm_autofill_shutdown: (skip)
  75  */
  76 void
  77 gnm_autofill_shutdown (void)
  78 {
  79         GDateMonth m;
  80         GDateWeekday wd;
  81         int q;
  82
  83         for (m = 1; m <= 12; m++) {
  84                 g_free (month_names_long[m - 1]);
  85                 g_free (month_names_short[m - 1]);
  86         }
  87         for (wd = 1; wd <= 7; wd++) {
  88                 g_free (weekday_names_long[wd - 1]);
  89                 g_free (weekday_names_short[wd - 1]);
  90         }
  91         for (q = 1; q <= 4; q++)
  92                 g_free (quarters[q - 1]);
  93 }
  94
  95 /* ------------------------------------------------------------------------- */
  96
  97 typedef enum {
  98         AFS_INCOMPLETE,
  99         AFS_READY,
 100         AFS_ERROR
 101 } AutoFillerStatus;
 102
 103 typedef struct _AutoFiller AutoFiller;
 104
 105 struct _AutoFiller {
 106         AutoFillerStatus status;
 107         int priority;
 108
 109         void (*finalize) (AutoFiller *af);
 110
 111         /* Given a new cell, adapt filler to that.  */
 112         void (*teach_cell) (AutoFiller *af, const GnmCell *cell, int n);
 113
 114         /* Set cell to the value of the nth sequence member.  */
 115         void (*set_cell) (AutoFiller *af, GnmCell *cell, int n);
 116
 117         /* Hint of what will be the nth element.  */
 118         char * (*hint) (AutoFiller *af, GnmCellPos *pos, int n);
 119 };
 120
 121 static void
 122 af_finalize (AutoFiller *af)
 123 {
 124         g_free (af);
 125 }
 126
 127 /* ------------------------------------------------------------------------- */
 128 /*
 129  * Arithmetic sequences:
 130  *
 131  * 1, 2, 3, ...
 132  * 1, 3, 5, ....
 133  * 1-Jan-2009, 2-Jan-2009, 3-Jan-2009, ...
 134  * 1-Jan-2009, 8-Jan-2009, 15-Jan-2009, ...
 135  * 00:00, 00:30, 01:00, ...
 136  */
 137
 138 typedef struct {
 139         AutoFiller filler;
 140
 141         gboolean singleton;  /* Missing step becomes 1.  */
 142         gnm_float base, step;
 143         GOFormat *format;
 144         GODateConventions const *dateconv;
 145 } AutoFillerArithmetic;
 146
 147 static void
 148 afa_finalize (AutoFiller *af)
 149 {
 150         AutoFillerArithmetic *afa = (AutoFillerArithmetic *)af;
 151         go_format_unref (afa->format);
 152         af_finalize (af);
 153 }
 154
 155 static void
 156 afa_teach_cell (AutoFiller *af, const GnmCell *cell, int n)
 157 {
 158         AutoFillerArithmetic *afa = (AutoFillerArithmetic *)af;
 159         GnmValue *value = cell ? cell->value : NULL;
 160         gnm_float f;
 161
 162         if (value == NULL ||
 163             gnm_cell_has_expr (cell) ||
 164             !VALUE_IS_NUMBER (value) ||
 165             VALUE_IS_BOOLEAN (value)) {
 166                 af->status = AFS_ERROR;
 167                 return;
 168         }
 169
 170         f = value_get_as_float (value);
 171
 172         switch (n) {
 173         case 0:
 174                 afa->dateconv = sheet_date_conv (cell->base.sheet);
 175                 afa->base = f;
 176                 if (afa->singleton) {
 177                         afa->step = 1;
 178                         af->status = AFS_READY;
 179                 }
 180                 if (VALUE_FMT (value))
 181                         afa->format = go_format_ref (VALUE_FMT (value));
 182                 break;
 183         case 1:
 184                 afa->step = f - afa->base;
 185                 af->status = AFS_READY;
 186                 break;
 187         default: {
 188                 gnm_float step2 = (f - afa->base) / n;
 189                 gnm_float step_sum = gnm_abs (afa->step) + gnm_abs (step2);
 190                 gnm_float err = step_sum
 191                         ? gnm_abs (afa->step - step2) / step_sum
 192                         : 0;
 193                 /* Be fairly lenient: */
 194                 if (err > (n + 64) * GNM_EPSILON) {
 195                         af->status = AFS_ERROR;
 196                         return;
 197                 }
 198         }
 199         }
 200 }
 201
 202 static GnmValue *
 203 afa_compute (AutoFillerArithmetic *afa, int n)
 204 {
 205         gnm_float f = afa->base + n * afa->step;
 206         GnmValue *v = value_new_float (f);
 207         if (afa->format)
 208                 value_set_fmt (v, afa->format);
 209         return v;
 210 }
 211
 212 static void
 213 afa_set_cell (AutoFiller *af, GnmCell *cell, int n)
 214 {
 215         AutoFillerArithmetic *afa = (AutoFillerArithmetic *)af;
 216         GnmValue *v = afa_compute (afa, n);
 217         gnm_cell_set_value (cell, v);
 218 }
 219
 220 static char *
 221 afa_hint (AutoFiller *af, GnmCellPos *pos, int n)
 222 {
 223         AutoFillerArithmetic *afa = (AutoFillerArithmetic *)af;
 224         GnmValue *v = afa_compute (afa, n);
 225         char *res = format_value (NULL, v, -1, afa->dateconv);
 226         value_release (v);
 227         return res;
 228 }
 229
 230 static AutoFiller *
 231 auto_filler_arithmetic (gboolean singleton)
 232 {
 233         AutoFillerArithmetic *res = g_new (AutoFillerArithmetic, 1);
 234
 235         res->filler.status = AFS_INCOMPLETE;
 236         res->filler.priority = 100;
 237         res->filler.finalize = afa_finalize;
 238         res->filler.teach_cell = afa_teach_cell;
 239         res->filler.set_cell = afa_set_cell;
 240         res->filler.hint = afa_hint;
 241         res->format = NULL;
 242         res->dateconv = NULL;
 243         res->singleton = singleton;
 244
 245         return &res->filler;
 246 }
 247
 248 /* ------------------------------------------------------------------------- */
 249
 250 typedef struct {
 251         gnm_float base, step;
 252         GString *prefix, *suffix;
 253         gboolean fixed_length;
 254         int base_phase, phases;
 255         gsize numlen;
 256         gnm_float p10;
 257 } ArithString;
 258
 259 static void
 260 as_finalize (ArithString *as)
 261 {
 262         if (as->prefix)
 263                 g_string_free (as->prefix, TRUE);
 264         if (as->suffix)
 265                 g_string_free (as->suffix, TRUE);
 266 }
 267
 268 static gboolean
 269 as_check_prefix_suffix (ArithString *as, char const *s, gsize slen)
 270 {
 271         if (as->prefix) {
 272                 if (slen < as->prefix->len ||
 273                     memcmp (s, as->prefix->str, as->prefix->len) != 0)
 274                         return TRUE;
 275                 s += as->prefix->len;
 276                 slen -= as->prefix->len;
 277         }
 278
 279         if (as->suffix) {
 280                 if (slen < as->suffix->len ||
 281                     memcmp (s + slen - as->suffix->len,
 282                             as->suffix->str,
 283                             as->suffix->len) != 0)
 284                         return TRUE;
 285         }
 286
 287         return FALSE;
 288 }
 289
 290 static gnm_float
 291 as_compute_val (ArithString *as, int n)
 292 {
 293         int pn = (n * as->step + as->base_phase) / as->phases;
 294         gnm_float f = as->base + pn;
 295         if (as->fixed_length)
 296                 f = gnm_fmod (f, as->p10);
 297         return f;
 298 }
 299
 300 static char *
 301 as_compute (ArithString *as, int n)
 302 {
 303         gnm_float f = as_compute_val (as, n);
 304         char const *prefix = as->prefix ? as->prefix->str : "";
 305         char const *suffix = as->suffix ? as->suffix->str : "";
 306
 307         if (as->fixed_length) {
 308                 return g_strdup_printf ("%s%0*.0" GNM_FORMAT_f "%s",
 309                                         prefix,
 310                                         (int)as->numlen, f,
 311                                         suffix);
 312         } else {
 313                 return g_strdup_printf ("%s%.0" GNM_FORMAT_f "%s",
 314                                         prefix,
 315                                         f,
 316                                         suffix);
 317         }
 318 }
 319
 320 static gboolean
 321 as_teach_first (ArithString *as, char const *s)
 322 {
 323         gsize pl;
 324         char *end;
 325
 326         for (pl = 0; s[pl]; pl++) {
 327                 if (g_ascii_isdigit (s[pl]))
 328                         break;
 329                 if (!as->fixed_length &&
 330                     (s[pl] == '+' || s[pl] == '-') &&
 331                     g_ascii_isdigit (s[pl + 1]))
 332                         break;
 333         }
 334         if (s[pl] == 0)
 335                 return TRUE;
 336
 337         if (pl > 0) {
 338                 if (as->prefix)
 339                         g_string_append_len (as->prefix, s, pl);
 340                 else
 341                         return TRUE;  /* No prefix allowed.  */
 342         }
 343         errno = 0;
 344         as->base = strtol (s + pl, &end, 10);
 345         as->step = 1;
 346         if (errno)
 347                 return TRUE;
 348         if (*end) {
 349                 if (as->suffix)
 350                         g_string_append (as->suffix, end);
 351                 else
 352                         return TRUE;  /* No suffix allowed.  */
 353         }
 354
 355         as->numlen = end - (s + pl);
 356         as->p10 = gnm_pow10 (as->numlen);
 357
 358         return FALSE;
 359 }
 360
 361 static gboolean
 362 as_teach_rest (ArithString *as, char const *s, int n, int phase)
 363 {
 364         gsize slen = strlen (s);
 365         char *end;
 366         gnm_float val;
 367         char const *s2 = s + (as->prefix ? as->prefix->len : 0);
 368
 369         if (as_check_prefix_suffix (as, s, slen))
 370                 return TRUE;
 371
 372         if (g_ascii_isspace (*s2))
 373                 return TRUE;
 374
 375         errno = 0;
 376         if (as->fixed_length) {
 377                 if (!g_ascii_isdigit (*s2))
 378                         return TRUE;
 379                 val = strtol (s2, &end, 10);
 380                 if (as->numlen != (gsize)(end - s2))
 381                         return TRUE;
 382         } else {
 383                 /*
 384                  * Verify no leading zero so the fixed-length
 385                  * version gets a chance.
 386                  */
 387                 char const *s3 = s2;
 388                 if (!g_ascii_isdigit (*s3))
 389                         s3++;
 390                 if (s3[0] == '0' && g_ascii_isdigit (s3[1]))
 391                         return TRUE;
 392                 val = strtol (s2, &end, 10);
 393         }
 394
 395         if (errno == ERANGE || end != s + slen - (as->suffix ? as->suffix->len : 0))
 396                 return TRUE;
 397
 398         if (n == 1) {
 399                 as->step = (val - as->base) * as->phases + (phase - as->base_phase);
 400                 if (as->fixed_length && as->step < 0)
 401                         as->step += as->p10 * as->phases;
 402         } else {
 403                 gnm_float f = as_compute_val (as, n);
 404                 if (gnm_abs (f - val) > 0.5)
 405                         return TRUE;
 406         }
 407
 408         return FALSE;
 409 }
 410
 411 /* ------------------------------------------------------------------------- */
 412
 413 /*
 414  * Arithmetic sequences in strings:
 415  *
 416  * "Foo 1", "Foo 2", "Foo 3", ...
 417  * "1 Bar", "3 Bar", "5 Bar", ...
 418  * "Fall '99", "Fall '00", "Fall '01", ...
 419  */
 420
 421 typedef struct {
 422         AutoFiller filler;
 423
 424         gboolean singleton;  /* Missing step becomes 1.  */
 425         ArithString as;
 426 } AutoFillerNumberString;
 427
 428 static void
 429 afns_finalize (AutoFiller *af)
 430 {
 431         AutoFillerNumberString *afns = (AutoFillerNumberString *)af;
 432         as_finalize (&afns->as);
 433         af_finalize (af);
 434 }
 435
 436 static void
 437 afns_teach_cell (AutoFiller *af, const GnmCell *cell, int n)
 438 {
 439         AutoFillerNumberString *afns = (AutoFillerNumberString *)af;
 440         GnmValue *value = cell ? cell->value : NULL;
 441         char const *s;
 442
 443         if (value == NULL ||
 444             gnm_cell_has_expr (cell) ||
 445             !VALUE_IS_STRING (value)) {
 446         bad:
 447                 af->status = AFS_ERROR;
 448                 return;
 449         }
 450
 451         s = value_peek_string (value);
 452
 453         if (n == 0) {
 454                 if (as_teach_first (&afns->as, s))
 455                         goto bad;
 456
 457                 if (afns->singleton)
 458                         af->status = AFS_READY;
 459         } else {
 460                 if (as_teach_rest (&afns->as, s, n, 0))
 461                         goto bad;
 462
 463                 af->status = AFS_READY;
 464         }
 465 }
 466
 467 static char *
 468 afns_compute (AutoFillerNumberString *afns, int n)
 469 {
 470         return as_compute (&afns->as, n);
 471 }
 472
 473 static void
 474 afns_set_cell (AutoFiller *af, GnmCell *cell, int n)
 475 {
 476         AutoFillerNumberString *afns = (AutoFillerNumberString *)af;
 477         char *s = afns_compute (afns, n);
 478         gnm_cell_set_value (cell, value_new_string_nocopy (s));
 479 }
 480
 481 static char *
 482 afns_hint (AutoFiller *af, GnmCellPos *pos, int n)
 483 {
 484         AutoFillerNumberString *afns = (AutoFillerNumberString *)af;
 485         return afns_compute (afns, n);
 486 }
 487
 488 static AutoFiller *
 489 auto_filler_number_string (gboolean singleton, gboolean fixed_length)
 490 {
 491         AutoFillerNumberString *res = g_new (AutoFillerNumberString, 1);
 492
 493         res->filler.status = AFS_INCOMPLETE;
 494         res->filler.priority = fixed_length ? 9 : 10;
 495         res->filler.finalize = afns_finalize;
 496         res->filler.teach_cell = afns_teach_cell;
 497         res->filler.set_cell = afns_set_cell;
 498         res->filler.hint = afns_hint;
 499         res->singleton = singleton;
 500         res->as.fixed_length = fixed_length;
 501         res->as.prefix = g_string_new (NULL);
 502         res->as.suffix = g_string_new (NULL);
 503         res->as.base_phase = 0;
 504         res->as.phases = 1;
 505
 506         return &res->filler;
 507 }
 508
 509 /* ------------------------------------------------------------------------- */
 510 /*
 511  * Month sequences:
 512  *
 513  * 1-Jan-2009, 1-Feb-2009, 1-Mar-2009, ...
 514  * 31-Jan-2009, 28-Feb-2009, 31-Mar-2009, ...
 515  * 1-Jan-2009, 1-Jan-2010, 1-Jan-2011, ...
 516  */
 517
 518 typedef struct {
 519         AutoFiller filler;
 520
 521         GODateConventions const *dateconv;
 522         GDate base;
 523         GOFormat *format;
 524         int nmonths;
 525         gboolean end_of_month, same_of_month;
 526 } AutoFillerMonth;
 527
 528 static void
 529 afm_finalize (AutoFiller *af)
 530 {
 531         AutoFillerMonth *afm = (AutoFillerMonth *)af;
 532         go_format_unref (afm->format);
 533         af_finalize (af);
 534 }
 535
 536 static void
 537 afm_teach_cell (AutoFiller *af, const GnmCell *cell, int n)
 538 {
 539         AutoFillerMonth *afm = (AutoFillerMonth *)af;
 540         GnmValue *value = cell ? cell->value : NULL;
 541         GDate d;
 542         const GOFormat *sf;
 543
 544         if (value == NULL || gnm_cell_has_expr (cell)) {
 545         bad:
 546                 af->status = AFS_ERROR;
 547                 return;
 548         }
 549
 550         sf = gnm_cell_get_format (cell);
 551         if (gnm_format_is_date_for_value (sf, value) != 1)
 552                 goto bad;
 553
 554         afm->dateconv = sheet_date_conv (cell->base.sheet);
 555         if (!datetime_value_to_g (&d, value, afm->dateconv))
 556                 goto bad;
 557
 558         if (!g_date_is_last_of_month (&d))
 559                 afm->end_of_month = FALSE;
 560
 561         if (n == 0) {
 562                 if (VALUE_FMT (value))
 563                         afm->format = go_format_ref (VALUE_FMT (value));
 564                 afm->base = d;
 565         } else {
 566                 int year = g_date_get_year (&d);
 567                 int month = g_date_get_month (&d);
 568                 int day = g_date_get_day (&d);
 569                 int nmonths;
 570
 571                 if (day != g_date_get_day (&afm->base))
 572                         afm->same_of_month = FALSE;
 573
 574                 if (!afm->same_of_month && !afm->end_of_month)
 575                         goto bad;
 576
 577                 nmonths = 12 * (year - g_date_get_year (&afm->base)) +
 578                         (month - g_date_get_month (&afm->base));
 579                 if (n == 1)
 580                         afm->nmonths = nmonths;
 581                 else if (nmonths != afm->nmonths * n)
 582                         goto bad;
 583
 584                 af->status = AFS_READY;
 585         }
 586 }
 587
 588 static GnmValue *
 589 afm_compute (AutoFillerMonth *afm, int n)
 590 {
 591         GDate d = afm->base;
 592         GnmValue *v;
 593
 594         gnm_date_add_months (&d, n * afm->nmonths);
 595
 596         if (!g_date_valid (&d) || g_date_get_year (&d) > 9999)
 597                 return NULL;
 598
 599         if (afm->end_of_month) {
 600                 int year = g_date_get_year (&d);
 601                 int month = g_date_get_month (&d);
 602                 g_date_set_day (&d, g_date_get_days_in_month (month, year));
 603         }
 604
 605         v = value_new_int (go_date_g_to_serial (&d, afm->dateconv));
 606         if (afm->format)
 607                 value_set_fmt (v, afm->format);
 608         return v;
 609 }
 610
 611 static void
 612 afm_set_cell (AutoFiller *af, GnmCell *cell, int n)
 613 {
 614         AutoFillerMonth *afm = (AutoFillerMonth *)af;
 615         GnmValue *v = afm_compute (afm, n);
 616
 617         if (v)
 618                 gnm_cell_set_value (cell, v);
 619         else {
 620                 GnmEvalPos ep;
 621                 eval_pos_init_cell (&ep, cell);
 622                 gnm_cell_set_value (cell, value_new_error_VALUE (&ep));
 623         }
 624 }
 625
 626 static char *
 627 afm_hint (AutoFiller *af, GnmCellPos *pos, int n)
 628 {
 629         AutoFillerMonth *afm = (AutoFillerMonth *)af;
 630         GnmValue *v = afm_compute (afm, n);
 631         char *res = NULL;
 632
 633         if (v) {
 634                 res = format_value (NULL, v, -1, afm->dateconv);
 635                 value_release (v);
 636         }
 637
 638         return res;
 639 }
 640
 641 static AutoFiller *
 642 auto_filler_month (void)
 643 {
 644         AutoFillerMonth *res = g_new (AutoFillerMonth, 1);
 645
 646         res->filler.status = AFS_INCOMPLETE;
 647         res->filler.priority = 200;
 648         res->filler.finalize = afm_finalize;
 649         res->filler.teach_cell = afm_teach_cell;
 650         res->filler.set_cell = afm_set_cell;
 651         res->filler.hint = afm_hint;
 652         res->format = NULL;
 653         res->dateconv = NULL;
 654         res->end_of_month = TRUE;
 655         res->same_of_month = TRUE;
 656
 657         return &res->filler;
 658 }
 659
 660 /* ------------------------------------------------------------------------- */
 661
 662 typedef struct {
 663         AutoFiller filler;
 664
 665         char **list;
 666         gboolean with_number;
 667         ArithString as;
 668 } AutoFillerList;
 669
 670 static void
 671 afl_finalize (AutoFiller *af)
 672 {
 673         AutoFillerList *afl = (AutoFillerList *)af;
 674         as_finalize (&afl->as);
 675         af_finalize (af);
 676 }
 677
 678 static int
 679 afl_compute_phase (AutoFillerList *afl, int n)
 680 {
 681         return (int)(n * afl->as.step + afl->as.base_phase) %
 682                 afl->as.phases;
 683 }
 684
 685 static void
 686 afl_teach_cell (AutoFiller *af, const GnmCell *cell, int n)
 687 {
 688         AutoFillerList *afl = (AutoFillerList *)af;
 689         GnmValue *value = cell ? cell->value : NULL;
 690         char const *s;
 691         gsize elen = 0;
 692         int ph;
 693
 694         if (value == NULL ||
 695             gnm_cell_has_expr (cell) ||
 696             !VALUE_IS_STRING (value)) {
 697         bad:
 698                 af->status = AFS_ERROR;
 699                 return;
 700         }
 701
 702         s = value_peek_string (value);
 703         for (ph = 0; ph < afl->as.phases; ph++) {
 704                 char const *e = afl->list[ph];
 705                 elen = strlen (e);
 706                 /* This isn't UTF-8 pretty.  */
 707                 /* This isn't case pretty.  */
 708                 /* This won't work if one list item is a prefix of another.  */
 709                 if (strncmp (s, e, elen) == 0)
 710                         break;
 711         }
 712         if (ph == afl->as.phases)
 713                 goto bad;
 714
 715         if (n == 0) {
 716                 afl->as.base_phase = ph;
 717
 718                 if (afl->with_number) {
 719                         afl->as.prefix = g_string_new (NULL);
 720                         afl->as.suffix = g_string_new (NULL);
 721                         if (as_teach_first (&afl->as, s + elen))
 722                                 goto bad;
 723                 } else {
 724                         if (s[elen] != 0)
 725                                 goto bad;
 726                 }
 727         } else {
 728                 if (afl->with_number) {
 729                         if (as_teach_rest (&afl->as, s + elen, n, ph))
 730                                 goto bad;
 731                 } else {
 732                         if (s[elen] != 0)
 733                                 goto bad;
 734
 735                         if (n == 1) {
 736                                 int step = ph - afl->as.base_phase;
 737                                 if (step == 0)
 738                                         goto bad;
 739                                 if (step < 0)
 740                                         step += afl->as.phases;
 741                                 afl->as.step = step;
 742                         } else {
 743                                 if (ph != afl_compute_phase (afl, n))
 744                                         goto bad;
 745                         }
 746                 }
 747
 748                 af->status = AFS_READY;
 749         }
 750 }
 751
 752 static char *
 753 afl_compute (AutoFillerList *afl, int n)
 754 {
 755         GString *res = g_string_new (afl->list[afl_compute_phase (afl, n)]);
 756
 757         if (afl->with_number) {
 758                 char *s = as_compute (&afl->as, n);
 759                 g_string_append (res, s);
 760                 g_free (s);
 761         }
 762
 763         return g_string_free (res, FALSE);
 764 }
 765
 766 static void
 767 afl_set_cell (AutoFiller *af, GnmCell *cell, int n)
 768 {
 769         AutoFillerList *afl = (AutoFillerList *)af;
 770         char *str = afl_compute (afl, n);
 771         GnmValue *val = value_new_string_nocopy (str);
 772         gnm_cell_set_value (cell, val);
 773 }
 774
 775 static char *
 776 afl_hint (AutoFiller *af, GnmCellPos *pos, int n)
 777 {
 778         AutoFillerList *afl = (AutoFillerList *)af;
 779         return afl_compute (afl, n);
 780 }
 781
 782 static AutoFiller *
 783 auto_filler_list (char **list, int prio, gboolean with_number)
 784 {
 785         AutoFillerList *res = g_new (AutoFillerList, 1);
 786
 787         res->filler.status = AFS_INCOMPLETE;
 788         res->filler.priority = prio;
 789         res->filler.finalize = afl_finalize;
 790         res->filler.teach_cell = afl_teach_cell;
 791         res->filler.set_cell = afl_set_cell;
 792         res->filler.hint = afl_hint;
 793         res->list = list;
 794         res->with_number = with_number;
 795         res->as.phases = g_strv_length (list);
 796         res->as.fixed_length = TRUE;
 797         res->as.prefix = NULL;
 798         res->as.suffix = NULL;
 799
 800         return &res->filler;
 801 }
 802
 803 /* ------------------------------------------------------------------------- */
 804
 805 typedef struct {
 806         AutoFiller filler;
 807
 808         int size;
 809         GnmCellPos last;
 810         const GnmCell ** cells;
 811 } AutoFillerCopy;
 812
 813 static void
 814 afc_finalize (AutoFiller *af)
 815 {
 816         AutoFillerCopy *afe = (AutoFillerCopy *)af;
 817         g_free (afe->cells);
 818         af_finalize (af);
 819 }
 820
 821 static void
 822 afc_teach_cell (AutoFiller *af, const GnmCell *cell, int n)
 823 {
 824         AutoFillerCopy *afe = (AutoFillerCopy *)af;
 825         afe->cells[n] = cell;
 826         if (n == afe->size - 1) {
 827                 /* This actually includes the all-empty case.  */
 828                 af->status = AFS_READY;
 829         }
 830 }
 831
 832 static char *
 833 afc_set_cell_hint (AutoFiller *af, GnmCell *cell, GnmCellPos const *pos,
 834                    int n, gboolean doit)
 835 {
 836         AutoFillerCopy *afe = (AutoFillerCopy *)af;
 837         GnmCell const *src = afe->cells[n % afe->size];
 838         char *res = NULL;
 839         if (src && gnm_cell_has_expr (src)) {
 840                 GnmExprRelocateInfo rinfo;
 841                 GnmExprTop const *texpr;
 842                 GnmExprTop const *src_texpr = src->base.texpr;
 843                 Sheet *sheet = src->base.sheet;
 844
 845                 /* Arrays are always assigned fully at the corner.  */
 846                 if (gnm_expr_top_is_array_elem (src_texpr, NULL, NULL))
 847                         return NULL;
 848
 849                 rinfo.reloc_type = GNM_EXPR_RELOCATE_MOVE_RANGE;
 850                 rinfo.target_sheet = rinfo.origin_sheet = NULL;
 851                 rinfo.col_offset   = rinfo.row_offset = 0;
 852                 rinfo.origin.start = rinfo.origin.end = *pos;
 853                 parse_pos_init (&rinfo.pos, sheet->workbook, sheet,
 854                         pos->col, pos->row);
 855
 856                 texpr = gnm_expr_top_relocate (src_texpr, &rinfo, FALSE);
 857
 858                 /* Clip arrays that are only partially copied.  */
 859                 if (gnm_expr_top_is_array_corner (src_texpr)) {
 860                         GnmExpr const *aexpr;
 861                         int limit_x = afe->last.col - pos->col + 1;
 862                         int limit_y = afe->last.row - pos->row + 1;
 863                         int cols, rows;
 864
 865                         gnm_expr_top_get_array_size (texpr, &cols, &rows);
 866                         cols = MIN (limit_x, cols);
 867                         rows = MIN (limit_y, rows);
 868
 869                         if (texpr) {
 870                                 aexpr = gnm_expr_copy (gnm_expr_top_get_array_expr (texpr));
 871                                 gnm_expr_top_unref (texpr);
 872                         } else
 873                                 aexpr = gnm_expr_copy (gnm_expr_top_get_array_expr (src_texpr));
 874
 875                         if (doit)
 876                                 gnm_cell_set_array_formula
 877                                         (cell->base.sheet,
 878                                          pos->col, cell->pos.row,
 879                                          pos->col + (cols - 1),
 880                                          pos->row + (rows - 1),
 881                                          gnm_expr_top_new (aexpr));
 882                         else {
 883                                 res = gnm_expr_as_string (aexpr,
 884                                                           &rinfo.pos,
 885                                                           sheet->convs);
 886                                 gnm_expr_free (aexpr);
 887                         }
 888                 } else if (texpr) {
 889                         if (doit)
 890                                 gnm_cell_set_expr (cell, texpr);
 891                         else
 892                                 res = gnm_expr_top_as_string (texpr,
 893                                                               &rinfo.pos,
 894                                                               sheet->convs);
 895                         gnm_expr_top_unref (texpr);
 896                 } else {
 897                         if (doit)
 898                                 gnm_cell_set_expr (cell, src_texpr);
 899                         else
 900                                 res = gnm_expr_top_as_string (src_texpr,
 901                                                               &rinfo.pos,
 902                                                               sheet->convs);
 903                 }
 904         } else if (src) {
 905                 if (doit)
 906                         gnm_cell_set_value (cell, value_dup (src->value));
 907                 else {
 908                         Sheet const *sheet = src->base.sheet;
 909                         GODateConventions const *dateconv =
 910                                 sheet_date_conv (sheet);
 911                         GOFormat const *format = gnm_cell_get_format (src);
 912                         return format_value (format, src->value, -1,
 913                                              dateconv);
 914                 }
 915         } else {
 916                 if (doit)
 917                         sheet_cell_remove (cell->base.sheet, cell, TRUE, TRUE);
 918                 else
 919                         res = g_strdup (_("(empty)"));
 920         }
 921
 922         return res;
 923 }
 924
 925 static void
 926 afc_set_cell (AutoFiller *af, GnmCell *cell, int n)
 927 {
 928         afc_set_cell_hint (af, cell, &cell->pos, n, TRUE);
 929 }
 930
 931 static char *
 932 afc_hint (AutoFiller *af, GnmCellPos *pos, int n)
 933 {
 934         return afc_set_cell_hint (af, NULL, pos, n, FALSE);
 935 }
 936
 937 static AutoFiller *
 938 auto_filler_copy (int size, guint last_col, guint last_row)
 939 {
 940         AutoFillerCopy *res = g_new (AutoFillerCopy, 1);
 941
 942         res->filler.status = AFS_INCOMPLETE;
 943         res->filler.priority = 1;
 944         res->filler.finalize = afc_finalize;
 945         res->filler.teach_cell = afc_teach_cell;
 946         res->filler.set_cell = afc_set_cell;
 947         res->filler.hint = afc_hint;
 948         res->size = size;
 949         res->last.col = last_col;
 950         res->last.row = last_row;
 951         res->cells = g_new0 (GnmCell const *, size);
 952
 953         return &res->filler;
 954 }
 955
 956 /* ------------------------------------------------------------------------- */
 957
 958 static int
 959 calc_steps (const GnmRange *r, int col_inc, int row_inc)
 960 {
 961         if (r)
 962                 return col_inc
 963                         ? range_width (r) / ABS (col_inc)
 964                         : range_height (r) / ABS (row_inc);
 965         else
 966                 return 1;
 967 }
 968
 969
 970 /*
 971  * (base_col,base_row): start of source area.
 972  * (col_inc,row_inc): direction of fill.
 973  * count_max: size of source+fill area in direction of fill.
 974  * region_size: size of source area in direction of fill.
 975  * (last_col,last_row): last cell of entire area being filled.
 976  */
 977
 978 static char *
 979 sheet_autofill_dir (Sheet *sheet, gboolean singleton,
 980                     int base_col, int base_row,
 981                     int region_size,
 982                     int count_max,
 983                     int col_inc, int row_inc,
 984                     int last_col, int last_row,
 985                     gboolean doit)
 986 {
 987         GList *fillers = NULL;
 988         GList *f;
 989         int i, j, true_region_size;
 990         AutoFiller *af = NULL;
 991         GnmStyle const **styles;
 992         GnmRange const **merges;
 993         int *merge_size;
 994         char *hint = NULL;
 995         gboolean reverse;
 996
 997         if (count_max <= 0 || region_size <= 0)
 998                 return NULL;
 999
1000         /*
1001          * These are both indexed by cell number in the sequence we see
1002          * cells.  I.e., they go 0, 1, 2, ... no matter what way we fill
1003          * and no matter if some cells are merged.
1004          *
1005          * The allocations may be larger than we need, but we don't know
1006          * the right size yet.
1007          */
1008         styles = doit ? g_new0 (GnmStyle const *, region_size) : NULL;
1009         merges = g_new0 (GnmRange const *, region_size);
1010
1011         /*
1012          * i counts rows/cols.
1013          * j follows, but skips hidden parts of merged cells.
1014          */
1015
1016         /*
1017          * Pass 1: Have a look at the merges.  We always go right or down
1018          * in this pass.
1019          */
1020         merge_size = g_new0 (int, region_size);
1021         reverse = (col_inc < 0 || row_inc < 0);
1022         i = j = 0;
1023         while (i < region_size) {
1024                 int i2 = (reverse ? region_size - 1 - i : i);
1025                 int j2 = (reverse ? /*true_*/region_size - 1 - j : j);
1026                 int col2 = base_col + i2 * col_inc;
1027                 int row2 = base_row + i2 * row_inc;
1028                 GnmCellPos pos;
1029                 int di;
1030
1031                 if (styles) {
1032                         styles[j2] = sheet_style_get (sheet, col2, row2);
1033                         gnm_style_ref (styles[j2]);
1034                 }
1035
1036                 pos.col = col2;
1037                 pos.row = row2;
1038                 merges[j2] = gnm_sheet_merge_contains_pos (sheet, &pos);
1039                 di = calc_steps (merges[j2], col_inc, row_inc);
1040                 merge_size[j2] = di - 1;
1041                 i += di;
1042                 j++;
1043         }
1044         true_region_size = j;
1045
1046         /* We didn't know true_region_size up there.  Patch up things.  */
1047         if (reverse) {
1048                 memmove (merge_size,
1049                          merge_size + (region_size - true_region_size),
1050                          true_region_size * sizeof (*merge_size));
1051                 memmove (merges,
1052                          merges + (region_size - true_region_size),
1053                          true_region_size * sizeof (*merges));
1054                 if (styles)
1055                         memmove (styles,
1056                                  styles + (region_size - true_region_size),
1057                                  true_region_size * sizeof (*styles));
1058         }
1059
1060         fillers = g_list_prepend
1061                 (fillers, auto_filler_arithmetic (singleton));
1062         fillers = g_list_prepend
1063                 (fillers, auto_filler_number_string (singleton, TRUE));
1064         fillers = g_list_prepend
1065                 (fillers, auto_filler_number_string (singleton, FALSE));
1066         fillers = g_list_prepend
1067                 (fillers, auto_filler_month ());
1068         fillers = g_list_prepend
1069                 (fillers, auto_filler_copy (true_region_size,
1070                                             last_col, last_row));
1071         fillers = g_list_prepend (fillers, auto_filler_list (quarters, 50, TRUE));
1072
1073         fillers = g_list_prepend
1074                 (fillers, auto_filler_list (month_names_long, 61, TRUE));
1075         fillers = g_list_prepend
1076                 (fillers, auto_filler_list (month_names_short, 51, TRUE));
1077         fillers = g_list_prepend
1078                 (fillers, auto_filler_list (month_names_long, 61, FALSE));
1079         fillers = g_list_prepend
1080                 (fillers, auto_filler_list (month_names_short, 51, FALSE));
1081         fillers = g_list_prepend
1082                 (fillers, auto_filler_list (weekday_names_long, 60, FALSE));
1083         fillers = g_list_prepend
1084                 (fillers, auto_filler_list (weekday_names_short, 50, FALSE));
1085
1086         /*
1087          * Pass 2: Present all cells to the fillers and remove fillers that
1088          * cannot handle the contents.
1089          */
1090         for (i = j = 0; j < true_region_size; j++) {
1091                 int ms = merge_size[j];
1092                 int col = base_col + i * col_inc;
1093                 int row = base_row + i * row_inc;
1094                 GnmCell *cell;
1095                 GList *f = fillers;
1096
1097                 if (reverse && merges[j]) {
1098                         col -= range_width (merges[j]) - 1;
1099                         row -= range_height (merges[j]) - 1;
1100                 }
1101                 cell = sheet_cell_get (sheet, col, row);
1102
1103                 while (f) {
1104                         AutoFiller *af = f->data;
1105                         GList *next = f->next;
1106
1107                         af->teach_cell (af, cell, j);
1108
1109                         if (af->status == AFS_ERROR) {
1110                                 fillers = g_list_delete_link (fillers, f);
1111                                 af->finalize (af);
1112                         }
1113
1114                         f = next;
1115                 }
1116
1117                 i += (ms + 1);
1118         }
1119
1120         /* Find the best filler that's ready.  */
1121         for (f = fillers; f; f = f->next) {
1122                 AutoFiller *af1 = f->data;
1123                 if (af1->status == AFS_READY &&
1124                     (af == NULL || af1->priority > af->priority)) {
1125                         af = af1;
1126                 }
1127         }
1128
1129         if (!af) {
1130                 /* Strange, but no fill.  */
1131         } else if (doit) {
1132                 while (i < count_max) {
1133                         int k = j % true_region_size;
1134                         int ms = merge_size[k];
1135                         int col = base_col + i * col_inc;
1136                         int row = base_row + i * row_inc;
1137                         GnmCell *cell;
1138
1139                         if (reverse && merges[k]) {
1140                                 col -= range_width (merges[k]) - 1;
1141                                 row -= range_height (merges[k]) - 1;
1142                         }
1143                         cell = sheet_cell_fetch (sheet, col, row);
1144                         af->set_cell (af, cell, j);
1145
1146                         sheet_style_set_pos (sheet, col, row,
1147                                              gnm_style_dup (styles[k]));
1148                         if (merges[k]) {
1149                                 GnmRange r = *merges[k];
1150                                 int ofs = (i / region_size) * region_size;
1151                                 range_translate (&r, sheet,
1152                                                  ofs * col_inc,
1153                                                  ofs * row_inc);
1154                                 gnm_sheet_merge_add (sheet, &r, FALSE, NULL);
1155                         }
1156                         i += (ms + 1);
1157                         j++;
1158                 }
1159         } else {
1160                 GnmCellPos pos;
1161                 int repeats = (count_max - 1) / region_size;
1162                 i = repeats * region_size;
1163                 j = 0;
1164                 while (i < count_max) {
1165                         int ms = merge_size[j];
1166                         pos.col = base_col + i * col_inc;
1167                         pos.row = base_row + i * row_inc;
1168                         i += (ms + 1);
1169                         j++;
1170                 }
1171
1172                 hint = af->hint (af, &pos, repeats * true_region_size + j - 1);
1173         }
1174
1175         while (fillers) {
1176                 AutoFiller *af = fillers->data;
1177                 fillers = g_list_delete_link (fillers, fillers);
1178                 af->finalize (af);
1179         }
1180
1181         if (styles) {
1182                 int i;
1183                 for (i = 0; i < true_region_size; i++)
1184                         if (styles[i])
1185                                 gnm_style_unref (styles[i]);
1186                 g_free (styles);
1187         }
1188
1189         g_free (merges);
1190         g_free (merge_size);
1191
1192         return hint;
1193 }
1194
1195 static void
1196 add_item (GString *dst, char *item, char const *sep)
1197 {
1198         if (!dst) return;
1199         if (dst->len)
1200                 g_string_append (dst, sep);
1201         if (item) {
1202                 g_string_append (dst, item);
1203                 g_free (item);
1204         } else
1205                 g_string_append (dst, "?");
1206 }
1207
1208 static GString *
1209 sheet_autofill_internal (Sheet *sheet, gboolean singleton,
1210                          int base_col, int base_row,
1211                          int w, int h,
1212                          int end_col, int end_row,
1213                          gboolean doit)
1214 {
1215         int series = 0;
1216         int right_col = MAX (base_col, end_col);
1217         int bottom_row = MAX (base_row, end_row);
1218         GString *res = NULL;
1219         GnmCellPos pos;
1220         GnmRange const *mr;
1221
1222         g_return_val_if_fail (IS_SHEET (sheet), NULL);
1223
1224         if (!doit)
1225                 res = g_string_new (NULL);
1226
1227         pos.col = base_col;
1228         pos.row = base_row;
1229
1230         if (base_col > end_col || base_row > end_row) {
1231                 if (base_col != end_col + w - 1) {
1232                         /* LEFT */
1233                         while (series < h) {
1234                                 add_item (res,
1235                                           sheet_autofill_dir (sheet, singleton,
1236                                                               base_col, base_row - series,
1237                                                               w, ABS (base_col - (end_col - 1)),
1238                                                               -1, 0,
1239                                                               right_col, bottom_row,
1240                                                               doit),
1241                                           "\n");
1242
1243                                 pos.row = base_row - series;
1244                                 mr = gnm_sheet_merge_contains_pos (sheet, &pos);
1245                                 series += mr ? range_height (mr) : 1;
1246                         }
1247                 } else {
1248                         /* UP */
1249                         while (series < w) {
1250                                 add_item (res,
1251                                           sheet_autofill_dir (sheet, singleton,
1252                                                               base_col - series, base_row,
1253                                                               h, ABS (base_row - (end_row - 1)),
1254                                                               0, -1,
1255                                                               right_col, bottom_row,
1256                                                               doit),
1257                                           " | ");
1258
1259                                 pos.col = base_col - series;
1260                                 mr = gnm_sheet_merge_contains_pos (sheet, &pos);
1261                                 series += mr ? range_width (mr) : 1;
1262                         }
1263                 }
1264         } else {
1265                 if (end_col != base_col + w - 1) {
1266                         /* RIGHT */
1267                         while (series < h) {
1268                                 add_item (res,
1269                                           sheet_autofill_dir (sheet, singleton,
1270                                                               base_col, base_row + series,
1271                                                               w, ABS (base_col - (end_col + 1)),
1272                                                               1, 0,
1273                                                               right_col, bottom_row,
1274                                                               doit),
1275                                           "\n");
1276
1277                                 pos.row = base_row + series;
1278                                 mr = gnm_sheet_merge_contains_pos (sheet, &pos);
1279                                 series += mr ? range_height (mr) : 1;
1280                         }
1281                 } else {
1282                         /* DOWN */
1283                         while (series < w) {
1284                                 add_item (res,
1285                                           sheet_autofill_dir (sheet, singleton,
1286                                                               base_col + series, base_row,
1287                                                               h, ABS (base_row - (end_row + 1)),
1288                                                               0, 1,
1289                                                               right_col, bottom_row,
1290                                                               doit),
1291                                           " | ");
1292                                 pos.col = base_col + series;
1293                                 mr = gnm_sheet_merge_contains_pos (sheet, &pos);
1294                                 series += mr ? range_width (mr) : 1;
1295                         }
1296                 }
1297         }
1298
1299         return res;
1300 }
1301
1302
1303
1304 /**
1305  * gnm_autofill_fill:
1306  *
1307  * An internal routine to autofill a region.  It does NOT
1308  * queue a recalc, flag a status update, or regen spans.
1309  */
1310 void
1311 gnm_autofill_fill (Sheet *sheet, gboolean singleton,
1312                    int base_col, int base_row,
1313                    int w, int h,
1314                    int end_col, int end_row)
1315 {
1316         sheet_autofill_internal (sheet, singleton,
1317                                  base_col, base_row,
1318                                  w, h,
1319                                  end_col, end_row,
1320                                  TRUE);
1321 }
1322
1323 GString *
1324 gnm_autofill_hint (Sheet *sheet, gboolean default_increment,
1325                    int base_col, int base_row,
1326                    int w,        int h,
1327                    int end_col,  int end_row)
1328 {
1329         return sheet_autofill_internal (sheet, default_increment,
1330                                         base_col, base_row,
1331                                         w, h,
1332                                         end_col, end_row,
1333                                         FALSE);
1334 }