1 Copyright (C) 1989, 1990, 1991, 1992, 1993 Aladdin Enterprises. 2 All rights reserved. 3 4This file is part of Ghostscript. 5 6Ghostscript is distributed in the hope that it will be useful, but 7WITHOUT ANY WARRANTY. No author or distributor accepts responsibility 8to anyone for the consequences of using it or for whether it serves any 9particular purpose or works at all, unless he says so in writing. Refer 10to the Ghostscript General Public License for full details. 11 12Everyone is granted permission to copy, modify and redistribute 13Ghostscript, but only under the conditions described in the Ghostscript 14General Public License. A copy of this license is supposed to have been 15given to you along with Ghostscript so you can know your rights and 16responsibilities. It should be in a file named COPYING. Among other 17things, the copyright notice and this notice must be preserved on all 18copies. 19 20- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 21 22This file, drivers.doc, describes the interface between Ghostscript and 23device drivers. 24 25For an overview of Ghostscript and a list of the documentation files, see 26README. 27 28******** 29******** Adding a driver ******** 30******** 31 32To add a driver to Ghostscript, all you need to do is edit devs.mak in 33two places. The first is the list of devices, in the section headed 34 35# -------------------------------- Catalog ------------------------------- # 36 37Pick a name for your device, say smurf, and add smurf to the list. 38(Device names must be 1 to 8 characters, consisting of only letters, 39digits, and underscores, of which the first character must be a letter. 40Case is significant: all current device names are lower case.) 41The second is the section headed 42 43# ---------------------------- Device drivers ---------------------------- # 44 45Suppose the files containing the smurf driver are called joe and fred. 46Then you should add the following lines: 47 48# ------ The SMURF device ------ # 49 50smurf_=joe.$(OBJ) fred.$(OBJ) 51smurf.dev: $(smurf_) 52 $(SHP)gssetdev smurf $(smurf_) 53 54joe.$(OBJ): joe.c ...and whatever it depends on 55 56fred.$(OBJ): fred.c ...and whatever it depends on 57 58If the smurf driver also needs special libraries, e.g., a library named 59gorf, then the gssetdev line should look like 60 $(SHP)gssetdev smurf $(smurf_) 61 $(SHP)gsaddmod smurf -lib gorf 62 63******** 64******** Keeping things simple 65******** 66 67If you want to add a simple device (specifically, a black-and-white 68printer), you probably don't need to read the rest of this document; just 69use the code in an existing driver as a guide. The Epson and BubbleJet 70drivers (gdevepsn.c and gdevbj10.c) are good models for dot-matrix 71printers, which require presenting the data for many scan lines at once; 72the DeskJet/LaserJet drivers (gdevdjet.c) are good models for laser 73printers, which take a single scan line at a time but support data 74compression. For color printers, the DeskJet 500 C driver (gdevcdj.c) is 75a good place to start. 76 77On the other hand, if you're writing a driver for some more esoteric 78device, or want to do something like add new settable attributes (besides 79page size and resolution), you probably do need at least some of the 80information in the rest of this document. It might be a good idea for you 81to read it in conjunction with one of the existing drivers. 82 83******** 84******** Driver structure ******** 85******** 86 87A device is represented by a structure divided into three parts: 88 89 - procedures that are shared by all instances of each device; 90 91 - parameters that are present in all devices but may be different 92 for each device or instance; and 93 94 - device-specific parameters that may be different for each instance. 95 96Normally, the procedure structure is defined and initialized at compile 97time. A prototype of the parameter structure (including both generic and 98device-specific parameters) is defined and initialized at compile time, 99but is copied and filled in when an instance of the device is created. 100 101The gx_device_common macro defines the common structure elements, with the 102intent that devices define and export a structure along the following 103lines: 104 105 typedef struct smurf_device_s { 106 gx_device_common; 107 ... device-specific parameters ... 108 } smurf_device; 109 smurf_device gs_smurf_device = { 110 sizeof(smurf_device), * params_size 111 { ... procedures ... }, * procs 112 ... generic parameter values ... 113 ... device-specific parameter values ... 114 }; 115 116The device structure instance *must* have the name gs_smurf_device, where 117smurf is the device name used in devs.mak. 118 119All the device procedures are called with the device as the first 120argument. Since each device type is actually a different structure type, 121the device procedures must be declared as taking a gx_device * as their 122first argument, and must cast it to smurf_device * internally. For 123example, in the code for the "memory" device, the first argument to all 124routines is called dev, but the routines actually use md to reference 125elements of the full structure, by virtue of the definition 126 127 #define md ((gx_device_memory *)dev) 128 129(This is a cheap version of "object-oriented" programming: in C++, for 130example, the cast would be unnecessary, and in fact the procedure table 131would be constructed by the compiler.) 132 133Structure definition 134-------------------- 135 136This essentially duplicates the structure definition in gxdevice.h. 137 138typedef struct gx_device_s { 139 int params_size; /* size of this structure */ 140 gx_device_procs *procs; /* pointer to procedure structure */ 141 char *name; /* the device name */ 142 int width; /* width in pixels */ 143 int height; /* height in pixels */ 144 float x_pixels_per_inch; /* x density */ 145 float y_pixels_per_inch; /* y density */ 146 gs_rect margin_inches; /* margins around imageable area, */ 147 /* in inches */ 148 gx_device_color_info color_info; /* color information */ 149 int is_open; /* true if device has been opened */ 150} gx_device; 151 152The name in the structure should be the same as the name in devs.mak. 153 154gx_device_common is a macro consisting of just the element definitions. 155 156For sophisticated developers only 157--------------------------------- 158 159If for any reason you need to change the definition of the basic device 160structure, or add procedures, you must change the following places: 161 162 - This document and NEWS (if you want to keep the 163 documentation up to date). 164 - The definition of gx_device_common and/or the procedures 165 in gxdevice.h. 166 - The null device in gsdevice.c. (Note that this device does 167 not allow procedure defaulting.) 168 - The tracing "device" in gstdev.c. (Ditto.) 169 - The command list "device" in gxclist.c. (Ditto.) 170 - The clip list accumulation and clipping "devices" in gxcpath.c. 171 (Ditto.) 172 - The "memory" devices in gdevmem.h and gdevmem*.c. (Ditto.) 173 - The generic printer device macros in gdevprn.h. 174 - The generic printer device code in gdevprn.c. 175 - All the real devices in the standard Ghostscript distribution, 176 as listed in devs.mak. (Most of the printer devices are 177 created with the macros in gdevprn.h, so you may not have to 178 edit the source code for them.) 179 - Any other drivers you have that aren't part of the standard 180 Ghostscript distribution. 181 182You may also have to change the code for gx_default_get_props and/or 183gx_default_put_props (in gsdevice.c). Note that if all you are doing 184is adding optional procedures, you do NOT have to modify any device 185drivers other than the ones specifically listed above; Ghostscript 186will substitute the default procedures properly. 187 188******** 189******** Coding conventions ******** 190******** 191 192While most drivers (especially printer drivers) follow a very similar 193template, there is one important coding convention that is not obvious 194from reading the code for existing drivers: Driver procedures must not use 195malloc to allocate any storage that stays around after the procedure 196returns. Instead, they must use gs_malloc and gs_free, which have 197slightly different calling conventions. (The prototypes for these are in 198gs.h, which is included in gx.h, which is included in gdevprn.h.) This is 199necessary so that Ghostscript can clean up all allocated memory before 200exiting, which is essential in environments that provide only 201single-address-space multi-tasking (specifically, Microsoft Windows). 202 203char *gs_malloc(uint num_elements, uint element_size, 204 const char *client_name); 205 206 Like calloc, but unlike malloc, gs_malloc takes an element count 207and an element size. For structures, num_elements is 1 and element_size 208is sizeof the structure; for byte arrays, num_elements is the number of 209bytes and element_size is 1. 210 211 The client_name is used for tracing and debugging. It must be a 212real string, not NULL. Normally it is the name of the procedure in which 213the call occurs. 214 215void gs_free(char *data, uint num_elements, uint element_size, 216 const char *client_name); 217 218 Unlike free, gs_free demands that num_elements and element_size be 219supplied. It also requires a client name, like gs_malloc. 220 221******** 222******** Types and coordinates ******** 223******** 224 225Coordinate system 226----------------- 227 228Since each driver specifies the initial transformation from user to device 229coordinates, the driver can use any coordinate system it wants, as long as 230a device coordinate will fit in an int. (This is only an issue on MS-DOS 231systems, where ints are only 16 bits. User coordinates are represented as 232floats.) Typically the coordinate system will have (0,0) in the upper 233left corner, with X increasing to the right and Y increasing toward the 234bottom. This happens to be the coordinate system that all the currently 235supported devices use. However, there is supposed to be nothing in the 236rest of Ghostscript that assumes this. 237 238Drivers must check (and, if necessary, clip) the coordinate parameters 239given to them: they should not assume the coordinates will be in bounds. 240The fit_fill and fit_copy macros in gxdevice.h are very helpful in doing 241this. 242 243Color definition 244---------------- 245 246Ghostscript represents colors internally as RGB or CMYK values. In 247communicating with devices, however, it assumes that each device has a 248palette of colors identified by integers (to be precise, elements of type 249gx_color_index). Drivers may provide a uniformly spaced gray ramp or 250color cube for halftoning, or they may do their own color approximation, 251or both. 252 253The color_info member of the device structure defines the color and 254gray-scale capabilities of the device. Its type is defined as follows: 255 256typedef struct gx_device_color_info_s { 257 int num_components; /* 1 = gray only, 3 = RGB, */ 258 /* 4 = CMYK */ 259 int depth; /* # of bits per pixel */ 260 gx_color_value max_gray; /* # of distinct gray levels -1 */ 261 gx_color_value max_rgb; /* # of distinct color levels -1 */ 262 /* (only relevant if num_comp. > 1) */ 263 gx_color_value dither_gray; /* size of gray ramp for halftoning */ 264 gx_color_value dither_rgb; /* size of color cube ditto */ 265 /* (only relevant if num_comp. > 1) */ 266} gx_device_color_info; 267 268The following macros (in gxdevice.h) provide convenient shorthands for 269initializing this structure for ordinary black-and-white or color devices: 270 271#define dci_black_and_white { 1, 1, 1, 0, 2, 0 } 272#define dci_color(depth,maxv,dither) { 3, depth, maxv, maxv, dither, dither } 273 274The idea is that a device has a certain number of gray levels (max_gray 275+1) and a certain number of colors (max_rgb +1) that it can produce 276directly. When Ghostscript wants to render a given RGB color as a device 277color, it first tests whether the color is a gray level. (If 278num_components is 1, it converts all colors to gray levels.) If so: 279 280 - If max_gray is large (>= 31), Ghostscript asks the device to 281approximate the gray level directly. If the device returns a 282gx_color_value, Ghostscript uses it. Otherwise, Ghostscript assumes that 283the device can represent dither_gray distinct gray levels, equally spaced 284along the diagonal of the color cube, and uses the two nearest ones to the 285desired color for halftoning. 286 287If the color is not a gray level: 288 289 - If max_rgb is large (>= 31), Ghostscript asks the device to 290approximate the color directly. If the device returns a 291gx_color_value, Ghostscript uses it. Otherwise, Ghostscript assumes 292that the device can represent dither_rgb * dither_rgb * dither_rgb 293distinct colors, equally spaced throughout the color cube, and uses 294two of the nearest ones to the desired color for halftoning. 295 296Types 297----- 298 299Here is a brief explanation of the various types that appear as parameters 300or results of the drivers. 301 302gx_color_value (defined in gxdevice.h) 303 304 This is the type used to represent RGB color values. It is 305currently equivalent to unsigned short. However, Ghostscript may use less 306than the full range of the type to represent color values: 307gx_color_value_bits is the number of bits actually used, and 308gx_max_color_value is the maximum value (equal to 3092^gx_max_color_value_bits - 1). 310 311gx_device (defined in gxdevice.h) 312 313 This is the device structure, as explained above. 314 315gs_matrix (defined in gsmatrix.h) 316 317 This is a 2-D homogenous coordinate transformation matrix, used by 318many Ghostscript operators. 319 320gx_color_index (defined in gxdevice.h) 321 322 This is meant to be whatever the driver uses to represent a device 323color. For example, it might be an index in a color map. Ghostscript 324doesn't ever do any computations with these values: it gets them from 325map_rgb_color or map_cmyk_color and hands them back as arguments to 326several other procedures. The special value gx_no_color_index (defined as 327(gx_color_index)(-1)) means "transparent" for some of the procedures. The 328type definition is simply: 329 330 typedef unsigned long gx_color_index; 331 332gs_prop_item (defined in gsprops.h) 333 334 This is an element of a property list, which is used to read and 335set attributes in a device. See the comments in gsprops.h, and the 336description of the get_props and put_props procedures below, for more 337detail. 338 339gx_bitmap (defined in gxbitmap.h) 340 341 This structure type represents a bitmap to be used as a tile for 342filling a region (rectangle). Here is a copy of the relevant part of the 343file: 344 345/* 346 * Structure for describing stored bitmaps. 347 * Bitmaps are stored bit-big-endian (i.e., the 2^7 bit of the first 348 * byte corresponds to x=0), as a sequence of bytes (i.e., you can't 349 * do word-oriented operations on them if you're on a little-endian 350 * platform like the Intel 80x86 or VAX). Each scan line must start on 351 * a (32-bit) word boundary, and hence is padded to a word boundary, 352 * although this should rarely be of concern, since the raster and width 353 * are specified individually. The first scan line corresponds to y=0 354 * in whatever coordinate system is relevant. 355 * 356 * For bitmaps used as halftone tiles, we may replicate the tile in 357 * X and/or Y, but it is still valuable to know the true tile dimensions. 358 */ 359typedef struct gx_bitmap_s { 360 byte *data; 361 int raster; /* bytes per scan line */ 362 gs_int_point size; /* width, height */ 363 gx_bitmap_id id; 364 ushort rep_width, rep_height; /* true size of tile */ 365} gx_bitmap; 366 367******** 368******** Driver procedures ******** 369******** 370 371All the procedures that return int results return 0 on success, or an 372appropriate negative error code in the case of error conditions. The 373error codes are defined in gserrors.h. The relevant ones for drivers 374are as follows: 375 376 gs_error_invalidfileaccess 377 An attempt to open a file failed. 378 379 gs_error_limitcheck 380 An otherwise valid parameter value was too large for 381 the implementation. 382 383 gs_error_rangecheck 384 A parameter was outside the valid range. 385 386 gs_error_VMerror 387 An attempt to allocate memory failed. (If this 388 happens, the procedure should release all memory it 389 allocated before it returns.) 390 391If a driver does return an error, it should use the return_error 392macro rather than a simple return statement, e.g., 393 394 return_error(gs_error_VMerror); 395 396This macro is defined in gx.h, which is automatically included by 397gdevprn.h but not by gserrors.h. 398 399Most of the procedures that a driver may implement are optional. If a 400device doesn't supply an optional procedure <proc>, the entry in the 401procedure structure may be either gx_default_<proc>, e.g. 402gx_default_tile_rectangle, or NULL or 0. (The device procedure must also 403call the gx_default_ procedure if it doesn't implement the function for 404particular values of the arguments.) Since C compilers supply 0 as the 405value for omitted structure elements, this convention means that 406statically initialized procedure structures will continue to work even if 407new (optional) members are added. 408 409Life cycle 410---------- 411 412Ghostscript "opens" and "closes" drivers explicitly; a driver can assume 413that no output operations will be done through it while it is closed. 414Ghostscript keeps track of whether a given driver is open, so a driver 415will never be opened when it is already open, or closed when it is already 416closed. 417 418The following are the only driver procedures that may be called when the 419driver is closed: 420 open_device 421 get_initial_matrix 422 get_props 423 put_props 424 425Open/close/sync 426--------------- 427 428int (*open_device)(P1(gx_device *)) [OPTIONAL] 429 430 Open the device: do any initialization associated with making the 431device instance valid. This must be done before any output to the device. 432The default implementation does nothing. 433 434void (*get_initial_matrix)(P2(gx_device *, gs_matrix *)) [OPTIONAL] 435 436 Construct the initial transformation matrix mapping user 437coordinates (nominally 1/72" per unit) to device coordinates. The default 438procedure computes this from width, height, and x/y_pixels_per_inch on the 439assumption that the origin is in the upper left corner, i.e. 440 xx = x_pixels_per_inch/72, xy = 0, 441 yx = 0, yy = -y_pixels_per_inch/72, 442 tx = 0, ty = height. 443 444int (*sync_output)(P1(gx_device *)) [OPTIONAL] 445 446 Synchronize the device. If any output to the device has been 447buffered, send / write it now. Note that this may be called several times 448in the process of constructing a page, so printer drivers should NOT 449implement this by printing the page. The default implementation does 450nothing. 451 452int (*output_page)(P3(gx_device *, int num_copies, int flush)) [OPTIONAL] 453 454 Output a fully composed page to the device. The num_copies 455argument is the number of copies that should be produced for a hardcopy 456device. (This may be ignored if the driver has some other way to specify 457the number of copies.) The flush argument is true for showpage, false for 458copypage. The default definition just calls sync_output. Printer drivers 459should implement this by printing and ejecting the page. 460 461int (*close_device)(P1(gx_device *)) [OPTIONAL] 462 463 Close the device: release any associated resources. After this, 464output to the device is no longer allowed. The default implementation 465does nothing. 466 467Color mapping 468------------- 469 470A given driver normally will implement either map_rgb_color or 471map_cmyk_color, but not both; black-and-white drivers do not need to 472implement either one. 473 474gx_color_index (*map_rgb_color)(P4(gx_device *, gx_color_value red, 475 gx_color_value green, gx_color_value blue)) [OPTIONAL] 476 477 Map a RGB color to a device color. The range of legal values of 478the RGB arguments is 0 to gx_max_color_value. The default algorithm uses 479the map_cmyk_color procedure if the driver supplies one, otherwise returns 4801 if any of the values exceeds gx_max_color_value/2, 0 otherwise. 481 482 Ghostscript assumes that for devices that have color capability 483(i.e., color_info.num_components > 1), map_rgb_color returns a color index 484for a gray level (as opposed to a non-gray color) iff red = green = blue. 485 486gx_color_index (*map_cmyk_color)(P5(gx_device *, gx_color_value cyan, 487 gx_color_value magenta, gx_color_value yellow, gx_color_value black)) 488 [OPTIONAL] 489 490 Map a CMYK color to a device color. The range of legal values of 491the CMYK arguments is 0 to gx_max_color_value. The default algorithm 492calls the map_rgb_color procedure, with suitably transformed arguments. 493 494 Ghostscript assumes that for devices that have color capability 495(i.e., color_info.num_components > 1), map_cmyk_color returns a color 496index for a gray level (as opposed to a non-gray color) iff cyan = magenta 497= yellow. 498 499int (*map_color_rgb)(P3(gx_device *, gx_color_index color, 500 gx_color_value rgb[3])) [OPTIONAL] 501 502 Map a device color code to RGB values. The default algorithm 503returns (0 if color==0 else gx_max_color_value) for all three components. 504 505Drawing 506------- 507 508All drawing operations use device coordinates and device color values. 509 510int (*fill_rectangle)(P6(gx_device *, int x, int y, 511 int width, int height, gx_color_index color)) 512 513 Fill a rectangle with a color. The set of pixels filled is 514{(px,py) | x <= px < x + width and y <= py < y + height}. In other words, 515the point (x,y) is included in the rectangle, as are (x+w-1,y), (x,y+h-1), 516and (x+w-1,y+h-1), but *not* (x+w,y), (x,y+h), or (x+w,y+h). If width <= 5170 or height <= 0, fill_rectangle should return 0 without drawing anything. 518 519int (*draw_line)(P6(gx_device *, int x0, int y0, int x1, int y1, 520 gx_color_index color)) [OPTIONAL] 521 522 Draw a minimum-thickness line from (x0,y0) to (x1,y1). The 523precise set of points to be filled is defined as follows. First, if y1 < 524y0, swap (x0,y0) and (x1,y1). Then the line includes the point (x0,y0) 525but not the point (x1,y1). If x0=x1 and y0=y1, draw_line should return 0 526without drawing anything. 527 528Bitmap imaging 529-------------- 530 531Bitmap (or pixmap) images are stored in memory in a nearly standard way. 532The first byte corresponds to (0,0) in the image coordinate system: bits 533(or polybit color values) are packed into it left-to-right. There may be 534padding at the end of each scan line: the distance from one scan line to 535the next is always passed as an explicit argument. 536 537int (*copy_mono)(P11(gx_device *, const unsigned char *data, int data_x, 538 int raster, gx_bitmap_id id, int x, int y, int width, int height, 539 gx_color_index color0, gx_color_index color1)) 540 541 Copy a monochrome image (similar to the PostScript image 542operator). Each scan line is raster bytes wide. Copying begins at 543(data_x,0) and transfers a rectangle of the given width at height to the 544device at device coordinate (x,y). (If the transfer should start at some 545non-zero y value in the data, the caller can adjust the data address by 546the appropriate multiple of the raster.) The copying operation writes 547device color color0 at each 0-bit, and color1 at each 1-bit: if color0 or 548color1 is gx_no_color_index, the device pixel is unaffected if the image 549bit is 0 or 1 respectively. If id is different from gx_no_bitmap_id, it 550identifies the bitmap contents unambiguously; a call with the same id will 551always have the same data, raster, and data contents. 552 553 This operation is the workhorse for text display in Ghostscript, 554so implementing it efficiently is very important. 555 556int (*tile_rectangle)(P10(gx_device *, const gx_bitmap *tile, 557 int x, int y, int width, int height, 558 gx_color_index color0, gx_color_index color1, 559 int phase_x, int phase_y)) [OPTIONAL] 560 561 Tile a rectangle. Tiling consists of doing multiple copy_mono 562operations to fill the rectangle with copies of the tile. The tiles are 563aligned with the device coordinate system, to avoid "seams". 564Specifically, the (phase_x, phase_y) point of the tile is aligned with the 565origin of the device coordinate system. (Note that this is backwards from 566the PostScript definition of halftone phase.) phase_x and phase_y are 567guaranteed to be in the range [0..tile->width) and [0..tile->height) 568respectively. 569 570 If color0 and color1 are both gx_no_color_index, then the tile is 571a color pixmap, not a bitmap: see the next section. 572 573Pixmap imaging 574-------------- 575 576Pixmaps are just like bitmaps, except that each pixel occupies more than 577one bit. All the bits for each pixel are grouped together (this is 578sometimes called "chunky" or "Z" format). The number of bits per pixel is 579given by the color_info.depth parameter in the device structure: the legal 580values are 1, 2, 4, 8, 16, 24, or 32. The pixel values are device color 581codes (i.e., whatever it is that map_rgb_color returns). 582 583int (*copy_color)(P9(gx_device *, const unsigned char *data, int data_x, 584 int raster, gx_bitmap_id id, int x, int y, int width, int height)) 585 586 Copy a color image with multiple bits per pixel. The raster is in 587bytes, but x and width are in pixels, not bits. If the device doesn't 588actually support color, this is OPTIONAL; the default is equivalent to 589copy_mono with color0 = 0 and color1 = 1. If id is different from 590gx_no_bitmap_id, it identifies the bitmap contents unambiguously; a call 591with the same id will always have the same data, raster, and data 592contents. 593 594tile_rectangle can also take colored tiles. This is indicated by the 595color0 and color1 arguments both being gx_no_color_index. In this case, 596as for copy_color, the raster and height in the "bitmap" are interpreted 597as for real bitmaps, but the x and width are in pixels, not bits. 598 599Reading bits back 600----------------- 601 602int (*get_bits)(P4(gx_device *, int y, byte *str, byte **actual_data)) 603 [OPTIONAL] 604 605 Read one scan line of bits back from the device into the area 606starting at str, starting with scan line y. If the bits cannot be 607read back (e.g., from a printer), return -1; otherwise return a value 608as described below. The contents of the bits beyond the last valid 609bit in the scan line (as defined by the device width) are 610unpredictable. 611 612 If actual_data is NULL, the bits are always returned at str. 613If actual_data is not NULL, get_bits may either copy the bits to str 614and set *actual_data = str, or it may leave the bits where they are 615and return a point to them in *actual_data. In the latter case, the 616bits are guaranteed to start on a 32-bit boundary and to be padded to 617a multiple of 32 bits; also in this case, the bits are not guaranteed 618to still be there after the next call on get_bits. 619 620Properties 621---------- 622 623Devices may have an open-ended set of properties, which are simply pairs 624consisting of a name and a value. The value may be of various types: 625integer, boolean, float, string, array of integer, or array of float. 626 627Property lists are somewhat complex. If your device has properties beyond 628those of a straightforward display or printer, we strongly advise using 629the code for the default implementation of get_props and put_props in 630gsdevice.c as a model for your own code. 631 632int (*get_props)(P2(gx_device *dev, gs_prop_item *plist)) [OPTIONAL] 633 634 Read all the properties of the device into the property list at 635plist. Return the number of properties. See gsprops.h for more details, 636gx_default_get_props in gsdevice.c for an example. 637 638 If plist is NULL, just return the number of properties plus the 639total number of elements in all array-valued properties. This is how the 640getdeviceprops operator finds out how much storage to allocate for the 641property list. 642 643int (*put_props)(P3(gx_device *dev, gs_prop_item *plist, 644 int count)) [OPTIONAL] 645 646 Set the properties of the device from the property list at plist. 647Return 0 if everything was OK, an error code 648(gs_error_undefined/typecheck/rangecheck/limitcheck) if some property had 649an invalid type or out-of-range value. See gsprops.h for more details, 650gx_default_put_props in gsdevice.c for an example. 651 652 Changing device properties may require closing the device and 653reopening it. If this is the case, the put_props procedure should just 654close the device; a higher-level routine (gs_putdeviceprops) will reopen 655it. 656 657External fonts 658-------------- 659 660Drivers may include the ability to display text. More precisely, they may 661supply a set of procedures that in turn implement some font and text 662handling capabilities. These procedures are documented in another file, 663xfonts.doc. The link between the two is the driver procedure that 664supplies the font/text procedures: 665 666xfont_procs *(*get_xfont_procs)(P1(gx_device *dev)) [OPTIONAL] 667 668 Return a structure of procedures for handling external fonts and 669text display. A NULL value means that this driver doesn't provide this 670capability. 671 672For technical reasons, a second procedure is also needed: 673 674gx_device *(*get_xfont_device)(P1(gx_device *dev)) [OPTIONAL] 675 676 Return the device that implements get_xfont_procs in a non-default 677way for this device, if any. Except for certain special internal devices, 678this is always the device argument. 679