ui_win32.c

另一个分形程序

	  }
      if (msg.message == WM_KEYDOWN)
	{
	  // any key
	  switch (msg.wParam)
	    {
	    case VK_MENU:
	      /*x_message("Alt"); */
	      altPressed = 1;
	      break;
	    case VK_UP:
	      *c = UIKEY_UP;
	      arrowsPressed |= 4;
	      break;
	    case VK_DOWN:
	      *c = UIKEY_DOWN;
	      arrowsPressed |= 8;
	      break;
	    case VK_LEFT:
	      *c = UIKEY_LEFT;
	      arrowsPressed |= 1;
	      break;
	    case VK_RIGHT:
	      *c = UIKEY_RIGHT;
	      arrowsPressed |= 2;
	      break;
	    case VK_ESCAPE:
	      *c = UIKEY_ESC;
	      break;
	    case VK_BACK:
	      *c = UIKEY_BACKSPACE;
	      break;
	    case VK_TAB:
	      *c = UIKEY_TAB;
	      break;
	    case VK_HOME:
	      *c = UIKEY_HOME;
	      break;
	    case VK_END:
	      *c = UIKEY_END;
	      break;
	    case VK_PRIOR:
	      *c = UIKEY_PGUP;
	      break;
	    case VK_NEXT:
	      *c = UIKEY_PGDOWN;
	      break;
#ifdef DDRAW_DRIVER
	    case VK_RETURN:
	      /*x_message("Enter %i",altPressed); */
	      if (altPressed)
		{
		  HDC hDC;
		  CONST char *cmd;
		  CONST menuitem *item;
		  if (directX == DXFULLSCREEN)
		    {
		      int depth;
		      cmd = "dX-windowed";
		      hDC = CreateDC ("DISPLAY", NULL, NULL, NULL);
		      depth = GetDeviceCaps (hDC, BITSPIXEL);
		      DeleteDC (hDC);
		      if (!DXSUPPORTEDDEPTH (0, depth))
			cmd = "win32";
		    }
		  else
		    {
		      cmd = "dX-fullscreen";
		    }
		  item = menu_findcommand (cmd);
		  ui_menuactivate (item, NULL);
		}
	      break;
#endif
	    }
	}
      // forward messages to window
      TranslateMessage (&msg);
      DispatchMessage (&msg);
    }
  getmouse (mx, my, mb);	// get mouse position

  *k = arrowsPressed;

  if (closeFlag)
    *c = -2;			// force quit if so requested

}

// calculate BITMAPINFO structure. It is used to copy bitmaps
static void
CalculateBITMAPINFO ()
{
  int i;
  if (!bmp)
    bmp = (BITMAPINFO *) malloc (sizeof (BITMAPINFOHEADER) + 4 * 256);

  memset (bmp, 0, sizeof (BITMAPINFOHEADER));
  bmp->bmiHeader.biSize = sizeof (BITMAPINFOHEADER);
  bmp->bmiHeader.biWidth = displayX;
  bmp->bmiHeader.biHeight = -displayY;
  bmp->bmiHeader.biPlanes = 1;
  bmp->bmiHeader.biBitCount = bitDepth;

  // create default palette
  for (i = 0; i < 256; i++)
    {
      bmp->bmiColors[i].rgbRed = i;
      bmp->bmiColors[i].rgbGreen = i;
      bmp->bmiColors[i].rgbBlue = i;
    }
}

#ifdef DDRAW_DRIVER

/**************************************************************************************
                             DirectDraw driver helper routines
 */
