Return to win32.c CVS log

Up to [UNIX Amiga Emulator] / uae / src / od-win32

Annotation of uae/src/od-win32/win32.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * UAE - The Un*x Amiga Emulator
        !             3:  *
        !             4:  * Win32 interface
        !             5:  *
        !             6:  * Copyright 1997 Mathias Ortmann
        !             7:  */
        !             8: 
        !             9: #ifdef __GNUC__
        !            10: #define __int64 long long
        !            11: #include "machdep/winstuff.h"
        !            12: #else
        !            13: #include <windows.h>
        !            14: #include <ddraw.h>
        !            15: #include <stdlib.h>
        !            16: #include <stdarg.h>
        !            17: #include <commctrl.h>
        !            18: #include <commdlg.h>
        !            19: #include <stdio.h>
        !            20: #include <fcntl.h>
        !            21: #include <sys/stat.h>
        !            22: #include <io.h>
        !            23: #endif
        !            24: 
        !            25: #include "config.h"
        !            26: #include "sysconfig.h"
        !            27: #include "sysdeps.h"
        !            28: 
        !            29: #include "options.h"
        !            30: #include "gensound.h"
        !            31: #include "sounddep/sound.h"
        !            32: #include "uae.h"
        !            33: #include "threaddep/penguin.h"
        !            34: #include "memory.h"
        !            35: #include "custom.h"
        !            36: #include "events.h"
        !            37: #include "xwin.h"
        !            38: #include "keyboard.h"
        !            39: #include "picasso96.h"
        !            40: 
        !            41: #include "osdep/win32gui.h"
        !            42: #include "resource.h"
        !            43: #include "osdep/win32.h"
        !            44: 
        !            45: extern struct picasso_vidbuf_description picasso_vidinfo;
        !            46: #define IHF_WINDOWHIDDEN 6
        !            47: 
        !            48: static BOOL (WINAPI *pGetOpenFileNameA) (LPOPENFILENAME);
        !            49: static HRESULT (WINAPI *pDirectDrawCreate) (GUID FAR *, LPDIRECTDRAW FAR *, IUnknown FAR *);
        !            50: static HRESULT CALLBACK modesCallback (LPDDSURFACEDESC modeDesc, LPVOID context);
        !            51: 
        !            52: HWND hAmigaWnd, hMainWnd;
        !            53: HINSTANCE hInst;
        !            54: /*DWORD Keys;*/
        !            55: static RECT amigawin_rect;
        !            56: 
        !            57: drive_specs drives[NUM_DRIVES];
        !            58: char *start_path = NULL;
        !            59: 
        !            60: static LPDIRECTDRAW lpDD;
        !            61: static LPDIRECTDRAWSURFACE lpDDS;
        !            62: static LPDIRECTDRAWCLIPPER lpDDC;
        !            63: static LPDIRECTDRAWPALETTE lpDDP;
        !            64: static DDSURFACEDESC ddsd;
        !            65: HANDLE hEmuThread;
        !            66: 
        !            67: static HDC hBackDC;
        !            68: static HBITMAP hBackBM;
        !            69: 
        !            70: static CRITICAL_SECTION csDraw;
        !            71: 
        !            72: #define TITLETEXT PROGNAME " -- Amiga Display"
        !            73: char VersionStr[256];
        !            74: extern int current_width, current_height;
        !            75: 
        !            76: static uae_sem_t picasso_switch_sem;
        !            77: 
        !            78: static int fullscreen = 0;
        !            79: int current_width, current_height;
        !            80: static int current_pixbytes;
        !            81: 
        !            82: static int changemode;
        !            83: 
        !            84: static int screen_is_picasso = 0;
        !            85: static int picasso_fullscreen = 1;
        !            86: int amiga_fullscreen = 1, customsize = 0;
        !            87: 
        !            88: int bActive;
        !            89: int capslock;
        !            90: int toggle_sound;
        !            91: 
        !            92: int process_desired_pri;
        !            93: 
        !            94: int cycles_per_instruction = 4;
        !            95: int good_cpu = 0;
        !            96: 
        !            97: BOOL allow_quit_from_property_sheet = TRUE;
        !            98: BOOL viewing_child = FALSE;
        !            99: 
        !           100: static char scrlinebuf[8192];  /* this is too large, but let's rather play on the safe side here */
        !           101: static int scrindirect;
        !           102: 
        !           103: static void set_linemem (void)
        !           104: {
        !           105:     if (scrindirect)
        !           106:        gfxvidinfo.linemem = scrlinebuf;
        !           107:     else
        !           108:        gfxvidinfo.linemem = 0;
        !           109: }
        !           110: 
        !           111: /* Keyboard emulation, Win32 helper routines. */
        !           112: static LPARAM keysdown[256];
        !           113: static short numkeysdown;
        !           114: 
        !           115: int getcapslock (void)
        !           116: {
        !           117:     BYTE keyState[256];
        !           118: 
        !           119:     GetKeyboardState (keyState);
        !           120:     return keyState[VK_CAPITAL] & 1;
        !           121: }
        !           122: 
        !           123: int helppressed (void)
        !           124: {
        !           125:     return GetAsyncKeyState (VK_END) & 0x8000;
        !           126: }
        !           127: 
        !           128: int shiftpressed (void)
        !           129: {
        !           130:     return GetAsyncKeyState (VK_SHIFT) & 0x8000 ? 1 : 0;
        !           131: }
        !           132: 
        !           133: int checkkey (int vkey, LPARAM lParam)
        !           134: {
        !           135:     switch (vkey) {
        !           136:     case VK_SHIFT:
        !           137:     case VK_LSHIFT:
        !           138:     case VK_RSHIFT:
        !           139:     case VK_CONTROL:
        !           140:     case VK_LCONTROL:
        !           141:     case VK_RCONTROL:
        !           142:     case VK_MENU:
        !           143:     case VK_LMENU:
        !           144:     case VK_RMENU:
        !           145:        return GetKeyState (vkey) & 0x8000;
        !           146:     }
        !           147:     return GetAsyncKeyState (vkey) & 0x8000;
        !           148: }
        !           149: 
        !           150: /* Mouse emulation, Win32 interface */
        !           151: static int mousecx = 160, mousecy = 100, mousedx = 160, mousedy = 100;
        !           152: static int mousecl = MAKELONG (160, 100);
        !           153: int mouseactive;
        !           154: 
        !           155: void setmouseactive (int active)
        !           156: {
        !           157:     mousedx = (amigawin_rect.right - amigawin_rect.left) / 2;
        !           158:     mousedy = (amigawin_rect.bottom - amigawin_rect.top) / 2;
        !           159:     mousecl = MAKELONG (mousedx, mousedy);
        !           160:     mousecx = amigawin_rect.left + mousedx;
        !           161:     mousecy = amigawin_rect.top + mousedy;
        !           162: 
        !           163:     if (active == mouseactive)
        !           164:        return;
        !           165:     mouseactive = active;
        !           166: 
        !           167:     if (active) {
        !           168:        ShowCursor (FALSE);
        !           169:        SetCursorPos (mousecx, mousecy);
        !           170:        SetWindowText (hMainWnd ? hMainWnd : hAmigaWnd, TITLETEXT " [Mouse active - press Alt-Tab to cancel]");
        !           171:        ClipCursor (&amigawin_rect);
        !           172:     } else {
        !           173:        ShowCursor (TRUE);
        !           174:        SetWindowText (hMainWnd ? hMainWnd : hAmigaWnd, TITLETEXT);
        !           175:        ClipCursor (NULL);
        !           176:     }
        !           177: }
        !           178: 
        !           179: static int hascapture = 0;
        !           180: 
        !           181: void setcapture (void)
        !           182: {
        !           183:     if (hascapture)
        !           184:        return;
        !           185:     hascapture++;
        !           186:     SetCapture (hAmigaWnd);
        !           187: }
        !           188: 
        !           189: static __inline__ void releasecapture (void)
        !           190: {
        !           191:     if (!hascapture)
        !           192:        return;
        !           193:     hascapture--;
        !           194:     ReleaseCapture ();
        !           195: }
        !           196: 
        !           197: static void figure_processor_speed (void)
        !           198: {
        !           199:     SYSTEM_INFO sysinfo;
        !           200:     OSVERSIONINFO osinfo;
        !           201:     HKEY hKey;
        !           202:     DWORD value;
        !           203:     DWORD type, size;
        !           204:     unsigned long mhz = 0;
        !           205:     char cpuid[40];
        !           206:     char *envptr;
        !           207: 
        !           208:     vsynctime = -1;
        !           209:     if ((envptr = getenv ("PROCESSOR_LEVEL")) && atoi (envptr) < 5)
        !           210:        goto bad_cpu;
        !           211: 
        !           212:     if (RegOpenKeyEx (HKEY_LOCAL_MACHINE, "HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0", 0L, KEY_READ, &hKey) == ERROR_SUCCESS) {
        !           213:        size = sizeof (value);
        !           214:        if (RegQueryValueEx (hKey, "~MHz", NULL, &type, (LPBYTE) & value, &size) == ERROR_SUCCESS) 
        !           215:            mhz = value;
        !           216:        size = sizeof cpuid;
        !           217:        if (RegQueryValueEx (hKey, "VendorIdentifier", NULL, &type, (LPBYTE) cpuid, &size) == ERROR_SUCCESS) {
        !           218:            good_cpu = (strncmp (cpuid, "AuthenticAMD", 12) == 0
        !           219:                        || strncmp (cpuid, "GenuineIntel", 12) == 0);
        !           220:        }
        !           221:        RegCloseKey (hKey);
        !           222:     }
        !           223:     if (!good_cpu)
        !           224:        goto bad_cpu;
        !           225: 
        !           226: #ifdef FRAME_RATE_HACK
        !           227:     if (mhz == 0) {
        !           228:        frame_time_t t;
        !           229:        DWORD oldpri = GetPriorityClass (GetCurrentProcess ());
        !           230: 
        !           231:        write_log ("Calibrating delay loop.. ");
        !           232: 
        !           233:        SetPriorityClass (GetCurrentProcess (), REALTIME_PRIORITY_CLASS);
        !           234:        vsynctime = 1;
        !           235:        t = read_processor_time ();
        !           236:        Sleep (1001);
        !           237:        t = 2*read_processor_time () - t;
        !           238:        Sleep (1);
        !           239:        t -= read_processor_time ();
        !           240:        SetPriorityClass (GetCurrentProcess (), oldpri);
        !           241: 
        !           242:        MyOutputDebugString ("ok - %.2f BogoMIPS\n", (double)t / 1000000.0);
        !           243:        vsynctime = t / 50;
        !           244:        return;
        !           245:     }
        !           246: #endif
        !           247:     if (mhz != 0) {
        !           248:        vsynctime = mhz * 1000000 / 50;
        !           249:        return;
        !           250:     }
        !           251:     write_log ("Could not determine clock speed of your CPU.\n");
        !           252:     return;
        !           253: bad_cpu:
        !           254:     write_log ("Processor level too low - disabling frame rate hack\n");
        !           255: }
        !           256: 
        !           257: /* DirectDraw stuff*/
        !           258: char *getddrname (HRESULT ddrval)
        !           259: {
        !           260:     switch (ddrval) {
        !           261:     case DDERR_ALREADYINITIALIZED:
        !           262:        return "This object is already initialized.";
        !           263:     case DDERR_BLTFASTCANTCLIP:
        !           264:        return "Cannot use BLTFAST with Clipper attached to surface.";
        !           265:     case DDERR_CANNOTATTACHSURFACE:
        !           266:        return "Cannot attach surface.";
        !           267:     case DDERR_CANNOTDETACHSURFACE:
        !           268:        return "Cannot detach surface.";
        !           269:     case DDERR_CANTCREATEDC:
        !           270:        return "Cannot create DC Device Context.";
        !           271:     case DDERR_CANTDUPLICATE:
        !           272:        return "Cannot duplicate.";
        !           273:     case DDERR_CANTLOCKSURFACE:
        !           274:        return "Access to surface refused (no DCI provider).";
        !           275:     case DDERR_CANTPAGELOCK:
        !           276:        return "PageLock failure.";
        !           277:     case DDERR_CANTPAGEUNLOCK:
        !           278:        return "PageUnlock failure.";
        !           279:     case DDERR_CLIPPERISUSINGHWND:
        !           280:        return "Can't set a clip-list for a Clipper which is attached to an HWND.";
        !           281:     case DDERR_COLORKEYNOTSET:
        !           282:        return "No source colour-key provided.";
        !           283:     case DDERR_CURRENTLYNOTAVAIL:
        !           284:        return "Support unavailable.";
        !           285:     case DDERR_DCALREADYCREATED:
        !           286:        return "Surface already has a Device Context.";
        !           287:     case DDERR_DIRECTDRAWALREADYCREATED:
        !           288:        return "DirectDraw already bound to this process.";
        !           289:     case DDERR_EXCEPTION:
        !           290:        return "Unexpected exception.";
        !           291:     case DDERR_EXCLUSIVEMODEALREADYSET:
        !           292:        return "Already in exclusive mode.";
        !           293:     case DDERR_GENERIC:
        !           294:        return "Undefined";     /* THIS MAKES SENSE!  FUCKING M$ */
        !           295: 
        !           296:     case DDERR_HEIGHTALIGN:
        !           297:        return "Height needs to be aligned.";
        !           298:     case DDERR_HWNDALREADYSET:
        !           299:        return "HWND already set for cooperative level.";
        !           300:     case DDERR_HWNDSUBCLASSED:
        !           301:        return "HWND has been subclassed.";
        !           302:     case DDERR_IMPLICITLYCREATED:
        !           303:        return "Can't restore an implicitly created surface.";
        !           304:     case DDERR_INCOMPATIBLEPRIMARY:
        !           305:        return "New params doesn't match existing primary surface.";
        !           306:     case DDERR_INVALIDCAPS:
        !           307:        return "Device doesn't have requested capabilities.";
        !           308:     case DDERR_INVALIDCLIPLIST:
        !           309:        return "Provided clip-list not supported.";
        !           310:     case DDERR_INVALIDDIRECTDRAWGUID:
        !           311:        return "Invalid GUID.";
        !           312:     case DDERR_INVALIDMODE:
        !           313:        return "Mode not supported.";
        !           314:     case DDERR_INVALIDOBJECT:
        !           315:        return "Invalid object.";
        !           316:     case DDERR_INVALIDPARAMS:
        !           317:        return "Invalid params.";
        !           318:     case DDERR_INVALIDPIXELFORMAT:
        !           319:        return "Device doesn't support requested pixel format.";
        !           320:     case DDERR_INVALIDPOSITION:
        !           321:        return "Overlay position illegal.";
        !           322:     case DDERR_INVALIDRECT:
        !           323:        return "Invalid RECT.";
        !           324:     case DDERR_INVALIDSURFACETYPE:
        !           325:        return "Wrong type of surface.";
        !           326:     case DDERR_LOCKEDSURFACES:
        !           327:        return "Surface locked.";
        !           328:     case DDERR_NO3D:
        !           329:        return "No 3d capabilities.";
        !           330:     case DDERR_NOALPHAHW:
        !           331:        return "No alpha h/w.";
        !           332:     case DDERR_NOBLTHW:
        !           333:        return "No blit h/w.";
        !           334:     case DDERR_NOCLIPLIST:
        !           335:        return "No clip-list.";
        !           336:     case DDERR_NOCLIPPERATTACHED:
        !           337:        return "No Clipper attached.";
        !           338:     case DDERR_NOCOLORCONVHW:
        !           339:        return "No colour-conversion h/w.";
        !           340:     case DDERR_NOCOLORKEY:
        !           341:        return "No colour-key.";
        !           342: 
        !           343:     case DDERR_NOTLOCKED:
        !           344:        return "Not locked.";
        !           345:     case DDERR_NOTPAGELOCKED:
        !           346:        return "Not page-locked.";
        !           347:     case DDERR_NOTPALETTIZED:
        !           348:        return "Not palette-based.";
        !           349: 
        !           350:     case DDERR_OUTOFCAPS:
        !           351:        return "out of caps";
        !           352:     case DDERR_OUTOFMEMORY:
        !           353:        return "Out of memory.";
        !           354:     case DDERR_OUTOFVIDEOMEMORY:
        !           355:        return "out of video memory.";
        !           356:     case DDERR_PALETTEBUSY:
        !           357:        return "Palette busy.";
        !           358:     case DDERR_PRIMARYSURFACEALREADYEXISTS:
        !           359:        return "Already a primary surface.";
        !           360: 
        !           361:     case DDERR_SURFACEBUSY:
        !           362:        return "Surface busy.";
        !           363:        /*case DDERR_SURFACEOBSCURED:     return "Surface is obscured.";*/
        !           364:     case DDERR_SURFACELOST:
        !           365:        return "Surface lost.";
        !           366: 
        !           367:     case DDERR_UNSUPPORTED:
        !           368:        return "Unsupported.";
        !           369:     case DDERR_UNSUPPORTEDFORMAT:
        !           370:        return "Unsupported format.";
        !           371: 
        !           372:     case DDERR_WASSTILLDRAWING:
        !           373:        return "Was still drawing.";
        !           374:     }
        !           375:     return "";
        !           376: }
        !           377: 
        !           378: static int lockcnt = 0;
        !           379: 
        !           380: static int do_surfacelock (void)
        !           381: {
        !           382:     HRESULT ddrval = IDirectDrawSurface_Lock (lpDDS, NULL, &ddsd, DDLOCK_SURFACEMEMORYPTR | DDLOCK_WAIT, NULL);
        !           383:     if (ddrval != DD_OK) {
        !           384:        if (ddrval == DDERR_SURFACELOST)
        !           385:            ddrval = IDirectDrawSurface_Restore (lpDDS);
        !           386:        else if (ddrval != DDERR_SURFACEBUSY)
        !           387:            MyOutputDebugString ("lpDDS->Lock() failed - %s (%d)\n", getddrname (ddrval), (unsigned short) ddrval);
        !           388:        return 0;
        !           389:     }
        !           390:     lockcnt++;
        !           391:     return 1;
        !           392: }
        !           393: 
        !           394: void unlockscr (void)
        !           395: {
        !           396:     lockcnt--;
        !           397:     IDirectDrawSurface_Unlock (lpDDS, ddsd.lpSurface);
        !           398: }
        !           399: 
        !           400: static void release_ddraw_stuff (void)
        !           401: {
        !           402:     if (lpDD) {
        !           403:        IDirectDraw_RestoreDisplayMode (lpDD);
        !           404:        IDirectDraw_SetCooperativeLevel (lpDD, hAmigaWnd, DDSCL_NORMAL);
        !           405:     }
        !           406:     if (lpDDC)
        !           407:        IDirectDrawClipper_Release (lpDDC);
        !           408:     if (lpDDS)
        !           409:        IDirectDrawSurface_Release (lpDDS);
        !           410:     if (lpDDP)
        !           411:        IDirectDrawPalette_Release (lpDDP);
        !           412:     if (lpDD)
        !           413:        IDirectDraw_Release (lpDD);
        !           414:     lpDDC = 0;
        !           415:     lpDDS = 0;
        !           416:     lpDDP = 0;
        !           417:     lpDD = 0;
        !           418: }
        !           419: 
        !           420: static int set_ddraw (int width, int height, int wantfull, int *pbytes,
        !           421:                      LPPALETTEENTRY pal)
        !           422: {
        !           423:     int bits = 8 * *pbytes;
        !           424:     HRESULT ddrval;
        !           425: 
        !           426: #ifdef __GNUC__
        !           427:     ddrval = (*pDirectDrawCreate) (NULL, &lpDD, NULL);
        !           428: #else
        !           429:     ddrval = DirectDrawCreate (NULL, &lpDD, NULL);
        !           430: #endif
        !           431:     if (ddrval != DD_OK)
        !           432:        goto oops;
        !           433: 
        !           434:     ddrval = IDirectDraw_SetCooperativeLevel (lpDD, hAmigaWnd,
        !           435:                                               (wantfull
        !           436:                                                ? DDSCL_ALLOWREBOOT | DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN
        !           437:                                                : DDSCL_NORMAL));
        !           438:     if (ddrval != DD_OK)
        !           439:        goto oops;
        !           440: 
        !           441:     ddrval = IDirectDraw_CreateClipper (lpDD, 0, &lpDDC, NULL);
        !           442:     if (ddrval != DD_OK) {
        !           443:        MyOutputDebugString ("DirectDraw error: Clipper unavailable! (%d)\n", ddrval);
        !           444:     } else {
        !           445:        if (IDirectDrawClipper_SetHWnd (lpDDC, 0, hAmigaWnd) != DD_OK)
        !           446:            MyOutputDebugString ("DirectDraw error: Can't attach HWnd!\n");
        !           447:     }
        !           448: 
        !           449:     if (wantfull) {
        !           450:        ddrval = IDirectDraw_SetDisplayMode (lpDD, width, height, bits);
        !           451:        if (ddrval != DD_OK)
        !           452:            goto oops;
        !           453:     }
        !           454:     ddsd.dwSize = sizeof (ddsd);
        !           455:     ddsd.dwFlags = DDSD_CAPS;
        !           456:     ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
        !           457: 
        !           458:     ddrval = IDirectDraw_CreateSurface (lpDD, &ddsd, &lpDDS, NULL);
        !           459:     if (ddrval != DD_OK)
        !           460:        goto oops;
        !           461: 
        !           462:     if (! do_surfacelock ())
        !           463:        return 0;
        !           464:     unlockscr ();
        !           465: 
        !           466:     bits = (ddsd.ddpfPixelFormat.dwRGBBitCount + 7) & ~7;
        !           467:     current_pixbytes = *pbytes = bits >> 3;
        !           468: 
        !           469:     if (bits == 8) {
        !           470:        ddrval = IDirectDraw_CreatePalette (lpDD, DDPCAPS_8BIT | DDPCAPS_ALLOW256,
        !           471:                                             pal,
        !           472:                                             &lpDDP, NULL);
        !           473:        if (ddrval != DD_OK)
        !           474:            goto oops;
        !           475: 
        !           476:        ddrval = IDirectDrawSurface2_SetPalette (lpDDS, lpDDP);
        !           477:        if (ddrval != DD_OK)
        !           478:            goto oops;
        !           479:     }
        !           480:     /* Set global values for current width,height */
        !           481:        current_width  = width;
        !           482:        current_height = height;
        !           483: 
        !           484:     return 1;
        !           485: 
        !           486: oops:
        !           487:     MyOutputDebugString ("DirectDraw initialization failed with %s/%d\n", getddrname (ddrval), ddrval);
        !           488:     return 0;
        !           489: }
        !           490: 
        !           491: /* Color management */
        !           492: static int bits_in_mask (unsigned long mask)
        !           493: {
        !           494:     int n = 0;
        !           495:     while (mask) {
        !           496:        n += mask & 1;
        !           497:        mask >>= 1;
        !           498:     }
        !           499:     return n;
        !           500: }
        !           501: 
        !           502: static int mask_shift (unsigned long mask)
        !           503: {
        !           504:     int n = 0;
        !           505:     while (!(mask & 1)) {
        !           506:        n++;
        !           507:        mask >>= 1;
        !           508:     }
        !           509:     return n;
        !           510: }
        !           511: 
        !           512: static xcolnr xcol8[4096];
        !           513: static PALETTEENTRY colors256[256];
        !           514: static int ncols256 = 0;
        !           515: 
        !           516: static int get_color (int r, int g, int b, xcolnr *cnp)
        !           517: {
        !           518:     if (ncols256 == 256)
        !           519:        return 0;
        !           520:     colors256[ncols256].peRed = r * 0x11;
        !           521:     colors256[ncols256].peGreen = g * 0x11;
        !           522:     colors256[ncols256].peBlue = b * 0x11;
        !           523:     colors256[ncols256].peFlags = 0;
        !           524:     *cnp = ncols256;
        !           525:     ncols256++;
        !           526:     return 1;
        !           527: }
        !           528: 
        !           529: static void init_colors (void)
        !           530: {
        !           531:     if (ncols256 == 0)
        !           532:        alloc_colors256 (get_color);
        !           533:     memcpy (xcol8, xcolors, sizeof xcol8);
        !           534: 
        !           535:     /* init colors */
        !           536: 
        !           537:     switch (current_pixbytes) {
        !           538:      case 1:
        !           539:        memcpy (xcolors, xcol8, sizeof xcolors);
        !           540:        if (lpDDP != 0) {
        !           541:            HRESULT ddrval = IDirectDrawPalette_SetEntries (lpDDP, 0, 0, 256, colors256);
        !           542:            if (ddrval != DD_OK)
        !           543:                MyOutputDebugString ("DX_SetPalette() failed with %s/%d\n", getddrname (ddrval), ddrval);
        !           544:        }
        !           545:        break;
        !           546: 
        !           547:      case 2:
        !           548:      case 3:
        !           549:      case 4:
        !           550:        {
        !           551:            int red_bits = bits_in_mask (ddsd.ddpfPixelFormat.dwRBitMask);
        !           552:            int green_bits = bits_in_mask (ddsd.ddpfPixelFormat.dwGBitMask);
        !           553:            int blue_bits = bits_in_mask (ddsd.ddpfPixelFormat.dwBBitMask);
        !           554:            int red_shift = mask_shift (ddsd.ddpfPixelFormat.dwRBitMask);
        !           555:            int green_shift = mask_shift (ddsd.ddpfPixelFormat.dwGBitMask);
        !           556:            int blue_shift = mask_shift (ddsd.ddpfPixelFormat.dwBBitMask);
        !           557: 
        !           558:            alloc_colors64k (red_bits, green_bits, blue_bits, red_shift,
        !           559:                             green_shift, blue_shift);
        !           560:        }
        !           561:        break;
        !           562:     }
        !           563: }
        !           564: 
        !           565: static void close_windows (void)
        !           566: {
        !           567:     int i;
        !           568: 
        !           569:     gfxvidinfo.bufmem = 0;
        !           570:     gfxvidinfo.linemem = 0;
        !           571: 
        !           572:     releasecapture ();
        !           573:     setmouseactive (0);
        !           574:     ClipCursor (NULL);
        !           575:     release_ddraw_stuff ();
        !           576: 
        !           577:     if (!hMainWnd && hAmigaWnd) {
        !           578:        /*ShowWindow (hAmigaWnd, SW_MINIMIZE);*/
        !           579:     }
        !           580:     if (hAmigaWnd)
        !           581:        DestroyWindow (hAmigaWnd);
        !           582:     if (hMainWnd)
        !           583:        DestroyWindow (hMainWnd);
        !           584:     PostQuitMessage (0);
        !           585:     hMainWnd = 0;
        !           586:     hAmigaWnd = 0;
        !           587: }
        !           588: 
        !           589: static void destroy_window (int nowait)
        !           590: {
        !           591:     if (currprefs.produce_sound > 1)
        !           592:        stopsound ();
        !           593: 
        !           594:     if (!nowait) {
        !           595:        frame_do_semup = 1;
        !           596:        set_inhibit_frame (5);
        !           597:        uae_sem_wait (&frame_sem);
        !           598:     }
        !           599: 
        !           600:     /*SuspendThread (hEmuThread);*/
        !           601:     close_windows ();
        !           602: }
        !           603: 
        !           604: void displaychange (void)
        !           605: {
        !           606:     changemode = 1;
        !           607:     destroy_window (0);
        !           608: }
        !           609: 
        !           610: void toggle_fullscreen (void)
        !           611: {
        !           612:     changemode = 1;
        !           613:     if (screen_is_picasso)
        !           614:        picasso_fullscreen ^= 1;
        !           615:     else
        !           616:        amiga_fullscreen ^= 1;
        !           617:     destroy_window (0);
        !           618: }
        !           619: 
        !           620: int can_draw (void)
        !           621: {
        !           622:     return gfxvidinfo.pixbytes != 0;
        !           623: }
        !           624: 
        !           625: long FAR PASCAL AmigaWindowProc (HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
        !           626: {
        !           627:     PAINTSTRUCT ps;
        !           628:     HDC hDC;
        !           629: 
        !           630:     if (changemode != 0)
        !           631:        return DefWindowProc (hWnd, message, wParam, lParam);
        !           632: 
        !           633:     switch (message) {
        !           634:     case WM_ACTIVATEAPP:
        !           635:        if (bActive = wParam) {
        !           636:            if (fullscreen) {
        !           637:                SetCursor (NULL);
        !           638:                SetCursorPos (mousecx, mousecy);
        !           639: #ifdef PICASSO96
        !           640:         if( !picasso96_state.RefreshPending )
        !           641:             picasso96_state.RefreshPending = 1;
        !           642: #endif
        !           643:            }
        !           644:            my_kbd_handler (VK_CAPITAL, 0x3a, TRUE);
        !           645:        } else {
        !           646:            if (!fullscreen)
        !           647:                setmouseactive (0);
        !           648:        }
        !           649:        break;
        !           650: 
        !           651:     case WM_ACTIVATE:
        !           652:        if (LOWORD (wParam) != WA_INACTIVE) {
        !           653:            ShowWindow (hWnd, SW_RESTORE);
        !           654:        }
        !           655:        break;
        !           656: 
        !           657:     case WM_SETCURSOR:
        !           658:        if (fullscreen) {
        !           659:            SetCursor (NULL);
        !           660:            return TRUE;
        !           661:        }
        !           662:        break;
        !           663: 
        !           664:     case WM_SYSCOMMAND:
        !           665:        if (wParam == SC_ZOOM) {
        !           666:            toggle_fullscreen ();
        !           667:            return 0;
        !           668:        }
        !           669:        break;
        !           670: 
        !           671:     case WM_KEYUP:
        !           672:     case WM_SYSKEYUP:
        !           673:        numkeysdown--;
        !           674:        keysdown[wParam] = 0;
        !           675:        my_kbd_handler (wParam, (lParam >> 16) & 0x1ff, FALSE);
        !           676:        break;
        !           677: 
        !           678:     case WM_KEYDOWN:
        !           679:     case WM_SYSKEYDOWN:
        !           680:        if (LOWORD (lParam) == 1) {
        !           681:            if (numkeysdown) {
        !           682:                int key;
        !           683:                numkeysdown = 0;
        !           684: 
        !           685:                for (key = 256; key--;) {
        !           686:                    if (keysdown[key]) {
        !           687:                        if (checkkey (key, lParam))
        !           688:                            numkeysdown++;
        !           689:                        else {
        !           690:                            my_kbd_handler (key, (keysdown[key] >> 16) & 0x1ff, FALSE);
        !           691:                            keysdown[key] = 0;
        !           692:                        }
        !           693:                    }
        !           694:                }
        !           695:            }
        !           696:            if (!keysdown[wParam]) {
        !           697:                keysdown[wParam] = lParam;
        !           698:                numkeysdown++;
        !           699:            }
        !           700:            numkeysdown++;
        !           701:            my_kbd_handler (wParam, (lParam >> 16) & 0x1ff, TRUE);
        !           702:        }
        !           703:        break;
        !           704: 
        !           705:     case WM_LBUTTONDOWN:
        !           706:        if (ievent_alive) {
        !           707:            setcapture ();
        !           708:            buttonstate[0] = 1;
        !           709:        } else if (!fullscreen && !mouseactive)
        !           710:            setmouseactive (1);
        !           711:        else
        !           712:            buttonstate[0] = 1;
        !           713:        break;
        !           714: 
        !           715:     case WM_LBUTTONUP:
        !           716:        releasecapture ();
        !           717:        buttonstate[0] = 0;
        !           718:        break;
        !           719: 
        !           720:     case WM_MBUTTONDOWN:
        !           721:        if (ievent_alive)
        !           722:            setcapture ();
        !           723:        buttonstate[1] = 1;
        !           724:        break;
        !           725: 
        !           726:     case WM_MBUTTONUP:
        !           727:        releasecapture ();
        !           728:        buttonstate[1] = 0;
        !           729:        break;
        !           730: 
        !           731:     case WM_RBUTTONDOWN:
        !           732:        if (ievent_alive)
        !           733:            setcapture ();
        !           734:        buttonstate[2] = 1;
        !           735:        break;
        !           736: 
        !           737:     case WM_RBUTTONUP:
        !           738:        releasecapture ();
        !           739:        buttonstate[2] = 0;
        !           740:        break;
        !           741: 
        !           742:     case WM_MOUSEMOVE:
        !           743:        if ((mouseactive && !ievent_alive) || fullscreen) {
        !           744:            /*
        !           745:             * In this mode, the mouse pointer is always centered in the window,
        !           746:             * this is ensured by the SetCursorPos call below.
        !           747:             * We don't want to handle messages that result from such a SetCursorPos
        !           748:             * call (recursion!), so exit early if we see one.
        !           749:             */
        !           750:            if (lParam == mousecl)
        !           751:                break;
        !           752:            lastmx += (signed short) LOWORD (lParam) - mousedx;
        !           753:            lastmy += (signed short) HIWORD (lParam) - mousedy;
        !           754:            if (ievent_alive) {
        !           755:                if (lastmx < 0)
        !           756:                    lastmx = 0;
        !           757:                if (lastmx > current_width)
        !           758:                    lastmx = current_width;
        !           759:                if (lastmy < 0)
        !           760:                    lastmy = 0;
        !           761:                if (lastmy > current_height)
        !           762:                    lastmy = current_height;
        !           763: 
        !           764:            }
        !           765:            SetCursorPos (mousecx, mousecy);
        !           766:            break;
        !           767:        }
        !           768:        lastmx = (signed short) LOWORD (lParam);
        !           769:        lastmy = (signed short) HIWORD (lParam);
        !           770:        break;
        !           771: 
        !           772:     case WM_PAINT:
        !           773:        hDC = BeginPaint (hWnd, &ps);
        !           774:        clear_inhibit_frame (IHF_WINDOWHIDDEN);
        !           775:        if (hBackDC)
        !           776:            BitBlt (hDC, ps.rcPaint.left, ps.rcPaint.top,
        !           777:                    ps.rcPaint.right - ps.rcPaint.left,
        !           778:                    ps.rcPaint.bottom - ps.rcPaint.top, hBackDC,
        !           779:                    ps.rcPaint.left, ps.rcPaint.top, SRCCOPY);
        !           780:        else
        !           781:            notice_screen_contents_lost ();
        !           782: 
        !           783:        EndPaint (hWnd, &ps);
        !           784:        break;
        !           785: 
        !           786:     case WM_DROPFILES:
        !           787:        if (DragQueryFile ((HDROP) wParam, (UINT) - 1, NULL, 0)) {
        !           788:            if (DragQueryFile ((HDROP) wParam, 0, NULL, 0) < 255)
        !           789:                DragQueryFile ((HDROP) wParam, 0, changed_prefs.df[0], sizeof (changed_prefs.df[0]));
        !           790:        }
        !           791:        DragFinish ((HDROP) wParam);
        !           792:        break;
        !           793: 
        !           794:     case WM_CAPTURECHANGED:
        !           795:        if (lParam != hWnd)
        !           796:            buttonstate[0] = buttonstate[1] = buttonstate[2] = 0;
        !           797:        break;
        !           798: 
        !           799:     case WM_TIMER:
        !           800: #if 0
        !           801:        if (wParam == 2) {
        !           802:            KillTimer (hwnd, timer_id);
        !           803:            timer_id = 0;
        !           804:            ClearVisibleAreaAndRefresh ();
        !           805:        } else
        !           806: #endif
        !           807:        {
        !           808:            finishjob ();
        !           809:        }
        !           810:        break;
        !           811: 
        !           812:     case WM_USER + 0x200:
        !           813:        DoSomeWeirdPrintingStuff(wParam);
        !           814:        break;
        !           815: 
        !           816:     case WM_USER + 0x201:
        !           817:        changemode = 2;
        !           818:        destroy_window (1);
        !           819:        break;
        !           820: 
        !           821:     case WM_CREATE:
        !           822:        DragAcceptFiles (hWnd, TRUE);
        !           823:        break;
        !           824: 
        !           825:     case WM_DESTROY:
        !           826:        changemode = 3;
        !           827:        destroy_window (0);
        !           828:        break;
        !           829:     }
        !           830: 
        !           831:     return DefWindowProc (hWnd, message, wParam, lParam);
        !           832: }
        !           833: 
        !           834: long FAR PASCAL MainWindowProc (HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
        !           835: {
        !           836:     PAINTSTRUCT ps;
        !           837:     RECT rc, rc2;
        !           838:     HDC hDC;
        !           839: 
        !           840:     if (changemode != 0)
        !           841:        return DefWindowProc (hWnd, message, wParam, lParam);
        !           842: 
        !           843:     switch (message) {
        !           844:      case WM_LBUTTONDOWN:
        !           845:      case WM_MOUSEMOVE:
        !           846:      case WM_ACTIVATEAPP:
        !           847:      case WM_ACTIVATE:
        !           848:      case WM_SETCURSOR:
        !           849:      case WM_SYSCOMMAND:
        !           850:      case WM_KEYUP:
        !           851:      case WM_SYSKEYUP:
        !           852:      case WM_KEYDOWN:
        !           853:      case WM_SYSKEYDOWN:
        !           854:      case WM_LBUTTONUP:
        !           855:      case WM_MBUTTONDOWN:
        !           856:      case WM_MBUTTONUP:
        !           857:      case WM_RBUTTONDOWN:
        !           858:      case WM_RBUTTONUP:
        !           859:      case WM_DROPFILES:
        !           860:      case WM_CREATE:
        !           861:      case WM_DESTROY:
        !           862:      case WM_USER + 0x200:
        !           863:      case WM_USER + 0x201:
        !           864:        return AmigaWindowProc (hWnd, message, wParam, lParam);
        !           865: 
        !           866:      case WM_DISPLAYCHANGE:
        !           867:        if (!fullscreen && !changemode && (wParam + 7) / 8 != current_pixbytes)
        !           868:            displaychange ();
        !           869:        break;
        !           870: 
        !           871:      case WM_ENTERSIZEMOVE:
        !           872:        if (!fullscreen) {
        !           873:            frame_do_semup = 1;
        !           874:            set_inhibit_frame (5);
        !           875:            uae_sem_wait (&frame_sem);
        !           876:        }
        !           877:        break;
        !           878: 
        !           879:      case WM_EXITSIZEMOVE:
        !           880:        clear_inhibit_frame (5);
        !           881:        /* fall through */
        !           882: 
        !           883:      case WM_WINDOWPOSCHANGED:
        !           884:        GetWindowRect (hAmigaWnd, &amigawin_rect);
        !           885: 
        !           886:        if (!fullscreen && hAmigaWnd) {
        !           887:            if (current_pixbytes == 2) {
        !           888:                if (amigawin_rect.left & 1) {
        !           889:                    GetWindowRect (hMainWnd, &rc2);
        !           890:                    if (1 /*!mon || rc2.left + 4 < GetSystemMetrics (SM_CXSCREEN)*/)
        !           891:                        MoveWindow (hMainWnd, rc2.left + 1, rc2.top,
        !           892:                                    rc2.right - rc2.left, rc2.bottom - rc2.top, TRUE);
        !           893:                }
        !           894:            } else if (current_pixbytes == 3) {
        !           895:                if (amigawin_rect.left >= 0) {
        !           896:                    if (amigawin_rect.left & 3) {
        !           897:                        GetWindowRect (hMainWnd, &rc2);
        !           898:                        if (1 /*!mon || rc2.left + 4 < GetSystemMetrics (SM_CXSCREEN)*/)
        !           899:                            MoveWindow (hMainWnd, rc2.left - amigawin_rect.left % 4, rc2.top,
        !           900:                                        rc2.right - rc2.left, rc2.bottom - rc2.top, TRUE);
        !           901:                    }
        !           902:                }
        !           903:            }
        !           904:            setmouseactive (0);
        !           905:            return 0;
        !           906:        }
        !           907:        break;
        !           908: 
        !           909:      case WM_PAINT:
        !           910:        hDC = BeginPaint (hWnd, &ps);
        !           911:        GetClientRect (hWnd, &rc);
        !           912:        DrawEdge (hDC, &rc, EDGE_SUNKEN, BF_RECT);
        !           913: 
        !           914:        EndPaint (hWnd, &ps);
        !           915:        break;
        !           916: 
        !           917:      case WM_NCLBUTTONDBLCLK:
        !           918:        if (wParam == HTCAPTION) {
        !           919:            toggle_fullscreen ();
        !           920:            return 0;
        !           921:        }
        !           922:     }
        !           923: 
        !           924:     return DefWindowProc (hWnd, message, wParam, lParam);
        !           925: }
        !           926: 
        !           927: static int HasConsole;
        !           928: static HANDLE stdouthandle;
        !           929: static HANDLE debugfile;
        !           930: 
        !           931: /* Console Win32 helper routines */
        !           932: void activate_debugger ();
        !           933: 
        !           934: static BOOL __stdcall ctrlchandler (DWORD type)
        !           935: {
        !           936:     SetConsoleCtrlHandler ((PHANDLER_ROUTINE) ctrlchandler, FALSE);
        !           937: 
        !           938:     if (type == CTRL_C_EVENT) {
        !           939:        activate_debugger ();
        !           940:        return TRUE;
        !           941:     }
        !           942:     return FALSE;
        !           943: }
        !           944: 
        !           945: void setup_brkhandler (void)
        !           946: {
        !           947:     SetConsoleCtrlHandler ((PHANDLER_ROUTINE) ctrlchandler, TRUE);
        !           948: }
        !           949: 
        !           950: void remove_brkhandler (void)
        !           951: {
        !           952:     SetConsoleCtrlHandler ((PHANDLER_ROUTINE) ctrlchandler, FALSE);
        !           953: }
        !           954: 
        !           955: int PASCAL WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine,
        !           956:                    int nCmdShow)
        !           957: {
        !           958:     char *posn;
        !           959:     int i;
        !           960: 
        !           961:     hInst = hInstance;
        !           962: 
        !           963:     debugfile = CreateFile ("outfile", GENERIC_WRITE, 0, 0, CREATE_ALWAYS,
        !           964:                            0, NULL);
        !           965: 
        !           966:     for (i = 0; i < NUM_DRIVES; i++) {
        !           967:        drives[i].path[0] = 0;
        !           968:        drives[i].name[0] = 0;
        !           969:        drives[i].rw = TRUE;
        !           970:     }
        !           971: 
        !           972:     /* Get our executable's root-path */
        !           973:     start_path = xmalloc(MAX_PATH);
        !           974:     GetModuleFileName (hInst, start_path, MAX_PATH);
        !           975:     if (posn = strrchr (start_path, '\\'))
        !           976:        *posn = 0;
        !           977: 
        !           978: 
        !           979:     HasConsole = 0;/*AllocConsole ();*/
        !           980:     if (HasConsole)
        !           981:        stdouthandle = GetStdHandle (STD_OUTPUT_HANDLE);
        !           982: 
        !           983:     write_log ("UAE " UAEWINVERSION " Win32/DirectX, release " UAEWINRELEASE "\n");
        !           984:     strcpy (VersionStr, PROGNAME);
        !           985:     write_log ("\n(c) 1995-1997 Bernd Schmidt   - Core UAE concept and implementation."
        !           986:               "\n(c) 1996-1997 Mathias Ortmann - Win32 port and enhancements."
        !           987:               "\n(c) 1996-1997 Brian King      - Picasso96 and AHI support, GUI.\n"
        !           988:               "\nPress F12 to show the Settings Dialog (GUI), Alt-F4 to quit.\n"
        !           989:               "\nhttp://www.informatik.tu-muenchen.de/~ortmann/uae/\n\n");
        !           990: 
        !           991:     currprefs.copper_pos = -1;
        !           992:     /*initgfxspecs();*/
        !           993:     if (initlibs ())
        !           994:        real_main (__argc, __argv);
        !           995:     cleanuplibs();
        !           996: 
        !           997:     if (HasConsole)
        !           998:        FreeConsole ();
        !           999: 
        !          1000:     return FALSE;
        !          1001: }
        !          1002: 
        !          1003: static int register_classes (void)
        !          1004: {
        !          1005:     WNDCLASS wc;
        !          1006: 
        !          1007:     wc.style = 0;
        !          1008:     wc.lpfnWndProc = AmigaWindowProc;
        !          1009:     wc.cbClsExtra = 0;
        !          1010:     wc.cbWndExtra = 0;
        !          1011:     wc.hInstance = 0;
        !          1012:     wc.hIcon = LoadIcon (GetModuleHandle (NULL), IDI_APPICON);
        !          1013:     wc.hCursor = LoadCursor (NULL, IDC_ARROW);
        !          1014:     wc.hbrBackground = GetStockObject (BLACK_BRUSH);
        !          1015:     wc.lpszMenuName = NULL;
        !          1016:     wc.lpszClassName = "AmigaPowah";
        !          1017:     if (!RegisterClass (&wc))
        !          1018:        return 0;
        !          1019: 
        !          1020:     wc.style = 0;
        !          1021:     wc.lpfnWndProc = MainWindowProc;
        !          1022:     wc.cbClsExtra = 0;
        !          1023:     wc.cbWndExtra = 0;
        !          1024:     wc.hInstance = 0;
        !          1025:     wc.hIcon = LoadIcon (GetModuleHandle (NULL), IDI_APPICON);
        !          1026:     wc.hCursor = LoadCursor (NULL, IDC_ARROW);
        !          1027:     wc.hbrBackground = GetStockObject (BLACK_BRUSH);
        !          1028:     wc.lpszMenuName = NULL;
        !          1029:     wc.lpszClassName = "PCsuxRox";
        !          1030:     if (!RegisterClass (&wc))
        !          1031:        return 0;
        !          1032:     return 1;
        !          1033: }
        !          1034: 
        !          1035: int graphics_setup (void)
        !          1036: {
        !          1037:     DWORD ddrval;
        !          1038: 
        !          1039:     if (!register_classes ())
        !          1040:        return 0;
        !          1041: 
        !          1042:     uae_sem_init (&picasso_switch_sem, 0, 0);
        !          1043:     return 1;
        !          1044: }
        !          1045: 
        !          1046: #define NORMAL_WINDOW_STYLE (WS_VISIBLE | WS_BORDER | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX)
        !          1047: 
        !          1048: static int create_windows (void)
        !          1049: {
        !          1050:     POINT pt;
        !          1051: 
        !          1052:     if (!fullscreen) {
        !          1053:        RECT rc;
        !          1054: 
        !          1055:        rc.left = 0;
        !          1056:        rc.top = 0;
        !          1057:        rc.right = current_width;
        !          1058:        rc.bottom = current_height;
        !          1059:        rc.right += 4;
        !          1060:        rc.bottom += 4;
        !          1061:        AdjustWindowRect (&rc, NORMAL_WINDOW_STYLE, FALSE);
        !          1062: 
        !          1063:        hMainWnd = CreateWindowEx (WS_EX_ACCEPTFILES,
        !          1064:                                   "PCsuxRox",
        !          1065:                                   TITLETEXT,
        !          1066:                                   NORMAL_WINDOW_STYLE,
        !          1067:                                   CW_USEDEFAULT, CW_USEDEFAULT,
        !          1068:                                   rc.right - rc.left, rc.bottom - rc.top,
        !          1069:                                   NULL,
        !          1070:                                   NULL,
        !          1071:                                   0,
        !          1072:                                   NULL);
        !          1073: 
        !          1074:        if (! hMainWnd)
        !          1075:            return 0;
        !          1076:     } else
        !          1077:        hMainWnd = NULL;
        !          1078: 
        !          1079:     hAmigaWnd = CreateWindowEx (fullscreen ? WS_EX_TOPMOST : WS_EX_ACCEPTFILES,
        !          1080:                                "AmigaPowah",
        !          1081:                                PROGNAME,
        !          1082:                                hMainWnd ? WS_VISIBLE | WS_CHILD : WS_VISIBLE | WS_POPUP,
        !          1083:                                hMainWnd ? 2 : CW_USEDEFAULT, hMainWnd ? 2 : CW_USEDEFAULT,
        !          1084:                                fullscreen ? GetSystemMetrics (SM_CXSCREEN) : current_width,
        !          1085:                                fullscreen ? GetSystemMetrics (SM_CYSCREEN) : current_height,
        !          1086:                                hMainWnd,
        !          1087:                                NULL,
        !          1088:                                0,
        !          1089:                                NULL);
        !          1090: 
        !          1091:     if (!hAmigaWnd) {
        !          1092:        if (hMainWnd)
        !          1093:            DestroyWindow (hMainWnd);
        !          1094:        return 0;
        !          1095:     }
        !          1096: 
        !          1097:     if (hMainWnd)
        !          1098:        UpdateWindow (hMainWnd);
        !          1099:     if (hAmigaWnd)
        !          1100:        UpdateWindow (hAmigaWnd);
        !          1101: 
        !          1102:     return 1;
        !          1103: }
        !          1104: 
        !          1105: void doPreInit( void )
        !          1106: {
        !          1107:     void *blah;
        !          1108:     DWORD ddrval;
        !          1109: #ifdef __GNUC__
        !          1110:     ddrval = (*pDirectDrawCreate)(NULL,&lpDD,NULL);
        !          1111: #else
        !          1112:     ddrval = DirectDrawCreate( NULL, &lpDD, NULL );
        !          1113: #endif
        !          1114:     if (ddrval == DD_OK)
        !          1115:     {
        !          1116:         //IDirectDraw2_QueryInterface( lpDD, &IID_IDirectDraw2, &blah );
        !          1117: 
        !          1118:         mode_count = DX_FillResolutions( &picasso96_pixel_format );
        !          1119: 
        !          1120:            // If we've got no command-line arguments, then we use the integrated-GUI
        !          1121:            if( ( __argc == 1 ) && 
        !          1122:                ( GetSettings() == FALSE ) )
        !          1123:            {
        !          1124:                MyOutputDebugString("GetSettings() trying to quit...\n"); 
        !          1125:                shutdownmain();
        !          1126:            }
        !          1127:     }
        !          1128: }
        !          1129: 
        !          1130: BOOL doInit (void)
        !          1131: {
        !          1132:     if (! create_windows ())
        !          1133:        return 0;
        !          1134: #ifdef PICASSO96
        !          1135:     if (screen_is_picasso) {
        !          1136:        if (!set_ddraw (current_width, current_height, fullscreen, &picasso_vidinfo.depth,
        !          1137:                        (LPPALETTEENTRY)&picasso96_state.CLUT))
        !          1138:            goto oops;
        !          1139:        picasso_vidinfo.rowbytes = ddsd.lPitch;
        !          1140:     } else
        !          1141: #endif
        !          1142:     {
        !          1143:        gfxvidinfo.pixbytes = 2;
        !          1144:        if (!set_ddraw (current_width, current_height, fullscreen, &gfxvidinfo.pixbytes, colors256))
        !          1145:            goto oops;
        !          1146:        gfxvidinfo.bufmem = 0;
        !          1147:        gfxvidinfo.linemem = 0;
        !          1148:        gfxvidinfo.maxblocklines = 0;
        !          1149:        gfxvidinfo.width = current_width;
        !          1150:        gfxvidinfo.height = current_height;
        !          1151:        gfxvidinfo.rowbytes = ddsd.lPitch;
        !          1152:        gfxvidinfo.can_double = 1;
        !          1153:     }
        !          1154: 
        !          1155:     if (fullscreen) {
        !          1156:        scrindirect = 0;
        !          1157:        gfxvidinfo.linemem = 0;
        !          1158:        mousecx = 160, mousecy = 100, mousedx = 160, mousedy = 100, mousecl = MAKELONG (160, 100);
        !          1159:     }
        !          1160: 
        !          1161:     if (! do_surfacelock ())
        !          1162:        goto oops;
        !          1163:     unlockscr ();
        !          1164: 
        !          1165:     if ((ddsd.ddpfPixelFormat.dwFlags & (DDPF_RGB | DDPF_PALETTEINDEXED8 | DDPF_RGBTOYUV)) != 0)
        !          1166:     {
        !          1167:        MyOutputDebugString ("%s mode (bits: %d, pixbytes: %d)\n", fullscreen ? "Full screen" : "Window",
        !          1168:                             ddsd.ddpfPixelFormat.dwRGBBitCount, current_pixbytes);
        !          1169: #ifdef PICASSO96
        !          1170:             if( ddsd.ddpfPixelFormat.dwRBitMask == 0x0000F800 )
        !          1171:                 picasso96_pixel_format |= RGBFF_R5G6B5PC;
        !          1172:             else if( ddsd.ddpfPixelFormat.dwRBitMask == 0x00007C00 )
        !          1173:                 picasso96_pixel_format |= RGBFF_R5G5B5PC;
        !          1174:             else if( ddsd.ddpfPixelFormat.dwBBitMask == 0x0000F800 )
        !          1175:                 picasso96_pixel_format |= RGBFF_B5G6R5PC;
        !          1176:             else
        !          1177:                 picasso96_pixel_format |= RGBFF_B5G5R5PC;
        !          1178: #endif
        !          1179:     } else {
        !          1180:        MyOutputDebugString ("Error: Unsupported pixel format - use a different screen mode\n");
        !          1181:        goto oops;
        !          1182:     }
        !          1183: #ifdef PICASSO96
        !          1184:     if (screen_is_picasso)
        !          1185:        DX_SetPalette (0, 256);
        !          1186:     else
        !          1187: #endif
        !          1188:        init_colors ();
        !          1189: 
        !          1190:     if (!fullscreen)
        !          1191:        MainWindowProc (0, WM_WINDOWPOSCHANGED, 0, 0);
        !          1192:     return 1;
        !          1193: 
        !          1194: oops:
        !          1195:     if (hMainWnd)
        !          1196:        DestroyWindow (hMainWnd);
        !          1197:     if (hAmigaWnd)
        !          1198:        DestroyWindow (hAmigaWnd);
        !          1199:     return 0;
        !          1200: }
        !          1201: 
        !          1202: struct myRGNDATA {
        !          1203:     RGNDATAHEADER rdh;
        !          1204:     RECT rects[640];   /* fixed buffers suck, but this is _very_ unlikely to overflow */
        !          1205: } ClipList = { {
        !          1206:     sizeof (ClipList), RDH_RECTANGLES, 0, 640 * sizeof (RECT)
        !          1207: } };
        !          1208: 
        !          1209: 
        !          1210: /* this is the way the display line is put to screen
        !          1211:  * if the display is not 16 bits deep or the window is not fully visible */
        !          1212: static void clipped_linetoscr (char *dst, char *src, int y)
        !          1213: {
        !          1214:     LPRECT lpRect = ClipList.rects;
        !          1215:     int i;
        !          1216: 
        !          1217:     switch (current_pixbytes) {
        !          1218:     case 1:
        !          1219:        for (i = ClipList.rdh.nCount; i--; lpRect++) {
        !          1220:            if (y >= lpRect->top && y < lpRect->bottom) {
        !          1221:                memcpy (dst + lpRect->left, src + lpRect->left, lpRect->right);
        !          1222:            }
        !          1223:        }
        !          1224:        break;
        !          1225: 
        !          1226:     case 2:
        !          1227:        for (i = ClipList.rdh.nCount; i--; lpRect++) {
        !          1228:            if (y >= lpRect->top && y < lpRect->bottom) {
        !          1229:                memcpy (dst + lpRect->left*2, src + lpRect->left*2, lpRect->right*2);
        !          1230:            }
        !          1231:        }
        !          1232:        break;
        !          1233: 
        !          1234:     case 3:
        !          1235:        for (i = ClipList.rdh.nCount; i--; lpRect++) {
        !          1236:            if (y >= lpRect->top && y < lpRect->bottom) {
        !          1237:                memcpy (dst + lpRect->left*3, src + lpRect->left*3, lpRect->right*3);
        !          1238:            }
        !          1239:        }
        !          1240:        break;
        !          1241: 
        !          1242:      case 4:
        !          1243:        for (i = ClipList.rdh.nCount; i--; lpRect++) {
        !          1244:            if (y >= lpRect->top && y < lpRect->bottom) {
        !          1245:                memcpy (dst + lpRect->left*4, src + lpRect->left*4, lpRect->right*4);
        !          1246:            }
        !          1247:        }
        !          1248:        break;
        !          1249:     }
        !          1250: }
        !          1251: 
        !          1252: void flush_line(int lineno)
        !          1253: {
        !          1254:     if (scrindirect)
        !          1255:        clipped_linetoscr(gfxvidinfo.bufmem + lineno * gfxvidinfo.rowbytes,
        !          1256:                          scrlinebuf, lineno);
        !          1257: }
        !          1258: 
        !          1259: void flush_block(int a, int b)
        !          1260: {
        !          1261: }
        !          1262: 
        !          1263: void flush_screen(int a, int b)
        !          1264: {
        !          1265: }
        !          1266: 
        !          1267: char *lockscr (void)
        !          1268: {
        !          1269:     char *surface, *oldsurface;
        !          1270:     DWORD tmp;
        !          1271:     LPRECT lpRect;
        !          1272: 
        !          1273:     if (!do_surfacelock ())
        !          1274:        return NULL;
        !          1275: 
        !          1276:     surface = ddsd.lpSurface;
        !          1277:     oldsurface = gfxvidinfo.bufmem;
        !          1278:     if (!fullscreen) {
        !          1279:        surface += amigawin_rect.top * ddsd.lPitch + current_pixbytes * amigawin_rect.left;
        !          1280:     }
        !          1281:     gfxvidinfo.bufmem = surface;
        !          1282:     if (surface != oldsurface && ! screen_is_picasso) {
        !          1283:        write_log ("Need to init_row_map\n");
        !          1284:        init_row_map ();
        !          1285:     }
        !          1286: 
        !          1287:     scrindirect = 0;
        !          1288: 
        !          1289:     if (fullscreen) {
        !          1290:        set_linemem ();
        !          1291:        clear_inhibit_frame (IHF_WINDOWHIDDEN);
        !          1292:        return surface;
        !          1293:     }
        !          1294: 
        !          1295:     tmp = sizeof (ClipList.rects);
        !          1296: 
        !          1297:     /* This is the VERY instruction that drags other threads (input/file system) down when in windowed
        !          1298:      * mode - WHY can't Microsoft implement the IsClipListChanged() method as documented? ARGH! */
        !          1299:     if (IDirectDrawClipper_GetClipList (lpDDC, NULL, (LPRGNDATA) & ClipList, &tmp) == DD_OK) {
        !          1300:        lpRect = ClipList.rects;
        !          1301: 
        !          1302:        if (!ClipList.rdh.nCount) {
        !          1303:            write_log("ClipList empty\n");
        !          1304:            set_inhibit_frame (IHF_WINDOWHIDDEN);
        !          1305:            unlockscr ();
        !          1306:            return 0;
        !          1307:        }
        !          1308: 
        !          1309:        if (ClipList.rdh.nCount != 1
        !          1310:            || lpRect->right - lpRect->left != current_width
        !          1311:            || lpRect->bottom - lpRect->top != current_height)
        !          1312:        {
        !          1313:            scrindirect = 1;
        !          1314:            for (tmp = ClipList.rdh.nCount; tmp--; lpRect++) {
        !          1315:                lpRect->left -= amigawin_rect.left;
        !          1316:                lpRect->right -= amigawin_rect.left;
        !          1317:                lpRect->top -= amigawin_rect.top;
        !          1318:                lpRect->bottom -= amigawin_rect.top;
        !          1319: 
        !          1320:                lpRect->right -= lpRect->left;
        !          1321:            }
        !          1322:        }
        !          1323:     }
        !          1324: 
        !          1325:     set_linemem ();
        !          1326:     clear_inhibit_frame (IHF_WINDOWHIDDEN);
        !          1327:     return surface;
        !          1328: }
        !          1329: 
        !          1330: int graphics_init (void)
        !          1331: {
        !          1332:     static int first_time = 1;
        !          1333:     if (first_time)
        !          1334:        figure_processor_speed ();
        !          1335:     first_time = 0;
        !          1336: #ifdef PICASSO96
        !          1337:     if (screen_is_picasso) {
        !          1338:        fullscreen = picasso_fullscreen;
        !          1339:        current_width = picasso_vidinfo.width;
        !          1340:        current_height = picasso_vidinfo.height;
        !          1341:     } else 
        !          1342: #endif
        !          1343:     {
        !          1344:        fullscreen = amiga_fullscreen;
        !          1345:        current_width = currprefs.gfx_width;
        !          1346:        current_height = currprefs.gfx_height;
        !          1347: 
        !          1348:        if (!fullscreen) {
        !          1349:            if (current_height > 290 << currprefs.gfx_linedbl)
        !          1350:                current_height = 290 << currprefs.gfx_linedbl;
        !          1351:            if (current_width > 800 >> currprefs.gfx_lores)
        !          1352:                current_width = 800 >> currprefs.gfx_lores;
        !          1353:        }
        !          1354:        current_width = (current_width + 7) & ~7;
        !          1355:     }
        !          1356: 
        !          1357:     if (!doInit ())
        !          1358:        return 0;
        !          1359: 
        !          1360:     *xcolors = 0;
        !          1361: 
        !          1362:     return 1;
        !          1363: }
        !          1364: 
        !          1365: void graphics_leave (void)
        !          1366: {
        !          1367:     dumpcustom ();
        !          1368: }
        !          1369: 
        !          1370: void shutdownmain (void)
        !          1371: {
        !          1372:     changemode = 3;
        !          1373:     PostMessage (hAmigaWnd, WM_QUIT, 0, 0);
        !          1374: }
        !          1375: 
        !          1376: void workthread(void)
        !          1377: {
        !          1378:     if (use_debugger && debuggable ())
        !          1379:        activate_debugger ();
        !          1380: 
        !          1381:     do_start_program();
        !          1382:     shutdownmain();
        !          1383: }
        !          1384: 
        !          1385: void start_program (void)
        !          1386: {
        !          1387:     DWORD id;
        !          1388:     MSG msg;
        !          1389: 
        !          1390:     SetPriorityClass (GetCurrentProcess (), process_desired_pri);
        !          1391: 
        !          1392:     hEmuThread = CreateThread (NULL, 0, (LPTHREAD_START_ROUTINE) workthread, 0, CREATE_SUSPENDED, &id);
        !          1393:     SetThreadPriority (hEmuThread, THREAD_PRIORITY_BELOW_NORMAL);
        !          1394:     ResumeThread (hEmuThread);
        !          1395: 
        !          1396:     for (;;) {
        !          1397:        int cm;
        !          1398:        while (GetMessage (&msg, NULL, 0, 0)) {
        !          1399:            TranslateMessage (&msg);
        !          1400:            DispatchMessage (&msg);
        !          1401:        }
        !          1402:        cm = changemode;
        !          1403:        if (cm == 3)
        !          1404:            break;
        !          1405: 
        !          1406:        changemode = 0;
        !          1407:        current_pixbytes = 0;
        !          1408:        if (!graphics_init ())
        !          1409:            break;
        !          1410: 
        !          1411:        if (cm == 2) {
        !          1412:            uae_sem_post (&picasso_switch_sem);
        !          1413:        }
        !          1414:        clear_inhibit_frame (5);
        !          1415:        notice_screen_contents_lost ();
        !          1416:        notice_new_xcolors ();
        !          1417: 
        !          1418:        notice_new_xcolors ();
        !          1419: 
        !          1420:        /*ResumeThread (hEmuThread);*/
        !          1421: 
        !          1422:        if (currprefs.produce_sound > 1)
        !          1423:            startsound ();
        !          1424:     }
        !          1425: }
        !          1426: 
        !          1427: void handle_events (void)
        !          1428: {
        !          1429: }
        !          1430: 
        !          1431: #ifdef CONFIG_FOR_SMP
        !          1432: int uae_sem_initcs (LPCRITICAL_SECTION * cs)
        !          1433: {
        !          1434:     *cs = (LPCRITICAL_SECTION) GlobalAlloc (GPTR, sizeof csDraw);
        !          1435:     InitializeCriticalSection (*cs);
        !          1436: }
        !          1437: 
        !          1438: void uae_sem_enter (LPCRITICAL_SECTION cs)
        !          1439: {
        !          1440:     EnterCriticalSection (cs);
        !          1441: }
        !          1442: 
        !          1443: void uae_sem_leave (LPCRITICAL_SECTION cs)
        !          1444: {
        !          1445:     LeaveCriticalSection (cs);
        !          1446: }
        !          1447: 
        !          1448: void uae_sleep (int ms)
        !          1449: {
        !          1450:     Sleep (ms);
        !          1451: }
        !          1452: 
        !          1453: #endif
        !          1454: 
        !          1455: /* this is the semaphore for protecting the actual drawing against intermittent window movements */
        !          1456: void begindrawing (void)
        !          1457: {
        !          1458:     EnterCriticalSection (&csDraw);
        !          1459: }
        !          1460: 
        !          1461: void enddrawing (void)
        !          1462: {
        !          1463:     LeaveCriticalSection (&csDraw);
        !          1464: }
        !          1465: 
        !          1466: /* this truly sucks, I'll include a native gunzip() routine soon */
        !          1467: int gunzip_hack (const char *src, const char *dst)
        !          1468: {
        !          1469:     char buf[1024];
        !          1470:     STARTUPINFO si =
        !          1471:     {sizeof si};
        !          1472:     PROCESS_INFORMATION pi;
        !          1473: 
        !          1474:     strcpy (buf, dst);
        !          1475:     strcat (buf, ".gz");
        !          1476: 
        !          1477:     if (CopyFile (src, buf, FALSE)) {
        !          1478:        sprintf (buf, "gzip -f -d \"%s.gz\"", dst);
        !          1479:        si.dwFlags = STARTF_USESTDHANDLES;
        !          1480:        if (CreateProcess (NULL, buf, NULL, NULL, TRUE, 0, NULL, NULL, &si, &pi)) {
        !          1481:            WaitForSingleObject (pi.hProcess, INFINITE);
        !          1482:            return -1;
        !          1483:        } else {
        !          1484:            MyOutputDebugString ("Error: You need gzip.exe (32 bit) to use .adz/.roz files!\n");
        !          1485:        }
        !          1486:     }
        !          1487:     return 0;
        !          1488: }
        !          1489: 
        !          1490: /* file name requester. hBackBM will hopefully be dropped in the near future. */
        !          1491: static OPENFILENAME ofn = {
        !          1492:     sizeof (OPENFILENAME),
        !          1493:     NULL, NULL, "Amiga Disk Files\000*.adf;*.adz\000",
        !          1494:     NULL, 0, 0, 0, 256, NULL, 0, "",
        !          1495:     0,
        !          1496:     OFN_NOCHANGEDIR | OFN_EXPLORER | OFN_FILEMUSTEXIST | OFN_HIDEREADONLY,
        !          1497:     0,
        !          1498:     0,
        !          1499:     "adf",
        !          1500:     0,
        !          1501:     NULL,
        !          1502:     NULL
        !          1503: };
        !          1504: 
        !          1505: int requestfname (char *title, char *name)
        !          1506: {
        !          1507:     HDC hDC;
        !          1508:     char *result;
        !          1509:     RECT rc;
        !          1510: #ifdef PICASSO96
        !          1511:     uae_u8 old_switch_state = picasso96_state.SwitchState;
        !          1512: #endif
        !          1513: 
        !          1514:     ofn.hwndOwner = hAmigaWnd;
        !          1515:     ofn.lpstrTitle = title;
        !          1516:     ofn.lpstrFile = name;
        !          1517: 
        !          1518:     if (pGetOpenFileNameA == 0)
        !          1519:        return 0;
        !          1520: 
        !          1521:     if (IDirectDrawSurface_GetDC (lpDDS, &hDC) == DD_OK) {
        !          1522:        if ((hBackBM = CreateCompatibleBitmap (hDC, currprefs.gfx_width, currprefs.gfx_height))
        !          1523:            && (hBackDC = CreateCompatibleDC (hDC))) {
        !          1524:            SelectObject (hBackDC, hBackBM);
        !          1525: 
        !          1526:            if (fullscreen)
        !          1527:                BitBlt (hBackDC, 0, 0, currprefs.gfx_width, currprefs.gfx_height, hDC, 0, 0, SRCCOPY);
        !          1528:            else {
        !          1529:                BitBlt (hBackDC, 0, 0, currprefs.gfx_width, currprefs.gfx_height, hDC,
        !          1530:                        amigawin_rect.left, amigawin_rect.top, SRCCOPY);
        !          1531:            }
        !          1532:        }
        !          1533:        IDirectDrawSurface_ReleaseDC (lpDDS, hDC);
        !          1534:     }
        !          1535:     if (!fullscreen)
        !          1536:        setmouseactive (0);
        !          1537: 
        !          1538:     if (title)
        !          1539:        result = (char *)((*pGetOpenFileNameA) (&ofn));
        !          1540:     else {
        !          1541:        GetSettings ();
        !          1542:     }
        !          1543: 
        !          1544:     if (!fullscreen || !mouseactive)
        !          1545:        SetCursor (NULL);
        !          1546: 
        !          1547:     if (hBackBM) {
        !          1548:        if (hBackDC) {
        !          1549:            if (fullscreen && IDirectDrawSurface_GetDC (lpDDS, &hDC) == DD_OK) {
        !          1550:                BitBlt (hDC, 0, 0, currprefs.gfx_width, currprefs.gfx_height, hBackDC, 0, 0, SRCCOPY);
        !          1551:                IDirectDrawSurface_ReleaseDC (lpDDS, hDC);
        !          1552:            }
        !          1553:            DeleteObject (hBackDC);
        !          1554:            hBackDC = NULL;
        !          1555:        }
        !          1556:        DeleteObject (hBackBM);
        !          1557:        hBackBM = NULL;
        !          1558:     }
        !          1559:     notice_screen_contents_lost ();
        !          1560: 
        !          1561:     if (result)
        !          1562:        return 1;
        !          1563: 
        !          1564:     return 0;
        !          1565: }
        !          1566: 
        !          1567: int DisplayGUI( void )
        !          1568: {
        !          1569:     HBITMAP hBackBM2 = NULL;
        !          1570: #ifdef PICASSO96
        !          1571:     BITMAPINFO bminfo = { sizeof( BITMAPINFOHEADER ), current_width, -current_height, 1, 8, BI_RGB, 0, 0, 0, 0, 0, &picasso96_state.CLUT };
        !          1572: #endif
        !          1573:        HDC hDC;
        !          1574:     void *blah;
        !          1575:        RECT rc;
        !          1576:     uae_u8 p96_8bit = 0;
        !          1577: 
        !          1578:     if (pGetOpenFileNameA)
        !          1579:        {
        !          1580:         if (IDirectDrawSurface_GetDC(lpDDS,&hDC) == DD_OK)
        !          1581:                {
        !          1582: #ifdef PICASSO96
        !          1583:             if( picasso96_state.SwitchState && ( picasso96_state.BytesPerPixel == 1 ) )
        !          1584:             {
        !          1585:                 p96_8bit = 1;
        !          1586:                 hBackBM2 = CreateDIBSection( hDC, &bminfo, DIB_PAL_COLORS, &blah, NULL, 0 );
        !          1587:             }
        !          1588:             else
        !          1589: #endif
        !          1590:                 hBackBM = CreateCompatibleBitmap( hDC, current_width, current_height );
        !          1591: 
        !          1592:             if( (hBackBM2 || hBackBM ) && ( hBackDC = CreateCompatibleDC( hDC ) ) )
        !          1593:                        {
        !          1594: #ifdef PICASSO96
        !          1595:                 if( hBackBM2 )
        !          1596:                 {
        !          1597:                     SelectObject( hBackDC, hBackBM2 );
        !          1598:                     hBackBM = CreateCompatibleBitmap( hDC, current_width, current_height );
        !          1599:                 }
        !          1600:                 else
        !          1601: #endif
        !          1602:                     SelectObject( hBackDC, hBackBM );
        !          1603: 
        !          1604:                                if( fullscreen ) 
        !          1605:                     BitBlt( hBackDC, 0, 0, current_width, current_height, hDC, 0, 0, SRCCOPY );
        !          1606:                                else
        !          1607:                                {
        !          1608:                                        GetWindowRect(hAmigaWnd,&rc);
        !          1609:                                        BitBlt(hBackDC,0,0,current_width,current_height,hDC,rc.left,rc.top,SRCCOPY);
        !          1610:                                }
        !          1611: 
        !          1612:                 IDirectDrawSurface2_SetPalette( lpDDS, NULL );
        !          1613:                 if( hBackBM2 )
        !          1614:                     BitBlt( hDC, 0, 0, current_width, current_height, hBackDC, 0, 0, SRCCOPY );
        !          1615:                        }
        !          1616:                        IDirectDrawSurface_ReleaseDC( lpDDS, hDC );
        !          1617:                }
        !          1618: 
        !          1619:                if (!fullscreen) setmouseactive(FALSE);
        !          1620: 
        !          1621:         GetSettings();
        !          1622:         if( lpDDP )
        !          1623:             IDirectDrawSurface2_SetPalette( lpDDS, lpDDP );
        !          1624:        
        !          1625:                if (!fullscreen || !mouseactive) SetCursor(NULL);
        !          1626: 
        !          1627:                if( hBackBM || hBackBM2 )
        !          1628:                {
        !          1629:                        if( hBackDC )
        !          1630:                        {
        !          1631: #ifdef PICASSO96
        !          1632:                 if( p96_8bit )
        !          1633:                 {
        !          1634:                     picasso96_state.RefreshPending = 1;
        !          1635:                 }
        !          1636:                 else
        !          1637: #endif
        !          1638:                 if( fullscreen && IDirectDrawSurface_GetDC( lpDDS, &hDC ) == DD_OK )
        !          1639:                                {
        !          1640:                                        BitBlt( hDC, 0, 0, current_width, current_height, hBackDC, 0, 0, SRCCOPY );
        !          1641:                                        IDirectDrawSurface_ReleaseDC( lpDDS, hDC );
        !          1642:                                }
        !          1643:                                DeleteObject( hBackDC );
        !          1644:                                hBackDC = NULL;
        !          1645:                        }
        !          1646:             if( hBackBM2 )
        !          1647:                 DeleteObject( hBackBM2 );
        !          1648:             if( hBackBM )
        !          1649:             {
        !          1650:                            DeleteObject( hBackBM );
        !          1651:                            hBackBM = NULL;
        !          1652:             }
        !          1653:                }
        !          1654:        }
        !          1655:        return 0;
        !          1656: }
        !          1657: 
        !          1658: #ifdef __GNUC__
        !          1659: #undef WINAPI
        !          1660: #define WINAPI
        !          1661: #endif
        !          1662: 
        !          1663: static HINSTANCE hDDraw = NULL, hComDlg32 = NULL, hRichEdit = NULL;
        !          1664: 
        !          1665: int cleanuplibs(void)
        !          1666: {
        !          1667:     if (hRichEdit)
        !          1668:        FreeLibrary(hRichEdit);
        !          1669:     if (hDDraw)
        !          1670:        FreeLibrary(hDDraw);
        !          1671:     if (hComDlg32)
        !          1672:        FreeLibrary(hComDlg32);
        !          1673:     return 1;
        !          1674: }
        !          1675: 
        !          1676: /* try to load COMDLG32 and DDRAW, initialize csDraw, try to obtain the system clock frequency
        !          1677:  * from the registry, try to find out if we are running on a Pentium */
        !          1678: int initlibs (void)
        !          1679: {
        !          1680:     /* Make sure we do an InitCommonControls() to get some advanced controls */
        !          1681:     InitCommonControls ();
        !          1682: 
        !          1683:     if (hComDlg32 = LoadLibrary ("COMDLG32.DLL")) {
        !          1684:        pGetOpenFileNameA = (BOOL (WINAPI *) (LPOPENFILENAME)) GetProcAddress (hComDlg32, "GetOpenFileNameA");
        !          1685:     } else
        !          1686:        /* System administrator? ROFL! -- Bernd */
        !          1687:        MyOutputDebugString ("COMDLG32.DLL not available. Please contact your system administrator.\n");
        !          1688: 
        !          1689:     /* LoadLibrary the richedit control stuff */
        !          1690:     if ((hRichEdit = LoadLibrary ("RICHED32.DLL")) == NULL) {
        !          1691:        MyOutputDebugString ("RICHED32.DLL not available. Please contact your system administrator.\n");
        !          1692:     }
        !          1693:     if (hDDraw = LoadLibrary ("DDRAW.DLL")) {
        !          1694: #ifdef __GNUC__
        !          1695:        pDirectDrawCreate = (HRESULT (WINAPI *) (GUID FAR *, LPDIRECTDRAW FAR *, IUnknown FAR *)) GetProcAddress (hDDraw, "DirectDrawCreate");
        !          1696: #endif
        !          1697:        InitializeCriticalSection (&csDraw);
        !          1698: 
        !          1699:        process_desired_pri = IDLE_PRIORITY_CLASS;
        !          1700: 
        !          1701:        return 1;
        !          1702:     } else
        !          1703:        MyOutputDebugString ("You have to install DirectX on your system before you can use UAE.\nRefer to the documentation for further details.\n");
        !          1704: 
        !          1705:     return 0;
        !          1706: }
        !          1707: 
        !          1708: void MyOutputDebugString (char *format,...)
        !          1709: {
        !          1710:     char buffer[512];
        !          1711:     va_list parms;
        !          1712: 
        !          1713:     va_start (parms, format);
        !          1714:     vsprintf (buffer, format, parms);
        !          1715:     va_end (parms);
        !          1716:     write_log (buffer);
        !          1717: }
        !          1718: 
        !          1719: void write_log (const char *txt)
        !          1720: {
        !          1721:     DWORD numwritten;
        !          1722: #ifdef _DEBUG
        !          1723:     OutputDebugString( txt );
        !          1724: #endif
        !          1725:     fprintf (stderr, "%s", txt);
        !          1726:     /* if (HasConsole)
        !          1727:        WriteConsole (stdouthandle, txt, strlen (txt), &numwritten, NULL);*/
        !          1728:     WriteFile (debugfile, txt, strlen (txt), &numwritten, NULL);
        !          1729: }
        !          1730: 
        !          1731: int debuggable (void)
        !          1732: {
        !          1733:     return 1;
        !          1734: }
        !          1735: 
        !          1736: int needmousehack (void)
        !          1737: {
        !          1738:     return 1;
        !          1739: }
        !          1740: 
        !          1741: void LED (int on)
        !          1742: {
        !          1743: }
        !          1744: 
        !          1745: 
        !          1746: static uae_u16 *ppicasso_format;
        !          1747: static int picasso_modecount;
        !          1748: 
        !          1749: static HRESULT CALLBACK modesCallback (LPDDSURFACEDESC modeDesc, LPVOID context)
        !          1750: {
        !          1751:     int bpp;
        !          1752: 
        !          1753:     if (picasso_modecount >= MAX_PICASSO_MODES)
        !          1754:        return DDENUMRET_CANCEL;
        !          1755: 
        !          1756:     if (modeDesc->dwFlags & (DDSD_PIXELFORMAT | DDSD_WIDTH | DDSD_HEIGHT | DDSD_REFRESHRATE)) {
        !          1757:        bpp = modeDesc->ddpfPixelFormat.dwRGBBitCount;
        !          1758: #ifdef PICASSO96
        !          1759:        switch (bpp) {
        !          1760:        case 8:
        !          1761:            *ppicasso_format |= RGBFF_CHUNKY;
        !          1762:            break;
        !          1763:        case 16:
        !          1764:            /* figure out which actual format it is using based on the RGB masks */
        !          1765: 
        !          1766:         /* Bernd - this doesn't work for some reason.  Instead, I figure out the modes in doInit(),
        !          1767:          *         where I have the surface's description and pixel formats.  Damned DirectDraw stuff!
        !          1768:          */
        !          1769:            break;
        !          1770:        case 24:
        !          1771:            /* figure out which actual format it is using based on the RGB masks */
        !          1772:            if (modeDesc->ddpfPixelFormat.dwRBitMask == 0x00FF0000)
        !          1773:                *ppicasso_format |= RGBFF_B8G8R8;
        !          1774:            else
        !          1775:                *ppicasso_format |= RGBFF_R8G8B8;
        !          1776:            break;
        !          1777:        case 32:
        !          1778:            /* figure out which actual format it is using based on the RGB masks */
        !          1779:            if (modeDesc->ddpfPixelFormat.dwRBitMask == 0x00FF0000)
        !          1780:                *ppicasso_format |= RGBFF_B8G8R8A8;
        !          1781:            else if (modeDesc->ddpfPixelFormat.dwRBitMask == 0x000000FF)
        !          1782:                *ppicasso_format |= RGBFF_R8G8B8A8;
        !          1783:            else if (modeDesc->ddpfPixelFormat.dwBBitMask == 0xFF000000)
        !          1784:                *ppicasso_format |= RGBFF_A8R8G8B8;
        !          1785:            else
        !          1786:                *ppicasso_format |= RGBFF_A8B8G8R8;
        !          1787:            break;
        !          1788:        }
        !          1789: #endif
        !          1790:        DisplayModes[picasso_modecount].res.width = modeDesc->dwWidth;
        !          1791:        DisplayModes[picasso_modecount].res.height = modeDesc->dwHeight;
        !          1792:        DisplayModes[picasso_modecount].depth = bpp/8;
        !          1793:        if (modeDesc->dwRefreshRate)
        !          1794:     {
        !          1795:         sprintf(DisplayModes[picasso_modecount].name,"%dx%d, %d-bit, %d Hz",modeDesc->dwWidth,
        !          1796:             modeDesc->dwHeight, bpp, modeDesc->dwRefreshRate );
        !          1797:            DisplayModes[picasso_modecount].refresh = modeDesc->dwRefreshRate;
        !          1798:     }
        !          1799:        else
        !          1800:     {
        !          1801:         sprintf(DisplayModes[picasso_modecount].name,"%dx%d, %d-bit",modeDesc->dwWidth,
        !          1802:             modeDesc->dwHeight, bpp );
        !          1803:            DisplayModes[picasso_modecount].refresh = 75; /* fake a 75-Hz refresh rate... BLAH! */
        !          1804:     }
        !          1805:        picasso_modecount++;
        !          1806:     }
        !          1807:     return DDENUMRET_OK;
        !          1808: }
        !          1809: 
        !          1810: int DX_FillResolutions (uae_u16 *ppixel_format)
        !          1811: {
        !          1812:     static int from_preInit = 1;
        !          1813:     if( from_preInit )
        !          1814:     {
        !          1815:         picasso_modecount = 0;
        !          1816:         *ppixel_format = 0;
        !          1817:         ppicasso_format = ppixel_format;
        !          1818: 
        !          1819:         IDirectDraw_EnumDisplayModes (lpDD, 0, NULL, NULL, modesCallback);
        !          1820:         from_preInit = 0;
        !          1821:     }
        !          1822:     return picasso_modecount;
        !          1823: }
        !          1824: 
        !          1825: #ifdef PICASSO96
        !          1826: 
        !          1827: void DX_SetPalette (int start, int count)
        !          1828: {
        !          1829:     HRESULT ddrval;
        !          1830: 
        !          1831:     if (!screen_is_picasso)
        !          1832:        return;
        !          1833: 
        !          1834:     /* Set our DirectX palette here */
        !          1835:     if (lpDDP && (picasso96_state.BytesPerPixel == 1)) {
        !          1836:        /* For now, until I figure this out, just set the entire range of CLUT values */
        !          1837:        ddrval = IDirectDrawPalette_SetEntries (lpDDP, 0, 0, 256, (LPPALETTEENTRY) &picasso96_state.CLUT);
        !          1838:        if (ddrval != DD_OK)
        !          1839:            MyOutputDebugString ("DX_SetPalette() failed with %s/%d\n", getddrname (ddrval), ddrval);
        !          1840:     } else
        !          1841:        MyOutputDebugString ("ERROR - DX_SetPalette() doesn't have palette, or isn't Chunky mode.\n");
        !          1842: }
        !          1843: 
        !          1844: void DX_Invalidate (int first, int last)
        !          1845: {
        !          1846: }
        !          1847: 
        !          1848: int DX_BitsPerCannon (void)
        !          1849: {
        !          1850:     return 8;
        !          1851: }
        !          1852: 
        !          1853: int DX_FillRect (uaecptr addr, uae_u16 X, uae_u16 Y, uae_u16 Width, uae_u16 Height, uae_u32 Pen, uae_u8 Bpp)
        !          1854: {
        !          1855:     return 0;
        !          1856: }
        !          1857: 
        !          1858: void gfx_set_picasso_state (int on)
        !          1859: {
        !          1860:     if (screen_is_picasso == on)
        !          1861:        return;
        !          1862:     screen_is_picasso = on;
        !          1863:     PostMessage (hAmigaWnd, WM_USER + 0x201, 0, 0);
        !          1864:     uae_sem_wait (&picasso_switch_sem);
        !          1865: }
        !          1866: 
        !          1867: void gfx_set_picasso_modeinfo (int w, int h, int depth)
        !          1868: {
        !          1869:     depth >>= 3;
        !          1870:     if (picasso_vidinfo.width == w
        !          1871:        && picasso_vidinfo.height == h
        !          1872:        && picasso_vidinfo.depth == depth)
        !          1873:        return;
        !          1874: 
        !          1875:     picasso_vidinfo.width = w;
        !          1876:     picasso_vidinfo.height = h;
        !          1877:     picasso_vidinfo.depth = depth;
        !          1878:     picasso_vidinfo.extra_mem = 1;
        !          1879: 
        !          1880:     if (screen_is_picasso) {
        !          1881:        PostMessage (hAmigaWnd, WM_USER + 0x201, 0, 0);
        !          1882:        uae_sem_wait (&picasso_switch_sem);
        !          1883:     }
        !          1884: }
        !          1885: 
        !          1886: #endif

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.