cups/mark.c

   1 /*
   2  * "$Id: mark.c 5238 2006-03-07 04:41:42Z mike $"
   3  *
   4  *   Option marking routines for the Common UNIX Printing System (CUPS).
   5  *
   6  *   Copyright 1997-2006 by Easy Software Products, all rights reserved.
   7  *
   8  *   These coded instructions, statements, and computer programs are the
   9  *   property of Easy Software Products and are protected by Federal
  10  *   copyright law.  Distribution and use rights are outlined in the file
  11  *   "LICENSE.txt" which should have been included with this file.  If this
  12  *   file is missing or damaged please contact Easy Software Products
  13  *   at:
  14  *
  15  *       Attn: CUPS Licensing Information
  16  *       Easy Software Products
  17  *       44141 Airport View Drive, Suite 204
  18  *       Hollywood, Maryland 20636 USA
  19  *
  20  *       Voice: (301) 373-9600
  21  *       EMail: cups-info@cups.org
  22  *         WWW: http://www.cups.org
  23  *
  24  *   PostScript is a trademark of Adobe Systems, Inc.
  25  *
  26  *   This file is subject to the Apple OS-Developed Software exception.
  27  *
  28  * Contents:
  29  *
  30  *   ppdConflicts()        - Check to see if there are any conflicts.
  31  *   ppdFindChoice()       - Return a pointer to an option choice.
  32  *   ppdFindMarkedChoice() - Return the marked choice for the specified option.
  33  *   ppdFindOption()       - Return a pointer to the specified option.
  34  *   ppdFirstOption()      - Return the first option in the PPD file.
  35  *   ppdNextOption()       - Return the next option in the PPD file.
  36  *   ppdIsMarked()         - Check to see if an option is marked...
  37  *   ppdMarkDefaults()     - Mark all default options in the PPD file.
  38  *   ppdMarkOption()       - Mark an option in a PPD file.
  39  *   ppd_defaults()        - Set the defaults for this group and all sub-groups.
  40  */
  41
  42 /*
  43  * Include necessary headers...
  44  */
  45
  46 #include "cups.h"
  47 #include "string.h"
  48 #include "debug.h"
  49
  50
  51 /*
  52  * Local functions...
  53  */
  54
  55 static void     ppd_defaults(ppd_file_t *ppd, ppd_group_t *g);
  56
  57
  58 /*
  59  * 'ppdConflicts()' - Check to see if there are any conflicts.
  60  */
  61
  62 int                             /* O - Number of conflicts found */
  63 ppdConflicts(ppd_file_t *ppd)   /* I - PPD to check */
  64 {
  65   int           i, j, k,        /* Looping variables */
  66                 conflicts;      /* Number of conflicts */
  67   ppd_const_t   *c;             /* Current constraint */
  68   ppd_group_t   *g, *sg;        /* Groups */
  69   ppd_option_t  *o1, *o2;       /* Options */
  70   ppd_choice_t  *c1, *c2;       /* Choices */
  71
  72
  73   if (ppd == NULL)
  74     return (0);
  75
  76  /*
  77   * Clear all conflicts...
  78   */
  79
  80   conflicts = 0;
  81
  82   for (i = ppd->num_groups, g = ppd->groups; i > 0; i --, g ++)
  83   {
  84     for (j = g->num_options, o1 = g->options; j > 0; j --, o1 ++)
  85       o1->conflicted = 0;
  86
  87     for (j = g->num_subgroups, sg = g->subgroups; j > 0; j --, sg ++)
  88       for (k = sg->num_options, o1 = sg->options; k > 0; k --, o1 ++)
  89         o1->conflicted = 0;
  90   }
  91
  92  /*
  93   * Loop through all of the UI constraints and flag any options
  94   * that conflict...
  95   */
  96
  97   for (i = ppd->num_consts, c = ppd->consts; i > 0; i --, c ++)
  98   {
  99    /*
 100     * Grab pointers to the first option...
 101     */
 102
 103     o1 = ppdFindOption(ppd, c->option1);
 104
 105     if (o1 == NULL)
 106       continue;
 107     else if (c->choice1[0] != '\0')
 108     {
 109      /*
 110       * This constraint maps to a specific choice.
 111       */
 112
 113       c1 = ppdFindChoice(o1, c->choice1);
 114     }
 115     else
 116     {
 117      /*
 118       * This constraint applies to any choice for this option.
 119       */
 120
 121       for (j = o1->num_choices, c1 = o1->choices; j > 0; j --, c1 ++)
 122         if (c1->marked)
 123           break;
 124
 125       if (j == 0 ||
 126           strcasecmp(c1->choice, "None") == 0 ||
 127           strcasecmp(c1->choice, "Off") == 0 ||
 128           strcasecmp(c1->choice, "False") == 0)
 129         c1 = NULL;
 130     }
 131
 132    /*
 133     * Grab pointers to the second option...
 134     */
 135
 136     o2 = ppdFindOption(ppd, c->option2);
 137
 138     if (o2 == NULL)
 139       continue;
 140     else if (c->choice2[0] != '\0')
 141     {
 142      /*
 143       * This constraint maps to a specific choice.
 144       */
 145
 146       c2 = ppdFindChoice(o2, c->choice2);
 147     }
 148     else
 149     {
 150      /*
 151       * This constraint applies to any choice for this option.
 152       */
 153
 154       for (j = o2->num_choices, c2 = o2->choices; j > 0; j --, c2 ++)
 155         if (c2->marked)
 156           break;
 157
 158       if (j == 0 ||
 159           strcasecmp(c2->choice, "None") == 0 ||
 160           strcasecmp(c2->choice, "Off") == 0 ||
 161           strcasecmp(c2->choice, "False") == 0)
 162         c2 = NULL;
 163     }
 164
 165    /*
 166     * If both options are marked then there is a conflict...
 167     */
 168
 169     if (c1 != NULL && c1->marked &&
 170         c2 != NULL && c2->marked)
 171     {
 172       DEBUG_printf(("%s->%s conflicts with %s->%s (%s %s %s %s)\n",
 173                     o1->keyword, c1->choice, o2->keyword, c2->choice,
 174                     c->option1, c->choice1, c->option2, c->choice2));
 175       conflicts ++;
 176       o1->conflicted = 1;
 177       o2->conflicted = 1;
 178     }
 179   }
 180
 181  /*
 182   * Return the number of conflicts found...
 183   */
 184
 185   return (conflicts);
 186 }
 187
 188
 189 /*
 190  * 'ppdFindChoice()' - Return a pointer to an option choice.
 191  */
 192
 193 ppd_choice_t *                          /* O - Choice pointer or NULL */
 194 ppdFindChoice(ppd_option_t *o,          /* I - Pointer to option */
 195               const char   *choice)     /* I - Name of choice */
 196 {
 197   int           i;              /* Looping var */
 198   ppd_choice_t  *c;             /* Current choice */
 199
 200
 201   if (o == NULL || choice == NULL)
 202     return (NULL);
 203
 204   for (i = o->num_choices, c = o->choices; i > 0; i --, c ++)
 205     if (strcasecmp(c->choice, choice) == 0)
 206       return (c);
 207
 208   return (NULL);
 209 }
 210
 211
 212 /*
 213  * 'ppdFindMarkedChoice()' - Return the marked choice for the specified option.
 214  */
 215
 216 ppd_choice_t *                          /* O - Pointer to choice or NULL */
 217 ppdFindMarkedChoice(ppd_file_t *ppd,    /* I - PPD file */
 218                     const char *option) /* I - Keyword/option name */
 219 {
 220   int           i;              /* Looping var */
 221   ppd_option_t  *o;             /* Pointer to option */
 222   ppd_choice_t  *c;             /* Pointer to choice */
 223
 224
 225   if ((o = ppdFindOption(ppd, option)) == NULL)
 226     return (NULL);
 227
 228   for (i = o->num_choices, c = o->choices; i > 0; i --, c ++)
 229     if (c->marked)
 230       return (c);
 231
 232   return (NULL);
 233 }
 234
 235
 236 /*
 237  * 'ppdFindOption()' - Return a pointer to the specified option.
 238  */
 239
 240 ppd_option_t *                          /* O - Pointer to option or NULL */
 241 ppdFindOption(ppd_file_t *ppd,          /* I - PPD file data */
 242               const char *option)       /* I - Option/Keyword name */
 243 {
 244   ppd_option_t  key;                    /* Option search key */
 245
 246
 247  /*
 248   * Range check input...
 249   */
 250
 251   if (!ppd || !option)
 252     return (NULL);
 253
 254  /*
 255   * Search...
 256   */
 257
 258   strlcpy(key.keyword, option, sizeof(key.keyword));
 259
 260   return ((ppd_option_t *)cupsArrayFind(ppd->options, &key));
 261 }
 262
 263
 264 /*
 265  * 'ppdIsMarked()' - Check to see if an option is marked...
 266  */
 267
 268 int                             /* O - Non-zero if option is marked */
 269 ppdIsMarked(ppd_file_t *ppd,    /* I - PPD file data */
 270             const char *option, /* I - Option/Keyword name */
 271             const char *choice) /* I - Choice name */
 272 {
 273   ppd_option_t  *o;             /* Option pointer */
 274   ppd_choice_t  *c;             /* Choice pointer */
 275
 276
 277   if (ppd == NULL)
 278     return (0);
 279
 280   if ((o = ppdFindOption(ppd, option)) == NULL)
 281     return (0);
 282
 283   if ((c = ppdFindChoice(o, choice)) == NULL)
 284     return (0);
 285
 286   return (c->marked);
 287 }
 288
 289
 290 /*
 291  * 'ppdMarkDefaults()' - Mark all default options in the PPD file.
 292  */
 293
 294 void
 295 ppdMarkDefaults(ppd_file_t *ppd)/* I - PPD file record */
 296 {
 297   int           i;              /* Looping variables */
 298   ppd_group_t   *g;             /* Current group */
 299
 300
 301   if (ppd == NULL)
 302     return;
 303
 304   for (i = ppd->num_groups, g = ppd->groups; i > 0; i --, g ++)
 305     ppd_defaults(ppd, g);
 306 }
 307
 308
 309 /*
 310  * 'ppdMarkOption()' - Mark an option in a PPD file.
 311  *
 312  * Notes:
 313  *
 314  *   -1 is returned if the given option would conflict with any currently
 315  *   selected option.
 316  */
 317
 318 int                                     /* O - Number of conflicts */
 319 ppdMarkOption(ppd_file_t *ppd,          /* I - PPD file record */
 320               const char *option,       /* I - Keyword */
 321               const char *choice)       /* I - Option name */
 322 {
 323   int           i, j;                   /* Looping vars */
 324   ppd_option_t  *o;                     /* Option pointer */
 325   ppd_choice_t  *c;                     /* Choice pointer */
 326   struct lconv  *loc;                   /* Locale data */
 327
 328
 329   DEBUG_printf(("ppdMarkOption(ppd=%p, option=\"%s\", choice=\"%s\")\n",
 330                 ppd, option, choice));
 331
 332  /*
 333   * Range check input...
 334   */
 335
 336   if (!ppd || !option || !choice)
 337     return (0);
 338
 339  /*
 340   * AP_D_InputSlot is the "default input slot" on MacOS X, and setting
 341   * it clears the regular InputSlot choices...
 342   */
 343
 344   if (!strcasecmp(option, "AP_D_InputSlot"))
 345   {
 346     if ((o = ppdFindOption(ppd, "InputSlot")) != NULL)
 347       for (i = 0; i < o->num_choices; i ++)
 348         o->choices[i].marked = 0;
 349   }
 350
 351  /*
 352   * Check for custom options...
 353   */
 354
 355   if ((o = ppdFindOption(ppd, option)) == NULL)
 356     return (0);
 357
 358   loc = localeconv();
 359
 360   if (!strncasecmp(choice, "Custom.", 7))
 361   {
 362    /*
 363     * Handle a custom option...
 364     */
 365
 366     if ((c = ppdFindChoice(o, "Custom")) == NULL)
 367       return (0);
 368
 369     if (!strcasecmp(option, "PageSize"))
 370     {
 371      /*
 372       * Handle custom page sizes...
 373       */
 374
 375       ppdPageSize(ppd, choice);
 376     }
 377     else
 378     {
 379      /*
 380       * Handle other custom options...
 381       */
 382
 383       ppd_coption_t     *coption;       /* Custom option */
 384       ppd_cparam_t      *cparam;        /* Custom parameter */
 385       char              *units;         /* Custom points units */
 386
 387       if ((coption = ppdFindCustomOption(ppd, option)) != NULL)
 388       {
 389         if ((cparam = (ppd_cparam_t *)cupsArrayFirst(coption->params)) == NULL)
 390           return (0);
 391
 392         switch (cparam->type)
 393         {
 394           case PPD_CUSTOM_CURVE :
 395           case PPD_CUSTOM_INVCURVE :
 396           case PPD_CUSTOM_REAL :
 397               cparam->current.custom_real = _cupsStrScand(choice + 7, NULL,
 398                                                           loc);
 399               break;
 400
 401           case PPD_CUSTOM_POINTS :
 402               cparam->current.custom_points = _cupsStrScand(choice + 7,
 403                                                             &units, loc);
 404
 405               if (units)
 406               {
 407                 if (!strcasecmp(units, "cm"))
 408                   cparam->current.custom_points *= 72.0 / 2.54;
 409                 else if (!strcasecmp(units, "mm"))
 410                   cparam->current.custom_points *= 72.0 / 25.4;
 411                 else if (!strcasecmp(units, "m"))
 412                   cparam->current.custom_points *= 72.0 / 0.0254;
 413                 else if (!strcasecmp(units, "in"))
 414                   cparam->current.custom_points *= 72.0;
 415                 else if (!strcasecmp(units, "ft"))
 416                   cparam->current.custom_points *= 12 * 72.0;
 417               }
 418               break;
 419
 420           case PPD_CUSTOM_INT :
 421               cparam->current.custom_int = atoi(choice + 7);
 422               break;
 423
 424           case PPD_CUSTOM_PASSCODE :
 425           case PPD_CUSTOM_PASSWORD :
 426           case PPD_CUSTOM_STRING :
 427               if (cparam->current.custom_string)
 428                 free(cparam->current.custom_string);
 429
 430               cparam->current.custom_string = strdup(choice + 7);
 431               break;
 432         }
 433       }
 434     }
 435   }
 436   else if (choice[0] == '{')
 437   {
 438    /*
 439     * Handle multi-value custom options...
 440     */
 441
 442     ppd_coption_t       *coption;       /* Custom option */
 443     ppd_cparam_t        *cparam;        /* Custom parameter */
 444     char                *units;         /* Custom points units */
 445     int                 num_vals;       /* Number of values */
 446     cups_option_t       *vals,          /* Values */
 447                         *val;           /* Value */
 448
 449
 450     if ((c = ppdFindChoice(o, "Custom")) == NULL)
 451       return (0);
 452
 453     if ((coption = ppdFindCustomOption(ppd, option)) != NULL)
 454     {
 455       num_vals = cupsParseOptions(choice + 1, 0, &vals);
 456
 457       for (i = 0, val = vals; i < num_vals; i ++, val ++)
 458       {
 459         if ((cparam = ppdFindCustomParam(coption, val->name)) == NULL)
 460           continue;
 461
 462         switch (cparam->type)
 463         {
 464           case PPD_CUSTOM_CURVE :
 465           case PPD_CUSTOM_INVCURVE :
 466           case PPD_CUSTOM_REAL :
 467               cparam->current.custom_real = _cupsStrScand(val->value, NULL,
 468                                                           loc);
 469               break;
 470
 471           case PPD_CUSTOM_POINTS :
 472               cparam->current.custom_points = _cupsStrScand(val->value, &units,
 473                                                             loc);
 474
 475               if (units)
 476               {
 477                 if (!strcasecmp(units, "cm"))
 478                   cparam->current.custom_points *= 72.0 / 2.54;
 479                 else if (!strcasecmp(units, "mm"))
 480                   cparam->current.custom_points *= 72.0 / 25.4;
 481                 else if (!strcasecmp(units, "m"))
 482                   cparam->current.custom_points *= 72.0 / 0.0254;
 483                 else if (!strcasecmp(units, "in"))
 484                   cparam->current.custom_points *= 72.0;
 485                 else if (!strcasecmp(units, "ft"))
 486                   cparam->current.custom_points *= 12 * 72.0;
 487               }
 488               break;
 489
 490           case PPD_CUSTOM_INT :
 491               cparam->current.custom_int = atoi(val->value);
 492               break;
 493
 494           case PPD_CUSTOM_PASSCODE :
 495           case PPD_CUSTOM_PASSWORD :
 496           case PPD_CUSTOM_STRING :
 497               if (cparam->current.custom_string)
 498                 free(cparam->current.custom_string);
 499
 500               cparam->current.custom_string = strdup(val->value);
 501               break;
 502         }
 503       }
 504
 505       cupsFreeOptions(num_vals, vals);
 506     }
 507   }
 508   else
 509   {
 510     for (i = o->num_choices, c = o->choices; i > 0; i --, c ++)
 511       if (!strcasecmp(c->choice, choice))
 512         break;
 513
 514     if (!i)
 515       return (0);
 516   }
 517
 518  /*
 519   * Option found; mark it and then handle unmarking any other options.
 520   */
 521
 522   c->marked = 1;
 523
 524   if (o->ui != PPD_UI_PICKMANY)
 525   {
 526    /*
 527     * Unmark all other choices...
 528     */
 529
 530     for (i = o->num_choices, c = o->choices; i > 0; i --, c ++)
 531       if (strcasecmp(c->choice, choice))
 532       {
 533         c->marked = 0;
 534
 535         if (!strcasecmp(option, "PageSize") ||
 536             !strcasecmp(option, "PageRegion"))
 537         {
 538          /*
 539           * Mark current page size...
 540           */
 541
 542           for (j = 0; j < ppd->num_sizes; j ++)
 543             ppd->sizes[j].marked = !strcasecmp(ppd->sizes[j].name,
 544                                                choice);
 545
 546          /*
 547           * Unmark the current PageSize or PageRegion setting, as
 548           * appropriate...
 549           */
 550
 551           if (!strcasecmp(option, "PageSize"))
 552           {
 553             if ((o = ppdFindOption(ppd, "PageRegion")) != NULL)
 554               for (j = 0; j < o->num_choices; j ++)
 555                 o->choices[j].marked = 0;
 556           }
 557           else
 558           {
 559             if ((o = ppdFindOption(ppd, "PageSize")) != NULL)
 560               for (j = 0; j < o->num_choices; j ++)
 561                 o->choices[j].marked = 0;
 562           }
 563         }
 564         else if (!strcasecmp(option, "InputSlot"))
 565         {
 566          /*
 567           * Unmark ManualFeed True and possibly mark ManualFeed False
 568           * option...
 569           */
 570
 571           if ((o = ppdFindOption(ppd, "ManualFeed")) != NULL)
 572             for (j = 0; j < o->num_choices; j ++)
 573               o->choices[j].marked = !strcasecmp(o->choices[j].choice, "False");
 574         }
 575         else if (!strcasecmp(option, "ManualFeed") &&
 576                  !strcasecmp(choice, "True"))
 577         {
 578          /*
 579           * Unmark InputSlot option...
 580           */
 581
 582           if ((o = ppdFindOption(ppd, "InputSlot")) != NULL)
 583             for (j = 0; j < o->num_choices; j ++)
 584               o->choices[j].marked = 0;
 585         }
 586       }
 587   }
 588
 589  /*
 590   * Return the number of conflicts...
 591   */
 592
 593   return (ppdConflicts(ppd));
 594 }
 595
 596
 597 /*
 598  * 'ppdFirstOption()' - Return the first option in the PPD file.
 599  *
 600  * Options are returned from all groups in sorted order.
 601  *
 602  * @since CUPS 1.2@
 603  */
 604
 605 ppd_option_t *                          /* O - First option or NULL */
 606 ppdFirstOption(ppd_file_t *ppd)         /* I - PPD file */
 607 {
 608   if (!ppd)
 609     return (NULL);
 610   else
 611     return ((ppd_option_t *)cupsArrayFirst(ppd->options));
 612 }
 613
 614
 615 /*
 616  * 'ppdNextOption()' - Return the next option in the PPD file.
 617  *
 618  * Options are returned from all groups in sorted order.
 619  *
 620  * @since CUPS 1.2@
 621  */
 622
 623 ppd_option_t *                          /* O - Next option or NULL */
 624 ppdNextOption(ppd_file_t *ppd)          /* I - PPD file */
 625 {
 626   if (!ppd)
 627     return (NULL);
 628   else
 629     return ((ppd_option_t *)cupsArrayNext(ppd->options));
 630 }
 631
 632
 633 /*
 634  * 'ppd_defaults()' - Set the defaults for this group and all sub-groups.
 635  */
 636
 637 static void
 638 ppd_defaults(ppd_file_t  *ppd,  /* I - PPD file */
 639              ppd_group_t *g)    /* I - Group to default */
 640 {
 641   int           i;              /* Looping var */
 642   ppd_option_t  *o;             /* Current option */
 643   ppd_group_t   *sg;            /* Current sub-group */
 644
 645
 646   if (g == NULL)
 647     return;
 648
 649   for (i = g->num_options, o = g->options; i > 0; i --, o ++)
 650     if (strcasecmp(o->keyword, "PageRegion") != 0)
 651       ppdMarkOption(ppd, o->keyword, o->defchoice);
 652
 653   for (i = g->num_subgroups, sg = g->subgroups; i > 0; i --, sg ++)
 654     ppd_defaults(ppd, sg);
 655 }
 656
 657
 658 /*
 659  * End of "$Id: mark.c 5238 2006-03-07 04:41:42Z mike $".
 660  */