static char *resstr[MAXRESOLUTIONS];
static struct resolutions
{
  int width, height;
}
ressize[MAXRESOLUTIONS];
static int nresolutions;
/* callback for DirectX resolutions */
static HRESULT WINAPI
EnumModesCallback (LPDDSURFACEDESC lpDDSurfaceDesc, LPVOID lpContext)
{
  if (nresolutions < MAXRESOLUTIONS)
    if (lpDDSurfaceDesc->ddpfPixelFormat.u1.dwRGBBitCount == 8 ||
	lpDDSurfaceDesc->ddpfPixelFormat.u1.dwRGBBitCount == 16 ||
	lpDDSurfaceDesc->ddpfPixelFormat.u1.dwRGBBitCount == 24 ||
	lpDDSurfaceDesc->ddpfPixelFormat.u1.dwRGBBitCount == 32)
      {
	int i;
	char s[20];
	for (i = 0; i < nresolutions; i++)
	  if ((int) ressize[i].width == (int) lpDDSurfaceDesc->dwWidth
	      && (int) ressize[i].height == (int) lpDDSurfaceDesc->dwHeight)
	    return DDENUMRET_OK;
	ressize[nresolutions].width = lpDDSurfaceDesc->dwWidth;
	ressize[nresolutions].height = lpDDSurfaceDesc->dwHeight;
	sprintf (s, "%ix%i", lpDDSurfaceDesc->dwWidth,
		 lpDDSurfaceDesc->dwHeight);
	resstr[nresolutions] = strdup (s);
	nresolutions++;
      }
  return DDENUMRET_OK;
}
typedef HRESULT WINAPI (*ddrawcreateptr) (GUID FAR * lpGUID,
					  LPDIRECTDRAW FAR * lplpDD,
					  IUnknown FAR * pUnkOuter);
static ddrawcreateptr DirectDrawCreatePtr;

static int
ResizeDD (int fullscreen)
{
  HRESULT ddrval;
  DDSURFACEDESC ddsd;
  /*DDCAPS2 ddscaps; */
  LPDIRECTDRAWCLIPPER pClipper;
  int dxwidth;
  int dxheight;
  int dxbpp;

  // free DirectX objects
  if (lpSurfaces[0])
    IDirectDrawSurface_Release (lpSurfaces[0]);
  lpSurfaces[0] = NULL;
  if (dxPalette)
    IDirectDrawPalette_Release (dxPalette);
  dxPalette = NULL;
  /* Set cooperative level */
  ddrval = IDirectDraw2_SetCooperativeLevel (lpDD2, hWnd,
					     fullscreen ? (DDSCL_FULLSCREEN |
							   DDSCL_EXCLUSIVE |
							   DDSCL_ALLOWREBOOT)
					     : DDSCL_NORMAL);
  if (ddrval != DD_OK)
    {
      DeInitDD ();
      x_error ("Failed to set cooperative level");
      return 0;
    }

  if (fullscreen)
    {
      if (sscanf (dxsize, "%ix%ix%i", &dxwidth, &dxheight, &dxbpp) != 3)
	{
	  dxwidth = DXWIDTH;
	  dxheight = DXHEIGHT;
	  dxbpp = DXBPP;
	}
      displayX = dxwidth;
      displayY = dxheight;
      bitDepth = dxbpp;
      if (bitDepth < 10)
	bitDepth = 8;
      if (bitDepth >= 10 && bitDepth < 20)
	bitDepth = 16;
      if (bitDepth >= 20 && bitDepth < 28)
	bitDepth = 24;
      if (bitDepth >= 32 && bitDepth < 32)
	bitDepth = 32;

      /* set resolution and bit depth */
      ddrval =
	IDirectDraw2_SetDisplayMode (lpDD2, displayX, displayY, bitDepth, 0,
				     0);
      if (ddrval != DD_OK)
	{
	  /* The display mode cannot be changed. 
	     The mode is either not supported or 
	     another application has exclusive mode.

	     Try 320x200x256 and 640x480x256 modes before giving up */
	  displayX = 320;
	  displayY = 200;
	  bitDepth = 8;
	  ddrval =
	    IDirectDraw2_SetDisplayMode (lpDD2, displayX, displayY, bitDepth,
					 0, 0);
	  if (ddrval != DD_OK)
	    {
	      displayY = 240;
	      if (ddrval != DD_OK)
		{
		  displayX = 640;
		  displayY = 480;
		  ddrval =
		    IDirectDraw2_SetDisplayMode (lpDD2, displayX, displayY,
						 bitDepth, 0, 0);
		  if (ddrval != DD_OK)
		    {
		      /* Bad luck... give up. */
		      DeInitDD ();
		      return 0;
		    }
		}
	    }
	}
      SetRect (&rcViewport, 0, 0, displayX, displayY);
      rcScreen = rcViewport;
    }
  else
    {
      /* Get the dimensions of the viewport and screen bounds */
      GetClientRect (hWnd, &rcViewport);
      GetClientRect (hWnd, &rcScreen);
      ClientToScreen (hWnd, (POINT *) & rcScreen.left);
      ClientToScreen (hWnd, (POINT *) & rcScreen.right);
      /*bitDepth = GetDeviceCaps (hDC, BITSPIXEL); */

      /* Create clipper object for window */
      ddrval = IDirectDraw_CreateClipper (lpDD, 0, &pClipper, NULL);
      if (ddrval != DD_OK)
	{
	  DeInitDD ();
	  x_error ("Failed to create clipper object");
	  return 0;
	}
      /* Asociate it */
      IDirectDrawClipper_SetHWnd (pClipper, 0, hWnd);
    }
  /* Create the primary surface with one back buffer */
  CalculateBITMAPINFO ();	// calculate BITMAPINFO structure

  memset (&ddsd, 0, sizeof (ddsd));
  ddsd.dwSize = sizeof (ddsd);
  ddsd.dwFlags = DDSD_CAPS;
  ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;

  ddrval = IDirectDraw_CreateSurface (lpDD, &ddsd, &lpSurfaces[0], NULL);
  if (ddrval != DD_OK)
    {
      DeInitDD ();
      x_error ("Failed to create flipping surface");
      return 0;
    }

  if (!fullscreen)
    {
      IDirectDrawSurface_SetClipper (lpSurfaces[0], pClipper);
      IDirectDrawClipper_Release (pClipper);
      if (IDirectDrawSurface_GetSurfaceDesc (lpSurfaces[0], &ddsd) != DD_OK)
	{
	  DeInitDD ();
	  x_error ("Failed to get pixel format");
	  return 0;
	}
      bitDepth = ddsd.ddpfPixelFormat.u1.dwRGBBitCount;
    }

  if (bitDepth == 8)
    {
      /* create palette */
      ddrval =
	IDirectDraw_CreatePalette (lpDD, DDPCAPS_8BIT,
				   (LPPALETTEENTRY) bmp->bmiColors,
				   &dxPalette, NULL);
      if (ddrval != DD_OK)
	{
	  DeInitDD ();
	  x_error ("Failed to create palette");
	  return 0;
	}

      /* set palette */
      IDirectDrawSurface_SetPalette (lpSurfaces[0], dxPalette);
    }
  if (fullscreen)
    SetCursor (NULL);
  needredraw = 1;
  return 1;

}

