diff options
Diffstat (limited to 'app/xlockmore/win32')
| -rw-r--r-- | app/xlockmore/win32/Makefile.win32 | 40 | ||||
| -rw-r--r-- | app/xlockmore/win32/Xapi.c | 2856 | ||||
| -rw-r--r-- | app/xlockmore/win32/Xapi.h | 971 | ||||
| -rw-r--r-- | app/xlockmore/win32/readme.txt | 334 | ||||
| -rw-r--r-- | app/xlockmore/win32/todo.txt | 46 | ||||
| -rw-r--r-- | app/xlockmore/win32/xlock.ico | bin | 0 -> 2238 bytes | |||
| -rw-r--r-- | app/xlockmore/win32/xlock95.c | 225 | ||||
| -rw-r--r-- | app/xlockmore/win32/xlock95.h | 13 | ||||
| -rw-r--r-- | app/xlockmore/win32/xlockrc.rc | 31 |
9 files changed, 4516 insertions, 0 deletions
diff --git a/app/xlockmore/win32/Makefile.win32 b/app/xlockmore/win32/Makefile.win32 new file mode 100644 index 000000000..998d3b9b0 --- /dev/null +++ b/app/xlockmore/win32/Makefile.win32 @@ -0,0 +1,40 @@ +# build applications +CC=gcc +MAKE=make +RES=windres + +# compiler flags +CFLAGS=-DWIN32 -D_DEBUG -DSYSV -mno-cygwin -mwindows -O2 +#CFLAGS=-DWIN32 -DSYSV -mno-cygwin -mwindows -O2 + +# Include & Library directories +WIN32API=/usr/include/w32api +INCS=-I$(WIN32API) -I../xlock -I. + +# sources +SRC= xlockrc.rc \ + Xapi.c \ + xlock95.c \ + +# objects +OBJS = $(SRC:.rc=.o) +OBJS += $(SRC:.c=.o) + +# general rules +.rc.o: + $(RES) --include-dir $(WIN32API) -i $< -o $@ + +.c.o: + $(CC) $(CFLAGS) -c -o $@ $< $(INCS) + +# specific rules +all: $(OBJS) + +xlock95.o: xlock95.h +xlockrc.o: xlock95.h + +xlockrc.o: xlockrc.rc + $(RES) --include-dir $(WIN32API) -i $< -o $@ + +clean: + rm -f *.o *.scr core *~ *% *.bak *.rej *.orig *.patch *.pure diff --git a/app/xlockmore/win32/Xapi.c b/app/xlockmore/win32/Xapi.c new file mode 100644 index 000000000..fe22a9853 --- /dev/null +++ b/app/xlockmore/win32/Xapi.c @@ -0,0 +1,2856 @@ +/* -*- Mode: C; tab-width: 4 -*- */ +/* Xapi --- mapped X API calls */ + +#if !defined( lint ) && !defined( SABER ) +static const char sccsid[] = "@(#)Xapi.c 4.07 98/04/16 xlockmore"; + +#endif + +#ifdef WIN32 + +#include <stdlib.h> +#include <math.h> +#include "xlock.h" + +#define NUMBER_GC (1024) +#define NUMBER_BITMAP (1024) + +typedef struct { + unsigned long background; + unsigned long foreground; +} TColor; + +typedef struct { + int hasFillRule; + int value; +} TFillRule; + +typedef struct { + int hasFillStyle; + int value; +} TFillStyle; + +typedef struct { + int hasFont; + Font value; +} TFont; + +typedef struct { + int hasFunction; + int value; +} TFunction; + +typedef struct { + int hasLineAttributes; + unsigned int width; + int lineStyle; + int capStyle; + int joinStyle; +} TLineAttributes; + +typedef struct { + int hasStipple; + Pixmap graphic; +} TStipple; + +typedef struct { + int hasOrigin; + int x; + int y; +} TTSOrigin; + +typedef struct { + int isActive; + int needsReset; + TColor color; + TFillRule fillRule; + TFillStyle fillStyle; + TFunction function; + TLineAttributes lineAttributes; + TTSOrigin tsorigin; + TStipple stipple; + TFont font; +} TGCInfo; + +typedef struct { + int isActive; + int type; + int width; + int height; + HBITMAP bitmap; +} TBMInfo; + + +/* -------------------------------------------------------------------- */ + +int GCCreate(void); +HDC GCGetDC(Drawable d, GC gc); +int BMInfoCreate(void); +HBITMAP DrawableGetBitmap(Drawable d); + +/* -------------------------------------------------------------------- */ + +/*- + * global variables + */ +HWND hwnd; /* window handle */ +HDC hdc; /* device context */ +HGDIOBJ noPen = NULL; /* no pen used in fills */ +int cred, cgreen, cblue; /* color reference of the pen */ +unsigned char *red, *green, *blue; /* holds a list of colors */ +int colorcount; /* number of colors used */ +unsigned int randommode; /* number of mode to index */ +RECT rc; /* coords of the screen */ + +HANDLE thread; /* thread handle */ +DWORD thread_id; /* thread id number */ + +int numGCInfo = 0; /* number of GC Info */ +TGCInfo gcInfo[NUMBER_GC + 1] = { 0 }; /* information about GCs. Allow + NUMBER_GC GC's, + 1 as a spill + over for any modes that need + more */ +int numBMInfo = 0; /* number of Bitmap Info */ +TBMInfo bmInfo[NUMBER_BITMAP + 1] = { 0 }; /* information about Bitmaps/Pixmaps */ + +/* -------------------------------------------------------------------- */ + +/* the following functions are used to build up a graphic to display in + WIN32 + */ + +void SetByte(LPBYTE lpBMData, BYTE val, int loc, int maxLoc) +{ + if (loc < maxLoc) + { + lpBMData[loc] = val ^ 0xFF; + } +} + +void SetGraphic(LPBYTE lpBMData, XImage *image) +{ + const int w32bb = 4 * 8; + const int xbmbb = 1 * 8; + BYTE xbmval; + BYTE w32val; + int lineBitCnt = 0; + int w32BitsRemain; + int i, j, k; + int bmSize; + int loc = 0; + int actBytesPerLine; + int maxLoc; + + // initialise + actBytesPerLine = (image->width + 7) / 8; + bmSize = actBytesPerLine * image->height; + maxLoc = (actBytesPerLine + ((4 - (actBytesPerLine % 4)) % 4)) * + image->height; + + // for each byte in the xbm bit array + for (i=0; i<bmSize; i++) + { + xbmval = (image->data)[i]; + w32val = 0; + + // for each bit in the byte + for (j=0; j<8; j++) + { + w32val = (w32val << 1) | ((xbmval >> j) & 0x1); + + if (j == 7) /* we have processed all bits */ + { + SetByte(lpBMData, w32val, loc, maxLoc); + loc++; + } + + // check for a line of graphic + if (++lineBitCnt == image->width) + { + w32BitsRemain = (w32bb - (lineBitCnt % w32bb)) % w32bb; + + if (w32BitsRemain % 8) + { + w32val = w32val << (w32BitsRemain % 8); + SetByte(lpBMData, w32val, loc, maxLoc); + loc++; + } + if (w32BitsRemain / 8) + { + for (k=0; k<(w32BitsRemain / 8); k++) + { + SetByte(lpBMData, 0, loc, maxLoc); + loc++; + } + } + lineBitCnt = 0; + break; + } + } + } +} + +void +LCreateBitmap(XImage *image, HBITMAP *hBitmap, HPALETTE *hPalette) +{ + BYTE palette[2][3]; + LPBITMAPINFO lpbi; + HDC hScreenDC; + LPVOID lpBMData; + LPLOGPALETTE lpLogPal; + int i; + + /* setup color palette */ + palette[0][0] = 255; /* red */ + palette[0][1] = 255; /* green */ + palette[0][2] = 255; /* blue */ + + palette[1][0] = 000; /* red */ + palette[1][1] = 000; /* green */ + palette[1][2] = 000; /* blue */ + + /* allocate memory for the bitmap header */ + lpbi = (LPBITMAPINFO)LocalAlloc(LPTR, + sizeof(BITMAPINFOHEADER) + (2 * sizeof(RGBQUAD))); + if (lpbi == NULL) + { + return; + } + + /* set bitmap header info */ + lpbi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER); + lpbi->bmiHeader.biWidth = image->width; + lpbi->bmiHeader.biHeight = -1 * image->height; + lpbi->bmiHeader.biPlanes = 1; + lpbi->bmiHeader.biBitCount = 1; + lpbi->bmiHeader.biCompression = BI_RGB; + + /* fill in bitmap palette */ + for (i=0; i<2; i++) + { + lpbi->bmiColors[i].rgbRed = palette[i][0]; + lpbi->bmiColors[i].rgbGreen = palette[i][1]; + lpbi->bmiColors[i].rgbBlue = palette[i][2]; + } + + /* create bitmap area */ + hScreenDC = CreateCompatibleDC(hdc); + *hBitmap = CreateDIBSection(hScreenDC, lpbi, DIB_RGB_COLORS, + &lpBMData, NULL, 0); + + if (*hBitmap == NULL && lpBMData == NULL) + { + DeleteDC(hScreenDC); + LocalFree(lpbi); + return; + } + + DeleteDC(hScreenDC); + if (LocalFree(lpbi) != NULL) + return; + + /* copy XBM to bitmap */ + SetGraphic(lpBMData, image); + + /* create logical palette header */ + lpLogPal = (LPLOGPALETTE)LocalAlloc(LPTR, + sizeof(LOGPALETTE) + (1 * sizeof(PALETTEENTRY))); + if (lpLogPal == NULL) + { + return; + } + + /* set logical palette info */ + lpLogPal->palVersion = 0x0300; + lpLogPal->palNumEntries = 2; + for (i=0; i < 2; i++) + { + lpLogPal->palPalEntry[i].peRed = palette[i][0]; + lpLogPal->palPalEntry[i].peGreen = palette[i][1]; + lpLogPal->palPalEntry[i].peBlue = palette[i][2]; + } + + /* create palette */ + *hPalette = CreatePalette(lpLogPal); + if (*hPalette == NULL) + { + return; + } + + /* clean up palette creation data */ + LocalFree(lpLogPal); +} + +/* -------------------------------------------------------------------- */ + +/* the following functions to create, destroy, modify and access the + GC Info structure + */ +int GCCreate(void) +{ + int retVal = 0; + + for (retVal=0; retVal<NUMBER_GC; retVal++) + { + if (gcInfo[retVal].isActive == FALSE) + { + numGCInfo++; + break; + } + } + + gcInfo[retVal].isActive = TRUE; + gcInfo[retVal].needsReset = TRUE; + gcInfo[retVal].color.background = NUMCOLORS+1; + gcInfo[retVal].color.foreground = NUMCOLORS; + gcInfo[retVal].fillRule.hasFillRule = FALSE; + gcInfo[retVal].fillRule.value = 0; + gcInfo[retVal].fillStyle.hasFillStyle = FALSE; + gcInfo[retVal].fillStyle.value = 0; + gcInfo[retVal].function.hasFunction = FALSE; + gcInfo[retVal].function.value = 0; + gcInfo[retVal].lineAttributes.hasLineAttributes = FALSE; + gcInfo[retVal].lineAttributes.width = 0; + gcInfo[retVal].lineAttributes.lineStyle = 0; + gcInfo[retVal].lineAttributes.capStyle = 0; + gcInfo[retVal].lineAttributes.joinStyle = 0; + gcInfo[retVal].tsorigin.hasOrigin = FALSE; + gcInfo[retVal].tsorigin.x = 0; + gcInfo[retVal].tsorigin.y = 0; + gcInfo[retVal].stipple.hasStipple = FALSE; + gcInfo[retVal].stipple.graphic = -1; + + return retVal; +} + +/* -------------------------------------------------------------------- */ +HDC GCGetDC(Drawable d, GC gc) +{ + HGDIOBJ brush; + int fillfunc; + int fillrule; + int i; + LOGBRUSH lb; + LPLOGPALETTE lpLogPal; + BYTE palarray[2][3]; + HPALETTE palette; + HGDIOBJ pen; + DWORD penstyle; + HBITMAP stipple; + HDC lhdc; + char message[80]; + + static GC lastGc = -1; + static HDC sbhdc = NULL; + static HDC dbhdc = NULL; + + if (gc < 0 || gc >= numGCInfo) + { + sprintf(message, "GC passed in not in range 0..%d, gc=%d", + numGCInfo-1, gc); + xlockmore_set_debug(message); + return NULL; + } + + /* get DC - try and determine if its a window or bitmap */ + if (d > 0 && d < NUMBER_BITMAP) + { + if (dbhdc == NULL) + /* create a compatible DC from the saved intial DC. To draw + to this DC we still need to put a HBITMAP into it (not + done in this function) + */ + if ((dbhdc = CreateCompatibleDC(hdc)) == NULL) + { + sprintf(message, "CreateCompatibleDC() returned NULL"); + xlockmore_set_debug(message); + return NULL; + } + lhdc = dbhdc; + } + else + { + if (sbhdc == NULL) + /* create a DC for the window. We don't (and cannot) put + * a HBITMAP into this. It is ready to draw to (straight to + * the screen) + */ + if ((sbhdc = GetDC(hwnd)) == NULL) + { + sprintf(message, "GetDC() returned NULL"); + xlockmore_set_debug(message); + return NULL; + } + lhdc = sbhdc; + } + + /* check if we have already set up the DC in a previous call */ + if (lastGc == gc && gcInfo[gc].needsReset == FALSE) + return lhdc; + + /* set the current color constants */ + cred = red[gcInfo[gc].color.foreground]; + cgreen = green[gcInfo[gc].color.foreground]; + cblue = blue[gcInfo[gc].color.foreground]; + + /* set the text color */ + if (SetTextColor(lhdc, RGB(cred,cgreen,cblue)) == CLR_INVALID) + { + sprintf(message, "text: SetTextColor() returned CLR_INVALID [%d %d %d]", cred, cgreen, cblue); + xlockmore_set_debug(message); + return NULL; + } + if (SetBkColor(lhdc, RGB(red[gcInfo[gc].color.background], + green[gcInfo[gc].color.background], + blue[gcInfo[gc].color.background])) == CLR_INVALID) + { + sprintf(message, "text: SetBkColor() returned CLR_INVALID"); + xlockmore_set_debug(message); + return NULL; + } + + /* set the pen to the new color and line attributes */ + if (gcInfo[gc].lineAttributes.hasLineAttributes == FALSE) + { + /* no line attributes, just create solid pen and put into the DC*/ + if ((pen = CreatePen(PS_SOLID, 0, RGB(cred, cgreen, cblue))) == NULL) + { + sprintf(message, "pen: CreatePen() returned NULL"); + xlockmore_set_debug(message); + return NULL; + } + else + { + if ((pen = SelectObject(lhdc, pen)) == NULL) + { + sprintf(message, "pen: Failed to select pen into DC"); + xlockmore_set_debug(message); + return NULL; + } + /* remove the old pen */ + if (DeleteObject(pen) == 0) + { + sprintf(message, "pen: Failed to delete old pen"); + xlockmore_set_debug(message); + return NULL; + } + } + } + else + { + /* line attributes need to be set, create a more complex pen */ + + /* set the brush info */ + lb.lbStyle = BS_SOLID; + lb.lbColor = RGB(cred, cgreen, cblue); + lb.lbHatch = 0; + + /* set the pen style */ + penstyle = PS_GEOMETRIC; + + switch (gcInfo[gc].lineAttributes.lineStyle) + { + case LineSolid: + penstyle |= PS_SOLID; break; + case LineOnOffDash: + penstyle |= PS_DASH; break; + case LineDoubleDash: + penstyle |= PS_DOT; break; + } + + switch (gcInfo[gc].lineAttributes.capStyle) + { + case CapNotLast: + penstyle |= PS_ENDCAP_FLAT; break; + case CapButt: + penstyle |= PS_ENDCAP_FLAT; break; + case CapRound: + penstyle |= PS_ENDCAP_ROUND; break; + case CapProjecting: + penstyle |= PS_ENDCAP_SQUARE; break; + } + + switch (gcInfo[gc].lineAttributes.joinStyle) + { + case JoinMiter: + penstyle |= PS_JOIN_MITER; break; + case JoinRound: + penstyle |= PS_JOIN_ROUND; break; + case JoinBevel: + penstyle |= PS_JOIN_BEVEL; break; + } + + /* create the pen, putting it in the DC */ + pen = SelectObject(lhdc, + ExtCreatePen(penstyle, gcInfo[gc].lineAttributes.width, + &lb, 0, NULL)); + /* remove the old pen */ + DeleteObject(pen); + } + + /* set the palette to the new colors */ + palarray[0][0] = cred; /* red */ + palarray[0][1] = cgreen; /* green */ + palarray[0][2] = cblue; /* blue */ + + palarray[1][0] = red[gcInfo[gc].color.background]; /* red */ + palarray[1][1] = green[gcInfo[gc].color.background]; /* green */ + palarray[1][2] = blue[gcInfo[gc].color.background]; /* blue */ + + /* create logical palette header */ + lpLogPal = (LPLOGPALETTE)LocalAlloc(LPTR, + sizeof(LOGPALETTE) + (1 * sizeof(PALETTEENTRY))); + if (lpLogPal == NULL) + { + sprintf(message, "palette: Cannot alloacte memory for logical palette"); + xlockmore_set_debug(message); + return NULL; + } + + /* set logical palette info */ + lpLogPal->palVersion = 0x0300; + lpLogPal->palNumEntries = 2; + for (i=0; i < 2; i++) + { + lpLogPal->palPalEntry[i].peRed = palarray[i][0]; + lpLogPal->palPalEntry[i].peGreen = palarray[i][1]; + lpLogPal->palPalEntry[i].peBlue = palarray[i][2]; + } + + /* create palette */ + palette = CreatePalette(lpLogPal); + if (palette == NULL) + { + sprintf(message, "palette: CreatePalette() returned NULL"); + xlockmore_set_debug(message); + LocalFree(lpLogPal); + return NULL; + } + + /* set palette color */ + palette = SelectPalette(lhdc, palette, FALSE); + + /* clean up palette creation data */ + DeleteObject(palette); + LocalFree(lpLogPal); + + /* set brush origin */ + if (gcInfo[gc].tsorigin.hasOrigin == TRUE) + { + if (SetBrushOrgEx(lhdc, gcInfo[gc].tsorigin.x, + gcInfo[gc].tsorigin.y, NULL) == 0) + { + sprintf(message, "brush origin: SetBrushOrgEx() failed"); + xlockmore_set_debug(message); + return NULL; + } + } + + /* check if we need a pattern brush or solid brush */ + if (gcInfo[gc].stipple.hasStipple == FALSE || + (gcInfo[gc].fillStyle.hasFillStyle == TRUE && + gcInfo[gc].fillStyle.value == FillSolid)) + { + /* solid brush */ + brush = SelectObject(lhdc, + CreateSolidBrush(RGB(cred, cgreen, cblue))); + DeleteObject(brush); + } + /* check if we need to FillStippled, and if so don't make a + * brush, we will deal with this later (see XFillRectangle) + */ + else if (gcInfo[gc].stipple.graphic != -1 && + ! (gcInfo[gc].fillStyle.hasFillStyle == TRUE && + gcInfo[gc].fillStyle.value == FillStippled)) + { + /* pattern brush */ + HBRUSH oldBrush; + HBRUSH brush; + HDC hStippleDC; + HBITMAP hOldBitmap; + RGBQUAD rgbQuad = { cblue, cgreen, cred, 0 }; + + if ((stipple = DrawableGetBitmap(gcInfo[gc].stipple.graphic)) == NULL) + { + sprintf(message, "pattern brush: DrawableGetBitmap() returned NULL"); + xlockmore_set_debug(message); + return NULL; + } + + /* create a device context for setting the stipples color */ + if ((hStippleDC = CreateCompatibleDC(lhdc)) == NULL) + { + sprintf(message, "pattern brush: CreateCompatibleDC() returned NULL"); + xlockmore_set_debug(message); + return NULL; + } + + /* put the stipple into the DC */ + if ((hOldBitmap = (HBITMAP)SelectObject(hStippleDC, stipple)) == NULL) + { + sprintf(message, "pattern brush: cannot select stipple in stippleDC"); + xlockmore_set_debug(message); + DeleteDC(hStippleDC); + return NULL; + } + + /* set the correct color table */ + SetDIBColorTable(hStippleDC, 0, 1, &rgbQuad); + + /* get the stipple back from the DC with the correct color table */ + if ((stipple = (HBITMAP)SelectObject(hStippleDC, hOldBitmap)) == NULL) + { + sprintf(message, "pattern brush: cannot select stipple out of stippleDC"); + xlockmore_set_debug(message); + DeleteDC(hStippleDC); + return NULL; + } + + /* create a pattern brush out of it */ + if ((brush = CreatePatternBrush(stipple)) == NULL) + { + sprintf(message, "pattern brush: CreatePatternBrush() returned NULL"); + xlockmore_set_debug(message); + DeleteDC(hStippleDC); + return NULL; + } + + /* put the pattern brush into the DC */ + if ((oldBrush = SelectObject(lhdc, brush)) == NULL) + { + sprintf(message, "pattern brush: cannot select brush into DC"); + xlockmore_set_debug(message); + DeleteDC(hStippleDC); + return NULL; + } + + /* clean up and return */ + DeleteDC(hStippleDC); + DeleteObject(oldBrush); + } + + /* check if we need to set the fill function */ + if (gcInfo[gc].function.hasFunction == TRUE) + { + switch (gcInfo[gc].function.value) + { + case GXclear: fillfunc = R2_BLACK; break; + case GXand: fillfunc = R2_MERGEPEN; break; + case GXandReverse: fillfunc = R2_MERGEPENNOT; break; + case GXcopy: fillfunc = R2_COPYPEN; break; + case GXandInverted: fillfunc = R2_MERGENOTPEN; break; + case GXnoop: fillfunc = R2_NOP; break; + case GXxor: fillfunc = R2_XORPEN; break; + case GXor: fillfunc = R2_MASKPEN; break; + case GXnor: fillfunc = R2_NOTMERGEPEN; break; + case GXequiv: fillfunc = R2_NOTXORPEN; break; + case GXinvert: fillfunc = R2_NOT; break; + case GXorReverse: fillfunc = R2_MASKPENNOT; break; + case GXcopyInverted: fillfunc = R2_NOTCOPYPEN; break; + case GXorInverted: fillfunc = R2_MASKNOTPEN; break; + case GXnand: fillfunc = R2_NOTMASKPEN; break; + case GXset: fillfunc = R2_WHITE; break; + default: fillfunc = R2_COPYPEN; break; + } + + SetROP2(lhdc, fillfunc); + } + + /* set fill rule */ + if (gcInfo[gc].fillRule.hasFillRule == TRUE) + { + switch (gcInfo[gc].fillRule.value) + { + case EvenOddRule: fillrule = ALTERNATE; break; + case WindingRule: fillrule = WINDING; break; + default: fillrule = WINDING; break; + } + if (SetPolyFillMode(lhdc, fillrule) == 0) + { + sprintf(message, "fill rule: cannot set fill mode in DC"); + xlockmore_set_debug(message); + return NULL; + } + } + + /* + * if we call this function again and there is no change to the DC + * that needs to be done, we want to just return the DC that had + * already been set up. Set the information to allow this + */ + gcInfo[gc].needsReset = FALSE; + lastGc = gc; + + /* ignoring setting font for now */ + /* TODO: font */ + + /* return the DC */ + return lhdc; +} + + +/* the following functions to create, destroy, modify and access the + BM Info structure + */ +int BMInfoCreate(void) +{ + int retVal = 0; + HBITMAP hBitmap; + + /* start at 1, not 0 as this will be None */ + for (retVal=1; retVal<NUMBER_BITMAP; retVal++) + { + if (bmInfo[retVal].isActive == FALSE) + { + numBMInfo++; + break; + } + } + + if (retVal == NUMBER_BITMAP) + return -1; + + /* set the bitmap info */ + bmInfo[retVal].isActive = TRUE; + bmInfo[retVal].width = 0; + bmInfo[retVal].height = 0; + bmInfo[retVal].bitmap = NULL; + + return retVal; +} + +HBITMAP DrawableGetBitmap(Drawable d) +{ + char message[80]; + + if (d < 0 || d >= NUMBER_BITMAP) + { + sprintf(message, "Drawable passed in not in range 0..%d, d=%d", + numBMInfo-1, d); + xlockmore_set_debug(message); + return NULL; + } + + /* check for id of 0 */ + if (d == None) + { + sprintf(message, "Drawable is None"); + xlockmore_set_debug(message); + return NULL; + } + + if (bmInfo[d].isActive == FALSE) + { + sprintf(message, "Drawable not active, d=%d", d); + xlockmore_set_debug(message); + return NULL; + } + + return bmInfo[d].bitmap; +} + +/* -------------------------------------------------------------------- */ + +/* the following are functions in UNIX but not WIN32 */ + +/*- + * nice + */ +int nice(int level) +{ + return 1; +} + +/*- + * sleep + */ +void sleep(int sec) +{ +} + +/*- + * sigmask + */ +int sigmask(int signum) +{ + return 0; +} + + +/* the following are macros in X, but I have implemented as functions */ + +/*- + * BlackPixel + * returns the color cell of Black + * NOTE: this is currently set to the end of the color + * palette table, + */ +unsigned long BlackPixel(Display *display, int screen_number) +{ + return colorcount+1; +} + +/*- + * WhitePixel + * returns the color cell of White + * NOTE: this is currently set to the end of the color + * palette table - 1 + */ +unsigned long WhitePixel(Display *display, int screen_number) +{ + return colorcount; +} + +/*- + * BlackPixelOfScreen + * returns the color cell of Black + * NOTE: currently is fixed to color array + 2 + */ +int BlackPixelOfScreen(Screen *screen) +{ + return NUMCOLORS+1; +} + +/*- + * WhitePixelOfScreen + * returns the color cell of White + * NOTE: currently is fixed to color array + 1 + */ +int WhitePixelOfScreen(Screen *screen) +{ + return NUMCOLORS; +} + +/*- + * CellsOfScreen + * returns number of entries the colormap can hold + */ +int CellsOfScreen(Screen *screen) +{ + return colorcount; +} + +/*- + * DefaultColormap + * not currently used, returns 0 + */ +Colormap DefaultColormap(Display *display, int screen_number) +{ + return 0; +} + +/*- + * DefaultColormapOfScreen + * not currently used, returns 0 + */ +Colormap DefaultColormapOfScreen(Screen *screen) +{ + return 0; +} + +/*- + * DefaultVisual + * not currently used, returns NULL + */ +Visual *DefaultVisual(Display *display, int screen_number) +{ + return NULL; +} + +/*- + * DisplayPlanes + * not currently used, returns 0 + */ +int DisplayPlanes(Display *display, int screen_number) +{ + return 0; +} + +/*- + * DisplayString + * not currently used, returns NULL + */ +char *DisplayString(Display *display) +{ + return NULL; +} + +/*- + * RootWindow + * not currently used, returns 0 + */ +Window RootWindow(Display *display, int screen_number) +{ + return 0; +} + +/*- + * ScreenCount + * not correct, just return 1 + */ +int ScreenCount(Display *display) +{ + return 1; +} + +/*- + * ScreenOfDisplay + * not currently used, returns NULL + */ +Screen *ScreenOfDisplay(Display *display, int screen_number) +{ + return NULL; +} + +/* -------------------------------------------------------------------- */ + +/* X function mappings */ + +/*- + * XAddHosts + * not currently used + */ +void XAddHosts(Display *display, XHostAddress *hosts, int num_hosts) +{ +} + +/*- + * XAllocColor + * not currently used + */ +Status XAllocColor(Display *display, Colormap colormap, + XColor *screen_in_out) +{ + screen_in_out->pixel = 0; + return 1; +} + +/*- + * XAllocColorCells + * not currently used + */ +Status XAllocColorCells(Display *display, Colormap colormap, + Bool contig, unsigned long plane_masks_return[], + unsigned int nplanes, unsigned long pixels_return[], + unsigned int npixels) +{ + return 0; +} + +/*- + * XAllocNamedColor + * not currently used + */ +Status XAllocNamedColor(Display *display, Colormap colormap, + char *color_name, XColor *screen_def_return, + XColor *exact_def_return) +{ + return 0; +} + +/*- + * XBell + * not currently used + */ +void XBell(Display *display, int percent) +{ +} + +/*- + * XChangeGC + * changes values of the graphics context + */ +void XChangeGC(Display *display, GC gc, unsigned long valuemask, + XGCValues *values) +{ + if (valuemask & GCBackground) + { + XSetBackground(display, gc, values->background); + } + if (valuemask & GCFillRule) + { + XSetFillRule(display, gc, values->fill_rule); + } + if (valuemask & GCFillStyle) + { + XSetFillStyle(display, gc, values->fill_style); + } + if (valuemask & GCForeground) + { + XSetForeground(display, gc, values->foreground); + } + if (valuemask & GCFunction) + { + XSetFunction(display, gc, values->function); + } + if (valuemask & GCLineWidth) + { + XSetLineAttributes(display, gc, + values->line_width, + gcInfo[gc].lineAttributes.lineStyle, + gcInfo[gc].lineAttributes.capStyle, + gcInfo[gc].lineAttributes.joinStyle); + } + if (valuemask & GCLineStyle) + { + XSetLineAttributes(display, gc, + gcInfo[gc].lineAttributes.width, + values->line_style, + gcInfo[gc].lineAttributes.capStyle, + gcInfo[gc].lineAttributes.joinStyle); + } + if (valuemask & GCCapStyle) + { + XSetLineAttributes(display, gc, + gcInfo[gc].lineAttributes.width, + gcInfo[gc].lineAttributes.lineStyle, + values->cap_style, + gcInfo[gc].lineAttributes.joinStyle); + } + if (valuemask & GCJoinStyle) + { + XSetLineAttributes(display, gc, + gcInfo[gc].lineAttributes.width, + gcInfo[gc].lineAttributes.lineStyle, + gcInfo[gc].lineAttributes.capStyle, + values->join_style); + } + if (valuemask & GCStipple) + { + XSetStipple(display, gc, values->stipple); + } + if (valuemask & GCFont) + { + XSetFont(display, gc, values->font); + } + if (valuemask & GCTileStipXOrigin) + { + XSetTSOrigin(display, gc, values->ts_x_origin, gcInfo[gc].tsorigin.y); + } + if (valuemask & GCTileStipYOrigin) + { + XSetTSOrigin(display, gc, gcInfo[gc].tsorigin.x, values->ts_y_origin); + } + + /* the above are the only attributes we can set at this stage */ +} + + +/*- + * XCheckMaskEvent + * not currently used, return True + */ +Bool XCheckMaskEvent(Display *display, long event_mask, + XEvent *event_return) +{ + return True; +} + +/*- + * XClearArea + * clears a rectangular area in a window/screen + */ +void XClearArea(Display *display, Window w, int x, int y, + unsigned int width, unsigned int height, Bool exposures) +{ + RECT lrc; + + lrc.left = x; + lrc.top = y; + lrc.right = x + width; + lrc.bottom = y + height; + + FillRect(hdc, &lrc, (struct HBRUSH__ *)GetStockObject(BLACK_BRUSH)); +} + +/*- + * XClearWindow + * sets the base window/screen to black + */ +void XClearWindow(Display *display, Window w) +{ + FillRect(hdc, &rc, (struct HBRUSH__ *)GetStockObject(BLACK_BRUSH)); +} + +/*- + * XCloseDisplay + * not currently used + */ +void XCloseDisplay(Display *display) +{ +} + +/*- + * XConfigureWindow + * not currently used + */ +void XConfigureWindow(Display *display, Window w, + unsigned int value_mask, + XWindowChanges *values) +{ +} + +/*- + * XCopyArea + * copies one drawable to another + */ +int XCopyArea(Display *display, Drawable src, Drawable dest, GC gc, + int src_x, int src_y, unsigned int width, unsigned height, + int dest_x, int dest_y) +{ + HBITMAP hBitmap; + HBITMAP hOldBitmapS; + HBITMAP hOldBitmapD; + HDC hDestDC; + HDC hSrcDC; + + /* create the destination resource */ + if ((hDestDC = GCGetDC(dest, gc)) == NULL) + { + xlockmore_set_debug("XCopyArea: Failed to get destination DC"); + return BadGC; + } + + if (dest > 0 && dest < NUMBER_BITMAP) + if (bmInfo[dest].isActive == TRUE) + hOldBitmapD = SelectObject(hDestDC, DrawableGetBitmap(dest)); + + /* create the source resource */ + if (src > 0 && src <= numBMInfo) + { + /* source is a bitmap */ + if ((hBitmap = DrawableGetBitmap(src)) == NULL) + { + xlockmore_set_debug("XCopyArea: Failed to get bitmap"); + return BadDrawable; + } + + if ((hSrcDC = CreateCompatibleDC(hdc)) == NULL) + { + xlockmore_set_debug("XCopyArea: Failed to create compatible DC"); + return BadDrawable; + } + + hOldBitmapS = SelectObject(hSrcDC, hBitmap); + } + else + { + /* source is a window */ + if ((hSrcDC = GetDC((HWND)src)) == NULL) + { + xlockmore_set_debug("XCopyArea: Failed to get source DC"); + return BadDrawable; + } + } + + /* copy src to destination */ + if (BitBlt(hDestDC, dest_x, dest_y, width, height, hSrcDC, + src_x, src_y, SRCCOPY) == 0) + { + xlockmore_set_debug("XCopyArea: BitBlt() failed"); + } + + /* clean up */ + if (hOldBitmapS) + SelectObject(hSrcDC, hOldBitmapS); + if (hOldBitmapD) + SelectObject(hSrcDC, hOldBitmapD); + if (src > 0 && src <= numBMInfo) + DeleteDC(hSrcDC); + else + ReleaseDC((HWND)src, hSrcDC); + return Success; +} + +/*- + * XCopyColormapAndFree + * not currently used, returns 0 + */ +Colormap XCopyColormapAndFree(Display *display, Colormap colormap) +{ + return 0; +} + +/*- + * XCopyPlane + * to be implemented + */ +int XCopyPlane(Display *display, Drawable src, Drawable dest, GC gc, + int src_x, int src_y, unsigned width, int height, + int dest_x, int dest_y, unsigned long plane) +{ + return 0; +} + +/*- + * XCreateBitmapFromData + * used to create a bitmap + */ +Pixmap XCreateBitmapFromData(Display *display, Drawable drawable, + char *data, unsigned int width, + unsigned int height) +{ + XImage image; + HBITMAP hBitmap; + HPALETTE hPalette; + Pixmap pm; + + pm = BMInfoCreate(); + if (pm < 0 || pm >= NUMBER_BITMAP) + return None; + + image.width = width; + image.height = height; + image.data = data; + + LCreateBitmap(&image, &hBitmap, &hPalette); + DeleteObject(hPalette); /* we don't need the palette */ + + if (hBitmap == NULL) + { + bmInfo[pm].isActive = FALSE; + return None; + } + + bmInfo[pm].bitmap = hBitmap; + bmInfo[pm].type = 1; + bmInfo[pm].width = width; + bmInfo[pm].height = height; + return pm; +} + +/*- + * XCreateColormap + * used to create the colormap + */ +Colormap XCreateColormap(Display *display, Window w, + Visual *visual, int alloc) +{ + return None; +} + +/*- + * XCreateFontCursor + * not currently used, returns 0 + */ +Cursor XCreateFontCursor(Display *display, unsigned int shape) +{ + return 0; +} + +/*- + * XCreateGC + * creates a copy of the GC + */ +GC XCreateGC(Display *display, Drawable drawable, + unsigned long valuemask, XGCValues *values) +{ + GC newGc; + char message[80]; + + if ((newGc = GCCreate()) == -1) + { + sprintf(message, "Failed to create a GC"); + xlockmore_set_debug(message); + } + else + { + /* check if drawable is a bitmap, and adjust the 1 and 0 colors + (white and black) to their proper win32 values */ + if (drawable > 0 && drawable < NUMBER_BITMAP) + if (bmInfo[drawable].isActive == TRUE && bmInfo[drawable].type == 1) + { + if (valuemask & GCBackground) + if (values->background == 0 || values->background == 1) + values->background = 256 + values->background; + if (valuemask & GCForeground) + if (values->foreground == 0 || values->foreground == 1) + values->foreground = 256 + values->foreground; + } + XChangeGC(display, newGc, valuemask, values); + } + + return newGc; +} + +/*- + * XCreateImage + * creates an XImage structure and populates it + */ +XImage *XCreateImage(Display *display, Visual *visual, + unsigned int depth, int format, int offset, + char *data, unsigned int width, + unsigned int height, int bitmap_pad, + int bytes_per_line) +{ + XImage *newImage; + + if ((newImage = malloc(sizeof(XImage))) == NULL) + return NULL; + + memset(newImage, 0, sizeof(XImage)); + + newImage->width = width; + newImage->height = height; + newImage->xoffset = offset; + newImage->format = format; + newImage->data = data; + newImage->bitmap_pad = bitmap_pad; + newImage->depth = depth; + newImage->bytes_per_line = (bytes_per_line != 0) ? bytes_per_line : (width + 7) / 8; + + return newImage; +} + +/*- + * XCreatePixmap + * creates a pixmap + */ +Pixmap XCreatePixmap(Display *display, Drawable d, unsigned int width, + unsigned int height, unsigned int depth) +{ + Pixmap pm; + HBITMAP hBitmap; + + pm = BMInfoCreate(); + if (pm < 0 || pm >= NUMBER_BITMAP) + return None; + + /* create the bitmap */ + if ((hBitmap = + (depth == 1) ? CreateBitmap(width, height, depth, 1, NULL) : + CreateCompatibleBitmap(hdc, width, height)) == NULL) + { + bmInfo[pm].isActive = FALSE; + return None; + } + + bmInfo[pm].bitmap = hBitmap; + bmInfo[pm].type = depth; + bmInfo[pm].width = width; + bmInfo[pm].height = height; + + return pm; +} + +/*- + * XCreatePixmapCursor + * not currently used, returns 0 + */ +Cursor XCreatePixmapCursor(Display *display, + Pixmap source, Pixmap mask, + XColor *foreground_color, XColor *background_color, + unsigned int x_hot, unsigned int y_hot) +{ + return None; +} + +/*- + * XCreatePixmapFromBitmapData + * Creates a pixmap from bitmap data + */ +Pixmap XCreatePixmapFromBitmapData(Display *display, Drawable drawable, + char *data, unsigned int width, unsigned int height, + unsigned long fg, unsigned long bg, unsigned int depth) +{ + HDC hBitmapDC; + HBITMAP hOldBitmap; + Pixmap pm; + RGBQUAD rgbQuad[2] = { 0 }; + + /* create the bitmap */ + if ((pm = XCreateBitmapFromData(display, drawable, data, width, height)) == None) + { + return None; + } + + /* if depth is 1 create the bitmap using black and white */ + if (depth == 1) + { + fg = 257; + bg = 256; + } + + /* set the correct colors in the color table */ + rgbQuad[0].rgbRed = red[fg]; + rgbQuad[0].rgbGreen = green[fg]; + rgbQuad[0].rgbBlue = blue[fg]; + rgbQuad[0].rgbReserved = 0; + rgbQuad[1].rgbRed = red[bg]; + rgbQuad[1].rgbGreen = green[bg]; + rgbQuad[1].rgbBlue = blue[bg]; + rgbQuad[1].rgbReserved = 0; + + /* create a DC so we can set the bitmaps colortable */ + hBitmapDC = CreateCompatibleDC(hdc); + hOldBitmap = SelectObject(hBitmapDC, DrawableGetBitmap(pm)); + + /* set the colortable */ + SetDIBColorTable(hBitmapDC, 0, 2, rgbQuad); + + /* clean up */ + SelectObject(hBitmapDC, hOldBitmap); + DeleteDC(hBitmapDC); + + return pm; +} + +/* + * XDefineCursor + * not currently used + */ +void XDefineCursor(Display *display, Window window, Cursor cursor) +{ +} + +/*- + * XDestroyImage + * not currently used + */ +void XDestroyImage(XImage *ximage) +{ +} + +/*- + * XDisableAccessControl + * not currently used + */ +void XDisableAccessControl(Display *display) +{ +} + +/*- + * XDrawArc + * draws an arc + */ +void XDrawArc(Display *display, Drawable d, GC gc, int x, int y, + unsigned int width, unsigned int height, + int angle1, int angle2) +{ + int xa1, ya1; + int xa2, ya2; + int cx, cy; + double a1, a2; + double rx, ry; + double ang_inc = M_PI * 2.0 / 23040.0; + HDC dc; + HBITMAP hOldBitmap = NULL; + + rx = width/2.0; + ry = height/2.0; + cx = x + width/2; + cy = y + height/2; + + a1 = (23040 - (angle1 % 23040)) * ang_inc; + + xa1 = (int)((rx * cos(a1)) + cx); + ya1 = (int)((ry * sin(a1)) + cy); + + if (angle2 == 0) { + /* Special case - In X this is a point but Arc in Windows would + do a complete elipse! Draw a (thick) line instead. */ + + XDrawLine(display, d, gc, xa1, ya1, xa1, ya1); + + } else { + + a2 = (23040 - ((angle1 + angle2) % 23040)) * ang_inc; + + xa2 = (int)((rx * cos(a2)) + cx); + ya2 = (int)((ry * sin(a2)) + cy); + + if ((dc = GCGetDC(d, gc)) == NULL) + return; + + if (d > 0 && d < NUMBER_BITMAP) + if (bmInfo[d].isActive == TRUE) + hOldBitmap = SelectObject(dc, DrawableGetBitmap(d)); + + Arc(dc, x, y, x + width, y + height, xa1, ya1, xa2, ya2); + + if (hOldBitmap) + SelectObject(dc, hOldBitmap); + } +} + +/*- + * XDrawImageString + * not currently used + */ +void XDrawImageString(Display *display, Drawable d, GC gc, + int x, int y, char *string, int length) +{ +} + +/*- + * XDrawLine + * draws a line on the screen in the current pen color + */ +void XDrawLine(Display *display, Drawable d, GC gc, + int x1, int y1, int x2, int y2) +{ + HDC dc; + HBITMAP hOldBitmap = NULL; + + if ((dc = GCGetDC(d, gc)) == NULL) + return; + + if (d > 0 && d < NUMBER_BITMAP) + if (bmInfo[d].isActive == TRUE) + hOldBitmap = SelectObject(dc, DrawableGetBitmap(d)); + + MoveToEx(dc, x1, y1, NULL); + LineTo(dc, x2, y2); + + if (hOldBitmap) + SelectObject(dc, hOldBitmap); +} + +/*- + * XDrawLines + * draws a series of lines on the screen. Liness may be + * specified as being (1) relative to the origin, or + * (2) relative to the previous line (with the first line + * relative to the origin). + */ +void XDrawLines(Display *display, Drawable d, GC gc, + XPoint *points, int npoints, int mode) +{ + int i; + int tx, ty; + HDC dc; + HBITMAP hOldBitmap = NULL; + POINT *lppt; + BYTE *lpbTypes; + + if ((dc = GCGetDC(d, gc)) == NULL) + return; + + if (d > 0 && d < NUMBER_BITMAP) + if (bmInfo[d].isActive == TRUE) + hOldBitmap = SelectObject(dc, DrawableGetBitmap(d)); + + if (npoints > 1) { + lppt = (POINT*)malloc(npoints * sizeof(POINT)); + lpbTypes = (BYTE*)malloc(npoints * sizeof(BYTE)); + + lpbTypes[0] = PT_MOVETO; + lppt[0].x = points[0].x; + lppt[0].y = points[0].y; + + if (mode == CoordModeOrigin) { + for (i=1; i<npoints; i++) { + lpbTypes[i] = PT_LINETO; + lppt[i].x = points[i].x; + lppt[i].y = points[i].y; + } + } else if (mode == CoordModePrevious) { + tx = points[0].x; + ty = points[0].y; + for (i=1; i<npoints; i++) { + tx += points[i].x; + ty += points[i].y; + lpbTypes[i] = PT_LINETO; + lppt[i].x = tx; + lppt[i].y = ty; + } + } + PolyDraw(dc, lppt, lpbTypes, npoints); + free(lppt); + free(lpbTypes); + } + + if (hOldBitmap) + SelectObject(dc, hOldBitmap); +} + +/*- + * XDrawPoint + * draws a point on the screen + */ +void XDrawPoint(Display *display, Drawable d, GC gc, int x, int y) +{ + HDC dc; + HBITMAP hOldBitmap = NULL; + + if ((dc = GCGetDC(d, gc)) == NULL) + return; + + if (d > 0 && d < NUMBER_BITMAP) + if (bmInfo[d].isActive == TRUE) + hOldBitmap = SelectObject(dc, DrawableGetBitmap(d)); + + SetPixelV(dc, x, y, RGB(cred, cgreen, cblue)); + + if (hOldBitmap) + SelectObject(dc, hOldBitmap); +} + +/*- + * XDrawPoints + * draws a series of points on the screen. Points may be + * specified as being (1) relative to the origin, or + * (2) relative to the previous point (with the first point + * relative to the origin). + */ +void XDrawPoints(Display *display, Drawable d, GC gc, + XPoint *pts, int numpts, int mode) +{ + int i; + int tx, ty; + HDC dc; + HBITMAP hOldBitmap = NULL; + + if ((dc = GCGetDC(d, gc)) == NULL) + return; + + if (d > 0 && d < NUMBER_BITMAP) + if (bmInfo[d].isActive == TRUE) + hOldBitmap = SelectObject(dc, DrawableGetBitmap(d)); + + if (mode == CoordModeOrigin) + { + for (i=0; i<numpts; i++) + { + SetPixelV(dc, pts[i].x, pts[i].y, RGB(cred, cgreen, cblue)); + } + } + else if (mode == CoordModePrevious) + { + if (numpts > 0) + { + tx = pts[0].x; + ty = pts[0].y; + SetPixelV(dc, tx, ty, RGB(cred, cgreen, cblue)); + for (i=1; i<numpts; i++) + { + tx += pts[i].x; + ty += pts[i].y; + SetPixelV(dc, tx, ty, RGB(cred, cgreen, cblue)); + } + } + } + + if (hOldBitmap) + SelectObject(dc, hOldBitmap); +} + +/*- + * XDrawRectangle + * Draws an outline of a rectangle. + * Uses PolyDraw as Rectangle fills rectangle with brush + */ +void XDrawRectangle(Display *display, Drawable d, GC gc, int x, int y, + unsigned int width, unsigned int height) +{ + BYTE lpbTypes[6]; + POINT lppt[6]; + HDC dc; + HBITMAP hOldBitmap = NULL; + + if ((dc = GCGetDC(d, gc)) == NULL) + return; + + if (d > 0 && d < NUMBER_BITMAP) + if (bmInfo[d].isActive == TRUE) + hOldBitmap = SelectObject(dc, DrawableGetBitmap(d)); + + lpbTypes[0] = PT_MOVETO; + lppt[0].x = x, lppt[0].y = y; + lpbTypes[1] = PT_LINETO; + lppt[1].x = x + width, lppt[1].y = y; + lpbTypes[2] = PT_LINETO; + lppt[2].x = x + width, lppt[2].y = y + height; + lpbTypes[3] = PT_LINETO; + lppt[3].x = x, lppt[3].y = y + height; + lpbTypes[4] = PT_LINETO; + lppt[4].x = x, lppt[4].y = y; + /* overkill but need better closure */ + lpbTypes[5] = PT_LINETO; + lppt[5].x = x + width, lppt[5].y = y; + PolyDraw(dc, lppt, lpbTypes, 6); + + if (hOldBitmap) + SelectObject(dc, hOldBitmap); +} + +/*- + * XDrawSegments + * draws multiple disjoint lines. Lines do not have to be + * connected as each segment is one line. + */ +void XDrawSegments(Display *display, Drawable d, GC gc, + XSegment *segs, int numsegs) +{ + int i; + HDC dc; + HBITMAP hOldBitmap = NULL; + POINT *lppt; + BYTE *lpbTypes; + int cCount = 0; + + if ((dc = GCGetDC(d, gc)) == NULL) + return; + + if (d > 0 && d < NUMBER_BITMAP) + if (bmInfo[d].isActive == TRUE) + hOldBitmap = SelectObject(dc, DrawableGetBitmap(d)); + + lppt = (POINT*)malloc(numsegs * 2 * sizeof(POINT)); + lpbTypes = (BYTE*)malloc(numsegs * 2 * sizeof(BYTE)); + + for (i=0; i<numsegs; i++) { + lpbTypes[cCount] = PT_MOVETO; + lppt[cCount].x = segs[i].x1; + lppt[cCount].y = segs[i].y1; + cCount++; + lpbTypes[cCount] = PT_LINETO; + lppt[cCount].x = segs[i].x2; + lppt[cCount].y = segs[i].y2; + cCount++; + } + + PolyDraw(dc, lppt, lpbTypes, cCount); + + free(lppt); + free(lpbTypes); + + if (hOldBitmap) + SelectObject(dc, hOldBitmap); +} + +/*- + * XDrawString + * Draws a string of characters at specified location + */ +void XDrawString(Display *display, Drawable d, GC gc, int x, int y, + char *string, int length) +{ + int prevMode; + HDC dc; + HBITMAP hOldBitmap = NULL; + + if ((dc = GCGetDC(d, gc)) == NULL) + return; + + if (d > 0 && d < NUMBER_BITMAP) + if (bmInfo[d].isActive == TRUE) + hOldBitmap = SelectObject(dc, DrawableGetBitmap(d)); + + prevMode = GetBkMode(dc); + SetBkMode(dc, TRANSPARENT); + TextOut(dc, x + 3, y - 15, string, length); + SetBkMode(dc, prevMode); + + if (hOldBitmap) + SelectObject(dc, hOldBitmap); +} + +/*- + * XEnableAccessControl + * not currently used + */ +void XEnableAccessControl(Display *display) +{ +} + +/*- + * XFillArc + * draws a filled arc on screen + */ +void XFillArc(Display *display, Drawable d, GC gc, int x, int y, + unsigned int width, unsigned int height, + int angle1, int angle2) +{ + int xa1, ya1; + int xa2, ya2; + int cx, cy; + double a1, a2; + double rx, ry; + double ang_inc = M_PI * 2.0 / 23040.0; + HPEN oldPen; + HDC dc; + HBITMAP hOldBitmap = NULL; + + /* set the size of the arc a little larger because + we won't be drawing a border around it */ + width++; + height++; + + rx = width/2.0; + ry = height/2.0; + cx = x + width/2; + cy = y + height/2; + + a1 = (23040 - (angle1 % 23040)) * ang_inc; + + xa1 = (int)((rx * cos(a1)) + cx); + ya1 = (int)((ry * sin(a1)) + cy); + + if (angle2 == 0) { + /* Special case - In X this is a point but Arc in Windows would + do a complete elipse! Draw a (thick) line instead. */ + + XDrawLine(display, d, gc, cx, cy, xa1, ya1); + + } else { + if ((dc = GCGetDC(d, gc)) == NULL) + return; + + if (d > 0 && d < NUMBER_BITMAP) + if (bmInfo[d].isActive == TRUE) + hOldBitmap = SelectObject(dc, DrawableGetBitmap(d)); + + a2 = (23040 - ((angle1 + angle2) % 23040)) * ang_inc; + + xa2 = (int)((rx * cos(a2)) + cx); + ya2 = (int)((ry * sin(a2)) + cy); + + /* set the pen draw width to 1, and because its null it won't + use it, hence the reason we made the arc larger before */ + if (noPen == NULL) + if ((noPen = CreatePen(PS_NULL, 0, RGB(0,0,0))) == NULL) + { + xlockmore_set_debug("Failed to create pen"); + return; + } + oldPen = SelectObject(dc, noPen); + + /* should check for a pie or chord filled arc type, but + currently assuming pie filled arc */ + Pie(dc, x, y, x + width, y + height, xa1, ya1, xa2, ya2); + + /* reset back and clean up */ + SelectObject(dc, oldPen); + if (hOldBitmap) + SelectObject(dc, hOldBitmap); + } +} + +/*- + * XFillArcs + * draws a number of filled arcs on screen + */ +void XFillArcs(Display *display, Drawable d, GC gc, + XArc *arcs, int narcs) +{ + int i; + int xa1, ya1; + int xa2, ya2; + int cx, cy; + double a1, a2; + double rx, ry; + const double ang_inc = M_PI * 2.0 / 23040.0; + HDC dc; + HBITMAP hOldBitmap = NULL; + + if ((dc = GCGetDC(d, gc)) == NULL) + return; + + for (i=0; i<narcs; i++) { + rx = arcs[i].width/2.0; + ry = arcs[i].height/2.0; + cx = arcs[i].x + arcs[i].width/2; + cy = arcs[i].y + arcs[i].height/2; + + a1 = (23040 - (arcs[i].angle1 % 23040)) * ang_inc; + + xa1 = (int)((rx * cos(a1)) + cx); + ya1 = (int)((ry * sin(a1)) + cy); + + if (arcs[i].angle2 == 0) { + /* Special case - In X this is a point but Arc in Windows would + do a complete elipse! Draw a (thick) line instead. */ + + XDrawLine(display, d, gc, cx, cy, xa1, ya1); + + } else { + + if (d > 0 && d < NUMBER_BITMAP) + if (bmInfo[d].isActive == TRUE) + hOldBitmap = SelectObject(dc, DrawableGetBitmap(d)); + + a2 = (23040 - ((arcs[i].angle1 + arcs[i].angle2) % 23040)) * ang_inc; + xa2 = (int)((rx * cos(a2)) + cx); + ya2 = (int)((ry * sin(a2)) + cy); + + /* should check for a pie or chord filled arc type, but + currently assuming pie filled arc */ + Pie(dc, arcs[i].x, arcs[i].y, arcs[i].x + arcs[i].width, + arcs[i].y + arcs[i].height, xa1, ya1, xa2, ya2); + + if (hOldBitmap) + SelectObject(dc, hOldBitmap); + } + } +} + + +/*- + * XFillPolygon + * draws a filled polygon on screen. Points can be specified as + * being relative to the origin, or relative to the previous + * point (with the first point relative to the origin) + */ +void XFillPolygon(Display *display, Drawable d, GC gc, XPoint *points, + int npoints, int shape, int mode) +{ + int i; + int tx, ty; + POINT *pts; + HDC dc; + HBITMAP hOldBitmap = NULL; + + if ((dc = GCGetDC(d, gc)) == NULL) + return; + + if (npoints <= 0) + return; + + if (d > 0 && d < NUMBER_BITMAP) + if (bmInfo[d].isActive == TRUE) + hOldBitmap = SelectObject(dc, DrawableGetBitmap(d)); + + /* allocate memory */ + pts = calloc(npoints, sizeof(POINT)); + + if (mode == CoordModeOrigin) { + for (i=0; i<npoints; i++) { + pts[i].x = points[i].x; + pts[i].y = points[i].y; + } + } + else if (mode == CoordModePrevious) { + tx = pts[0].x = points[0].x; + ty = pts[0].y = points[0].y; + for (i=1; i<npoints; i++){ + tx += points[i].x; + ty += points[i].y; + pts[i].x = tx; + pts[i].y = ty; + } + } + + Polygon(dc, pts, npoints); + + /* free memory */ + free(pts); + + if (hOldBitmap) + SelectObject(dc, hOldBitmap); +} + +/*- + * XFillRectangle + * draws a filled rectangle on screen + */ +void XFillRectangle(Display *display, Drawable d, GC gc, int x, int y, + unsigned int width, unsigned int height) +{ + HPEN oldPen; + HDC dc; + HBITMAP hOldBitmap = NULL; + + if ((dc = GCGetDC(d, gc)) == NULL) + return; + + if (d > 0 && d < NUMBER_BITMAP) + if (bmInfo[d].isActive == TRUE) + hOldBitmap = SelectObject(dc, DrawableGetBitmap(d)); + + /* check if we are doing a FillStippled fill or a normal rectangle */ + if (gcInfo[gc].fillStyle.hasFillStyle == TRUE && + gcInfo[gc].fillStyle.value == FillStippled) + { + HBITMAP hOldBitmapS = NULL; + HBITMAP hStipple = NULL; + HDC hStippleDC; + int i, j; + RGBQUAD rgbQuad = { cblue, cgreen, cred, 0 }; + int sHeight; + int sWidth; + + /* FillStippled fill */ + if ((hStipple = DrawableGetBitmap(gcInfo[gc].stipple.graphic)) == NULL) + { + xlockmore_set_debug("XFillRectangle: Failed to get stipple"); + if (hOldBitmap) + SelectObject(dc, hOldBitmap); + return; + } + sWidth = bmInfo[gcInfo[gc].stipple.graphic].width; + sHeight = bmInfo[gcInfo[gc].stipple.graphic].height; + if ((hStippleDC = CreateCompatibleDC(hdc)) == NULL) + { + xlockmore_set_debug("XFillRectangle: Failed to create stipple DC"); + if (hOldBitmap) + SelectObject(dc, hOldBitmap); + return; + } + hOldBitmapS = SelectObject(hStippleDC, hStipple); + + /* set the correct color table */ + SetDIBColorTable(hStippleDC, 0, 1, &rgbQuad); + + for (i=y; i<y+height; i+=sHeight) + for (j=x; j<x+width; j+=sWidth) + if (MaskBlt(dc, j, i, sWidth, sHeight, hStippleDC, 0, 0, hStipple, 0, 0, + MAKEROP4(0x00AA0029, SRCCOPY)) == 0) + xlockmore_set_debug("XFillRectangle: MaskBlt() failed"); + + /* clean up */ + if (hOldBitmapS) + SelectObject(hStippleDC, hOldBitmapS); + DeleteDC(hStippleDC); + } + else + { + /* normal rectangle */ + if (width == 1 && height == 1) + { + SetPixelV(dc, x, y, RGB(cred, cgreen, cblue)); + } + else + { + if (noPen == NULL) + if ((noPen = CreatePen(PS_NULL, 0, RGB(0,0,0))) == NULL) + { + xlockmore_set_debug("XFillRectangle: Failed to create pen"); + if (hOldBitmap) + SelectObject(dc, hOldBitmap); + return; + } + + oldPen = SelectObject(dc, noPen); + Rectangle(dc, x, y, x + width + 1, y + height + 1); + SelectObject(dc, oldPen); + } + } + + if (hOldBitmap) + SelectObject(dc, hOldBitmap); +} + +/*- + * XFillRectangles + * draws a number of filled rectangles on screen + */ +void XFillRectangles(Display *display, Drawable d, GC gc, + XRectangle *rectangles, int nrectangles) +{ + int i; + + for (i=0; i<nrectangles; i++) { + XFillRectangle(display, d, gc, rectangles[i].x, rectangles[i].y, + rectangles[i].width, rectangles[i].height); + } +} + +/*- + * XFlush + * not currently used + */ +void XFlush(Display *display) +{ +} + +/*- + * XFree + * not currently used + */ +void XFree(void *data) +{ +} + +/*- + * XFreeColormap + * not currently used + */ +void XFreeColormap(Display *display, Colormap colormap) +{ +} + +/*- + * XFreeColors + * not currently used + */ +void XFreeColors(Display *display, Colormap colormap, + unsigned long pixels[], int npixels, + unsigned long planes) +{ +} + +/*- + * XFreeCursor + * not currently used + */ +void XFreeCursor(Display *display, Cursor cursor) +{ +} + +/*- + * XFreeFont + * not currently used + */ +int XFreeFont(Display *display, XFontStruct *font_struct) +{ + return 0; +} + +/*- + * XFreeFontInfo + * not currently used + */ +int XFreeFontInfo(char** names, XFontStruct* free_info, int actual_count) +{ + return 0; +} + +/*- + * XFreeGC + * Free the memory for a GC (HDC) + */ +void XFreeGC(Display *display, GC gc) +{ + if (gc >= 0 && gc < numGCInfo && gcInfo[gc].isActive == TRUE) + gcInfo[gc].isActive = FALSE; +} + +/*- + * XFreePixmap + * Free the memory allocated to a pixmap + */ +void XFreePixmap(Display *display, Pixmap pixmap) +{ + if (pixmap < 0 || pixmap >= NUMBER_BITMAP) + return; + + if (bmInfo[pixmap].isActive == FALSE) + return; + + if (bmInfo[pixmap].bitmap != NULL) + { + DeleteObject(bmInfo[pixmap].bitmap); + bmInfo[pixmap].isActive = FALSE; + bmInfo[pixmap].bitmap = NULL; + bmInfo[pixmap].width = 0; + bmInfo[pixmap].height = 0; + } +} + +/*- + * XGetGCValues + * not currently used + */ +Status XGetGCValues(Display* display, GC gc, + unsigned long valuemask, XGCValues* values_return) +{ + return None; +} + +/*- + * XGContextFromGC + * not currently used + */ +GContext XGContextFromGC(GC gc) +{ + return None; +} +/*- + * XGetVisualInfo + * not currently used + */ +XVisualInfo *XGetVisualInfo(Display *display, long vinfo_mask, + XVisualInfo *vinfo_template, + int *nitems_return) +{ + return NULL; +} + +/*- + * XGetWindowAttributes + * retrieves info about the window + */ +Status XGetWindowAttributes(Display *display, Window w, + XWindowAttributes *window_attr_return) +{ + memset(window_attr_return, 0, sizeof(XWindowAttributes)); + + window_attr_return->width = rc.right; + window_attr_return->height = rc.bottom; + window_attr_return->depth = 8; /* incorrect, but we'll set it to 8 */ + window_attr_return->root = (int)hwnd; + + return 0; +} + +/*- + * XGrabKeyboard + * not currently used + */ +int XGrabKeyboard(Display *display, Window grab_window, + Bool owner_events, int pointer_mode, + int keyboard_mode, Time time) +{ + return 0; +} + +/*- + * XGrabPointer + * not currently used + */ +int XGrabPointer(Display *display, Window grab_window, Bool owner_events, + unsigned int event_mask, int pointer_mode, + int keyboard_mode, Window confine_to, Cursor cursor, + Time time) +{ + return 0; +} + +/*- + * XGrabServer + * not currently used + */ +void XGrabServer(Display *display) +{ +} + +/*- + * XInstallColormap + * not currently used + */ +void XInstallColormap(Display *display, Colormap colormap) +{ +} + +/*- + * XListHosts + * not currently used, returns NULL + */ +XHostAddress *XListHosts(Display *display, int *nhosts_return, + Bool *state_return) +{ + return NULL; +} + +/*- + * XLoadQueryFont + * not currently used + */ +XFontStruct *XLoadQueryFont(Display *display, char *name) +{ + static XFontStruct fontStruct = { 0 }; + return &fontStruct; +} + +/*- + * XLookupString + * not currently used + */ +int XLookupString(XKeyEvent *event_struct, char *buffer_return, + int bytes_buffer, KeySym *keysym_return, + XComposeStatus *status_in_out) +{ + return 0; +} + +/*- + * XMapWindow + * not currently used + */ +void XMapWindow(Display *display, Window w) +{ +} + +/*- + * XNextEvent + * not currently used + */ +void XNextEvent(Display *display, XEvent *event_return) +{ +} + +/*- + * XOpenDisplay + * not currently used + */ +Display *XOpenDisplay(char *display_name) +{ + return NULL; +} + +/*- + * XParseColor + * not currently used + */ +Status XParseColor(Display *display, Colormap colormap, + char *spec, XColor *exact_def_return) +{ + return 0; +} + +/*- + * XPending + * not currently used, return 0 + */ +int XPending(Display *display) +{ + return 0; +} + +/*- + * XPutBackEvent + * not currently used + */ +void XPutBackEvent(Display *display, XEvent *event) +{ +} + +/*- + * XPutImage + * Draw an image in screen + */ +void XPutImage(Display *display, Drawable d, GC gc, XImage *image, int src_x, + int src_y, int dest_x, int dest_y, unsigned int width, + unsigned int height) +{ + HDC hBitmapDC; + HBITMAP hOldBitmap; + HBITMAP hBitmap; + HPALETTE hPalette; + RGBQUAD rgbQuad = { 0, 0, 0, 0 }; + HDC dc; + + if ((dc = GCGetDC(d, gc)) == NULL) + return; + + /* set the color table for the bitmap */ + rgbQuad.rgbRed = cred; + rgbQuad.rgbGreen = cgreen; + rgbQuad.rgbBlue = cblue; + + if (image->format == XYBitmap) + { + if (image->depth != 1) + return; + + if ((hBitmapDC = CreateCompatibleDC(dc)) == NULL) + return; + + LCreateBitmap(image, &hBitmap, &hPalette); + DeleteObject(hPalette); /* we don't need the palette */ + if (hBitmap == NULL) + { + DeleteObject(hBitmap); + DeleteDC(hBitmapDC); + return; + } + + if ((hOldBitmap = (HBITMAP)SelectObject(hBitmapDC, hBitmap)) == NULL) + { + DeleteObject(hBitmap); + DeleteDC(hBitmapDC); + return; + } + + /* set the correct color table */ + SetDIBColorTable(hBitmapDC, 0, 1, &rgbQuad); + + BitBlt(dc, dest_x, dest_y, width, height, hBitmapDC, + src_x, src_y, SRCCOPY); + + SelectObject(hBitmapDC, hOldBitmap); + DeleteObject(hBitmap); + DeleteDC(hBitmapDC); + } +} + +/*- + * XPutPixel + * Set a pixels color value on an image + * + * NOTE: I'm not sure what this function returns. The header files + * under cygwin says it should return int, but some references out + * on the web indicate void. I've used int, and it returns 0 if + * it fails, otherwise 1 + */ +int XPutPixel(XImage *ximage, int x, int y, unsigned long pixel) +{ + int pos = 0; + unsigned long val = 0; + + /* check ximage points to an image */ + if (ximage == NULL) + { + return 0; + } + + /* check x & y are within range */ + if ((x < 0 || x > ximage->width - 1) || + (y < 0 || y > ximage->height - 1)) + { + return 0; + } + + /* only support images of bit depth 1 or > 8 */ + if (ximage->depth == 1) + { + int byte_pos = 0; + int oldval = 0; + int i = 0; + + pos = (ximage->bytes_per_line * y) + (x / 8); + byte_pos = x % 8; + oldval = ximage->data[pos]; + for (i=0; i<8; i++) + { + val <<= 1; + val = (val & 0xFE) + ((byte_pos != i) ? oldval >> i : pixel) & 0x01; + } + } + else + { + pos = (ximage->width * y) + x; + val = pixel; + } + + ximage->data[pos] = val; + + return 1; +} + +/*- + * XQueryColor + * not currently used + */ +void XQueryColor(Display *display, Colormap colormap, XColor *def_in_out) +{ +} + +/*- + * XQueryFont + * not currently used + */ +XFontStruct *XQueryFont(Display* display, XID font_ID) +{ + static XFontStruct dummy; + return &dummy; +} + +/*- + * XQueryPointer + * not currently used + */ +Bool XQueryPointer(Display *display, Window w, Window *root_return, + Window *child_return, int *root_x_return, int *root_y_return, + int *win_x_return, int *win_y_return, + unsigned int *mask_return) +{ + return FALSE; +} + +/*- + * XQueryTree + * not currently used + */ +Status XQueryTree(Display *display, Window w, Window *root_return, + Window *parent_return, Window **children_return, + unsigned int *nchildren_return) +{ + return 0; +} + +/*- + * XRaiseWindow + * not currently used + */ +void XRaiseWindow(Display *display, Window w) +{ +} + +/*- + * XReadBitmapFile + * not currently used + */ +int XReadBitmapFile(Display *display, Drawable d, char *filename, + unsigned int *width_return, unsigned int *height_return, + Pixmap *bitmap_return, int *x_hot_return, int *y_hot_return) +{ + char *data; + unsigned int height; + int rv; + unsigned int width; + + /* TODO: implement me */ + return BitmapOpenFailed; + + /* read the file into data structure */ + + /* create the bitmap */ + if ((*bitmap_return = XCreateBitmapFromData(display, d, data, width, height)) != None) + { + *width_return = width; + *height_return = height; + /* TODO:: hot spot */ + *x_hot_return = -1; + *y_hot_return = -1; + rv = BitmapSuccess; + } + else + rv = BitmapFileInvalid; + + return rv; +} + +/*- + * XRemoveHosts + * not currently used + */ +void XRemoveHosts(Display *display, XHostAddress *hosts, int num_hosts) +{ +} + +/*- + * XResourceManagerString + * not currently used, return NULL + */ +char *XResourceManagerString(Display *display) +{ + return NULL; +} + +/*- + * XrmDestroyDatabase + * not currently used + */ +void XrmDestroyDatabase(XrmDatabase database) +{ +} + +/*- + * XrmGetFileDatabase + * not currently used, return NULL + */ +XrmDatabase XrmGetFileDatabase(char *filename) +{ + return NULL; +} + +/*- + * XrmGetResource + * not currently used, return True + */ +Bool XrmGetResource(XrmDatabase database, char *str_name, + char *str_class, char **str_type_return, + XrmValue *value_return) +{ + return True; +} + +/*- + * XrmGetFileDatabase + * not currently used, return NULL + */ +XrmDatabase XrmGetStringDatabase(char *data) +{ + return NULL; +} + +/*- + * XrmInitialize + * not currently used + */ +void XrmInitialize(void) +{ +} + +/*- + * XrmMergeDatabases + * not currently used + */ +void XrmMergeDatabases(XrmDatabase source_db, XrmDatabase *target_db) +{ +} + +/*- + * XrmParseCommand + * not currently used + */ +void XrmParseCommand(XrmDatabase *database, XrmOptionDescList table, + int table_count, char *name, int *argc_in_out, + char **argv_in_out) +{ +} + +/*- + * XSetBackground + * sets the background color of pens, shapes, etc + */ +void XSetBackground(Display *display, GC gc, unsigned long background) +{ + if (gc >= 0 && gc < numGCInfo && gcInfo[gc].isActive == TRUE) + { + gcInfo[gc].needsReset = TRUE; + /* check that the background is in range */ + if (background > (NUMCOLORS+1)) + gcInfo[gc].color.background = NUMCOLORS-1; + else + gcInfo[gc].color.background = background; + } +} + +/*- + * XSetFillRule + * sets the fill rule + */ +void XSetFillRule(Display *display, GC gc, int fill_rule) +{ + if (gc >= 0 && gc < numGCInfo && gcInfo[gc].isActive == TRUE) + { + gcInfo[gc].needsReset = TRUE; + gcInfo[gc].fillRule.hasFillRule = TRUE; + gcInfo[gc].fillRule.value = fill_rule; + } +} + +/*- + * XSetFillStyle + * sets the fill style + */ +void XSetFillStyle(Display *display, GC gc, int fill_style) +{ + if (gc >= 0 && gc < numGCInfo && gcInfo[gc].isActive == TRUE) + { + gcInfo[gc].needsReset = TRUE; + gcInfo[gc].fillStyle.hasFillStyle = TRUE; + gcInfo[gc].fillStyle.value = fill_style; + } +} + +/*- + * XSetFont + * sets the font to be used for text + */ +void XSetFont(Display *display, GC gc, Font font) +{ + if (gc >= 0 && gc < numGCInfo && gcInfo[gc].isActive == TRUE) + { + gcInfo[gc].needsReset = TRUE; + gcInfo[gc].font.hasFont = TRUE; + gcInfo[gc].font.value = font; + } +} + +/*- + * XSetForeground + * sets the color of the current color, forground pen and + * brush + */ +void XSetForeground(Display *display, GC gc, unsigned long foreground) +{ + if (gc >= 0 && gc < numGCInfo && gcInfo[gc].isActive == TRUE) + { + gcInfo[gc].needsReset = TRUE; + /* check that the foreground is in range */ + if (foreground > (NUMCOLORS+1)) + gcInfo[gc].color.foreground = NUMCOLORS-1; + else + gcInfo[gc].color.foreground = foreground; + } +} + +/*- + * XSetFunction + * sets the logical operation applied between source pixel + * and destination pixel + * Not fully implemented yet. + */ + +void XSetFunction(Display *display, GC gc, int function) +{ + if (gc >= 0 && gc < numGCInfo && gcInfo[gc].isActive == TRUE) + { + gcInfo[gc].needsReset = TRUE; + gcInfo[gc].function.hasFunction = TRUE; + gcInfo[gc].function.value = function; + } +} + +/*- + * XSetGraphicsExposures + * Not implemented yet. + */ + +int XSetGraphicsExposures(Display *display, GC gc, Bool graphics_exposures) +{ + return 0; +} + +/*- + * XSetLineAttributes + * creates a new pen that has the attributes given + */ +void XSetLineAttributes(Display *display, GC gc, + unsigned int line_width, int line_style, + int cap_style, int join_style) +{ + if (gc >= 0 && gc < numGCInfo && gcInfo[gc].isActive == TRUE) + { + gcInfo[gc].needsReset = TRUE; + gcInfo[gc].lineAttributes.hasLineAttributes = TRUE; + gcInfo[gc].lineAttributes.width = line_width; + gcInfo[gc].lineAttributes.lineStyle = line_style; + gcInfo[gc].lineAttributes.capStyle = cap_style; + gcInfo[gc].lineAttributes.joinStyle = join_style; + } +} + +/*- + * XSetScreenSaver + * not currently used + */ +void XSetScreenSaver(Display *display, int timeout, int interval, + int prefer_blanking, int allow_exposures) +{ +} + +/*- + * XSetStipple + * Set the stipple for filled objects + */ +void XSetStipple(Display *display, GC gc, Pixmap stipple) +{ + if (gc >= 0 && gc < numGCInfo && gcInfo[gc].isActive == TRUE) + { + gcInfo[gc].needsReset = TRUE; + gcInfo[gc].stipple.hasStipple = TRUE; + gcInfo[gc].stipple.graphic = stipple; + } +} + +/*- + * XSetTSOrigin + * Set the tile or stipple origin + */ +void XSetTSOrigin(Display *display, GC gc, int ts_x_origin, int ts_y_origin) +{ + if (gc >= 0 && gc < numGCInfo && gcInfo[gc].isActive == TRUE) + { + gcInfo[gc].needsReset = TRUE; + gcInfo[gc].tsorigin.hasOrigin = TRUE; + gcInfo[gc].tsorigin.x = ts_x_origin; + gcInfo[gc].tsorigin.y = ts_y_origin; + } +} + +/*- + * XSetWindowColormap + * not currently used + */ +void XSetWindowColormap(Display *display, Window w, Colormap colormap) +{ +} + +/*- + * XSetWMName + * not currently used + */ +void XSetWMName(Display *display, Window w, XTextProperty *text_prop) +{ +} + +/*- + * XStoreColors + * not currently used + */ +void XStoreColors(Display *display, Colormap colormap, XColor color[], + int ncolors) +{ +} + +/*- + * XStringListToTextProperty + * not currently used + */ +Status XStringListToTextProperty(char **list, int count, + XTextProperty *text_prop_return) +{ + return 0; +} + +/*- + * XSync + * not currently used + */ +void XSync(Display *display, Bool discard) +{ +} + +/*- + * XTextWidth + * not currently used, returns 0 + */ +int XTextWidth(XFontStruct *font_struct, char *string, int count) +{ + return 0; +} + +/*- + * XTranslateCoordinates + * Simple implementation ignores source and destination and just + * reports position of global hdc relative to the screen. + */ +Bool XTranslateCoordinates(Display* display, Window src_w, Window dest_w, + int src_x, int src_y, + int* dest_x_return, int* dest_y_return, + Window* child_return) +{ + POINT p; + /* use global hdc */ + if (GetDCOrgEx(hdc, &p)) { + *dest_x_return = p.x + src_x; + *dest_y_return = p.y + src_y; + + } else { + *dest_x_return = src_x; + *dest_y_return = src_y; + } + *child_return = None; + return 1; +} + +/*- + * XUngrabKeyboard + * not currently used + */ +void XUngrabKeyboard(Display *display, Time time) +{ +} + +/*- + * XUngrabPointer + * not currently used + */ +void XUngrabPointer(Display *display, Time time) +{ +} + +/*- + * XUngrabServer + * not currently used + */ +void XUngrabServer(Display *display) +{ +} + +/*- + * XUnmapWindow + * not currently used + */ +void XUnmapWindow(Display *display, Window w) +{ +} + +#endif /* WIN32 */ + +/* -------------------------------------------------------------------- */ diff --git a/app/xlockmore/win32/Xapi.h b/app/xlockmore/win32/Xapi.h new file mode 100644 index 000000000..ccf000f49 --- /dev/null +++ b/app/xlockmore/win32/Xapi.h @@ -0,0 +1,971 @@ +#ifndef __XLOCK_XAPI_H__ +#define __XLOCK_XAPI_H__ + +/*- + * @(#)Xapi.h 4.00 98/04/16 xlockmore + * + * Xapi.h - X API interface for WIN32 (windows 95/NT) platforms + * + * Copyright (c) 1998 by Petey Leinonen. + * + * See xlock.c for copying information. + * + * Revision History: + * + * 16-Apr-98: Initially written. Based off code written by myself for + * an older version of xlockmore for win95/NT + * + */ +#ifdef WIN32 +#define WIN32_LEAN_AND_MEAN + +/*- + * includes + */ + +#include <windows.h> + +extern HWND hwnd; /* window handle */ +extern HDC hdc; /* device context */ +extern int cred, cgreen, cblue; /* color reference of the pen */ +extern unsigned char *red, *green, *blue; /* holds a list of colors */ +extern int colorcount; /* number of colors used */ +unsigned int randommode; /* number of mode to index */ +extern RECT rc; /* coords of the screen */ + +/*- + * defines + */ + +/* -------------------------------------------------------------------- */ + +/***************************************************************** + * ERROR CODES + *****************************************************************/ + +#define Success 0 /* everything's okay */ +#define BadRequest 1 /* bad request code */ +#define BadValue 2 /* int parameter out of range */ +#define BadWindow 3 /* parameter not a Window */ +#define BadPixmap 4 /* parameter not a Pixmap */ +#define BadAtom 5 /* parameter not an Atom */ +#define BadCursor 6 /* parameter not a Cursor */ +#define BadFont 7 /* parameter not a Font */ +#define BadMatch 8 /* parameter mismatch */ +#define BadDrawable 9 /* parameter not a Pixmap or Window */ +#define BadAccess 10 /* depending on context: + - key/button already grabbed + - attempt to free an illegal + cmap entry + - attempt to store into a read-only + color map entry. + - attempt to modify the access control + list from other than the local host. + */ +#define BadAlloc 11 /* insufficient resources */ +#define BadColor 12 /* no such colormap */ +#define BadGC 13 /* parameter not a GC */ +#define BadIDChoice 14 /* choice not in range or already used */ +#define BadName 15 /* font or color name doesn't exist */ +#define BadLength 16 /* Request length incorrect */ +#define BadImplementation 17 /* server is defective */ + +/* window attributes */ +#define InputOutput 1 +#define InputOnly 2 + +#define IsUnmapped 0 +#define IsUnviewable 1 +#define IsViewable 2 + +/* redefined functions */ +#define XWhitePixelOfScreen WhitePixelOfScreen + +/* define False/True */ +#define False (0) +#define True (!False) + +#define None (0L) +#define CurrentTime (0L) + +#define DoRed (0x1) +#define DoGreen (0x2) +#define DoBlue (0x4) + +#define XYBitmap (0x01) +#define XYPixmap (0x02) +#define ZPixmap (0x04) + +#define LSBFirst (0x00) +#define MSBFirst (0x01) + +#define AllocNone (0x00) +#define AllocAll (0x01) + +#define BitmapSuccess (0) +#define BitmapOpenFailed (1) +#define BitmapFileInvalid (2) +#define BitmapNoMemory (3) + +#define StaticGray (0) +#define GrayScale (1) +#define StaticColor (2) +#define PseudoColor (3) +#define TrueColor (4) +#define DirectColor (5) + +/* Key masks. Used as modifiers to GrabButton and GrabKey, results of QueryPointer, + state in various key-, mouse-, and button-related events. */ +#define ShiftMask (1<<0) +#define LockMask (1<<1) +#define ControlMask (1<<2) +#define Mod1Mask (1<<3) +#define Mod2Mask (1<<4) +#define Mod3Mask (1<<5) +#define Mod4Mask (1<<6) +#define Mod5Mask (1<<7) + +/* button masks. Used in same manner as Key masks above. Not to be confused + with button names below. */ +#define Button1Mask (1<<8) +#define Button2Mask (1<<9) +#define Button3Mask (1<<10) +#define Button4Mask (1<<11) +#define Button5Mask (1<<12) + + + +#define VisualNoMask (0x0) +#define VisualIDMask (0x1) +#define VisualScreenMask (0x2) +#define VisualDepthMask (0x4) +#define VisualClassMask (0x8) +#define VisualRedMaskMask (0x10) +#define VisualGreenMaskMask (0x20) +#define VisualBlueMaskMask (0x40) +#define VisualColormapMaskMask (0x80) +#define VisualBitsPerRGBMask (0x100) +#define VisualAllMask (0x1FF) + +#define GrabModeSync (0) +#define GrabModeAsync (1) + +#define GrabSuccess (0) +#define AlreadyGrabbed (1) +#define GrabInvalidTime (2) +#define GrabNotViewable (3) +#define GrabFrozen (4) + +#define NoEventMask 0L +#define KeyPressMask (1L<<0) +#define KeyReleaseMask (1L<<1) +#define ButtonPressMask (1L<<2) +#define ButtonReleaseMask (1L<<3) +#define EnterWindowMask (1L<<4) +#define LeaveWindowMask (1L<<5) +#define PointerMotionMask (1L<<6) +#define PointerMotionHintMask (1L<<7) +#define Button1MotionMask (1L<<8) +#define Button2MotionMask (1L<<9) +#define Button3MotionMask (1L<<10) +#define Button4MotionMask (1L<<11) +#define Button5MotionMask (1L<<12) +#define ButtonMotionMask (1L<<13) +#define KeymapStateMask (1L<<14) +#define ExposureMask (1L<<15) +#define VisibilityChangeMask (1L<<16) +#define StructureNotifyMask (1L<<17) +#define ResizeRedirectMask (1L<<18) +#define SubstructureNotifyMask (1L<<19) +#define SubstructureRedirectMask (1L<<20) +#define FocusChangeMask (1L<<21) +#define PropertyChangeMask (1L<<22) +#define ColormapChangeMask (1L<<23) +#define OwnerGrabButtonMask (1L<<24) + +#define KeyPress 2 +#define KeyRelease 3 +#define ButtonPress 4 +#define ButtonRelease 5 +#define MotionNotify 6 +#define EnterNotify 7 +#define LeaveNotify 8 +#define FocusIn 9 +#define FocusOut 10 +#define KeymapNotify 11 +#define Expose 12 +#define GraphicsExpose 13 +#define NoExpose 14 +#define VisibilityNotify 15 +#define CreateNotify 16 +#define DestroyNotify 17 +#define UnmapNotify 18 +#define MapNotify 19 +#define MapRequest 20 +#define ReparentNotify 21 +#define ConfigureNotify 22 +#define ConfigureRequest 23 +#define GravityNotify 24 +#define ResizeRequest 25 +#define CirculateNotify 26 +#define CirculateRequest 27 +#define PropertyNotify 28 +#define SelectionClear 29 +#define SelectionRequest 30 +#define SelectionNotify 31 +#define ColormapNotify 32 +#define ClientMessage 33 +#define MappingNotify 34 +#define LASTEvent 35 + +#define VisibilityUnobscured (0) +#define VisibilityPartiallyObscured (1) +#define VisibilityFullyObscured (2) + +#define XC_left_ptr (68) + +#define Button1 (1) +#define Button2 (2) +#define Button3 (3) +#define Button4 (4) +#define Button5 (5) + +#define SIGHUP (0) +#define SIGQUIT (1) +#define SIGBUS (2) + +#define CoordModeOrigin (0) +#define CoordModePrevious (1) + +#define Complex (0) +#define Nonconvex (1) +#define Convex (2) + +#define LineSolid (0) +#define LineOnOffDash (1) +#define LineDoubleDash (2) + +#define CapNotLast (0) +#define CapButt (1) +#define CapRound (2) +#define CapProjecting (3) + +#define JoinMiter (0) +#define JoinRound (1) +#define JoinBevel (2) + + +#define GCFunction (1L<<0) +#define GCPlaneMask (1L<<1) +#define GCForeground (1L<<2) +#define GCBackground (1L<<3) +#define GCLineWidth (1L<<4) +#define GCLineStyle (1L<<5) +#define GCCapStyle (1L<<6) +#define GCJoinStyle (1L<<7) +#define GCFillStyle (1L<<8) +#define GCFillRule (1L<<9) +#define GCTile (1L<<10) +#define GCStipple (1L<<11) +#define GCTileStipXOrigin (1L<<12) +#define GCTileStipYOrigin (1L<<13) +#define GCFont (1L<<14) +#define GCSubwindowMode (1L<<15) +#define GCGraphicsExposures (1L<<16) +#define GCClipXOrigin (1L<<17) +#define GCClipYOrigin (1L<<18) +#define GCClipMask (1L<<19) +#define GCDashOffset (1L<<20) +#define GCDashList (1L<<21) +#define GCArcMode (1L<<22) + +#define FillSolid (0) +#define FillTiled (1) +#define FillStippled (2) +#define FillOpaqueStippled (3) + +#define GXclear (0x0) +#define GXand (0x1) +#define GXandReverse (0x2) +#define GXcopy (0x3) +#define GXandInverted (0x4) +#define GXnoop (0x5) +#define GXxor (0x6) +#define GXor (0x7) +#define GXnor (0x8) +#define GXequiv (0x9) +#define GXinvert (0xa) +#define GXorReverse (0xb) +#define GXcopyInverted (0xc) +#define GXorInverted (0xd) +#define GXnand (0xe) +#define GXset (0xf) + +/* fillRule */ +#define EvenOddRule 0 +#define WindingRule 1 + +/*- + * types + */ + +/* -------------------------------------------------------------------- */ + +/* simple */ + +/* XPointer type: not needed for WIN32 */ +typedef void* XPointer; + +/* XID type */ +typedef unsigned long XID; + +/* Atom type: not needed for WIN32*/ +typedef unsigned long Atom; + +/* Bool type */ +typedef int Bool; + +/* Colormap type: not needed for WIN32 */ +typedef XID Colormap; + +/* Cursor type: not needed for WIN32 */ +typedef XID Cursor; + +/* Display type: not needed for WIN32 */ +typedef int Display; + +/* Drawable type, can be bitmap or window */ +typedef int Drawable; + +/* Font type: not needed for WIN32 */ +typedef XID Font; + +/* GC type: really a HDC */ +typedef int GC; + +/* GContext type: not needed for WIN32 */ +typedef XID GContext; + +/* Keysym type: not needed for WIN32 */ +typedef XID KeySym; + +/* Pixel type, from <X11/Intrinsic.h> */ +typedef unsigned long Pixel; + +/* Pixmap type, implemented a bitmap handler for WIN32 */ +typedef int Pixmap; + +/* Screen type: not needed for WIN32 */ +typedef int Screen; + +/* Status type: not needed for WIN32 */ +typedef int Status; + +/* Time type: not needed for WIN32 */ +typedef unsigned long Time; + +/* VisualID type: not needed for WIN32 */ +typedef unsigned long VisualID; + +/* Window type: really a HWND but typecasting to int, + * this is because a Window is also a Drawable. + * We don't use this anyway */ +typedef int Window; + +/* XExtData type: used below */ +typedef char XExtData; + +/* XrmQuark, XrmQuarkList: not needed */ +typedef int XrmQuark, *XrmQuarkList; + +/* complex */ + +/* Visual type: not needed for WIN32 */ +typedef struct { + XExtData *ext_data; + VisualID visualid; +#if defined(__cplusplus) || defined(c_plusplus) + int c_class; +#else + int class; +#endif + unsigned long red_mask; + unsigned long green_mask; + unsigned long blue_mask; + int bits_per_rgb; + int map_entries; +} Visual; + +/* XAnyEvent type: not needed for WIN32 */ +typedef struct { + int type; + unsigned long serial; + Bool send_event; + Display *display; + Window window; +} XAnyEvent; + +/* XArc */ +typedef struct { + short x,y; + unsigned short width, height; + short angle1, angle2; +} XArc; + +/* XCharStruct type: not needed for WIN32 */ +typedef struct { + short lbearing; + short rbearing; + short width; + short ascent; + short descent; + unsigned short attributes; +} XCharStruct; + +/* XClassHint type: not needed for WIN32 */ +typedef struct { + char *res_name; + char *res_class; +} XClassHint; + +/* XComposeStatus type: not needed for WIN32 */ +typedef struct { + XPointer compose_ptr; + int chars_matched; +} XComposeStatus; + +/* XKeyEvent type: */ +typedef struct { + int type; + unsigned long serial; + Bool send_event; + Display *display; + Window window; + Window root; + Window subwindow; + Time time; + int x, y; + int x_root, y_root; + unsigned int state; + unsigned int keycode; + Bool same_screen; +} XKeyEvent; + +/* XButtonEvent type: */ +typedef struct { + int type; + unsigned long serial; + Bool send_event; + Display *display; + Window window; + Window root; + Window subwindow; + Time time; + int x, y; + int x_root, y_root; + unsigned int state; + unsigned int button; + Bool same_screen; +} XButtonEvent; + +/* XMotionEvent type */ +typedef struct { + int type; + unsigned long serial; + Bool send_event; + Display *display; + Window window; + Window root; + Window subwindow; + Time time; + int x, y; + int x_root, y_root; + unsigned int state; + char is_hint; + Bool same_screen; +} XMotionEvent; + +/* XExposeEvent */ +typedef struct { + int type; + unsigned long serial; + Bool send_event; + Display *display; + Window window; + int x, y; + int width, height; + int count; +} XExposeEvent; + +/* XVisibilityEvent type */ +typedef struct { + int type; + unsigned long serial; + Bool send_event; + Display *display; + Window window; + int state; +} XVisibilityEvent; + +/* XConfigureEvent type */ +typedef struct { + int type; + unsigned long serial; + Bool send_event; + Display *display; + Window event; + Window window; + int x, y; + int width, height; + int border_width; + Window above; + Bool override_redirect; +} XConfigureEvent; + +/* XEvent type: not needed for WIN32 */ +typedef union _XEvent { + int type; + XAnyEvent xany; + XKeyEvent xkey; + XButtonEvent xbutton; + XMotionEvent xmotion; +// XCrossingEvent xcrossing; +// XFocusChangeEvent xfocus; + XExposeEvent xexpose; +// XGraphicsExposeEvent xgraphicsexpose; +// XNoExposeEvent xnoexpose; + XVisibilityEvent xvisibility; +// XCreateWindowEvent xcreatewindow; +// XDestroyWindowEvent xdestroywindow; +// XUnmapEvent xunmap; +// XMapEvent xmap; +// XMapRequestEvent xmaprequest; +// XReparentEvent xreparent; + XConfigureEvent xconfigure; +// XGravityEvent xgravity; +// XResizeRequestEvent xresizerequest; +// XConfigureRequestEvent xconfigurerequest; +// XCirculateEvent xcirculate; +// XCirculateRequestEvent xcirculaterequest; +// XPropertyEvent xproperty; +// XSelectionClearEvent xselectionclear; +// XSelectionRequestEvent xselectionrequest; +// XSelectionEvent xselection; +// XColormapEvent xcolormap; +// XClientMessageEvent xclient; +// XMappingEvent xmapping; +// XErrorEvent xerror; +// XKeymapEvent xkeymap; + long pad[24]; +} XEvent; + +/* XFontProp type: not needed for WIN32 */ +typedef struct { + Atom name; + unsigned long card32; +} XFontProp; + +/* XFontStruct type: not needed for WIN32 */ +typedef struct { + XExtData *ext_data; + Font fid; + unsigned direction; + unsigned min_char_or_byte2; + unsigned max_char_or_byte2; + unsigned min_byte1; + unsigned max_byte1; + Bool all_chars_exist; + unsigned default_char; + int n_properties; + XFontProp *properties; + XCharStruct min_bounds; + XCharStruct max_bounds; + XCharStruct *per_char; + int ascent; + int descent; +} XFontStruct; + +/* XColor type */ +typedef struct { + unsigned long pixel; + unsigned short red, green, blue; + char flags; + char pad; +} XColor; + +/* XGCValues type */ +typedef struct { + int function; + unsigned long plane_mask; + unsigned long foreground; + unsigned long background; + int line_width; + int line_style; + int cap_style; + int join_style; + int fill_style; + int fill_rule; + int arc_mode; + Pixmap tile; + Pixmap stipple; + int ts_x_origin; + int ts_y_origin; + Font font; + int subwindow_mode; + Bool graphics_exposures; + int clip_x_origin; + int clip_y_origin; + Pixmap clip_mask; + int dash_offset; + char dashes; +} XGCValues; + +/* XHostAddress type: not needed for WIN32 */ +typedef struct { + int family; + int length; + char *address; +} XHostAddress; + +/* XImage type */ +typedef struct { + int width, height; + int xoffset; + int format; + char *data; + int byte_order; + int bitmap_unit; + int bitmap_bit_order; + int bitmap_pad; + int depth; + int bytes_per_line; +} XImage; + +/* XPoint type */ +typedef struct { + int x, y; +} XPoint; + +/* XRectangle type */ +typedef struct { + short x,y; + unsigned short width, height; +} XRectangle; + +/* XrmBinding & XrmBindingList types: not needed for WIN32 */ +typedef enum { + XrmBindTightly, + XrmBindLoosely +} XrmBinding, *XrmBindingList; + +/* XrmDatabase type: not needed for WIN32 */ +typedef char** XrmDatabase; + +/* XrmOptionKind type: used by XrmOptionDescRec */ +typedef enum { + XrmoptionNoArg, + XrmoptionIsArg, + XrmoptionStickyArg, + XrmoptionSepArg, + XrmoptionResArg, + XrmoptionSkipArg, + XrmoptionSkipLine, + XrmoptionSkipNArgs +} XrmOptionKind; + +/* XrmOptionDescRec type: not needed for WIN32 */ +typedef struct { + char *option; + char *specifier; + XrmOptionKind argKind; + XPointer value; +} XrmOptionDescRec, *XrmOptionDescList; + +/* XrmValue type: not needed for WIN32 */ +typedef struct { + unsigned int size; + XPointer addr; +} XrmValue, *XrmValuePtr; + +/* XSegment type */ +typedef struct { + short x1, y1, x2, y2; +} XSegment; + +/* XTextProperty type: not needed for WIN32 */ +typedef struct { + unsigned char *value; + Atom encoding; + int format; + unsigned long nitems; +} XTextProperty; + +/* XVisualInfo type: not needed for WIN32 */ +typedef struct { + Visual *visual; + VisualID visualid; + int screen; + int depth; +#if defined(__cplusplus) || defined(c_plusplus) + int c_class; +#else + int class; +#endif + unsigned long red_mask; + unsigned long green_mask; + unsigned long blue_mask; + int colormap_size; + int bits_per_rgb; +} XVisualInfo; + +/* XWindowAttributes type: not needed for WIN32 */ +typedef struct { + int x, y; + int width, height; + int border_width; + int depth; + Visual *visual; + Window root; + int class; + int bit_gravity; + int win_gravity; + int backing_store; + unsigned long backing_planes; + unsigned long backing_pixels; + Bool save_under; + Colormap colormap; + Bool map_installed; + int map_state; + long all_events_masks; + long your_event_mask; + long do_not_propogate_mask; + Bool override_redirect; + Screen *screen; +} XWindowAttributes; + +/* XWindowChanges type: not needed for WIN32 */ +typedef struct { + int x, y; + int width, height; + int border_width; + Window sibling; + int stack_mode; +} XWindowChanges; + + +/* caddr_t type: char address type */ +typedef char *caddr_t; + +/* -------------------------------------------------------------------- */ + +/*- + * prototypes + */ + +int nice(int level); +void sleep(int sec); +int sigmask(int signum); + +unsigned long BlackPixel(Display *display, int screen_number); +int BlackPixelOfScreen(Screen *screen); +int CellsOfScreen(Screen *screen); +Colormap DefaultColormap(Display *display, int screen_number); +Colormap DefaultColormapOfScreen(Screen *screen); +Visual *DefaultVisual(Display *display, int screen_number); +int DisplayPlanes(Display *display, int screen_number); +char *DisplayString(Display *display); +Window RootWindow(Display *display, int screen_number); +int ScreenCount(Display *display); +Screen *ScreenOfDisplay(Display *display, int screen_number); +unsigned long WhitePixel(Display *display, int screen_number); +int WhitePixelOfScreen(Screen *screen); + + + +void XAddHosts(Display *display, XHostAddress *hosts, int num_hosts); +Status XAllocColor(Display *display, Colormap colormap, + XColor *screen_in_out); +Status XAllocColorCells(Display *display, Colormap colormap, + Bool contig, unsigned long plane_masks_return[], + unsigned int nplanes, unsigned long pixels_return[], + unsigned int npixels); +Status XAllocNamedColor(Display *display, Colormap colormap, + char *color_name, XColor *screen_def_return, + XColor *exact_def_return); +void XBell(Display *display, int percent); +void XChangeGC(Display *display, GC gc, unsigned long valuemask, + XGCValues *values); +Bool XCheckMaskEvent(Display *display, long event_mask, + XEvent *event_return); +void XClearArea(Display *display, Window w, int x, int y, + unsigned int width, unsigned int height, Bool exposures); +void XClearWindow(Display *display, Window w); +void XCloseDisplay(Display *display); +void XConfigureWindow(Display *display, Window w, + unsigned int value_mask, + XWindowChanges *values); +int XCopyArea(Display *display, Drawable src, Drawable dest, GC gc, + int src_x, int src_y, unsigned int width, unsigned height, + int dest_x, int dest_y); +int XCopyPlane(Display *display, Drawable src, Drawable dest, GC gc, + int src_x, int src_y, unsigned width, int height, int dest_x, + int dest_y, unsigned long plane); +Colormap XCopyColormapAndFree(Display *display, Colormap colormap); +Pixmap XCreateBitmapFromData(Display *display, Drawable drawable, + char *data, unsigned int width, + unsigned int height); +Colormap XCreateColormap(Display *display, Window w, + Visual *visual, int alloc); +Cursor XCreateFontCursor(Display *display, unsigned int shape); +GC XCreateGC(Display *display, Drawable drawable, + unsigned long valuemask, XGCValues *values); +XImage *XCreateImage(Display *display, Visual *visual, + unsigned int depth, int format, int offset, + char *data, unsigned int width, + unsigned int height, int bitmap_pad, + int bytes_per_line); +Pixmap XCreatePixmap(Display *display, Drawable d, unsigned int width, + unsigned int height, unsigned int depth); +Cursor XCreatePixmapCursor(Display *display, + Pixmap source, Pixmap mask, + XColor *foreground_color, XColor *background_color, + unsigned int x_hot, unsigned int y_hot); +Pixmap XCreatePixmapFromBitmapData(Display *display, Drawable drawable, + char *data, unsigned int width, unsigned int height, + unsigned long fg, unsigned long bg, unsigned int depth); +void XDefineCursor(Display *display, Window window, Cursor cursor); +void XDestroyImage(XImage *ximage); +void XDisableAccessControl(Display *display); +void XDrawArc(Display *display, Drawable d, GC gc, int x, int y, + unsigned int width, unsigned int height, + int angle1, int angle2); +void XDrawImageString(Display *display, Drawable d, GC gc, + int x, int y, char *string, int length); +void XDrawLine(Display *display, Drawable d, GC gc, + int x1, int y1, int x2, int y2); +void XDrawLines(Display *display, Drawable d, GC gc, + XPoint *points, int npoints, int mode); +void XDrawPoint(Display *display, Drawable d, GC gc, int x, int y); +void XDrawPoints(Display *display, Drawable d, GC gc, + XPoint *pts, int numpts, int mode); +void XDrawRectangle(Display *display, Drawable d, GC gc, int x, int y, + unsigned int width, unsigned int height); +void XDrawSegments(Display *display, Drawable d, GC gc, + XSegment *segs, int numsegs); +void XDrawString(Display *display, Drawable d, GC gc, int x, int y, + char *string, int length); +void XEnableAccessControl(Display *display); +void XFillArc(Display *display, Drawable d, GC gc, int x, int y, + unsigned int width, unsigned int height, + int angle1, int angle2); +void XFillArcs(Display *display, Drawable d, GC gc, + XArc *arcs, int narcs); +void XFillPolygon(Display *display, Drawable d, GC gc, XPoint *points, + int npoints, int shape, int mode); +void XFillRectangle(Display *display, Drawable d, GC gc, int x, int y, + unsigned int width, unsigned int height); +void XFillRectangles(Display *display, Drawable d, GC gc, + XRectangle *rectangles, int nrectangles); +void XFlush(Display *display); +void XFree(void *data); +void XFreeColormap(Display *display, Colormap colormap); +void XFreeColors(Display *display, Colormap colormap, + unsigned long pixels[], int npixels, + unsigned long planes); +void XFreeCursor(Display *display, Cursor cursor); +int XFreeFont(Display *display, XFontStruct *font_struct); +int XFreeFontInfo(char** names, XFontStruct* free_info, int actual_count); +void XFreeGC(Display *display, GC gc); +void XFreePixmap(Display *display, Pixmap pixmap); +GContext XGContextFromGC(GC gc); +XVisualInfo *XGetVisualInfo(Display *display, long vinfo_mask, + XVisualInfo *vinfo_template, + int *nitems_return); +Status XGetWindowAttributes(Display *display, Window w, + XWindowAttributes *window_attr_return); +int XGrabKeyboard(Display *display, Window grab_window, + Bool owner_events, int pointer_mode, + int keyboard_mode, Time time); +int XGrabPointer(Display *display, Window grab_window, Bool owner_events, + unsigned int event_mask, int pointer_mode, + int keyboard_mode, Window confine_to, Cursor cursor, + Time time); +void XGrabServer(Display *display); +void XInstallColormap(Display *display, Colormap colormap); +XHostAddress *XListHosts(Display *display, int *nhosts_return, + Bool *state_return); +XFontStruct *XLoadQueryFont(Display *display, char *name); +int XLookupString(XKeyEvent *event_struct, char *buffer_return, + int bytes_buffer, KeySym *keysym_return, + XComposeStatus *status_in_out); +void XMapWindow(Display *display, Window w); +void XNextEvent(Display *display, XEvent *event_return); +Display *XOpenDisplay(char *display_name); +Status XParseColor(Display *display, Colormap colormap, + char *spec, XColor *exact_def_return); +int XPending(Display *display); +void XPutBackEvent(Display *display, XEvent *event); +void XPutImage(Display *display, Drawable d, GC gc, XImage *image, int src_x, + int src_y, int dest_x, int dest_y, unsigned int width, + unsigned int height); +int XPutPixel(XImage *ximage, int x, int y, unsigned long pixel); +void XQueryColor(Display *display, Colormap colormap, XColor *def_in_out); +XFontStruct *XQueryFont(Display* display, XID font_ID); +Bool XQueryPointer(Display *display, Window w, Window *root_return, + Window *child_return, int *root_x_return, int *root_y_return, + int *win_x_return, int *win_y_return, + unsigned int *mask_return); +Status XQueryTree(Display *display, Window w, Window *root_return, + Window *parent_return, Window **children_return, + unsigned int *nchildren_return); +void XRaiseWindow(Display *display, Window w); +int XReadBitmapFile(Display *display, Drawable d, char *filename, + unsigned int *width_return, unsigned int *height_return, + Pixmap *bitmap_return, int *x_hot_return, int *y_hot_return); +void XRemoveHosts(Display *display, XHostAddress *hosts, int num_hosts); +char *XResourceManagerString(Display *display); +void XrmDestroyDatabase(XrmDatabase database); +XrmDatabase XrmGetFileDatabase(char *filename); +Bool XrmGetResource(XrmDatabase database, char *str_name, + char *str_class, char **str_type_return, + XrmValue *value_return); +XrmDatabase XrmGetStringDatabase(char *data); +void XrmInitialize(void); +void XrmMergeDatabases(XrmDatabase source_db, XrmDatabase *target_db); +void XrmParseCommand(XrmDatabase *database, XrmOptionDescList table, + int table_count, char *name, int *argc_in_out, + char **argv_in_out); +void XSetBackground(Display *display, GC gc, unsigned long background); +void XSetFillRule(Display *display, GC gc, int fill_rule); +void XSetFillStyle(Display *display, GC gc, int fill_style); +void XSetFont(Display *display, GC gc, Font font); +void XSetForeground(Display *display, GC gc, unsigned long foreground); +void XSetFunction(Display *display, GC gc, int function); +int XSetGraphicsExposures(Display *display, GC gc, Bool graphics_exposures); +void XSetLineAttributes(Display *display, GC gc, + unsigned int line_width, int line_style, + int cap_style, int join_style); +void XSetScreenSaver(Display *display, int timeout, int interval, + int prefer_blanking, int allow_exposures); +void XSetStipple(Display *display, GC gc, Pixmap stipple); +void XSetTSOrigin(Display *display, GC gc, int ts_x_origin, int ts_y_origin); +void XSetWindowColormap(Display *display, Window w, Colormap colormap); +void XSetWMName(Display *display, Window w, XTextProperty *text_prop); +Status XStringListToTextProperty(char **list, int count, + XTextProperty *text_prop_return); +void XStoreColors(Display *display, Colormap colormap, XColor color[], + int ncolors); +void XSync(Display *display, Bool discard); +int XTextWidth(XFontStruct *font_struct, char *string, int count); +Bool XTranslateCoordinates(Display* display, Window src_w, Window dest_w, + int src_x, int src_y, + int* dest_x_return, int* dest_y_return, + Window* child_return); +void XUngrabKeyboard(Display *display, Time time); +void XUngrabPointer(Display *display, Time time); +void XUngrabServer(Display *display); +void XUnmapWindow(Display *display, Window w); +/* -------------------------------------------------------------------- */ + +#endif /* WIN32 */ +#endif /* __XLOCK_XAPI_H__ */ diff --git a/app/xlockmore/win32/readme.txt b/app/xlockmore/win32/readme.txt new file mode 100644 index 000000000..27e0d64cc --- /dev/null +++ b/app/xlockmore/win32/readme.txt @@ -0,0 +1,334 @@ +Xlock95 Readme.txt file. + +Version 0.11 + + +Requirements. +------------- + +Windows 95, 98, ME or Windows NT, 2000, XP running 256 colors or greater. +Don't know the minimum spec. machine, but I have run it on a +Pentium 166 (Win95), Pentium Pro 200 (Win NT), Pentium II 233 (Win95), +Pentium III 1000 (Win98) and Pentium 4 3Ghz (XP Pro). + +Building. +--------- +Cygwin - www.cygwin.com + (Gnu gcc compiler for windows) + +I no longer use MS VC++ to compile. It took about a day to +convert over to cygwin (and that was mainly setting up the +Makefiles). To compile under VC++ would take a little work +but it should be fairly painless. + +At top level +make -f Makefile.win32 + +Note: for other compilers things may be different. For VC++ there + were many more steps to set up. + + +Note2: When you use Debug configuration, you will only get one mode + working. When you want to debug a mode you will have to + change the mode you want. I set this up so when I debugged + any new mode that I have just added, the only mode displayed + was the one I set. To set debug mode, modify the Makefile in + the xlock sub-directory to define _DEBUG (ie -D_DEBUG) + + +Installation. +------------- + +Place the file "xlock95.scr" in either Windows system or Windows +directory ("C:\Windows\System\", "C:\Windows\", "C:\WINNT +which ever works, `cygpath -W` should tell you what this is) + +make -f Makefile.win32 install + +Set "xlock95" to be your screen saver. When you enter the +Screen Saver tab in the Display Properties it may take a little +while for control to come back to you if xlock95 is set. +If it does not show up the scr file is probably in the wrong directory. + +Alternatively you can just double click the .scr from +explorer and it should run fine (but thats not the +same as setting it up as a screen saver). + +Windows Screen Saver commandline arguments: + +xlock95.scr Runs screensaver's configuration window. +xlock95.scr /s Runs the screensaver on the full screen. +xlock95.scr /p 1234567 Runs the screensaver in windowid 1234567. + +The Scrnsave.lib clone provided by Cygwin/MinGW +(libscrnsave.a) doesn't appear to support multiple screens. +The source is available from Cygwin in the w32api package. +According to the MS screensaver docs, linking with the latest +scrnsaver.lib should handle multiple screens automatically. +See +http://msdn.microsoft.com/library/default.asp?url=/library/en-us/gdi/monitor_2eur.asp +xlock95 is also not yet coded to handle multiple screens. + +Notes. +------ + +If you have used an older version than 0.4, it was called +"xlock.scr". This is not needed anymore and can be deleted from +Windows system directory. Also timings from the older versions are +different than the versions 0.4 and above, so modes will be either +faster or slower. + +If you have used a version between 0.4 and 0.6, it was called +"xlockmore.scr". This is not needed anymore and can be deleted from +Windows system directory. + +When the screen saver is started, it randomly chooses a mode. At this +time, there are 86 modes. These are: + +Ant, Ant3D, Apollonian, Ball, Bat, Blot, Bouboule, Bounce, Braid, +Bug, Clock, Coral, Crystal, Daisy, Deco, Demon, Dilemma, Discrete, +Dragon, Drift, Euler2D, Eyes, Fadeplot, Fiberlamp, Flame, Flow, +Forest, Galaxy, Grav, Helix, Hop, Hyper, Ico, Image, Juggle, Julia, +Kaleid, Kumppa, Laser, Life, Life1D, Life3D, Lightning, Lisa, Lissie, +Loop, Lyapunov, Mandelbrot, Matrix, Maze, Mountain, Munch, Nose, +Pacman, Petal, Petri, Polyominoes, Pyro, Qix, Roll, Rotor, Scooter, +Shape, Sierpinski, Slip, Space, Sphere, Spiral, Spline, Star, +Starfish, Swarm, Tetris, Thornbird, Tik_tak, Toneclock, Triangle, +Tube, Turtle, Vines, Voters, Wator, Wire, World, Worm, Xjack + +In the X-Windows version it is possible to set variables that affect +how long certain things are done (eg how many vines or blots to be +drawn before clearing the screen). These variables are cycles, size and +batch counts, and every mode is affected by them. The Win95/NT version +currently isn't able to set these variables and therefore they use the +defaults. Also some modes read in settings from files (eg life3d reads +from file .life3d.rule3d). At the moment this isn't being done either. + +Running it from the commandline yields "Hello World!" and "Okie dokie". +These are the config dialogs. Eventually if +proper configuration is added, this is where it should +go. You'll get the same dialogs when you press the +settings button on the screensaver tab when +xlock95 is the active screensaver. + + +Future of Xlockmore95. +---------------------- + +At this stage I have done intermediate releases of Xlockmore95. I +know there are more modes I can add, but as to adding all the modes +that exist in Xlockmore, I'm not sure it is possible. There are modes +that use XPM images (X PixMap images), opengl, and there may be +X11 functions that just won't map easily to win32 functions (I've been +adding them on an as needed basis). + +This is a list of what I would like to do (but I'm not promising)... + . add more modes + . allowing users to set the cycles and batch count variables, probably + in the settings window. + . allowing users to set specific options to modes that require it, + probably in the settings window. + . allowing modes to read settings from files + . handle colors as X11 does + . add all modes (even opengl modes) + + +Differences with X11 & Bugs. +---------------------------- + +ball, crystal, munch, pyro, tik_tak: +XSetFunction() isn't drawing correctly. + +ant: truchet drawing messed up +ant3d and toneclock: double buffering ok but now label flashes +bouboule & some others: flickers. +crystal & tic_toc: xor errors in beginning +julia: red square dot +nose: text messed up +petri: only red germs +scooter: red rects +tube: needs closure for stars and triangles (does not handle sharp angles) +xjack: messed up when text gets to bottom + +There are small differences in Line Attributes between X11 and WIN32 + +Color model is totally different, so no color cycling occurs. + + +Change Log. +----------- + +version 0.1 +. initial release, Vines, Fadeplot, Sierpinski Triangles, Blot + +version 0.2 (not a public release) +. added Coral mode + +version 0.3 +. wasn't initialising some pointer variables, which could cause an + error if circumstances allowed. This is now fixed. + +. added the ability to redefine the color palette in a mode class. + This means it is possible to have modes that don't have a palette + saturation of 1.0 to recalculate the palette to how they require. + For example Blot mode now has a palette saturation of 0.4 + +. added Deco & Forest modes + +version 0.4 (debug build) +. added code for XDrawArc(), XFillArc() & XFillPolygon() + +. changed from using my own base source code to using the source code + for xlockmore 4.07. I still have to use some of my own code for + start-up and initialisation of the screen saver (cannot get around + this due to differences between X11 and Win32), and of course all + the X11 functions and structures. But the rest is xlockmore 4.07 + code. At some point I will see if David will integrate the Win32 + source code into the official distrubution. + +. As a result a lot more modes are now added. These are: + Braid, Clock, Daisy, Drift, Flame, Galaxy, Geometry, Grav, Helix, + Hop, Lightning, Lisa, Lissie, Petal, Qix, Roll, Rotor, Sphere, + Spiral, Spline, Triangle, Turtle + +version 0.5 +. determined that the problem with the Galaxy mode in the release + build was to do with VC++. When VC++ optimizes for speed, Galaxy + does not work. I now optimize for size. + +. life3d: added an extra check to life3dfile, to see if it was NULL + before doing the strlen() on it. This has fixed a crash I was + getting with it. This is the only mode I have changed. + +. added code for XCreateGC(), XChangeGC(), XDrawLines(), XFillArcs(), + XFillRectangles(), XSetFunction() so the following modes now work: + Ant, Ball, Bouboule, Bug, Crystal, Demon, Laser, Life3d, Loop, + Mountain, Munch, Pyro, Wire + +version 0.6 +. added code for XDrawSegments(), XClearArea() so the following modes + now work: Hyper, Ico, Kaleid, Worm + +. added code to set each modes default options (if there are any). + This affects every mode, but only boolean and string types are being + set at the moment. Ico refused to work until either edges or faces + were defined as true. This also allowed me to remove the code I + added to life3d. + +version 0.7 +. changed my build environment. Now using cygwin as my compiler. As a + result some small changes were needed to xlock.c. I am building it + with the -mno-cygwin option (mingw mode ???) so the cywin1.dll is + not used. Created Makefiles to build the screensaver. + +. no longer use the ScrPlus library, but the scrnsave library that + comes with cygwin. Initially used SetTimer(), but this was too slow, so + I created a thread, and use SendMessage() WM_TIMER from there. + +. modified XFillArc() so it now draws the Arc with a thin line before + it fills it. This fixes the minute and hour hands in clock. Other + modes may be affected (ball, bouboule, daisy, galaxy, grav), though + they looked OK. + +. added displaying the mode and its description in the top left hand + corner. + +. filled in code for XDrawString(), though it doesn't affect anything + (yet) + +. added code for XDrawRectangle(), XStoreColors() so the following + modes now works: mandelbrot, tube + +. added empty function calls to XPutImage(), XCreateBitmapFromData(), + XSetBackground(), XSetFillStyle(), XSetStipple() so Maze now works + (minus the operating system graphic) + +. fixed up XSetFunction so now it should utilise different drawing + functions. It does not seem to be 100% correct, but much better than + before. + +version 0.8 (8-Oct-2004) +. added code for XPutImage() so now the operating system graphic is + drawn in Maze. + +. added code for XCreateBitmapFromData(), XFreePixmap(), XCreateGC(), + XFreeGC() + +version 0.9 (15-May-2005) +. fixed XCreateGC() and XSetStipple() so the bad paths of Maze are + set properly (still a problem setting the stipple (brush) the right + color). Other modes are broken for now (such as Galaxy and Grav) as + they leave trails. + +version 0.10 (26-Jul-2005) +. fixed XDrawArc(), XFillArc() & XFillArcs so they draw fully the + complete angles. This was causing a graphical error in some modes, + for example clock. + +. fixed setting the stipple brush color on an XSetForeground. Now the + bad paths of Maze are the correct color. + +. fixed most of the broken modes. I think this had to do with + recreating the pen for a filled arc in XFillArc(). It wasn't always + creating the new pen. I create it now as null, so the border is not + drawn, and to make up for this I make the arc a little larger in the + function. This fixes Galaxy and Grav. Ball is still broken. + +. fixed ball. The problem had to do with XCreateGC(). The way I had + implemented this function meant only about 5 GCs could be created + before problems were occuring. This was fine for all other modes, + apart from ball which needs about 20 GCs. I now have totally + reorganised how GCs are created and are related back to a device + context (DC), which is what Windows uses. I now only have 1 DC, and + reset it when I use a different GC. This means that modes will run + slower. (31-Aug-2005) + +version 0.11 (29-Sep-2005) +. updated to use xlockmore-5.19. This is the first step of getting my + source code integrated into the offical source. A number of changes + had to be made to my code, but it was mostly OK. The following modes + are removed in this new version (removed in the official code): + geometry (14-Sep-2005) + +. many modes have changed, but some have now a few issues (maze - OS + graphic missing again, ico - not moving and artifacts left, + galaxy - awful flickering as there is no double buffering). + (29-Sep-2005) + +. there are many new modes but I have not attempted to implement any + just yet. (29-Sep-2005) + +[Now distributed with xlockmore... David changed back xlockmore95 back +to xlock95... David hopes this is OK with all concerned.] + +Download. +--------- + +Please don't email David with questions about Xlockmore95. +[Well actually David does not mind if you cc him :) ] +They can be directed to me: petey_leinonen@yahoo.com.au + +You can find the latest information about xlockmore from +David A. Bagley's site at http://www.tux.org/~bagleyd/xlockmore.html + + +Copyright. +---------- + +Copyright (c) 1988-91 by Patrick J. Naughton +Copyright (c) 1993-2005 by David A. Bagley +Copyright (c) 1998-2005 by Petey Leinonen (win95/NT version) + +Permission to use, copy, modify, and distribute this software and its +documentation for any purpose and without fee is hereby granted, +provided that the above copyright notice appear in all copies and that +both that copyright notice and this permission notice appear in +supporting documentation. + +Please note that I do not provide any warranties, and that you use this +executable and/or source code at your own risk. I will not be held +responsible for any damage that is incurred by using the executable +and/or source code. + + +Petey Leinonen, 14 September 2005 diff --git a/app/xlockmore/win32/todo.txt b/app/xlockmore/win32/todo.txt new file mode 100644 index 000000000..b57636212 --- /dev/null +++ b/app/xlockmore/win32/todo.txt @@ -0,0 +1,46 @@ +anemone (requires ???, red screen) +atlantis (requires OpenGL) +atunnels (requires OpenGL) +biof (requires OpenGL) +bubble (requires XSetGraphicsExposures(), XCopyPlane()) +bubble3d (requires OpenGL) +cage (requires OpenGL) +cartoon (requires OpenGL) +dclock (requires XCopyPlane(), XSetGraphicsExposures(), + XSetFont(), XFreeFont()) +decay (requires ???, black screen) +deluxe (requires ???, red screen) +fire (requires OpenGL) +flag (requires utsname.h) +fzort +gears (requires OpenGL) +glplanet (requires OpenGL) +goop (requires XCopyPlane(), XSetPlaneMask()) +ifs (requires XSetGraphicsExposures(), XCopyPlane()) +invert (requires OpenGL, C++) +kaleid2 (requires OpenGL) +lament (requires OpenGL) +marquee (requires XTextExtents(), XSetFont(), XFreeFont()) +moebius (requires OpenGL) +molecule (requires OpenGL) +morph3d (requires OpenGL) +noof (requires OpenGL) +penrose (many errors) +pipes (requires OpenGL) +puzzle (requires ???, black screen) +rubik (requires OpenGL) +run (requires SIGKILL) +sballs (requires OpenGL) +sierpinski3d (requires OpenGL) +skewb (requires OpenGL) +solitare (requires C++) +sproingies (requires OpenGL) +stairs (requires OpenGL) +strange (requires XCopyPlane(), XSetGraphicsExposures()) +superquadrics (requires OpenGL) +swirl (requires XPutPixel(), ScreenCount(), BitmapPad()) +t3d (requires ???, black screen) +text3d (requires OpenGL, C++) +text3d2 (requires OpenGL, C++) +xcl (requires DefaultScreen(), gettimeofday()) + diff --git a/app/xlockmore/win32/xlock.ico b/app/xlockmore/win32/xlock.ico Binary files differnew file mode 100644 index 000000000..d89b75aaf --- /dev/null +++ b/app/xlockmore/win32/xlock.ico diff --git a/app/xlockmore/win32/xlock95.c b/app/xlockmore/win32/xlock95.c new file mode 100644 index 000000000..e7a476b7c --- /dev/null +++ b/app/xlockmore/win32/xlock95.c @@ -0,0 +1,225 @@ +#include <windows.h> +#include <scrnsave.h> +#include <stdlib.h> +#include <time.h> +#include "xlock.h" +#include "xlock95.h" + +/* Win95 specific globals */ +extern HWND hwnd; // window handle +extern HDC hdc; // device context +extern RECT rc; // coords of the screen + +unsigned int xlockmore_create(void); +void xlockmore_destroy(void); +void xlockmore_init(void); +unsigned int xlockmore_timer(void); + +static int *enabled = NULL; + +char *xlock95_get_modelist() { + int m; + HKEY skey; + char key[1024]; + static char modelist[1024] = ""; /* make this dynamic!! */ + if(enabled == NULL) { + enabled = (int*)malloc((numprocs-1)*sizeof(int)); + } + /* Populate enabled[] from registry */ + for(m=0; m<numprocs-1; m++) { /* last one is "random" */ + sprintf(key, "Control Panel\\Screen Saver.xlock95\\%s", + LockProcs[m].cmdline_arg); + if (RegOpenKeyEx(HKEY_CURRENT_USER, key, 0,KEY_READ,&skey) !=ERROR_SUCCESS) + enabled[m] = 1; /* Default is enabled */ + else { + TCHAR buf[10]; + DWORD size = sizeof(buf); + if (RegQueryValueEx(skey,"Enabled",NULL,NULL,(LPBYTE)buf, &size) + !=ERROR_SUCCESS) + enabled[m] = 1; /* Default is enabled */ + else + enabled[m] = (strncmp(buf, "1", 2) == 0); + RegCloseKey(skey); + } + /* Construct modelist suitable for random.c */ + if(enabled[m]) { + snprintf(modelist, sizeof(modelist), + "%s%s,", modelist, LockProcs[m].cmdline_arg); + } + } + return modelist; +} + +BOOL WINAPI ScreenSaverConfigureDialog(hDlg, message, wParam, lParam) + HWND hDlg; + UINT message; + WPARAM wParam; + LPARAM lParam; +{ + int m; + int nItem; + HWND hwndList; + TCHAR tchBuffer[100]; + HRESULT hr; + HKEY skey; + LONG res; + char key[1024]; + + switch(message) + { + case WM_INITDIALOG: + m=8; + SendDlgItemMessage(hDlg, MODE_LIST, LB_SETTABSTOPS, 1, (LPARAM)&m); + (void) xlock95_get_modelist(); /* Populate enabled[] list */ + for(m=0; m<numprocs-1; m++) { /* last one is "random" */ + sprintf(tchBuffer, "%s\t%s", + enabled[m]?"x":"", LockProcs[m].cmdline_arg); + SendDlgItemMessage(hDlg, MODE_LIST, LB_ADDSTRING, 0, + (LPARAM) tchBuffer); + } + break; + case WM_COMMAND: + switch(LOWORD(wParam)) + { + case MODE_LIST: + switch (HIWORD(wParam)) + { + case LBN_SELCHANGE: + m = SendDlgItemMessage(hDlg, MODE_LIST, LB_GETCURSEL, 0, 0); + if(m >= 0 && m < numprocs-1) { + SetDlgItemText(hDlg, DESC_LABEL, LockProcs[m].desc); + SetDlgItemText(hDlg, DELAY_TEXT, + _itoa(LockProcs[m].def_delay, tchBuffer, 10)); + SetDlgItemText(hDlg, COUNT_TEXT, + _itoa(LockProcs[m].def_count, tchBuffer, 10)); + SetDlgItemText(hDlg, CYCLES_TEXT, + _itoa(LockProcs[m].def_cycles,tchBuffer, 10)); + SendDlgItemMessage(hDlg, ENABLE_BUTTON, BM_SETCHECK, + (WPARAM)(enabled[m]? + BST_CHECKED:BST_UNCHECKED), 0); + } + return TRUE; + break; + case LBN_DBLCLK: + m = SendDlgItemMessage(hDlg, MODE_LIST, LB_GETCURSEL, 0, 0); + if(m >= 0 && m < numprocs-1) { + enabled[m] = !enabled[m]; + + SendDlgItemMessage(hDlg, ENABLE_BUTTON, BM_SETCHECK, + (WPARAM)(enabled[m]? + BST_CHECKED:BST_UNCHECKED), 0); + sprintf(tchBuffer, "%c\t%s", + enabled[m]?'x':' ', LockProcs[m].cmdline_arg); + SendDlgItemMessage(hDlg, MODE_LIST, LB_DELETESTRING, + (WPARAM)m, 0); + SendDlgItemMessage(hDlg, MODE_LIST, LB_INSERTSTRING, m, + (LPARAM) tchBuffer); + SendDlgItemMessage(hDlg, MODE_LIST, LB_SETCURSEL, m, 0); + } + } + break; + case ENABLE_BUTTON: + switch (HIWORD(wParam)) + { + case BN_CLICKED: + m = SendDlgItemMessage(hDlg, MODE_LIST, LB_GETCURSEL, 0, 0); + if(m >= 0 && m < numprocs-1) { + enabled[m] = !enabled[m]; + SendDlgItemMessage(hDlg, ENABLE_BUTTON, BM_SETCHECK, + (WPARAM)(enabled[m]? + BST_CHECKED:BST_UNCHECKED), 0); + sprintf(tchBuffer, "%c\t%s", + enabled[m]?'x':' ', LockProcs[m].cmdline_arg); + SendDlgItemMessage(hDlg, MODE_LIST, LB_DELETESTRING, m, 0); + SendDlgItemMessage(hDlg, MODE_LIST, LB_INSERTSTRING, m, + (LPARAM)tchBuffer); + SendDlgItemMessage(hDlg, MODE_LIST, LB_SETCURSEL, m, 0); + } + return TRUE; + } + break; + case IDOK: + { + HKEY skey; + char key[1024]; + char buf[20]; + for(m=0; m<numprocs-1; m++) { + sprintf(key, "Control Panel\\Screen Saver.xlock95\\%s", + LockProcs[m].cmdline_arg); + if (RegCreateKeyEx(HKEY_CURRENT_USER, key, + 0,0,0,KEY_ALL_ACCESS,0,&skey,0) + !=ERROR_SUCCESS) return; + sprintf(buf, "%d", enabled[m]); + RegSetValueEx(skey,"Enabled",0,REG_SZ,buf,1); + RegCloseKey(skey); + } + } + EndDialog(hDlg, IDOK); + return TRUE; + case IDCANCEL: + EndDialog(hDlg, IDCANCEL); + return TRUE; + } + } + return FALSE; +} + +LONG WINAPI ScreenSaverProc(HWND myhwnd, UINT msg, WPARAM wParam, LPARAM lParam) +{ + static UINT uTimer; // timer identifier + static UINT uHasInit = 0; + switch (msg) + { + case WM_ERASEBKGND: + { + HDC myhdc=(HDC) wParam; RECT myrc; GetClientRect(myhwnd,&myrc); + FillRect(myhdc, &myrc, (struct HBRUSH__ *)GetStockObject(BLACK_BRUSH)); + } + break; + + case WM_CREATE: + { + int delay; + hwnd = myhwnd; + GetClientRect(hwnd, &rc); // get window coords + hdc = GetDC(hwnd); // get device context + SetTextColor(hdc, RGB(255,255,255)); // set text foreground to white + SetBkColor(hdc, RGB(0,0,0)); // set text background to black + + delay = xlockmore_create(); + // start the timer + uTimer = SetTimer(hwnd, 1, delay/1000, NULL); + } + break; + + case WM_DESTROY: + { + // Stop the timer + if (uTimer) + KillTimer(hwnd, uTimer); + xlockmore_destroy(); + } + break; + + case WM_TIMER: + { + if (uHasInit == 0) + { + xlockmore_init(); + uHasInit = 1; + } + return xlockmore_timer(); + } + break; + + default: + return DefScreenSaverProc(myhwnd, msg, wParam, lParam); + } + return 0; +} + +BOOL WINAPI RegisterDialogClasses(HANDLE hInst) +{ + return TRUE; +} + diff --git a/app/xlockmore/win32/xlock95.h b/app/xlockmore/win32/xlock95.h new file mode 100644 index 000000000..8c4676725 --- /dev/null +++ b/app/xlockmore/win32/xlock95.h @@ -0,0 +1,13 @@ +#define MODE_BOX 1000 +#define MODE_LIST 1010 +#define DESC_LABEL 1020 +#define DELAY_LABEL 1030 +#define DELAY_TEXT 1040 +#define COUNT_LABEL 1050 +#define COUNT_TEXT 1060 +#define CYCLES_LABEL 1070 +#define CYCLES_TEXT 1080 +#define ENABLE_BUTTON 1090 + + + diff --git a/app/xlockmore/win32/xlockrc.rc b/app/xlockmore/win32/xlockrc.rc new file mode 100644 index 000000000..8674dea57 --- /dev/null +++ b/app/xlockmore/win32/xlockrc.rc @@ -0,0 +1,31 @@ +#include <windows.h> +#include <scrnsave.h> +#include "xlock95.h" + +STRINGTABLE +BEGIN + IDS_DESCRIPTION "xlock95 Screen Saver" +END + +ICON_APP ICON DISCARDABLE "xlock.ico" + +DLG_SCRNSAVECONFIGURE DIALOG 6, 18, 250, 120 +STYLE DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU +CAPTION "xlock95 Screen Saver setup" +FONT 8, "MS Shell Dlg" +BEGIN + GROUPBOX "Mode", MODE_BOX, 5, 10, 80, 105 + LISTBOX MODE_LIST, 10, 20, 70, 100, WS_VSCROLL|LBS_USETABSTOPS + + GROUPBOX "", DESC_LABEL, 90, 10, 80, 80 + LTEXT "Delay", DELAY_LABEL, 100, 20, 20, 10 + LTEXT "", DELAY_TEXT, 130, 20, 20, 10 + LTEXT "Count", COUNT_LABEL, 100, 30, 20, 10 + LTEXT "", COUNT_TEXT, 130, 30, 20, 10 + LTEXT "Cycles", CYCLES_LABEL, 100, 40, 20, 10 + LTEXT "", CYCLES_TEXT, 130, 40, 20, 10 + CHECKBOX "Enabled", ENABLE_BUTTON,100, 50, 40, 10 + + PUSHBUTTON "OK", IDOK, 200, 20, 40, 14 + PUSHBUTTON "Cancel", IDCANCEL, 200, 60, 40, 14 +END |