xUtils.h

Go to the documentation of this file.

/* KB  07/16/97  \ken5\include\3rdparty\xUtils.h
* @doc
* $Workfile: xUtils.h $
* Copyright (c) 1995 - 1997 CoreTek, Inc.
* This work is protected by United States and international copyright laws 
* and contains certain trade secret information.  All use of this work is  
* governed by the terms of agreements between CoreTek Corporation and its     
* licensees or potential licensees.  Disclosure or disassembly of the      
* contents of embodied programs or algorithms is prohibited.  
* All rights reserved.
* Description: 
* $Revision: 11 $ $Author: Yury $ $Date: 4/29/97 4:00a $
************************************************************************/
#ifndef __XUTILS_H
#define __XUTILS_H

CString     RandomStr         (DWORD min, DWORD max);
DWORD    RandomInt         (DWORD min, DWORD max);
char     RandomChar        (void);

// I just can't remember CDialog::UpdateData()
#define     TO_DLG         FALSE
#define     FROM_DLG    TRUE


#ifdef _OS9
//@func void | SwapBytes | Swaps the bytes from Intel to Motorola format and
//    vise versa.
//@parm datatype *| data | Pointer to the data to be swapped. This can one of the: <nl>
//<tab><tab>   int *    - pointer to the integer<nl>
//<tab><tab>   WORD *   - pointer to the WORD<nl>
//<tab><tab>   short *  - pointer to the short<nl>
//<tab><tab>   long *   - pointer to the long<nl>
//<tab><tab>   float *  - pointer to the float<nl>
//<tab><tab>   double * - pointer to the double<nl>
//<tab><tab>   CSize *  - pointer to <c CSize> structure<nl>
//<tab><tab>   CPoint * - pointer to <c CPoint> structure<nl>
//<tab><tab>   CRect *  - pointer to <c CRect> structure<nl>
//<tab><tab>   BITMAPFILEHEADER *  - pointer to <c BITMAPFILEHEADER> structure<nl>
//<tab><tab>   BITMAPINFOHEADER *  - pointer to <c BITMAPINFOHEADER> structure<nl>
//<tab><tab>   DWORD *  - pointer to <c DWORD> structure<nl>
//<tab><tab>   XFORM * - pointer to <c XFORM> structure<nl>
//<tab><tab>   LOGPEN * - pointer to <c LOGPEN> structure<nl>
//<tab><tab>   LOGPALETTE pointer to <c LOGPALETTE> structure<nl>
//<tab><tab>   LOGFONT *  - pointer to <c LOGFONT> structure<nl>
//<tab><tab>   EXTLOGFONTW *  - pointer to <c EXTLOGFONTW> structure<nl>
//<tab><tab>   RGNDATAHEADER *  - pointer to <c RGNDATAHEADER> structure<nl>

void SwapBytes(POINTL *aptl, DWORD cnt);
void SwapBytes(POINTS *aptl, DWORD cnt);
void SwapBytes(DWORD *adw, DWORD cnt);
void SwapBytes(XFORM *xform);
void SwapBytes(LOGPEN *lp);
void SwapBytes(LOGBRUSH *lb);
void SwapBytes(LOGPALETTE *lpal);
void SwapBytes(LOGFONT *lf);
//void   SwapBytes(EXTLOGFONTW *lfw); // KB
void SwapBytes(BITMAPFILEHEADER* bmfHeader);
void SwapBytes(BITMAPINFOHEADER *lpBMIH);
void SwapBytes(RGNDATAHEADER *rgnHdr);



//@devnote This portable function operates only on the Mac platform. It's defined to be nothing on Win32.
inline void   SwapBytes(int *pLong)
{  
   BYTE *pByte = (BYTE *)pLong;
   *pLong = (long)(pByte[3] << 24) 
         + (long)(pByte[2] << 16) 
         + (long)(pByte[1] << 8) 
         + pByte[0];
}

inline void   SwapBytes(unsigned int *pLong)
{  
   BYTE *pByte = (BYTE *)pLong;
   *pLong = (long)(pByte[3] << 24) 
         + (long)(pByte[2] << 16) 
         + (long)(pByte[1] << 8) 
         + pByte[0];
}

inline void   SwapBytes(WORD *pWord)
{  
   BYTE *pByte = (BYTE *)pWord;
   *pWord = (WORD)((WORD)(pByte[1] << 8) + pByte[0]);
}

inline void   SwapBytes(short *pWord)
{  
   BYTE *pByte = (BYTE *)pWord;
   *pWord = (short)((short)(pByte[1] << 8) + pByte[0]);
}

inline void   SwapBytes(long *pLong)
{  
   BYTE *pByte = (BYTE *)pLong;
   *pLong = (long)(pByte[3] << 24) 
         + (long)(pByte[2] << 16) 
         + (long)(pByte[1] << 8) 
         + pByte[0];
}

inline void   SwapBytes(DWORD *pDWord)
{  
   BYTE *pByte = (BYTE *)pDWord;
   *pDWord = (DWORD)(pByte[3] << 24) 
         + (DWORD)(pByte[2] << 16) 
         + (DWORD)(pByte[1] << 8) 
         + pByte[0];
}

inline void   SwapBytes(float *pFloat)
{  
   BYTE *pByte = (BYTE *)pFloat;
   *pFloat = (float) ((long)(pByte[3] << 24) 
         + (long)(pByte[2] << 16) 
         + (long)(pByte[1] << 8) 
         + pByte[0]);
}

