xorg-server-1.4/hw/xprint/AttrValid.c

   1 /*
   2 (c) Copyright 1996 Hewlett-Packard Company
   3 (c) Copyright 1996 International Business Machines Corp.
   4 (c) Copyright 1996 Sun Microsystems, Inc.
   5 (c) Copyright 1996 Novell, Inc.
   6 (c) Copyright 1996 Digital Equipment Corp.
   7 (c) Copyright 1996 Fujitsu Limited
   8 (c) Copyright 1996 Hitachi, Ltd.
   9
  10 Permission is hereby granted, free of charge, to any person obtaining a copy
  11 of this software and associated documentation files (the "Software"), to deal
  12 in the Software without restriction, including without limitation the rights
  13 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  14 copies of the Software, and to permit persons to whom the Software is
  15 furnished to do so, subject to the following conditions:
  16
  17 The above copyright notice and this permission notice shall be included in
  18 all copies or substantial portions of the Software.
  19
  20 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  21 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  22 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
  23 COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
  24 IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  25 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  26
  27 Except as contained in this notice, the names of the copyright holders shall
  28 not be used in advertising or otherwise to promote the sale, use or other
  29 dealings in this Software without prior written authorization from said
  30 copyright holders.
  31 */
  32 #ifdef HAVE_DIX_CONFIG_H
  33 #include <dix-config.h>
  34 #endif
  35
  36 #include <scrnintstr.h>
  37
  38 #include "attributes.h"
  39
  40 /*
  41  * default medium-source-sizes supported = na-letter w/.25" margins
  42  */
  43 static XpOidMediumDiscreteSize DefaultMediumSize = {
  44     xpoid_val_medium_size_na_letter, xFalse, {6.35, 209.55, 6.35, 273.05}
  45 };
  46 static XpOidMediumDiscreteSizeList DefaultMediumSizeList = {
  47     &DefaultMediumSize, 1
  48 };
  49 static XpOidMediumSourceSize DefaultMediumSourceSize = {
  50     xpoid_unspecified, XpOidMediumSS_DISCRETE, { &DefaultMediumSizeList }
  51 };
  52 static XpOidMediumSS DefaultMediumSS = {
  53     &DefaultMediumSourceSize, 1
  54 };
  55
  56 /*
  57  * if 'valid_oid_list' is NULL any oid found is considered valid
  58  */
  59 XpOid
  60 XpGetOidAttr(XpContextPtr pContext,
  61              XPAttributes pool,
  62              XpOid oid,
  63              const XpOidList* valid_oid_list)
  64 {
  65     XpOid value_oid;
  66
  67     value_oid = XpOidFromString(XpGetStringAttr(pContext, pool, oid));
  68     if((const XpOidList*)NULL == valid_oid_list
  69        ||
  70        XpOidListHasOid(valid_oid_list, value_oid))
  71     {
  72         return value_oid;
  73     }
  74     else
  75     {
  76         return xpoid_none;
  77     }
  78 }
  79
  80 void
  81 XpPutOidAttr(XpContextPtr pContext,
  82              XPAttributes pool,
  83              XpOid oid,
  84              XpOid value_oid)
  85 {
  86     XpPutStringAttr(pContext, pool, oid, XpOidString(value_oid));
  87 }
  88
  89 void
  90 XpValidateOidAttr(XpContextPtr pContext,
  91                   XPAttributes pool,
  92                   XpOid oid,
  93                   const XpOidList* valid_oids,
  94                   XpOid default_oid)
  95 {
  96     XpOid value_oid;
  97     value_oid = XpGetOidAttr(pContext, pool, oid, valid_oids);
  98     XpPutOidAttr(pContext, pool, oid,
  99                  value_oid == xpoid_none ? default_oid : value_oid);
 100 }
 101
 102 /*
 103  * if 'valid_card_list' is NULL any cardinal found is considered valid
 104  */
 105 unsigned long
 106 XpGetCardAttr(XpContextPtr pContext,
 107               XPAttributes pool,
 108               XpOid oid,
 109               const XpOidCardList* valid_card_list)
 110 {
 111     unsigned long value_card;
 112
 113     if(XpOidParseUnsignedValue(XpGetStringAttr(pContext, pool, oid),
 114                                (const char**)NULL,
 115                                &value_card))
 116     {
 117         if((const XpOidCardList*)NULL == valid_card_list
 118            ||
 119            XpOidCardListHasCard(valid_card_list, value_card))
 120         {
 121             return value_card;
 122         }
 123     }
 124     return 0;
 125 }
 126
 127 void
 128 XpPutCardAttr(XpContextPtr pContext,
 129               XPAttributes pool,
 130               XpOid oid,
 131               unsigned long value_card)
 132 {
 133     if(value_card > 0)
 134     {
 135         char value_out[16];
 136         sprintf(value_out, "%lu", value_card);
 137         XpPutStringAttr(pContext, pool, oid, value_out);
 138     }
 139     else
 140         XpPutStringAttr(pContext, pool, oid, (const char*)NULL);
 141 }
 142
 143 void
 144 XpValidateCardAttr(XpContextPtr pContext,
 145                    XPAttributes pool,
 146                    XpOid oid,
 147                    const XpOidCardList* valid_cards,
 148                    unsigned long default_card)
 149 {
 150     unsigned long value_card;
 151     value_card = XpGetCardAttr(pContext, pool, oid, valid_cards);
 152     XpPutCardAttr(pContext, pool, oid,
 153                   value_card == 0 ? default_card : value_card);
 154 }
 155
 156 XpOidList*
 157 XpGetListAttr(XpContextPtr pContext,
 158               XPAttributes pool,
 159               XpOid oid,
 160               const XpOidList* valid_oid_list)
 161 {
 162     return XpOidListNew(XpGetStringAttr(pContext, pool, oid), valid_oid_list);
 163 }
 164
 165 void
 166 XpPutListAttr(XpContextPtr pContext,
 167               XPAttributes pool,
 168               XpOid oid,
 169               const XpOidList* list)
 170 {
 171     char* value_out;
 172
 173     value_out = XpOidListString(list);
 174     XpPutStringAttr(pContext, pool, oid, value_out);
 175     XpOidFree(value_out);
 176 }
 177
 178 void
 179 XpValidateListAttr(XpContextPtr pContext,
 180                    XPAttributes pool,
 181                    XpOid oid,
 182                    const XpOidList* valid_oids,
 183                    const XpOidList* default_oids)
 184 {
 185     XpOidList* list = XpGetListAttr(pContext, pool, oid, valid_oids);
 186     if(XpOidListCount(list) == 0)
 187         XpPutListAttr(pContext, pool, oid, default_oids);
 188     else
 189         XpPutListAttr(pContext, pool, oid, list);
 190     XpOidListDelete(list);
 191 }
 192
 193 XpOidCardList*
 194 XpGetCardListAttr(XpContextPtr pContext,
 195                   XPAttributes pool,
 196                   XpOid oid,
 197                   const XpOidCardList* valid_card_list)
 198 {
 199     return XpOidCardListNew(XpGetStringAttr(pContext, pool, oid),
 200                             valid_card_list);
 201 }
 202
 203 void
 204 XpPutCardListAttr(XpContextPtr pContext,
 205                   XPAttributes pool,
 206                   XpOid oid,
 207                   const XpOidCardList* list)
 208 {
 209     char* value_out;
 210
 211     value_out = XpOidCardListString(list);
 212     XpPutStringAttr(pContext, pool, oid, value_out);
 213     XpOidFree(value_out);
 214 }
 215
 216 void
 217 XpValidateCardListAttr(XpContextPtr pContext,
 218                        XPAttributes pool,
 219                        XpOid oid,
 220                        const XpOidCardList* valid_cards,
 221                        const XpOidCardList* default_cards)
 222 {
 223     XpOidCardList* list = XpGetCardListAttr(pContext, pool, oid, valid_cards);
 224     if(XpOidCardListCount(list) == 0 && (XpOidCardList*)NULL != default_cards)
 225         XpPutCardListAttr(pContext, pool, oid, default_cards);
 226     else
 227         XpPutCardListAttr(pContext, pool, oid, list);
 228     XpOidCardListDelete(list);
 229 }
 230
 231 XpOidDocFmtList*
 232 XpGetDocFmtListAttr(XpContextPtr pContext,
 233                     XPAttributes pool,
 234                     XpOid oid,
 235                     const XpOidDocFmtList* valid_fmt_list)
 236 {
 237     return XpOidDocFmtListNew(XpGetStringAttr(pContext, pool, oid),
 238                               valid_fmt_list);
 239 }
 240
 241 void
 242 XpPutDocFmtListAttr(XpContextPtr pContext,
 243                     XPAttributes pool,
 244                     XpOid oid,
 245                     const XpOidDocFmtList* list)
 246 {
 247     char* value_out;
 248
 249     value_out = XpOidDocFmtListString(list);
 250     XpPutStringAttr(pContext, pool, oid, value_out);
 251     XpOidFree(value_out);
 252 }
 253
 254 void
 255 XpValidateDocFmtListAttr(XpContextPtr pContext,
 256                          XPAttributes pool,
 257                          XpOid oid,
 258                          const XpOidDocFmtList* valid_fmts,
 259                          const XpOidDocFmtList* default_fmts)
 260 {
 261     XpOidDocFmtList* list;
 262
 263     list = XpGetDocFmtListAttr(pContext, pool, oid, valid_fmts);
 264     if(XpOidDocFmtListCount(list) == 0
 265        &&
 266        (XpOidDocFmtList*)NULL != default_fmts)
 267     {
 268         XpPutDocFmtListAttr(pContext, pool, oid, default_fmts);
 269     }
 270     else
 271     {
 272         XpPutDocFmtListAttr(pContext, pool, oid, list);
 273     }
 274     XpOidDocFmtListDelete(list);
 275 }
 276
 277 XpOidMediumSS*
 278 XpGetMediumSSAttr(XpContextPtr pContext,
 279                   XPAttributes pool,
 280                   XpOid oid,
 281                   const XpOidList* valid_trays,
 282                   const XpOidList* valid_sizes)
 283 {
 284     return XpOidMediumSSNew(XpGetStringAttr(pContext, pool, oid),
 285                             valid_trays, valid_sizes);
 286 }
 287
 288 void
 289 XpPutMediumSSAttr(XpContextPtr pContext,
 290                   XPAttributes pool,
 291                   XpOid oid,
 292                   const XpOidMediumSS* msss)
 293 {
 294     char* value_out;
 295
 296     value_out = XpOidMediumSSString(msss);
 297     XpPutStringAttr(pContext, pool, oid, value_out);
 298     XpOidFree(value_out);
 299 }
 300
 301 const XpOidMediumSS*
 302 XpGetDefaultMediumSS()
 303 {
 304     return &DefaultMediumSS;
 305 }
 306
 307 XpOidTrayMediumList*
 308 XpGetTrayMediumListAttr(XpContextPtr pContext,
 309                         XPAttributes pool,
 310                         XpOid oid,
 311                         const XpOidList* valid_trays,
 312                         const XpOidMediumSS* msss)
 313 {
 314     return XpOidTrayMediumListNew(XpGetStringAttr(pContext, pool, oid),
 315                                   valid_trays, msss);
 316 }
 317
 318 void
 319 XpPutTrayMediumListAttr(XpContextPtr pContext,
 320                         XPAttributes pool,
 321                         XpOid oid,
 322                         const XpOidTrayMediumList* tm)
 323 {
 324     char* value_out;
 325
 326     value_out = XpOidTrayMediumListString(tm);
 327     XpPutStringAttr(pContext, pool, oid, value_out);
 328     XpOidFree(value_out);
 329 }
 330
 331 void
 332 XpValidatePrinterMediaAttrs(XpContextPtr pContext,
 333                             const XpOidList* valid_trays,
 334                             const XpOidList* valid_sizes)
 335 {
 336     const XpOidMediumSS* msss;
 337     XpOidMediumSS* pool_msss;
 338     XpOidTrayMediumList* tm;
 339
 340     pool_msss = XpGetMediumSSAttr(pContext, XPPrinterAttr,
 341                                   xpoid_att_medium_source_sizes_supported,
 342                                   valid_trays, valid_sizes);
 343     if(0 == XpOidMediumSSCount(pool_msss))
 344         msss = XpGetDefaultMediumSS();
 345     else
 346         msss = pool_msss;
 347     XpPutMediumSSAttr(pContext, XPPrinterAttr,
 348                       xpoid_att_medium_source_sizes_supported, msss);
 349
 350     tm = XpGetTrayMediumListAttr(pContext, XPPrinterAttr,
 351                                  xpoid_att_input_trays_medium,
 352                                  valid_trays, msss);
 353     XpPutTrayMediumListAttr(pContext, XPPrinterAttr,
 354                             xpoid_att_input_trays_medium, tm);
 355
 356     XpOidMediumSSDelete(pool_msss);
 357     XpOidTrayMediumListDelete(tm);
 358 }
 359
 360
 361 void
 362 XpValidatePrinterPool(XpContextPtr pContext,
 363                       const XpValidatePoolsRec* vpr)
 364 {
 365     /*
 366      * content-orientations-supported
 367      */
 368     XpValidateListAttr(pContext, XPPrinterAttr,
 369                        xpoid_att_content_orientations_supported,
 370                        vpr->valid_content_orientations_supported,
 371                        vpr->default_content_orientations_supported);
 372     /*
 373      * document-formats-supported
 374      */
 375     XpValidateDocFmtListAttr(pContext, XPPrinterAttr,
 376                              xpoid_att_document_formats_supported,
 377                              vpr->valid_document_formats_supported,
 378                              vpr->default_document_formats_supported);
 379     /*
 380      * plexes-supported
 381      */
 382     XpValidateListAttr(pContext, XPPrinterAttr, xpoid_att_plexes_supported,
 383                        vpr->valid_plexes_supported,
 384                        vpr->default_plexes_supported);
 385     /*
 386      * printer-resolutions-supported
 387      */
 388     XpValidateCardListAttr(pContext, XPPrinterAttr,
 389                            xpoid_att_printer_resolutions_supported,
 390                            vpr->valid_printer_resolutions_supported,
 391                            vpr->default_printer_resolutions_supported);
 392     /*
 393      * xp-embedded-formats-supported
 394      */
 395     XpValidateDocFmtListAttr(pContext, XPPrinterAttr,
 396                              xpoid_att_xp_embedded_formats_supported,
 397                              vpr->valid_xp_embedded_formats_supported,
 398                              vpr->default_xp_embedded_formats_supported);
 399     /*
 400      * xp-listfonts-modes-supported
 401      */
 402     XpValidateListAttr(pContext, XPPrinterAttr,
 403                        xpoid_att_xp_listfonts_modes_supported,
 404                        vpr->valid_xp_listfonts_modes_supported,
 405                        vpr->default_xp_listfonts_modes_supported);
 406     /*
 407      * xp-raw-formats-supported
 408      */
 409     XpValidateDocFmtListAttr(pContext, XPPrinterAttr,
 410                              xpoid_att_xp_raw_formats_supported,
 411                              vpr->valid_xp_raw_formats_supported,
 412                              vpr->default_xp_raw_formats_supported);
 413     /*
 414      * xp-setup-proviso
 415      */
 416     XpValidateOidAttr(pContext, XPPrinterAttr, xpoid_att_xp_setup_proviso,
 417                       vpr->valid_xp_setup_proviso, xpoid_none);
 418     /*
 419      * medium-source-sizes-supported
 420      * input-trays-mdeium
 421      */
 422     XpValidatePrinterMediaAttrs(pContext,
 423                                 vpr->valid_input_trays,
 424                                 vpr->valid_medium_sizes);
 425     /*
 426      * available-compressions-supported
 427      */
 428     XpValidateListAttr(pContext, XPPrinterAttr,
 429                        xpoid_att_available_compressions_supported,
 430                        vpr->valid_available_compressions_supported,
 431                        vpr->default_available_compressions_supported);
 432 }
 433
 434
 435 void
 436 XpValidateNotificationProfile(XpContextPtr pContext)
 437 {
 438     const char* value_in;
 439     const char* value_out;
 440
 441     value_in = XpGetStringAttr(pContext, XPJobAttr,
 442                                xpoid_att_notification_profile);
 443     value_out = XpOidNotifyString(XpOidNotifyParse(value_in));
 444     XpPutStringAttr(pContext, XPJobAttr,
 445                     xpoid_att_notification_profile, value_out);
 446 }
 447
 448 void
 449 XpValidateJobPool(XpContextPtr pContext,
 450                   const XpValidatePoolsRec* vpr)
 451 {
 452     /*
 453      * Note: the 'vpr' argument is unused in this
 454      *       implementation; it is reserved for future use
 455      */
 456     XpOidList* job_attrs_supported;
 457     /*
 458      * only validate attributes found in job-attributes-supported
 459      */
 460     job_attrs_supported = XpGetListAttr(pContext, XPPrinterAttr,
 461                                         xpoid_att_job_attributes_supported,
 462                                         (const XpOidList*)NULL);
 463     /*
 464      * notification-profile
 465      */
 466     if(XpOidListHasOid(job_attrs_supported, xpoid_att_notification_profile))
 467     {
 468         XpValidateNotificationProfile(pContext);
 469     }
 470     /*
 471      * clean up
 472      */
 473     XpOidListDelete(job_attrs_supported);
 474 }
 475
 476
 477 static void
 478 XpValidateDocOrPagePool(XpContextPtr pContext,
 479                         XPAttributes pool, /* XPDocAttr or XPPageAttr */
 480                         const XpOidList* attrs_supported,
 481                         const XpValidatePoolsRec* vpr)
 482 {
 483     /*
 484      * content-orientation
 485      */
 486     if(XpOidListHasOid(attrs_supported, xpoid_att_content_orientation))
 487     {
 488         XpOidList* content_orientations_supported;
 489         content_orientations_supported =
 490             XpGetListAttr(pContext, XPPrinterAttr,
 491                           xpoid_att_content_orientations_supported,
 492                           vpr->valid_content_orientations_supported);
 493         XpValidateOidAttr(pContext, pool, xpoid_att_content_orientation,
 494                           content_orientations_supported, xpoid_none);
 495         XpOidListDelete(content_orientations_supported);
 496     }
 497     /*
 498      * copy-count
 499      */
 500     if(XpOidListHasOid(attrs_supported, xpoid_att_copy_count))
 501         XpValidateCardAttr(pContext, pool, xpoid_att_copy_count,
 502                            (const XpOidCardList*)NULL, 0);
 503     /*
 504      * default-printer-resolution
 505      */
 506     if(XpOidListHasOid(attrs_supported, xpoid_att_default_printer_resolution))
 507     {
 508         XpOidCardList* printer_resolutions_supported;
 509         printer_resolutions_supported =
 510             XpGetCardListAttr(pContext, XPPrinterAttr,
 511                               xpoid_att_printer_resolutions_supported,
 512                               vpr->valid_printer_resolutions_supported);
 513         XpValidateCardAttr(pContext, pool,
 514                            xpoid_att_default_printer_resolution,
 515                            printer_resolutions_supported, 0);
 516         XpOidCardListDelete(printer_resolutions_supported);
 517     }
 518     /*
 519      * default-input-tray
 520      */
 521     if(XpOidListHasOid(attrs_supported, xpoid_att_default_input_tray))
 522     {
 523         XpOidTrayMediumList* input_trays_medium;
 524         const char* value_in;
 525         XpOid value_tray;
 526
 527         input_trays_medium =
 528             XpGetTrayMediumListAttr(pContext, XPPrinterAttr,
 529                                     xpoid_att_input_trays_medium,
 530                                     (const XpOidList*)NULL,
 531                                     (const XpOidMediumSS*)NULL);
 532         value_in =
 533             XpGetStringAttr(pContext, pool, xpoid_att_default_input_tray);
 534         value_tray = XpOidFromString(value_in);
 535         if(!XpOidTrayMediumListHasTray(input_trays_medium, value_tray))
 536             value_tray = xpoid_none;
 537         XpPutOidAttr(pContext, pool, xpoid_att_default_input_tray, value_tray);
 538         XpOidTrayMediumListDelete(input_trays_medium);
 539     }
 540     /*
 541      * default-medium
 542      */
 543     if(XpOidListHasOid(attrs_supported, xpoid_att_default_medium))
 544     {
 545         XpOidMediumSS* msss;
 546         const char* value_in;
 547         XpOid value_size;
 548
 549         msss = XpGetMediumSSAttr(pContext, XPPrinterAttr,
 550                                  xpoid_att_medium_source_sizes_supported,
 551                                  (const XpOidList*)NULL,
 552                                  (const XpOidList*)NULL);
 553         value_in = XpGetStringAttr(pContext, pool, xpoid_att_default_medium);
 554         value_size = XpOidFromString(value_in);
 555         if(!XpOidMediumSSHasSize(msss, value_size))
 556             value_size = xpoid_none;
 557         XpPutOidAttr(pContext, pool, xpoid_att_default_medium, value_size);
 558         XpOidMediumSSDelete(msss);
 559     }
 560     /*
 561      * document-format
 562      */
 563     if(XpOidListHasOid(attrs_supported, xpoid_att_document_format))
 564     {
 565         XpOidDocFmtList* document_formats_supported;
 566         const char* value_in;
 567         XpOidDocFmt* document_format;
 568         const char* value_out;
 569
 570         document_formats_supported =
 571             XpGetDocFmtListAttr(pContext, XPPrinterAttr,
 572                                 xpoid_att_document_formats_supported,
 573                                 vpr->valid_document_formats_supported);
 574         value_in = XpGetStringAttr(pContext, pool, xpoid_att_document_format);
 575         document_format = XpOidDocFmtNew(value_in);
 576         if(XpOidDocFmtListHasFmt(document_formats_supported, document_format))
 577             value_out = XpOidDocFmtString(document_format);
 578         else
 579             value_out = XpOidDocFmtString(vpr->default_document_format);
 580         XpOidDocFmtListDelete(document_formats_supported);
 581         XpOidDocFmtDelete(document_format);
 582         XpPutStringAttr(pContext, pool, xpoid_att_document_format, value_out);
 583         XpOidFree(value_out);
 584     }
 585     /*
 586      * plex
 587      */
 588     if(XpOidListHasOid(attrs_supported, xpoid_att_plex))
 589     {
 590         XpOidList* plexes_supported;
 591         plexes_supported =
 592             XpGetListAttr(pContext, XPPrinterAttr, xpoid_att_plexes_supported,
 593                           vpr->valid_plexes_supported);
 594         XpValidateOidAttr(pContext, pool, xpoid_att_plex,
 595                           plexes_supported, xpoid_none);
 596         XpOidListDelete(plexes_supported);
 597     }
 598     /*
 599      * xp-listfonts-modes
 600      */
 601     if(XpOidListHasOid(attrs_supported, xpoid_att_xp_listfonts_modes))
 602     {
 603         XpOidList* xp_listfonts_modes_supported;
 604         xp_listfonts_modes_supported =
 605             XpGetListAttr(pContext, XPPrinterAttr,
 606                           xpoid_att_xp_listfonts_modes_supported,
 607                           vpr->valid_xp_listfonts_modes_supported);
 608         XpValidateListAttr(pContext, pool, xpoid_att_xp_listfonts_modes,
 609                            xp_listfonts_modes_supported,
 610                            (const XpOidList*)NULL);
 611         XpOidListDelete(xp_listfonts_modes_supported);
 612     }
 613     /*
 614      * available-compressions
 615      */
 616     if(XpOidListHasOid(attrs_supported, xpoid_att_available_compression))
 617     {
 618         XpOidList* available_compressions_supported;
 619         available_compressions_supported =
 620             XpGetListAttr(pContext, XPPrinterAttr,
 621                           xpoid_att_available_compressions_supported,
 622                           vpr->valid_available_compressions_supported);
 623         XpValidateOidAttr(pContext, pool, xpoid_att_available_compression,
 624                           available_compressions_supported, xpoid_none);
 625         XpOidListDelete(available_compressions_supported);
 626     }
 627 }
 628
 629 void
 630 XpValidateDocumentPool(XpContextPtr pContext,
 631                        const XpValidatePoolsRec* vpr)
 632 {
 633     XpOidList* document_attrs_supported;
 634     /*
 635      * only validate attributes found in document-attributes-supported
 636      */
 637     document_attrs_supported =
 638         XpGetListAttr(pContext, XPPrinterAttr,
 639                       xpoid_att_document_attributes_supported,
 640                       (const XpOidList*)NULL);
 641     /*
 642      * validate
 643      */
 644     XpValidateDocOrPagePool(pContext, XPDocAttr,
 645                             document_attrs_supported, vpr);
 646     /*
 647      * clean up
 648      */
 649     XpOidListDelete(document_attrs_supported);
 650 }
 651
 652 void
 653 XpValidatePagePool(XpContextPtr pContext,
 654                    const XpValidatePoolsRec* vpr)
 655 {
 656     XpOidList* page_attrs_supported;
 657     /*
 658      * only validate attributes found in xp-page-attributes-supported
 659      */
 660     page_attrs_supported =
 661         XpGetListAttr(pContext, XPPrinterAttr,
 662                       xpoid_att_xp_page_attributes_supported,
 663                       (const XpOidList*)NULL);
 664     /*
 665      * validate
 666      */
 667     XpValidateDocOrPagePool(pContext, XPPageAttr,
 668                             page_attrs_supported, vpr);
 669     /*
 670      * clean up
 671      */
 672     XpOidListDelete(page_attrs_supported);
 673 }
 674
 675 void
 676 XpValidateAttributePool(XpContextPtr pContext,
 677                         XPAttributes pool,
 678                         const XpValidatePoolsRec* vpr)
 679 {
 680     switch(pool)
 681     {
 682     case XPPrinterAttr:
 683         XpValidatePrinterPool(pContext, vpr);
 684         break;
 685
 686     case XPDocAttr:
 687         XpValidateDocumentPool(pContext, vpr);
 688         break;
 689
 690     case XPJobAttr:
 691         XpValidateJobPool(pContext, vpr);
 692         break;
 693
 694     case XPPageAttr:
 695         XpValidatePagePool(pContext, vpr);
 696         break;
 697
 698     default:
 699         break;
 700     }
 701 }