Main Page   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members

fxdefs.h

00001 /********************************************************************************
00002 *                                                                               *
00003 *                     FOX Definitions, Types, and Macros                        *
00004 *                                                                               *
00005 *********************************************************************************
00006 * Copyright (C) 1997,2004 by Jeroen van der Zijp.   All Rights Reserved.        *
00007 *********************************************************************************
00008 * This library is free software; you can redistribute it and/or                 *
00009 * modify it under the terms of the GNU Lesser General Public                    *
00010 * License as published by the Free Software Foundation; either                  *
00011 * version 2.1 of the License, or (at your option) any later version.            *
00012 *                                                                               *
00013 * This library is distributed in the hope that it will be useful,               *
00014 * but WITHOUT ANY WARRANTY; without even the implied warranty of                *
00015 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
00016 * Lesser General Public License for more details.                               *
00017 *                                                                               *
00018 * You should have received a copy of the GNU Lesser General Public              *
00019 * License along with this library; if not, write to the Free Software           *
00020 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
00021 *********************************************************************************
00022 * $Id: fxdefs.h,v 1.130 2004/02/08 17:17:34 fox Exp $                           *
00023 ********************************************************************************/
00024 #ifndef FXDEFS_H
00025 #define FXDEFS_H
00026 
00027 
00028 /********************************  Definitions  ********************************/
00029 
00030 // Truth values
00031 #ifndef TRUE
00032 #define TRUE 1
00033 #endif
00034 #ifndef FALSE
00035 #define FALSE 0
00036 #endif
00037 #ifndef MAYBE
00038 #define MAYBE 2
00039 #endif
00040 #ifndef NULL
00041 #define NULL 0
00042 #endif
00043 
00044 /// Pi
00045 #ifndef PI
00046 #define PI      3.1415926535897932384626433833
00047 #endif
00048 
00049 /// Euler constant
00050 #define EULER   2.7182818284590452353602874713
00051 
00052 /// Multiplier for degrees to radians
00053 #define DTOR    0.0174532925199432957692369077
00054 
00055 /// Multiplier for radians to degrees
00056 #define RTOD    57.295779513082320876798154814
00057 
00058 
00059 // Path separator
00060 #ifdef WIN32
00061 #define PATHSEP '\\'
00062 #define PATHSEPSTRING "\\"
00063 #define PATHLISTSEP ';'
00064 #define PATHLISTSEPSTRING ";"
00065 #define ISPATHSEP(c) ((c)=='/' || (c)=='\\')
00066 #else
00067 #define PATHSEP '/'
00068 #define PATHSEPSTRING "/"
00069 #define PATHLISTSEP ':'
00070 #define PATHLISTSEPSTRING ":"
00071 #define ISPATHSEP(c) ((c)=='/')
00072 #endif
00073 
00074 
00075 // End Of Line
00076 #ifdef WIN32
00077 #define EOLSTRING "\r\n"
00078 #else
00079 #define EOLSTRING "\n"
00080 #endif
00081 
00082 
00083 // For Windows
00084 #ifdef _DEBUG
00085 #ifndef DEBUG
00086 #define DEBUG
00087 #endif
00088 #endif
00089 #ifdef _NDEBUG
00090 #ifndef NDEBUG
00091 #define NDEBUG
00092 #endif
00093 #endif
00094 
00095 
00096 // Shared library support
00097 #ifdef WIN32
00098 #define FXEXPORT __declspec(dllexport)
00099 #define FXIMPORT __declspec(dllimport)
00100 #else
00101 #define FXEXPORT
00102 #define FXIMPORT
00103 #endif
00104 
00105 // Define FXAPI for DLL builds
00106 #ifdef FOXDLL
00107 #ifdef FOXDLL_EXPORTS
00108 #define FXAPI FXEXPORT
00109 #else
00110 #define FXAPI FXIMPORT
00111 #endif
00112 #else
00113 #define FXAPI
00114 #endif
00115 
00116 // Callback
00117 #ifdef WIN32
00118 #ifndef CALLBACK
00119 #define CALLBACK __stdcall
00120 #endif
00121 #endif
00122 
00123 
00124 // Checking printf and scanf format strings
00125 #if defined(_CC_GNU_) || defined(__GNUG__) || defined(__GNUC__)
00126 #define FX_PRINTF(fmt,arg) __attribute__((format(printf,fmt,arg)))
00127 #define FX_SCANF(fmt,arg)  __attribute__((format(scanf,fmt,arg)))
00128 #else
00129 #define FX_PRINTF(fmt,arg)
00130 #define FX_SCANF(fmt,arg)
00131 #endif
00132 
00133 // Raw event type
00134 #ifndef WIN32
00135 union _XEvent;
00136 #else
00137 struct tagMSG;
00138 #endif
00139 
00140 
00141 namespace FX {
00142 
00143 
00144 // FOX System Defined Selector Types
00145 enum FXSelType {
00146   SEL_NONE,
00147   SEL_KEYPRESS,                         /// Key pressed
00148   SEL_KEYRELEASE,                       /// Key released
00149   SEL_LEFTBUTTONPRESS,                  /// Left mouse button pressed
00150   SEL_LEFTBUTTONRELEASE,                /// Left mouse button released
00151   SEL_MIDDLEBUTTONPRESS,                /// Middle mouse button pressed
00152   SEL_MIDDLEBUTTONRELEASE,              /// Middle mouse button released
00153   SEL_RIGHTBUTTONPRESS,                 /// Right mouse button pressed
00154   SEL_RIGHTBUTTONRELEASE,               /// Right mouse button released
00155   SEL_MOTION,                           /// Mouse motion
00156   SEL_ENTER,                            /// Mouse entered window
00157   SEL_LEAVE,                            /// Mouse left window
00158   SEL_FOCUSIN,                          /// Focus into window
00159   SEL_FOCUSOUT,                         /// Focus out of window
00160   SEL_KEYMAP,
00161   SEL_UNGRABBED,                        /// Lost the grab (Windows)
00162   SEL_PAINT,                            /// Must repaint window
00163   SEL_CREATE,
00164   SEL_DESTROY,
00165   SEL_UNMAP,
00166   SEL_MAP,
00167   SEL_CONFIGURE,                      // Resize
00168   SEL_SELECTION_LOST,                 // Widget lost selection
00169   SEL_SELECTION_GAINED,               // Widget gained selection
00170   SEL_SELECTION_REQUEST,              // Inquire selection data
00171   SEL_RAISED,                         // Window to top of stack
00172   SEL_LOWERED,                        // Window to bottom of stack
00173   SEL_CLOSE,                          // Close window
00174   SEL_DELETE,                         // Delete window
00175   SEL_MINIMIZE,                       // Iconified
00176   SEL_RESTORE,                        // No longer iconified or maximized
00177   SEL_MAXIMIZE,                       // Maximized
00178   SEL_UPDATE,                         // GUI update
00179   SEL_COMMAND,                        // GUI command
00180   SEL_CLICKED,                        // Clicked
00181   SEL_DOUBLECLICKED,                  // Double-clicked
00182   SEL_TRIPLECLICKED,                  // Triple-clicked
00183   SEL_MOUSEWHEEL,                     // Mouse wheel
00184   SEL_CHANGED,                        // GUI has changed
00185   SEL_VERIFY,                         // Verify change
00186   SEL_DESELECTED,                     // Deselected
00187   SEL_SELECTED,                       // Selected
00188   SEL_INSERTED,                       // Inserted
00189   SEL_REPLACED,                       // Replaced
00190   SEL_DELETED,                        // Deleted
00191   SEL_OPENED,                         // Opened
00192   SEL_CLOSED,                         // Closed
00193   SEL_EXPANDED,                       // Expanded
00194   SEL_COLLAPSED,                      // Collapsed
00195   SEL_BEGINDRAG,                      // Start a drag
00196   SEL_ENDDRAG,                        // End a drag
00197   SEL_DRAGGED,                        // Dragged
00198   SEL_LASSOED,                        // Lassoed
00199   SEL_TIMEOUT,                        // Timeout occurred
00200   SEL_SIGNAL,                         // Signal received
00201   SEL_CLIPBOARD_LOST,                 // Widget lost clipboard
00202   SEL_CLIPBOARD_GAINED,               // Widget gained clipboard
00203   SEL_CLIPBOARD_REQUEST,              // Inquire clipboard data
00204   SEL_CHORE,                          // Background chore
00205   SEL_FOCUS_SELF,                     // Focus on widget itself
00206   SEL_FOCUS_RIGHT,                    // Focus movements
00207   SEL_FOCUS_LEFT,
00208   SEL_FOCUS_DOWN,
00209   SEL_FOCUS_UP,
00210   SEL_FOCUS_NEXT,
00211   SEL_FOCUS_PREV,
00212   SEL_DND_ENTER,                      // Drag action entering potential drop target
00213   SEL_DND_LEAVE,                      // Drag action leaving potential drop target
00214   SEL_DND_DROP,                       // Drop on drop target
00215   SEL_DND_MOTION,                     // Drag position changed over potential drop target
00216   SEL_DND_REQUEST,                    // Inquire drag and drop data
00217   SEL_IO_READ,                        // Read activity on a pipe
00218   SEL_IO_WRITE,                       // Write activity on a pipe
00219   SEL_IO_EXCEPT,                      // Except activity on a pipe
00220   SEL_PICKED,                         // Picked some location
00221   SEL_LAST                            // Last message
00222   };
00223 
00224 
00225 /// FOX Keyboard and Button states
00226 enum {
00227   SHIFTMASK        = 0x001,           /// Shift key is down
00228   CAPSLOCKMASK     = 0x002,           /// Caps Lock key is down
00229   CONTROLMASK      = 0x004,           /// Ctrl key is down
00230   ALTMASK          = 0x008,           /// Alt key is down
00231   METAMASK         = 0x040,           /// Meta key is down
00232   NUMLOCKMASK      = 0x010,           /// Num Lock key is down
00233   SCROLLLOCKMASK   = 0x0E0,           /// Scroll Lock key is down (seems to vary)
00234   LEFTBUTTONMASK   = 0x100,           /// Left mouse button is down
00235   MIDDLEBUTTONMASK = 0x200,           /// Middle mouse button is down
00236   RIGHTBUTTONMASK  = 0x400            /// Right mouse button is down
00237   };
00238 
00239 
00240 /// FOX Mouse buttons
00241 enum {
00242   LEFTBUTTON       = 1,
00243   MIDDLEBUTTON     = 2,
00244   RIGHTBUTTON      = 3
00245   };
00246 
00247 
00248 /// FOX window crossing modes
00249 enum {
00250   CROSSINGNORMAL,        /// Normal crossing event
00251   CROSSINGGRAB,          /// Crossing due to mouse grab
00252   CROSSINGUNGRAB         /// Crossing due to mouse ungrab
00253   };
00254 
00255 
00256 /// FOX window visibility modes
00257 enum {
00258   VISIBILITYTOTAL,
00259   VISIBILITYPARTIAL,
00260   VISIBILITYNONE
00261   };
00262 
00263 
00264 /// Options for fxfilematch
00265 enum {
00266   FILEMATCH_FILE_NAME   = 1,        /// No wildcard can ever match `/'
00267   FILEMATCH_NOESCAPE    = 2,        /// Backslashes don't quote special chars
00268   FILEMATCH_PERIOD      = 4,        /// Leading `.' is matched only explicitly
00269   FILEMATCH_LEADING_DIR = 8,        /// Ignore `/...' after a match
00270   FILEMATCH_CASEFOLD    = 16        /// Compare without regard to case
00271   };
00272 
00273 
00274 /// Drag and drop actions
00275 enum FXDragAction {
00276   DRAG_REJECT  = 0,                 /// Reject all drop actions
00277   DRAG_ACCEPT  = 1,                 /// Accept any drop action
00278   DRAG_COPY    = 2,                 /// Copy
00279   DRAG_MOVE    = 3,                 /// Move
00280   DRAG_LINK    = 4,                 /// Link
00281   DRAG_PRIVATE = 5                  /// Private
00282   };
00283 
00284 
00285 /// Origin of data
00286 enum FXDNDOrigin {
00287   FROM_SELECTION  = 0,              /// Primary selection
00288   FROM_CLIPBOARD  = 1,              /// Clipboard
00289   FROM_DRAGNDROP  = 2               /// Drag and drop source
00290   };
00291 
00292 
00293 /// Exponent display
00294 enum FXExponent {
00295   EXP_NEVER=FALSE,                  /// Never use exponential notation
00296   EXP_ALWAYS=TRUE,                  /// Always use exponential notation
00297   EXP_AUTO=MAYBE                    /// Use exponential notation if needed
00298   };
00299 
00300 
00301 /// Search modes for search/replace dialogs
00302 enum {
00303   SEARCH_FORWARD      = 0,    /// Search forward (default)
00304   SEARCH_BACKWARD     = 1,    /// Search backward
00305   SEARCH_NOWRAP       = 0,    /// Don't wrap (default)
00306   SEARCH_WRAP         = 2,    /// Wrap around to start
00307   SEARCH_EXACT        = 0,    /// Exact match (default)
00308   SEARCH_IGNORECASE   = 4,    /// Ignore case
00309   SEARCH_REGEX        = 8,    /// Regular expression match
00310   SEARCH_PREFIX       = 16    /// Prefix of subject string
00311   };
00312 
00313 
00314 /*********************************  Typedefs  **********************************/
00315 
00316 // Forward declarations
00317 class                          FXObject;
00318 class                          FXStream;
00319 class                          FXString;
00320 
00321 
00322 // Streamable types; these are fixed size!
00323 typedef char                   FXchar;
00324 typedef unsigned char          FXuchar;
00325 typedef FXuchar                FXbool;
00326 typedef unsigned short         FXushort;
00327 typedef short                  FXshort;
00328 typedef unsigned int           FXuint;
00329 typedef unsigned int           FXwchar;
00330 typedef int                    FXint;
00331 typedef float                  FXfloat;
00332 typedef double                 FXdouble;
00333 typedef FXObject              *FXObjectPtr;
00334 #if defined(_MSC_VER) || (defined(__BCPLUSPLUS__) && __BORLANDC__ > 0x500) || defined(__WATCOM_INT64__)
00335 #define FX_LONG
00336 typedef unsigned __int64       FXulong;
00337 typedef __int64                FXlong;
00338 #elif defined(__GNUG__) || defined(__GNUC__) || defined(__SUNPRO_CC) || defined(__MWERKS__) || defined(__SC__)
00339 #define FX_LONG
00340 typedef unsigned long long int FXulong;
00341 typedef long long int          FXlong;
00342 #endif
00343 
00344 // Integral types large enough to hold value of a pointer
00345 #if defined(_MSC_VER) && defined(_WIN64)
00346 typedef __int64                FXival;
00347 typedef unsigned __int64       FXuval;
00348 #else
00349 typedef long                   FXival;
00350 typedef unsigned long          FXuval;
00351 #endif
00352 
00353 
00354 // Handle to something in server
00355 #ifndef WIN32
00356 typedef unsigned long          FXID;
00357 #else
00358 typedef void*                  FXID;
00359 #endif
00360 
00361 // Time since January 1, 1970 (UTC)
00362 typedef long                   FXTime;
00363 
00364 // Pixel type (could be color index)
00365 typedef unsigned long          FXPixel;
00366 
00367 // RGBA pixel value
00368 typedef FXuint                 FXColor;
00369 
00370 // Hot key
00371 typedef FXuint                 FXHotKey;
00372 
00373 // Drag type
00374 #ifndef WIN32
00375 typedef FXID                   FXDragType;
00376 #else
00377 typedef FXushort               FXDragType;
00378 #endif
00379 
00380 // Input source handle type
00381 #ifndef WIN32
00382 typedef FXint                  FXInputHandle;
00383 #else
00384 typedef void*                  FXInputHandle;
00385 #endif
00386 
00387 // Raw event type
00388 #ifndef WIN32
00389 typedef _XEvent                FXRawEvent;
00390 #else
00391 typedef tagMSG                 FXRawEvent;
00392 #endif
00393 
00394 
00395 /**********************************  Macros  ***********************************/
00396 
00397 
00398 /// Abolute value
00399 #define FXABS(val) (((val)>=0)?(val):-(val))
00400 
00401 /// Return the maximum of a or b
00402 #define FXMAX(a,b) (((a)>(b))?(a):(b))
00403 
00404 /// Return the minimum of a or b
00405 #define FXMIN(a,b) (((a)>(b))?(b):(a))
00406 
00407 /// Return the minimum of x, y and z
00408 #define FXMIN3(x,y,z) ((x)<(y)?FXMIN(x,z):FXMIN(y,z))
00409 
00410 /// Return the maximum of x, y and z
00411 #define FXMAX3(x,y,z) ((x)>(y)?FXMAX(x,z):FXMAX(y,z))
00412 
00413 /// Return minimum and maximum of a, b
00414 #define FXMINMAX(lo,hi,a,b) ((a)<(b)?((lo)=(a),(hi)=(b)):((lo)=(b),(hi)=(a)))
00415 
00416 /// Clamp value x to range [lo..hi]
00417 #define FXCLAMP(lo,x,hi) ((x)<(lo)?(lo):((x)>(hi)?(hi):(x)))
00418 
00419 /// Swap a pair of numbers
00420 #define FXSWAP(a,b,t) ((t)=(a),(a)=(b),(b)=(t))
00421 
00422 /// Linear interpolation between a and b, where 0<=f<=1
00423 #define FXLERP(a,b,f) ((a)+((b)-(a))*(f))
00424 
00425 /// Offset of member in a structure
00426 #define STRUCTOFFSET(str,member) (((char *)(&(((str *)0)->member)))-((char *)0))
00427 
00428 /// Number of elements in a static array
00429 #define ARRAYNUMBER(array) (sizeof(array)/sizeof(array[0]))
00430 
00431 /// Container class of a member class
00432 #define CONTAINER(ptr,str,mem) ((str*)(((char*)(ptr))-STRUCTOFFSET(str,mem)))
00433 
00434 /// Make int out of two shorts
00435 #define MKUINT(l,h) ((((FX::FXuint)(l))&0xffff) | (((FX::FXuint)(h))<<16))
00436 
00437 /// Make selector from message type and message id
00438 #define FXSEL(type,id) ((((FX::FXuint)(id))&0xffff) | (((FX::FXuint)(type))<<16))
00439 
00440 /// Get type from selector
00441 #define FXSELTYPE(s) ((FX::FXushort)(((s)>>16)&0xffff))
00442 
00443 /// Get ID from selector
00444 #define FXSELID(s) ((FX::FXushort)((s)&0xffff))
00445 
00446 /// Reverse bits in byte
00447 #define FXBITREVERSE(b) (((b&0x01)<<7)|((b&0x02)<<5)|((b&0x04)<<3)|((b&0x08)<<1)|((b&0x10)>>1)|((b&0x20)>>3)|((b&0x40)>>5)|((b&0x80)>>7))
00448 
00449 // The order in memory is [R G B A] matches that in FXColor
00450 
00451 // Definitions for big-endian machines
00452 #if FOX_BIGENDIAN == 1
00453 
00454 /// Make RGBA color
00455 #define FXRGBA(r,g,b,a)    (((FX::FXuint)(FX::FXuchar)(r)<<24) | ((FX::FXuint)(FX::FXuchar)(g)<<16) | ((FX::FXuint)(FX::FXuchar)(b)<<8) | ((FX::FXuint)(FX::FXuchar)(a)))
00456 
00457 /// Make RGB color
00458 #define FXRGB(r,g,b)       (((FX::FXuint)(FX::FXuchar)(r)<<24) | ((FX::FXuint)(FX::FXuchar)(g)<<16) | ((FX::FXuint)(FX::FXuchar)(b)<<8) | 0x000000ff)
00459 
00460 /// Get red value from RGBA color
00461 #define FXREDVAL(rgba)     ((FX::FXuchar)(((rgba)>>24)&0xff))
00462 
00463 /// Get green value from RGBA color
00464 #define FXGREENVAL(rgba)   ((FX::FXuchar)(((rgba)>>16)&0xff))
00465 
00466 /// Get blue value from RGBA color
00467 #define FXBLUEVAL(rgba)    ((FX::FXuchar)(((rgba)>>8)&0xff))
00468 
00469 /// Get alpha value from RGBA color
00470 #define FXALPHAVAL(rgba)   ((FX::FXuchar)((rgba)&0xff))
00471 
00472 /// Get component value of RGBA color
00473 #define FXRGBACOMPVAL(rgba,comp) ((FX::FXuchar)(((rgba)>>((3-(comp))<<3))&0xff))
00474 
00475 #endif
00476 
00477 // Definitions for little-endian machines
00478 #if FOX_BIGENDIAN == 0
00479 
00480 /// Make RGBA color
00481 #define FXRGBA(r,g,b,a)    (((FX::FXuint)(FX::FXuchar)(r)) | ((FX::FXuint)(FX::FXuchar)(g)<<8) | ((FX::FXuint)(FX::FXuchar)(b)<<16) | ((FX::FXuint)(FX::FXuchar)(a)<<24))
00482 
00483 /// Make RGB color
00484 #define FXRGB(r,g,b)       (((FX::FXuint)(FX::FXuchar)(r)) | ((FX::FXuint)(FX::FXuchar)(g)<<8) | ((FX::FXuint)(FX::FXuchar)(b)<<16) | 0xff000000)
00485 
00486 /// Get red value from RGBA color
00487 #define FXREDVAL(rgba)     ((FX::FXuchar)((rgba)&0xff))
00488 
00489 /// Get green value from RGBA color
00490 #define FXGREENVAL(rgba)   ((FX::FXuchar)(((rgba)>>8)&0xff))
00491 
00492 /// Get blue value from RGBA color
00493 #define FXBLUEVAL(rgba)    ((FX::FXuchar)(((rgba)>>16)&0xff))
00494 
00495 /// Get alpha value from RGBA color
00496 #define FXALPHAVAL(rgba)   ((FX::FXuchar)(((rgba)>>24)&0xff))
00497 
00498 /// Get component value of RGBA color
00499 #define FXRGBACOMPVAL(rgba,comp) ((FX::FXuchar)(((rgba)>>((comp)<<3))&0xff))
00500 
00501 #endif
00502 
00503 
00504 /**
00505 * FXASSERT() prints out a message when the expression fails,
00506 * and nothing otherwise.  Unlike assert(), FXASSERT() will not
00507 * terminate the execution of the application.
00508 * When compiling your application for release, all assertions
00509 * are compiled out; thus there is no impact on execution speed.
00510 */
00511 #ifndef NDEBUG
00512 #define FXASSERT(exp) ((exp)?((void)0):(void)FX::fxassert(#exp,__FILE__,__LINE__))
00513 #else
00514 #define FXASSERT(exp) ((void)0)
00515 #endif
00516 
00517 
00518 /**
00519 * FXTRACE() allows you to trace the execution of your application
00520 * with increasing levels of detail the higher the trace level.
00521 * The trace level is determined by variable fxTraceLevel, which
00522 * may be set from the command line with "-tracelevel <level>".
00523 * When compiling your application for release, all trace statements
00524 * are compiled out, just like FXASSERT.
00525 * A statement like: FXTRACE((10,"The value of x=%d\n",x)) will
00526 * generate output only if fxTraceLevel is set to 11 or greater.
00527 * The default value fxTraceLevel=0 will block all trace outputs.
00528 * Note the double parentheses!
00529 */
00530 #ifndef NDEBUG
00531 #define FXTRACE(arguments) FX::fxtrace arguments
00532 #else
00533 #define FXTRACE(arguments) ((void)0)
00534 #endif
00535 
00536 
00537 /**
00538 * Allocate no elements of type to the specified pointer.
00539 * Return FALSE if size!=0 and allocation fails, TRUE otherwise.
00540 * An allocation of a zero size block returns a NULL pointer.
00541 */
00542 #define FXMALLOC(ptr,type,no)     (FX::fxmalloc((void **)(ptr),sizeof(type)*(no)))
00543 
00544 /**
00545 * Allocate no elements of type to the specified pointer, and clear this memory to zero.
00546 * Return FALSE if size!=0 and allocation fails, TRUE otherwise.
00547 * An allocation of a zero size block returns a NULL pointer.
00548 */
00549 #define FXCALLOC(ptr,type,no)     (FX::fxcalloc((void **)(ptr),sizeof(type)*(no)))
00550 
00551 /**
00552 * Resize a previously allocated block of memory.
00553 * Returns FALSE if size!=0 and reallocation fails, TRUE otherwise.
00554 * If reallocation fails, pointer is left to point to old block; a reallocation
00555 * to a zero size block has the effect of freeing it.
00556 */
00557 #define FXRESIZE(ptr,type,no)     (FX::fxresize((void **)(ptr),sizeof(type)*(no)))
00558 
00559 /**
00560 * Allocate and initialize memory from another block.
00561 * Return FALSE if size!=0 and source!=NULL and allocation fails, TRUE otherwise.
00562 * An allocation of a zero size block returns a NULL pointer.
00563 */
00564 #define FXMEMDUP(ptr,src,type,no) (FX::fxmemdup((void **)(ptr),(const void*)(src),sizeof(type)*(no)))
00565 
00566 /**
00567 * Free a block of memory allocated with either FXMALLOC, FXCALLOC, FXRESIZE, or FXMEMDUP.
00568 * It is OK to call free a NULL pointer.
00569 */
00570 #define FXFREE(ptr)               (FX::fxfree((void **)(ptr)))
00571 
00572 
00573 /**
00574 * These are some of the ISO C99 standard single-precision transcendental functions.
00575 * On LINUX, specify _GNU_SOURCE or _ISOC99_SOURCE to enable native implementation;
00576 * otherwise, these macros will be used.
00577 */
00578 #ifndef __USE_ISOC99
00579 #define sqrtf(x)    ((float)sqrt((double)(x)))
00580 #define fabsf(x)    ((float)fabs((double)(x)))
00581 #define ceilf(x)    ((float)ceil((double)(x)))
00582 #define floorf(x)   ((float)floor((double)(x)))
00583 #define sinf(x)     ((float)sin((double)(x)))
00584 #define cosf(x)     ((float)cos((double)(x)))
00585 #define tanf(x)     ((float)tan((double)(x)))
00586 #define asinf(x)    ((float)asin((double)(x)))
00587 #define acosf(x)    ((float)acos((double)(x)))
00588 #define atanf(x)    ((float)atan((double)(x)))
00589 #define atan2f(y,x) ((float)atan2((double)(y),(double)(x)))
00590 #define powf(x,y)   ((float)pow((double)(x),(double)(y)))
00591 #define expf(x)     ((float)exp((double)(x)))
00592 #define fmodf(x,y)  ((float)fmod((double)(x),(double)(y)))
00593 #define logf(x)     ((float)log((double)(x)))
00594 #define log10f(x)   ((float)log10((double)(x)))
00595 #endif
00596 
00597 /**********************************  Globals  **********************************/
00598 
00599 /// Simple, thread-safe, random number generator
00600 extern FXAPI FXuint fxrandom(FXuint& seed);
00601 
00602 /// Allocate memory
00603 extern FXAPI FXint fxmalloc(void** ptr,unsigned long size);
00604 
00605 /// Allocate cleaned memory
00606 extern FXAPI FXint fxcalloc(void** ptr,unsigned long size);
00607 
00608 /// Resize memory
00609 extern FXAPI FXint fxresize(void** ptr,unsigned long size);
00610 
00611 /// Duplicate memory
00612 extern FXAPI FXint fxmemdup(void** ptr,const void* src,unsigned long size);
00613 
00614 /// Free memory, resets ptr to NULL afterward
00615 extern FXAPI void fxfree(void** ptr);
00616 
00617 /// Error routine
00618 extern FXAPI void fxerror(const char* format,...) FX_PRINTF(1,2) ;
00619 
00620 /// Warning routine
00621 extern FXAPI void fxwarning(const char* format,...) FX_PRINTF(1,2) ;
00622 
00623 /// Log message to [typically] stderr
00624 extern FXAPI void fxmessage(const char* format,...) FX_PRINTF(1,2) ;
00625 
00626 /// Assert failed routine:- usually not called directly but called through FXASSERT
00627 extern FXAPI void fxassert(const char* expression,const char* filename,unsigned int lineno);
00628 
00629 /// Trace printout routine:- usually not called directly but called through FXTRACE
00630 extern FXAPI void fxtrace(unsigned int level,const char* format,...) FX_PRINTF(2,3) ;
00631 
00632 /// Sleep n microseconds
00633 extern FXAPI void fxsleep(unsigned int n);
00634 
00635 /// Match a file name with a pattern
00636 extern FXAPI FXint fxfilematch(const char *pattern,const char *string,FXuint flags=(FILEMATCH_NOESCAPE|FILEMATCH_FILE_NAME));
00637 
00638 /// Get highlight color
00639 extern FXAPI FXColor makeHiliteColor(FXColor clr);
00640 
00641 /// Get shadow color
00642 extern FXAPI FXColor makeShadowColor(FXColor clr);
00643 
00644 /// Get process id
00645 extern FXAPI FXint fxgetpid();
00646 
00647 /// Duplicate string
00648 extern FXAPI FXchar *fxstrdup(const FXchar* str);
00649 
00650 /// Calculate a hash value from a string
00651 extern FXAPI FXuint fxstrhash(const FXchar* str);
00652 
00653 /// Get RGB value from color name
00654 extern FXAPI FXColor fxcolorfromname(const FXchar* colorname);
00655 
00656 /// Get name of (closest) color to RGB
00657 extern FXAPI FXchar* fxnamefromcolor(FXchar *colorname,FXColor color);
00658 
00659 /// Convert RGB to HSV
00660 extern FXAPI void fxrgb_to_hsv(FXfloat& h,FXfloat& s,FXfloat& v,FXfloat r,FXfloat g,FXfloat b);
00661 
00662 /// Convert HSV to RGB
00663 extern FXAPI void fxhsv_to_rgb(FXfloat& r,FXfloat& g,FXfloat& b,FXfloat h,FXfloat s,FXfloat v);
00664 
00665 /// Floating point number classification: 0=OK, +/-1=Inf, +/-2=NaN
00666 extern FXAPI FXint fxieeefloatclass(FXfloat number);
00667 extern FXAPI FXint fxieeedoubleclass(FXdouble number);
00668 
00669 /// Parse geometry, a-la X11 geometry specification
00670 extern FXAPI FXint fxparsegeometry(const FXchar *string,FXint& x,FXint& y,FXint& w,FXint& h);
00671 
00672 /// True if executable with given path is a console application
00673 extern FXbool fxisconsole(const FXchar *path);
00674 
00675 /// Version number that the library has been compiled with
00676 extern FXAPI const FXuchar fxversion[3];
00677 
00678 
00679 /// Controls tracing level
00680 extern FXAPI unsigned int fxTraceLevel;
00681 
00682 /**
00683 * Parse accelerator from string, yielding modifier and
00684 * key code.  For example, fxparseAccel("Ctl+Shift+X")
00685 * yields MKUINT(KEY_X,CONTROLMASK|SHIFTMASK).
00686 */
00687 extern FXAPI FXHotKey fxparseAccel(const FXString& string);
00688 
00689 /**
00690 * Parse hot key from string, yielding modifier and
00691 * key code.  For example, fxparseHotKey(""Salt && &Pepper!"")
00692 * yields MKUINT(KEY_p,ALTMASK).
00693 */
00694 extern FXAPI FXHotKey fxparseHotKey(const FXString& string);
00695 
00696 /**
00697 * Obtain hot key offset in string, or -1 if not found.
00698 * For example, findHotKey("Salt && &Pepper!") yields 7.
00699 */
00700 extern FXAPI FXint fxfindHotKey(const FXString& string);
00701 
00702 /**
00703 * Strip hot key combination from the string.
00704 * For example, stripHotKey("Salt && &Pepper") should
00705 * yield "Salt & Pepper".
00706 */
00707 extern FXAPI FXString fxstripHotKey(const FXString& string);
00708 
00709 }
00710 
00711 #endif

Copyright © 1997-2004 Jeroen van der Zijp