/* init DirectX */
static int
InitDD (int fullscreen)
{
  HRESULT ddrval;
  HDC hDC;
  directX = fullscreen ? DXFULLSCREEN : DXWINDOWED;

  if (!hModule)
    hModule = LoadLibrary ("ddraw");
  if (!hModule)
    {
      /*x_error ("Unable to load DirectX (ddraw.dll)"); */
      return 0;
    }
  /* DirectDraw don't support 16 color modes. Don't even try to initialize
     it then. Also avoid unsupported bit depths in the windowed driver */
  hDC = CreateDC ("DISPLAY", NULL, NULL, NULL);
  bitDepth = GetDeviceCaps (hDC, BITSPIXEL);
  DeleteDC (hDC);

  if (!DXSUPPORTEDDEPTH (fullscreen, bitDepth))
    return 0;


  DirectDrawCreatePtr =
    (ddrawcreateptr) GetProcAddress (hModule, "DirectDrawCreate");
  if (!DirectDrawCreatePtr)
    {
      x_error
	("Unable to get hook DirectDrawCreate in ddraw.dll. Check your DirectX installation");
      return 0;
    }

  lpDD = NULL;
  lpDD2 = NULL;
  lpSurfaces[0] = NULL;
  lpSurfaces[1] = NULL;
  buffer1 = buffer2 = NULL;

  bitDepth = 8;

  InitWindow ();
  UpdateWindow (hWnd);
  SetFocus (hWnd);


  /* contact DirectX */
  ddrval = DirectDrawCreatePtr (NULL, &lpDD, NULL);
  if (ddrval != DD_OK)
    {
      DeInitDD ();
      x_error ("Failed to create DirectDraw object");
      return 0;
    }

  /* get IDirectDraw2 interface */
  ddrval =
    IDirectDraw_QueryInterface (lpDD, &IID_IDirectDraw2, (LPVOID *) & lpDD2);
  if (ddrval != DD_OK)
    {
      DeInitDD ();
      x_error ("Failed to get DirectDraw2 object");
      return 0;
    }
  /* enumerate modes */
#ifdef DDRAW_DRIVER
  if (!nresolutions && directX == DXFULLSCREEN)
    IDirectDraw2_EnumDisplayModes (lpDD2, 0, NULL, NULL, EnumModesCallback);
#endif


  if (!ResizeDD (fullscreen))
    return 0;
  if (fullscreen)
    {
      SetCapture (hWnd);	// make sure no other windows get mouse messages

      captured = 1;
    }

  return 1;
}