inline void   SwapBytes(double *pDouble)
{  
   DWORD *dwPtr = (DWORD *)(pDouble);
   DWORD dw;
   SwapBytes(&dwPtr[0]);
   SwapBytes(&dwPtr[1]);
   dw = dwPtr[0];
   dwPtr[0] = dwPtr[1];
   dwPtr[1] = dw;
}

inline void   SwapBytes(CRect *pRect)
{
   SwapBytes(&pRect->top);
   SwapBytes(&pRect->bottom);
   SwapBytes(&pRect->left);
   SwapBytes(&pRect->right);
}

inline void   SwapBytes(CPoint *pPoint)
{
   SwapBytes(&pPoint->x);
   SwapBytes(&pPoint->y);
}

inline void   SwapBytes(CSize *pSize)
{
   SwapBytes(&pSize->cx);
   SwapBytes(&pSize->cy);
}

inline void   SwapBytes(RECTL *pRect)
{
   SwapBytes(&pRect->top);
   SwapBytes(&pRect->bottom);
   SwapBytes(&pRect->left);
   SwapBytes(&pRect->right);
}

inline void   SwapBytes(POINTL *pPoint)
{
   SwapBytes(&pPoint->x);
   SwapBytes(&pPoint->y);
}

inline void   SwapBytes(POINT *pPoint)
{
   SwapBytes(&pPoint->x);
   SwapBytes(&pPoint->y);
}

inline void   SwapBytes(SIZEL *pSize)
{
   SwapBytes(&pSize->cx);
   SwapBytes(&pSize->cy);
}

void   SwapBytes(POINTL *aptl, DWORD cnt);
void   SwapBytes(POINTS *aptl, DWORD cnt);
void   SwapBytes(DWORD *adw, DWORD cnt);
void   SwapBytes(XFORM *xform);
void   SwapBytes(LOGPEN *lp);
void   SwapBytes(LOGBRUSH *lb);
void   SwapBytes(LOGPALETTE *lpal);
void   SwapBytes(LOGFONT *lf);
//void   SwapBytes(EXTLOGFONTW *lfw); // KB
void   SwapBytes(BITMAPFILEHEADER* bmfHeader);
void   SwapBytes(BITMAPINFOHEADER *lpBMIH);
void   SwapBytes(RGNDATAHEADER *rgnHdr);


void   SwapBits (unsigned char * dp, unsigned char * sp, int len);

// Some Pascal string helpers
char *pStrCat(char * pStr1, char * pStr2);
char *pStrCopy(char * pDesString, char * SrcString);


// Dialog utilities
#define ON 1
#define OFF 0
#define DI_ENABLE    0
#define DI_DISABLE      255
// Keys
#define     KEY_HOME    01
#define     KEY_END     04
#define     KEY_ENTRKEY 03
#define     KEY_BACK    8
#define     KEY_TAB     9
#define     KEY_PAGEUP     11
#define     KEY_PAGEDOWN   12
#define     KEY_RETURNKEY  13
#define     KEY_ESCAPEKEY  27
#define     KEY_LEFT    28
#define     KEY_RIGHT      29
#define     KEY_UP         30
#define     KEY_DOWN    31
#define     KEY_PLUS    43
#define     KEY_MINUS      45
#define     KEY_PERIODKEY  46
#define     KEY_ZERO    48
#define     KEY_NINE    57
#define     KEY_DELKEY     127

void    MacToggleCheck     (DialogPtr d, short i);
void    MacToggleRadio     (DialogPtr d, short i, short first, short last);

void    MacSetItemText     (DialogPtr d, short i, Str255 newText);
void    MacGetItemText     (DialogPtr d, short i, Str255 getText);
Boolean   MacIsDIHidden    (DialogPtr d, short i);
void    MacEnableDItem     (DialogPtr d, short i, Boolean on);
void    MacEnableDIText    (DialogPtr d, short i, Boolean on );
void    MacSetButtonText   (DialogPtr d, short i, Str255 s);
short   MacGetCtlMax    (DialogPtr d, short i);
short   MacGetCtlMin    (DialogPtr d, short i);
short   MacSetCtlMax    (DialogPtr d, short i, short v);
short   MacSetCtlMin    (DialogPtr d, short i, short v);
short   MacGetCtlValue     (DialogPtr d, short i);
void    MacSetCtlValue     (DialogPtr d, short i, short newVal);



// Note:  For the Mac, the X swap functions do nothing. This is the opposite of SwapBytes.
#define  SwapBytesX(x)

#else // Windows

// For Intel platforms define them to nothing
#define  SwapBytes(x)
#define  SwapBits(x,y,z)

inline void SwapBytesX(WORD *pWord)
{  
   BYTE *pByte = (BYTE *)pWord;
   *pWord = (WORD)((WORD)(pByte[0] << 8) + pByte[1]);
}

inline void SwapBytesX(short *pWord)
{  
   BYTE *pByte = (BYTE *)pWord;
   *pWord = (WORD)((WORD)(pByte[0] << 8) + pByte[1]);
}

inline void SwapBytesX(long *pLong)
{  
   BYTE *pByte = (BYTE *)pLong;
   *pLong = (long)(pByte[0] << 24) 
         + (long)(pByte[1] << 16) 
         + (long)(pByte[2] << 8) 
         + pByte[3];
}

#endif

#endif

---