1 #if !defined( AXIS_INCLUDED ) /* Include this file only once */ 2 #define AXIS_INCLUDED 3 /* 4 *+ 5 * Name: 6 * axis.h 7 8 * Type: 9 * C include file. 10 11 * Purpose: 12 * Define the interface to the Axis class. 13 14 * Invocation: 15 * #include "axis.h" 16 17 * Description: 18 * This include file defines the interface to the Axis class and 19 * provides the type definitions, function prototypes and macros, 20 * etc. needed to use this class. 21 * 22 * The Axis class implements the basic behaviour of a coordinate 23 * axis, several of which may be assembled to represent a 24 * coordinate system. 25 26 * Inheritance: 27 * The Axis class inherits from the Object class. 28 29 * Attributes Over-Ridden: 30 * None. 31 32 * New Attributes Defined: 33 * Bottom (double) 34 * Lowest legal value for axis. 35 * Digits (integer) 36 * Specifies how many digits of precision are required by 37 * default when a coordinate value for an Axis is formatted 38 * (e.g. using the astAxisFormat method). The Digits value acts 39 * as a default only and is over-ridden if a Format string is 40 * specified explicitly (using the astSetAxisFormat method). The 41 * default supplied by the Axis class for the Digits attribute 42 * itself is 7. 43 * Direction (integer) 44 * Specifies how coordinate values for an Axis should be 45 * displayed. By default, it has the value one, indicating that 46 * they should be shown in the conventional sense 47 * (i.e. increasing left to right for an abscissa and bottom to 48 * top for an ordinate). If set to zero, this attribute 49 * indicates that the direction should be reversed (as would 50 * often be done for an astronomical magnitude or a right 51 * ascension axis, for example). 52 * Format (string) 53 * Specifies the format to be used to display coordinate values 54 * for an Axis (i.e. to convert them from binary to character 55 * form). The interpretation of this string (e.g. by derived 56 * classes) is left to the astAxisFormat method, but the Axis 57 * class interprets this parameter as a C "printf" format string 58 * which should be capable of formatting a single coordinate 59 * value stored as a double (e.g. "%1.7G"). If no Format string 60 * is set, the default supplied by the Axis class is based on 61 * the value of the Digits attribute. 62 * Label (string) 63 * Specifies the label to be attached to an Axis when it is 64 * represented in (e.g.) a graph. It is intended purely for 65 * interpretation by human readers and not by software. The 66 * default supplied by the Axis class is the string "Coordinate 67 * Axis". 68 * Symbol (string) 69 * Specifies the symbol to be used to represent coordinate 70 * values for an Axis in "short form", such as in algebraic 71 * expressions where a full description of the Axis would be 72 * inappropriate. Examples include "RA" and "Dec" (for Right 73 * Ascension and Declination). The default supplied by the Axis 74 * class is the string "x". 75 * Top (double) 76 * Highest legal value for axis. 77 * Unit (string) 78 * Describes the units used to represent coordinate values on an 79 * Axis. The default supplied by the Axis class is an empty 80 * string "". 81 82 * Methods Over-Ridden: 83 * Public: 84 * None. 85 86 * Protected: 87 * astSetAttrib 88 * Set an attribute value for an Axis. 89 90 * New Methods Defined: 91 * Public: 92 * astAxisFormat 93 * Format a coordinate value for an Axis. 94 * astAxisNorm 95 * Normalise an Axis coordinate value. 96 * astAxisUnformat 97 * Read a formatted coordinate value for an Axis. 98 99 * Protected: 100 * astAxisAbbrev 101 * Abbreviate a formatted Axis value by skipping leading fields. 102 * astAxisDistance 103 * Find the distance between two axis values. 104 * astAxisFields 105 * Identify the fields within a formatted SkyAxis value. 106 * astAxisGap 107 * Find a "nice" gap for tabulating Axis values. 108 * astAxisOffset 109 * Add an increment onto a supplied axis value. 110 * astAxisOverlay 111 * Overlay the attributes of a template Axis on to another Axis. 112 * astClearAxisDigits 113 * Clear the Digits attribute for an Axis. 114 * astClearAxisDirection 115 * Clear the Direction attribute for an Axis. 116 * astClearAxisFormat 117 * Clear the Format attribute for an Axis. 118 * astClearAxisLabel 119 * Clear the Label attribute for an Axis. 120 * astClearAxisSymbol 121 * Clear the Symbol attribute for an Axis. 122 * astClearAxisUnit 123 * Clear the Unit attribute for an Axis. 124 * astGetAxisDigits 125 * Get the value of the Digits attribute for an Axis. 126 * astGetAxisDirection 127 * Get the value of the Direction attribute for an Axis. 128 * astGetAxisFormat 129 * Get a pointer to the Format attribute for an Axis. 130 * astGetAxisLabel 131 * Get a pointer to the Label attribute for an Axis. 132 * astGetAxisSymbol 133 * Get a pointer to the Symbol attribute for an Axis. 134 * astGetAxisUnit 135 * Get a pointer to the Unit attribute for an Axis. 136 * astSetAxisDigits 137 * Set the value of the Digits attribute for an Axis. 138 * astSetAxisDirection 139 * Set the value of the Direction attribute for an Axis. 140 * astSetAxisFormat 141 * Set the value of the Format attribute for an Axis. 142 * astSetAxisLabel 143 * Set the value of the Label attribute for an Axis. 144 * astSetAxisSymbol 145 * Set the value of the Symbol attribute for an Axis. 146 * astSetAxisUnit 147 * Set the value of the Unit attribute for an Axis. 148 * astTestAxisDigits 149 * Test whether a value has been set for the Digits attribute of an 150 * Axis. 151 * astTestAxisDirection 152 * Test whether a value has been set for the Direction attribute of an 153 * Axis. 154 * astTestAxisFormat 155 * Test whether a value has been set for the Format attribute of an 156 * Axis. 157 * astTestAxisLabel 158 * Test whether a value has been set for the Label attribute of an 159 * Axis. 160 * astTestAxisSymbol 161 * Test whether a value has been set for the Symbol attribute of an 162 * Axis. 163 * astTestAxisUnit 164 * Test whether a value has been set for the Unit attribute of an 165 * Axis. 166 167 * Other Class Functions: 168 * Public: 169 * astAxis 170 * Create an Axis. 171 * astIsAAxis 172 * Test class membership. 173 174 * Protected: 175 * astCheckAxis 176 * Validate class membership. 177 * astInitAxis 178 * Initialise an Axis. 179 * astLoadAxis 180 * Load an Axis. 181 182 * Macros: 183 * None. 184 185 * Type Definitions: 186 * Public: 187 * AstAxis 188 * Axis object type. 189 190 * Protected: 191 * AstAxisVtab 192 * Axis virtual function table type. 193 194 * Feature Test Macros: 195 * astCLASS 196 * If the astCLASS macro is undefined, only public symbols are 197 * made available, otherwise protected symbols (for use in other 198 * class implementations) are defined. This macro also affects 199 * the reporting of error context information, which is only 200 * provided for external calls to the AST library. 201 202 * Copyright: 203 * Copyright (C) 1997-2006 Council for the Central Laboratory of the 204 * Research Councils 205 206 * Licence: 207 * This program is free software: you can redistribute it and/or 208 * modify it under the terms of the GNU Lesser General Public 209 * License as published by the Free Software Foundation, either 210 * version 3 of the License, or (at your option) any later 211 * version. 212 * 213 * This program is distributed in the hope that it will be useful, 214 * but WITHOUT ANY WARRANTY; without even the implied warranty of 215 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 216 * GNU Lesser General Public License for more details. 217 * 218 * You should have received a copy of the GNU Lesser General 219 * License along with this program. If not, see 220 * <http://www.gnu.org/licenses/>. 221 222 * Authors: 223 * RFWS: R.F. Warren-Smith (Starlink) 224 * DSB: B.S. Berry (Starlink) 225 226 * History: 227 * 1-MAR-1996 (RFWS): 228 * Original version. 229 * 25-APR-1996 (RFWS): 230 * Made all attribute access functions protected. 231 * 10-SEP-1996 (RFWS): 232 * Added I/O facilities. 233 * 11-SEP-1996 (RFWS): 234 * Added astAxisGap (written by DSB). 235 * 25-FEB-1998 (RFWS): 236 * Added astAxisUnformat. 237 * 29-AUG-2001 (DSB): 238 * Added AxisDistance and AxisOffset. 239 * 10-OCT-2002 (DSB): 240 * Added Top and Bottom. 241 * 8-JAN-2003 (DSB): 242 * Added protected astInitAxisVtab method. 243 *- 244 */ 245 246 /* Include files. */ 247 /* ============== */ 248 /* Interface definitions. */ 249 /* ---------------------- */ 250 #include "object.h" /* Base Object class */ 251 #if defined(astCLASS) /* Protected */ 252 #include "channel.h" 253 #endif 254 255 256 /* Macros */ 257 /* ====== */ 258 #if defined(astCLASS) 259 #define AST__AXIS_GETDEFAULTFORMAT_BUFF_LEN 50 260 #define AST__AXIS_AXISFORMAT_BUFF_LEN 127 261 #define AST__AXIS_GETAXISNORMUNIT_BUFF_LEN 127 262 #define AST__AXIS_GETATTRIB_BUFF_LEN 50 263 #endif 264 265 /* Define a dummy __attribute__ macro for use on non-GNU compilers. */ 266 #ifndef __GNUC__ 267 # define __attribute__(x) /*NOTHING*/ 268 #endif 269 270 /* Type Definitions. */ 271 /* ================= */ 272 /* Axis structure. */ 273 /* --------------- */ 274 /* This structure contains all information that is unique to each 275 object in the class (e.g. its instance variables). */ 276 typedef struct AstAxis { 277 278 /* Attributes inherited from the parent class. */ 279 AstObject object; /* Parent class structure */ 280 281 /* Attributes specific to objects in this class. */ 282 char *label; /* Pointer to label string */ 283 char *format; /* Pointer to format string */ 284 char *symbol; /* Pointer to symbol string */ 285 char *unit; /* Pointer to unit string */ 286 int digits; /* Default digits of precision */ 287 int direction; /* Plot in conventional direction? */ 288 double top; /* Highest legal axis value */ 289 double bottom; /* Lowest legal axis value */ 290 } AstAxis; 291 292 /* Virtual function table. */ 293 /* ----------------------- */ 294 /* This table contains all information that is the same for all 295 objects in the class (e.g. pointers to its virtual functions). */ 296 #if defined(astCLASS) /* Protected */ 297 298 typedef struct AstAxisVtab { 299 300 /* Properties (e.g. methods) inherited from the parent class. */ 301 AstObjectVtab object_vtab; /* Parent class virtual function table */ 302 303 /* A Unique identifier to determine class membership. */ 304 AstClassIdentifier id; 305 306 /* Properties (e.g. methods) specific to this class. */ 307 const char *(* AxisAbbrev)( AstAxis *, const char *, const char *, const char *, int * ); 308 const char *(* AxisFormat)( AstAxis *, double, int * ); 309 const char *(* GetAxisFormat)( AstAxis *, int * ); 310 const char *(* GetAxisLabel)( AstAxis *, int * ); 311 const char *(* GetAxisSymbol)( AstAxis *, int * ); 312 const char *(* GetAxisUnit)( AstAxis *, int * ); 313 const char *(* GetAxisNormUnit)( AstAxis *, int * ); 314 double (* AxisGap)( AstAxis *, double, int *, int * ); 315 double (* AxisDistance)( AstAxis *, double, double, int * ); 316 double (* AxisOffset)( AstAxis *, double, double, int * ); 317 int (* AxisIn)( AstAxis *, double, double, double, int, int * ); 318 int (* AxisFields)( AstAxis *, const char *, const char *, int, char **, int *, double *, int * ); 319 int (* AxisUnformat)( AstAxis *, const char *, double *, int * ); 320 int (* GetAxisDigits)( AstAxis *, int * ); 321 int (* GetAxisDirection)( AstAxis *, int * ); 322 int (* TestAxisDigits)( AstAxis *, int * ); 323 int (* TestAxisDirection)( AstAxis *, int * ); 324 int (* TestAxisFormat)( AstAxis *, int * ); 325 int (* TestAxisLabel)( AstAxis *, int * ); 326 int (* TestAxisSymbol)( AstAxis *, int * ); 327 int (* TestAxisUnit)( AstAxis *, int * ); 328 int (* TestAxisNormUnit)( AstAxis *, int * ); 329 void (* AxisNorm)( AstAxis *, double *, int * ); 330 void (* AxisOverlay)( AstAxis *, AstAxis *, int * ); 331 void (* ClearAxisDigits)( AstAxis *, int * ); 332 void (* ClearAxisDirection)( AstAxis *, int * ); 333 void (* ClearAxisFormat)( AstAxis *, int * ); 334 void (* ClearAxisLabel)( AstAxis *, int * ); 335 void (* ClearAxisSymbol)( AstAxis *, int * ); 336 void (* ClearAxisUnit)( AstAxis *, int * ); 337 void (* SetAxisDigits)( AstAxis *, int, int * ); 338 void (* SetAxisDirection)( AstAxis *, int, int * ); 339 void (* SetAxisFormat)( AstAxis *, const char *, int * ); 340 void (* SetAxisLabel)( AstAxis *, const char *, int * ); 341 void (* SetAxisSymbol)( AstAxis *, const char *, int * ); 342 void (* SetAxisUnit)( AstAxis *, const char *, int * ); 343 344 double (* GetAxisTop)( AstAxis *, int * ); 345 int (* TestAxisTop)( AstAxis *, int * ); 346 void (* ClearAxisTop)( AstAxis *, int * ); 347 void (* SetAxisTop)( AstAxis *, double, int * ); 348 349 double (* GetAxisBottom)( AstAxis *, int * ); 350 int (* TestAxisBottom)( AstAxis *, int * ); 351 void (* ClearAxisBottom)( AstAxis *, int * ); 352 void (* SetAxisBottom)( AstAxis *, double, int * ); 353 354 } AstAxisVtab; 355 356 #if defined(THREAD_SAFE) 357 358 /* Define a structure holding all data items that are global within the 359 object.c file. */ 360 361 typedef struct AstAxisGlobals { 362 AstAxisVtab Class_Vtab; 363 int Class_Init; 364 char GetDefaultFormat_Buff[ AST__AXIS_GETDEFAULTFORMAT_BUFF_LEN + 1 ]; 365 char AxisFormat_Buff[ AST__AXIS_AXISFORMAT_BUFF_LEN + 1 ]; 366 char GetAxisNormUnit_Buff[ AST__AXIS_GETAXISNORMUNIT_BUFF_LEN + 1 ]; 367 char GetAttrib_Buff[ AST__AXIS_GETATTRIB_BUFF_LEN + 1 ]; 368 } AstAxisGlobals; 369 370 #endif 371 372 373 #endif 374 375 /* Function prototypes. */ 376 /* ==================== */ 377 /* Prototypes for standard class functions. */ 378 /* ---------------------------------------- */ 379 astPROTO_CHECK(Axis) /* Check class membership */ 380 astPROTO_ISA(Axis) /* Test class membership */ 381 382 /* Constructor. */ 383 #if defined(astCLASS) /* Protected. */ 384 AstAxis *astAxis_( const char *, int *, ...); 385 #else 386 AstAxis *astAxisId_( const char *, ... )__attribute__((format(printf,1,2))); 387 #endif 388 389 #if defined(astCLASS) /* Protected */ 390 391 /* Initialiser. */ 392 AstAxis *astInitAxis_( void *, size_t, int, AstAxisVtab *, const char *, int * ); 393 394 /* Vtab initialiser. */ 395 void astInitAxisVtab_( AstAxisVtab *, const char *, int * ); 396 397 /* Loader. */ 398 AstAxis *astLoadAxis_( void *, size_t, AstAxisVtab *, const char *, 399 AstChannel *, int * ); 400 401 /* Thread-safe initialiser for all global data used by this module. */ 402 #if defined(THREAD_SAFE) 403 void astInitAxisGlobals_( AstAxisGlobals * ); 404 #endif 405 406 #endif 407 408 /* Prototypes for member functions. */ 409 /* -------------------------------- */ 410 const char *astAxisFormat_( AstAxis *, double, int * ); 411 int astAxisUnformat_( AstAxis *, const char *, double *, int * ); 412 void astAxisNorm_( AstAxis *, double *, int * ); 413 414 #if defined(astCLASS) /* Protected */ 415 const char *astAxisAbbrev_( AstAxis *, const char *, const char *, const char *, int * ); 416 const char *astGetAxisFormat_( AstAxis *, int * ); 417 const char *astGetAxisLabel_( AstAxis *, int * ); 418 const char *astGetAxisSymbol_( AstAxis *, int * ); 419 const char *astGetAxisUnit_( AstAxis *, int * ); 420 const char *astGetAxisNormUnit_( AstAxis *, int * ); 421 double astAxisGap_( AstAxis *, double, int *, int * ); 422 double astAxisDistance_( AstAxis *, double, double, int * ); 423 double astAxisOffset_( AstAxis *, double, double, int * ); 424 int astGetAxisDigits_( AstAxis *, int * ); 425 int astGetAxisDirection_( AstAxis *, int * ); 426 int astTestAxisDigits_( AstAxis *, int * ); 427 int astTestAxisDirection_( AstAxis *, int * ); 428 int astAxisFields_( AstAxis *, const char *, const char *, int, char **, int *, double *, int * ); 429 int astAxisIn_( AstAxis *, double, double, double, int, int * ); 430 int astTestAxisFormat_( AstAxis *, int * ); 431 int astTestAxisLabel_( AstAxis *, int * ); 432 int astTestAxisSymbol_( AstAxis *, int * ); 433 int astTestAxisUnit_( AstAxis *, int * ); 434 int astTestAxisNormUnit_( AstAxis *, int * ); 435 void astAxisOverlay_( AstAxis *, AstAxis *, int * ); 436 void astClearAxisDigits_( AstAxis *, int * ); 437 void astClearAxisDirection_( AstAxis *, int * ); 438 void astClearAxisFormat_( AstAxis *, int * ); 439 void astClearAxisLabel_( AstAxis *, int * ); 440 void astClearAxisSymbol_( AstAxis *, int * ); 441 void astClearAxisUnit_( AstAxis *, int * ); 442 void astSetAxisDigits_( AstAxis *, int, int * ); 443 void astSetAxisDirection_( AstAxis *, int, int * ); 444 void astSetAxisFormat_( AstAxis *, const char *, int * ); 445 void astSetAxisLabel_( AstAxis *, const char *, int * ); 446 void astSetAxisSymbol_( AstAxis *, const char *, int * ); 447 void astSetAxisUnit_( AstAxis *, const char *, int * ); 448 449 double astGetAxisTop_( AstAxis *, int * ); 450 int astTestAxisTop_( AstAxis *, int * ); 451 void astClearAxisTop_( AstAxis *, int * ); 452 void astSetAxisTop_( AstAxis *, double, int * ); 453 454 double astGetAxisBottom_( AstAxis *, int * ); 455 int astTestAxisBottom_( AstAxis *, int * ); 456 void astClearAxisBottom_( AstAxis *, int * ); 457 void astSetAxisBottom_( AstAxis *, double, int * ); 458 459 #endif 460 461 /* Function interfaces. */ 462 /* ==================== */ 463 /* These macros are wrap-ups for the functions defined by this class 464 to make them easier to invoke (e.g. to avoid type mis-matches when 465 passing pointers to objects from derived classes). */ 466 467 /* Interfaces to standard class functions. */ 468 /* --------------------------------------- */ 469 /* Some of these functions provide validation, so we cannot use them 470 to validate their own arguments. We must use a cast when passing 471 object pointers (so that they can accept objects from derived 472 classes). */ 473 474 /* Check class membership. */ 475 #define astCheckAxis(this) astINVOKE_CHECK(Axis,this,0) 476 #define astVerifyAxis(this) astINVOKE_CHECK(Axis,this,1) 477 478 /* Test class membership. */ 479 #define astIsAAxis(this) astINVOKE_ISA(Axis,this) 480 481 /* Constructor. */ 482 #if defined(astCLASS) /* Protected. */ 483 #define astAxis astINVOKE(F,astAxis_) 484 #else 485 #define astAxis astINVOKE(F,astAxisId_) 486 #endif 487 488 #if defined(astCLASS) /* Protected. */ 489 490 /* Initialiser. */ 491 #define astInitAxis(mem,size,init,vtab,name) \ 492 astINVOKE(O,astInitAxis_(mem,size,init,vtab,name,STATUS_PTR)) 493 494 /* Vtab Initialiser. */ 495 #define astInitAxisVtab(vtab,name) astINVOKE(V,astInitAxisVtab_(vtab,name,STATUS_PTR)) 496 /* Loader. */ 497 #define astLoadAxis(mem,size,vtab,name,channel) \ 498 astINVOKE(O,astLoadAxis_(mem,size,vtab,name,astCheckChannel(channel),STATUS_PTR)) 499 #endif 500 501 /* Interfaces to public member functions. */ 502 /* -------------------------------------- */ 503 /* Here we make use of astCheckAxis to validate Axis pointers before 504 use. This provides a contextual error report if a pointer to the 505 wrong sort of object is supplied. */ 506 #define astAxisFormat(this,value) \ 507 astINVOKE(V,astAxisFormat_(astCheckAxis(this),value,STATUS_PTR)) 508 #define astAxisNorm(this,value) \ 509 astINVOKE(V,astAxisNorm_(astCheckAxis(this),value,STATUS_PTR)) 510 #define astAxisUnformat(this,string,value) \ 511 astINVOKE(V,astAxisUnformat_(astCheckAxis(this),string,value,STATUS_PTR)) 512 513 #if defined(astCLASS) /* Protected */ 514 #define astAxisAbbrev(this,fmt,str1,str2) \ 515 astINVOKE(V,astAxisAbbrev_(astCheckAxis(this),fmt,str1,str2,STATUS_PTR)) 516 #define astAxisGap(this,gap,ntick) \ 517 astINVOKE(V,astAxisGap_(astCheckAxis(this),gap,ntick,STATUS_PTR)) 518 #define astAxisFields(this,fmt,str,maxfld,fields,nc,val) \ 519 astINVOKE(V,astAxisFields_(astCheckAxis(this),fmt,str,maxfld,fields,nc,val,STATUS_PTR)) 520 #define astAxisIn(this,lo,hi,val,closed) \ 521 astINVOKE(V,astAxisIn_(astCheckAxis(this),lo,hi,val,closed,STATUS_PTR)) 522 #define astAxisDistance(this,v1,v2) \ 523 astINVOKE(V,astAxisDistance_(astCheckAxis(this),v1,v2,STATUS_PTR)) 524 #define astAxisOffset(this,v1,dist) \ 525 astINVOKE(V,astAxisOffset_(astCheckAxis(this),v1,dist,STATUS_PTR)) 526 #define astAxisOverlay(template,result) \ 527 astINVOKE(V,astAxisOverlay_(astCheckAxis(template),astCheckAxis(result),STATUS_PTR)) 528 #define astClearAxisDigits(this) \ 529 astINVOKE(V,astClearAxisDigits_(astCheckAxis(this),STATUS_PTR)) 530 #define astClearAxisDirection(this) \ 531 astINVOKE(V,astClearAxisDirection_(astCheckAxis(this),STATUS_PTR)) 532 #define astClearAxisFormat(this) \ 533 astINVOKE(V,astClearAxisFormat_(astCheckAxis(this),STATUS_PTR)) 534 #define astClearAxisLabel(this) \ 535 astINVOKE(V,astClearAxisLabel_(astCheckAxis(this),STATUS_PTR)) 536 #define astClearAxisSymbol(this) \ 537 astINVOKE(V,astClearAxisSymbol_(astCheckAxis(this),STATUS_PTR)) 538 #define astClearAxisUnit(this) \ 539 astINVOKE(V,astClearAxisUnit_(astCheckAxis(this),STATUS_PTR)) 540 #define astGetAxisDigits(this) \ 541 astINVOKE(V,astGetAxisDigits_(astCheckAxis(this),STATUS_PTR)) 542 #define astGetAxisDirection(this) \ 543 astINVOKE(V,astGetAxisDirection_(astCheckAxis(this),STATUS_PTR)) 544 #define astGetAxisFormat(this) \ 545 astINVOKE(V,astGetAxisFormat_(astCheckAxis(this),STATUS_PTR)) 546 #define astGetAxisLabel(this) \ 547 astINVOKE(V,astGetAxisLabel_(astCheckAxis(this),STATUS_PTR)) 548 #define astGetAxisSymbol(this) \ 549 astINVOKE(V,astGetAxisSymbol_(astCheckAxis(this),STATUS_PTR)) 550 #define astGetAxisUnit(this) \ 551 astINVOKE(V,astGetAxisUnit_(astCheckAxis(this),STATUS_PTR)) 552 #define astGetAxisNormUnit(this) \ 553 astINVOKE(V,astGetAxisNormUnit_(astCheckAxis(this),STATUS_PTR)) 554 #define astSetAxisDigits(this,digits) \ 555 astINVOKE(V,astSetAxisDigits_(astCheckAxis(this),digits,STATUS_PTR)) 556 #define astSetAxisDirection(this,direction) \ 557 astINVOKE(V,astSetAxisDirection_(astCheckAxis(this),direction,STATUS_PTR)) 558 #define astSetAxisFormat(this,format) \ 559 astINVOKE(V,astSetAxisFormat_(astCheckAxis(this),format,STATUS_PTR)) 560 #define astSetAxisLabel(this,label) \ 561 astINVOKE(V,astSetAxisLabel_(astCheckAxis(this),label,STATUS_PTR)) 562 #define astSetAxisSymbol(this,symbol) \ 563 astINVOKE(V,astSetAxisSymbol_(astCheckAxis(this),symbol,STATUS_PTR)) 564 #define astSetAxisUnit(this,unit) \ 565 astINVOKE(V,astSetAxisUnit_(astCheckAxis(this),unit,STATUS_PTR)) 566 #define astTestAxisDigits(this) \ 567 astINVOKE(V,astTestAxisDigits_(astCheckAxis(this),STATUS_PTR)) 568 #define astTestAxisDirection(this) \ 569 astINVOKE(V,astTestAxisDirection_(astCheckAxis(this),STATUS_PTR)) 570 #define astTestAxisFormat(this) \ 571 astINVOKE(V,astTestAxisFormat_(astCheckAxis(this),STATUS_PTR)) 572 #define astTestAxisLabel(this) \ 573 astINVOKE(V,astTestAxisLabel_(astCheckAxis(this),STATUS_PTR)) 574 #define astTestAxisSymbol(this) \ 575 astINVOKE(V,astTestAxisSymbol_(astCheckAxis(this),STATUS_PTR)) 576 #define astTestAxisUnit(this) \ 577 astINVOKE(V,astTestAxisUnit_(astCheckAxis(this),STATUS_PTR)) 578 #define astTestAxisNormUnit(this) \ 579 astINVOKE(V,astTestAxisNormUnit_(astCheckAxis(this),STATUS_PTR)) 580 581 #define astClearAxisTop(this) \ 582 astINVOKE(V,astClearAxisTop_(astCheckAxis(this),STATUS_PTR)) 583 #define astGetAxisTop(this) \ 584 astINVOKE(V,astGetAxisTop_(astCheckAxis(this),STATUS_PTR)) 585 #define astSetAxisTop(this,top) \ 586 astINVOKE(V,astSetAxisTop_(astCheckAxis(this),top,STATUS_PTR)) 587 #define astTestAxisTop(this) \ 588 astINVOKE(V,astTestAxisTop_(astCheckAxis(this),STATUS_PTR)) 589 590 #define astClearAxisBottom(this) \ 591 astINVOKE(V,astClearAxisBottom_(astCheckAxis(this),STATUS_PTR)) 592 #define astGetAxisBottom(this) \ 593 astINVOKE(V,astGetAxisBottom_(astCheckAxis(this),STATUS_PTR)) 594 #define astSetAxisBottom(this,bottom) \ 595 astINVOKE(V,astSetAxisBottom_(astCheckAxis(this),bottom,STATUS_PTR)) 596 #define astTestAxisBottom(this) \ 597 astINVOKE(V,astTestAxisBottom_(astCheckAxis(this),STATUS_PTR)) 598 599 #endif 600 #endif 601 602 603 604 605 606