/* uninitialize DirectX */
static void
DeInitDD (void)
{
  if (captured)
    ReleaseCapture (), captured = 0;	// free mouse

  // free DirectX objects
  if (lpSurfaces[0])
    IDirectDrawSurface_Release (lpSurfaces[0]);
  lpSurfaces[0] = NULL;
  if (BackSurface[0])
    IDirectDrawSurface_Release (BackSurface[0]);
  BackSurface[0] = NULL;
  if (BackSurface[1])
    IDirectDrawSurface_Release (BackSurface[1]);
  BackSurface[1] = NULL;
  if (dxPalette)
    IDirectDrawPalette_Release (dxPalette);
  dxPalette = NULL;
  if (lpDD2)
    IDirectDraw2_Release (lpDD2);
  lpDD2 = NULL;
  if (lpDD)
    IDirectDraw_Release (lpDD);
  lpDD = NULL;
  DeInitWindow ();
  if (hModule != NULL)
    FreeLibrary (hModule), hModule = NULL;
  hWnd = NULL;
  directX = 0;
}

static LRESULT CALLBACK WindowProc (HWND hwnd,	// handle to window
				    UINT uMsg,	// message identifier
				    WPARAM wParam,	// first message parameter
				    LPARAM lParam	// second message parameter
  );
static void
UpdateMouseDD ()
{
  DDSURFACEDESC m_surface;
  PUCHAR dst;
  DWORD ddrval;
  memset (&m_surface, 0, sizeof (DDSURFACEDESC));
  m_surface.dwSize = sizeof (DDSURFACEDESC);
  ddrval = IDirectDrawSurface_Lock (lpSurfaces[0], NULL, &m_surface,
				    DDLOCK_WAIT, NULL);
  if (ddrval != DD_OK)
    {
      return;
    }

  dst = (PUCHAR) m_surface.lpSurface;
  if (storeddata)
    {
      restore (dst, storeddata, bitDepth, m_surface.u1.lPitch, displayX,
	       displayY, oldmouseX, oldmouseY);
      free (storeddata);
    }
  storeddata =
    store (dst, bitDepth, m_surface.u1.lPitch, displayX, displayY, mouseX,
	   mouseY);
  drawmouse (dst, mousepointer, bitDepth, m_surface.u1.lPitch, displayX,
	     displayY, mouseX, mouseY);
  oldmouseX = mouseX;
  oldmouseY = mouseY;
  IDirectDrawSurface_Unlock (lpSurfaces[0], m_surface.lpSurface);
}

/* Display buffer */
static void
PaintDD ()
{
  DWORD ddrval;
  if (!IsWindowVisible (hWnd) || !active || !initialized || !BackSurface[0])
    return;
  IDirectDrawSurface_Unlock (BackSurface[0], surface[0].lpSurface);
  IDirectDrawSurface_Unlock (BackSurface[1], surface[1].lpSurface);
  if (directX == DXFULLSCREEN)
    {
      if (storeddata)
	free (storeddata), storeddata = NULL;
      storeddata =
	store (currentbuff ? buffer2 : buffer1, bitDepth, lineSize, displayX,
	       displayY, mouseX, mouseY);
      drawmouse (currentbuff ? buffer2 : buffer1, mousepointer, bitDepth,
		 lineSize, displayX, displayY, mouseX, mouseY);
      ddrval =
	IDirectDrawSurface_BltFast (lpSurfaces[0], 0, 0,
				    BackSurface[currentbuff], &rcScreen,
				    FALSE);
      restore (currentbuff ? buffer2 : buffer1, storeddata, bitDepth,
	       lineSize, displayX, displayY, mouseX, mouseY);
      oldmouseX = mouseX;
      oldmouseY = mouseY;
    }
  else
    {
      ddrval = IDirectDrawSurface_Blt (lpSurfaces[0], &rcScreen,
				       BackSurface[currentbuff], &rcViewport,
				       DDBLT_WAIT, NULL);
    }
  if (ddrval != DD_OK)
    {
      if ((int) ddrval == (int) DDERR_SURFACELOST)
	{
	  IDirectDrawSurface_Restore (lpSurfaces[0]);
	  IDirectDrawSurface_Restore (BackSurface[0]);
	  IDirectDrawSurface_Restore (BackSurface[1]);
	  ddrval = IDirectDrawSurface_Blt (lpSurfaces[0], &rcScreen,
					   BackSurface[currentbuff],
					   &rcViewport, DDBLT_WAIT, NULL);
	  //if (ddrval == DDERR_SURFACELOST) resized=1; /*We've lost our fractal*/
	}
    }
  ddrval = IDirectDrawSurface_Lock (BackSurface[0], NULL, &surface[0],
				    DDLOCK_WAIT, NULL);
  ddrval = IDirectDrawSurface_Lock (BackSurface[1], NULL, &surface[1],
				    DDLOCK_WAIT, NULL);
  if (buffer1 != (char *) surface[0].lpSurface ||
      buffer2 != (char *) surface[1].lpSurface)
    {
      DeInitDD ();
      x_fatalerror
	("Unexpected event - buffers moved! Please contact authors!");
    }
  needredraw = 0;

}
#endif

