cups/mark.c

   1 /*
   2  * "$Id: mark.c 5119 2006-02-16 15:52:06Z 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 "ppd.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
 327
 328   DEBUG_printf(("ppdMarkOption(ppd=%p, option=\"%s\", choice=\"%s\")\n",
 329                 ppd, option, choice));
 330
 331  /*
 332   * Range check input...
 333   */
 334
 335   if (!ppd || !option || !choice)
 336     return (0);
 337
 338  /*
 339   * AP_D_InputSlot is the "default input slot" on MacOS X, and setting
 340   * it clears the regular InputSlot choices...
 341   */
 342
 343   if (!strcasecmp(option, "AP_D_InputSlot"))
 344   {
 345     if ((o = ppdFindOption(ppd, "InputSlot")) != NULL)
 346       for (i = 0; i < o->num_choices; i ++)
 347         o->choices[i].marked = 0;
 348   }
 349
 350  /*
 351   * Check for custom options...
 352   */
 353
 354   if ((o = ppdFindOption(ppd, option)) == NULL)
 355     return (0);
 356
 357
 358   if (!strncasecmp(choice, "Custom.", 7) /* TODO || strchr(choice, '=') */ )
 359   {
 360    /*
 361     * Handle a custom option...
 362     */
 363
 364     if ((c = ppdFindChoice(o, "Custom")) == NULL)
 365       return (0);
 366
 367     if (!strcasecmp(option, "PageSize"))
 368     {
 369      /*
 370       * Handle custom page sizes...
 371       */
 372
 373       ppdPageSize(ppd, choice);
 374     }
 375     else
 376     {
 377      /*
 378       * Handle other custom options...
 379       */
 380
 381       ppd_coption_t     *coption;       /* Custom option */
 382       ppd_cparam_t      *cparam;        /* Custom parameter */
 383       char              units[33];      /* Custom points units */
 384
 385
 386      /*
 387       * TODO: Detect and support custom option values using the
 388       * collection format "{Name1=foo Name2=bar}".  For now, just
 389       * support Custom.value for single-valued custom options.
 390       */
 391
 392       if ((coption = ppdFindCustomOption(ppd, option)) != NULL)
 393       {
 394         if ((cparam = (ppd_cparam_t *)cupsArrayFirst(coption->params)) == NULL)
 395           return (0);
 396
 397         switch (cparam->type)
 398         {
 399           case PPD_CUSTOM_CURVE :
 400           case PPD_CUSTOM_INVCURVE :
 401           case PPD_CUSTOM_REAL :
 402               cparam->current.custom_real = atof(choice + 7);
 403               break;
 404
 405           case PPD_CUSTOM_POINTS :
 406               if (sscanf(choice + 7, "%f%s", &(cparam->current.custom_points),
 407                          units) < 2)
 408                 strcpy(units, "pt");
 409
 410               if (!strcasecmp(units, "cm"))
 411                 cparam->current.custom_points *= 72.0 / 2.54;
 412               else if (!strcasecmp(units, "mm"))
 413                 cparam->current.custom_points *= 72.0 / 25.4;
 414               else if (!strcasecmp(units, "m"))
 415                 cparam->current.custom_points *= 72.0 / 0.0254;
 416               else if (!strcasecmp(units, "in"))
 417                 cparam->current.custom_points *= 72.0;
 418               else if (!strcasecmp(units, "ft"))
 419                 cparam->current.custom_points *= 12 * 72.0;
 420               break;
 421
 422           case PPD_CUSTOM_INT :
 423               cparam->current.custom_int = atoi(choice + 7);
 424               break;
 425
 426           case PPD_CUSTOM_PASSCODE :
 427           case PPD_CUSTOM_PASSWORD :
 428           case PPD_CUSTOM_STRING :
 429               if (cparam->current.custom_string)
 430                 free(cparam->current.custom_string);
 431
 432               cparam->current.custom_string = strdup(choice + 7);
 433               break;
 434         }
 435       }
 436     }
 437   }
 438   else
 439   {
 440     for (i = o->num_choices, c = o->choices; i > 0; i --, c ++)
 441       if (!strcasecmp(c->choice, choice))
 442         break;
 443
 444     if (!i)
 445       return (0);
 446   }
 447
 448  /*
 449   * Option found; mark it and then handle unmarking any other options.
 450   */
 451
 452   c->marked = 1;
 453
 454   if (o->ui != PPD_UI_PICKMANY)
 455   {
 456    /*
 457     * Unmark all other choices...
 458     */
 459
 460     for (i = o->num_choices, c = o->choices; i > 0; i --, c ++)
 461       if (strcasecmp(c->choice, choice))
 462       {
 463         c->marked = 0;
 464
 465         if (!strcasecmp(option, "PageSize") ||
 466             !strcasecmp(option, "PageRegion"))
 467         {
 468          /*
 469           * Mark current page size...
 470           */
 471
 472           for (j = 0; j < ppd->num_sizes; j ++)
 473             ppd->sizes[j].marked = !strcasecmp(ppd->sizes[j].name,
 474                                                choice);
 475
 476          /*
 477           * Unmark the current PageSize or PageRegion setting, as
 478           * appropriate...
 479           */
 480
 481           if (!strcasecmp(option, "PageSize"))
 482           {
 483             if ((o = ppdFindOption(ppd, "PageRegion")) != NULL)
 484               for (j = 0; j < o->num_choices; j ++)
 485                 o->choices[j].marked = 0;
 486           }
 487           else
 488           {
 489             if ((o = ppdFindOption(ppd, "PageSize")) != NULL)
 490               for (j = 0; j < o->num_choices; j ++)
 491                 o->choices[j].marked = 0;
 492           }
 493         }
 494         else if (!strcasecmp(option, "InputSlot"))
 495         {
 496          /*
 497           * Unmark ManualFeed True and possibly mark ManualFeed False
 498           * option...
 499           */
 500
 501           if ((o = ppdFindOption(ppd, "ManualFeed")) != NULL)
 502             for (j = 0; j < o->num_choices; j ++)
 503               o->choices[j].marked = !strcasecmp(o->choices[j].choice, "False");
 504         }
 505         else if (!strcasecmp(option, "ManualFeed") &&
 506                  !strcasecmp(choice, "True"))
 507         {
 508          /*
 509           * Unmark InputSlot option...
 510           */
 511
 512           if ((o = ppdFindOption(ppd, "InputSlot")) != NULL)
 513             for (j = 0; j < o->num_choices; j ++)
 514               o->choices[j].marked = 0;
 515         }
 516       }
 517   }
 518
 519  /*
 520   * Return the number of conflicts...
 521   */
 522
 523   return (ppdConflicts(ppd));
 524 }
 525
 526
 527 /*
 528  * 'ppdFirstOption()' - Return the first option in the PPD file.
 529  *
 530  * Options are returned from all groups in sorted order.
 531  *
 532  * @since CUPS 1.2@
 533  */
 534
 535 ppd_option_t *                          /* O - First option or NULL */
 536 ppdFirstOption(ppd_file_t *ppd)         /* I - PPD file */
 537 {
 538   if (!ppd)
 539     return (NULL);
 540   else
 541     return ((ppd_option_t *)cupsArrayFirst(ppd->options));
 542 }
 543
 544
 545 /*
 546  * 'ppdNextOption()' - Return the next option in the PPD file.
 547  *
 548  * Options are returned from all groups in sorted order.
 549  *
 550  * @since CUPS 1.2@
 551  */
 552
 553 ppd_option_t *                          /* O - Next option or NULL */
 554 ppdNextOption(ppd_file_t *ppd)          /* I - PPD file */
 555 {
 556   if (!ppd)
 557     return (NULL);
 558   else
 559     return ((ppd_option_t *)cupsArrayNext(ppd->options));
 560 }
 561
 562
 563 /*
 564  * 'ppd_defaults()' - Set the defaults for this group and all sub-groups.
 565  */
 566
 567 static void
 568 ppd_defaults(ppd_file_t  *ppd,  /* I - PPD file */
 569              ppd_group_t *g)    /* I - Group to default */
 570 {
 571   int           i;              /* Looping var */
 572   ppd_option_t  *o;             /* Current option */
 573   ppd_group_t   *sg;            /* Current sub-group */
 574
 575
 576   if (g == NULL)
 577     return;
 578
 579   for (i = g->num_options, o = g->options; i > 0; i --, o ++)
 580     if (strcasecmp(o->keyword, "PageRegion") != 0)
 581       ppdMarkOption(ppd, o->keyword, o->defchoice);
 582
 583   for (i = g->num_subgroups, sg = g->subgroups; i > 0; i --, sg ++)
 584     ppd_defaults(ppd, sg);
 585 }
 586
 587
 588 /*
 589  * End of "$Id: mark.c 5119 2006-02-16 15:52:06Z mike $".
 590  */