/**************************************************************************************
                             Drivers implementation
 */



static void
flip_buffers (void)
{
  currentbuff ^= 1;
}


static void
processevents (int wait, int *mx, int *my, int *mb, int *k)
{
  int c = -1;
  *mb = 0;
  *k = 0;
  Processevents (wait, mx, my, mb, k, &c);
  if (c > -1)
    {
      ui_key (c);
    }

  if (c == -2)
    ui_quit ();			// -2 signals program exit

  if (resized)
    {
      ui_resize ();		// tell Xaos to resize

    }
}
static void
print (int x, int y, CONST char *text)
{
  HDC hDC;
  static char current[256];
  char s[256];
#ifdef DDRAW_DRIVER
  if (directX == DXFULLSCREEN)
    {
      HGLOBAL oldFont;
      if (IDirectDrawSurface_GetDC (lpSurfaces[0], &hDC) != DD_OK)
	return;
      SetTextColor (hDC, 0xffffff);
      SetBkColor (hDC, 0x000000);
      oldFont = SelectObject (hDC, hFont);
      ExtTextOut (hDC, x, y, 0, NULL, text, strlen (text), NULL);
      SelectObject (hDC, oldFont);
      IDirectDrawSurface_ReleaseDC (lpSurfaces[0], hDC);
      return;
    }
#endif
  if (!text[0])
    strcpy (s, "XaoS");
  else
    sprintf (s, "XaoS - %s", text);
  if (strcmp (current, s))
    strcpy (current, s), SetWindowText (hWnd, s);
}

static void
mousetype (int type)
{
  char *cursor;
  switch (type)
    {
    default:
    case 0:
      cursor = IDC_ARROW;
      break;
    case 1:
      cursor = IDC_WAIT;
      break;
    case 2:
      cursor = IDC_NO;
      break;
    }
  SetCursor (LoadCursor (NULL, cursor));
}
static void
set_palette (ui_palette pal1, int start, int end)
{
  PUCHAR pal = (PUCHAR) pal1;
  HDC hDC;
  int i;
  // store new palette entries locally
  memcpy (backpalette + 4 * start, pal, (end - start) * 4);
  for (i = start; i <= end; i++)
    {
      bmp->bmiColors[i].rgbRed = *(pal + 4 * (i - start) + 0);
      bmp->bmiColors[i].rgbGreen = *(pal + 4 * (i - start) + 1);
      bmp->bmiColors[i].rgbBlue = *(pal + 4 * (i - start) + 2);
      bmp->bmiColors[i].rgbReserved = 0;
    }
  // update window/screen
#ifdef DDRAW_DRIVER
  if (directX)
    {
      IDirectDrawPalette_SetEntries (dxPalette, 0, start, end - start + 1,
				     (PALETTEENTRY *) pal);
    }
  else
#endif
    {
      SetPaletteEntries (hPalette, start, end - start + 1,
			 (PALETTEENTRY *) pal);
      hDC = GetDC (hWnd);
      UnrealizeObject (hPalette);
      RealizePalette (hDC);
      ReleaseDC (hWnd, hDC);
      win32_display ();
    }
}

static void
win32_copy (struct uih_context *uih)
{
  char *c = ui_getpos ();
  HANDLE hData = GlobalAlloc (GMEM_DDESHARE, strlen (c) + 1);