X-Git-Url: https://git.artsoft.org/?a=blobdiff_plain;f=src%2Flibgame%2Fx11.c;h=61d1a1a5d2b06d7759ea32533004215b3ffe6286;hb=de8b3ae622eae10f1caf96872fb1790f7bd9644b;hp=3ee9b582a2e59ad949801e95062b27f18429a3e7;hpb=ff56a43aa3799aa3357f4deca4d6482fc25a6a41;p=rocksndiamonds.git

diff --git a/src/libgame/x11.c b/src/libgame/x11.c
index 3ee9b582..61d1a1a5 100644
--- a/src/libgame/x11.c
+++ b/src/libgame/x11.c
@@ -1,7 +1,7 @@
 /***********************************************************
 * Artsoft Retro-Game Library                               *
 *----------------------------------------------------------*
-* (c) 1994-2000 Artsoft Entertainment                      *
+* (c) 1994-2002 Artsoft Entertainment                      *
 *               Holger Schemel                             *
 *               Detmolder Strasse 189                      *
 *               33604 Bielefeld                            *
@@ -12,13 +12,15 @@
 ***********************************************************/
 
 #include "system.h"
+#include "pcx.h"
 #include "misc.h"
+#include "setup.h"
 
 
 #if defined(TARGET_X11)
 
 static void X11InitDisplay();
-static DrawWindow X11InitWindow();
+static DrawWindow *X11InitWindow();
 
 inline void X11InitVideoDisplay(void)
 {
@@ -29,7 +31,7 @@ inline void X11InitVideoDisplay(void)
   video.default_depth = XDefaultDepth(display, screen);
 }
 
-inline void X11InitVideoBuffer(DrawBuffer *backbuffer, DrawWindow *window)
+inline void X11InitVideoBuffer(DrawBuffer **backbuffer, DrawWindow **window)
 {
   *window = X11InitWindow();
 
@@ -72,23 +74,17 @@ static void X11InitDisplay()
 
   /* got appropriate visual? */
   if (depth < 8)
-  {
-    printf("Sorry, displays with less than 8 bits per pixel not supported.\n");
-    exit(-1);
-  }
+    Error(ERR_EXIT, "X11 display not supported (less than 8 bits per pixel)");
   else if ((depth ==8 && visual->class != PseudoColor) ||
 	   (depth > 8 && visual->class != TrueColor &&
 	    visual->class != DirectColor))
-  {
-    printf("Sorry, cannot get appropriate visual.\n");
-    exit(-1);
-  }
+    Error(ERR_EXIT, "X11 display not supported (inappropriate visual)");
 #endif /* !PLATFORM_MSDOS */
 }
 
-static DrawWindow X11InitWindow()
+static DrawWindow *X11InitWindow()
 {
-  DrawWindow new_window = CreateBitmapStruct();
+  DrawWindow *new_window = CreateBitmapStruct();
   unsigned int border_width = 4;
   XGCValues gc_values;
   unsigned long gc_valuemask;
@@ -97,7 +93,9 @@ static DrawWindow X11InitWindow()
   Pixmap icon_pixmap, iconmask_pixmap;
   unsigned int icon_width, icon_height;
   int icon_hot_x, icon_hot_y;
+#if 0
   char icon_filename[256];
+#endif
   XSizeHints size_hints;
   XWMHints wm_hints;
   XClassHint class_hints;
@@ -111,6 +109,7 @@ static DrawWindow X11InitWindow()
   unsigned long pen_fg = WhitePixel(display,screen);
   unsigned long pen_bg = BlackPixel(display,screen);
   const int width = video.width, height = video.height;
+  int i;
 
 #if 0
 #if !defined(PLATFORM_MSDOS)
@@ -142,26 +141,26 @@ static DrawWindow X11InitWindow()
 		    PropModePrepend, (unsigned char *) &delete_atom, 1);
 
 #if 0
-  sprintf(icon_filename, "%s/%s/%s",
-	  options.ro_base_directory, GRAPHICS_DIRECTORY,
+  sprintf(icon_filename, "%s/%s", options.graphics_directory,
 	  icon_pic.picture_filename);
 #endif
-  XReadBitmapFile(display, new_window->drawable, program.x11_icon_filename,
-		  &icon_width, &icon_height,
-		  &icon_pixmap, &icon_hot_x, &icon_hot_y);
-  if (!icon_pixmap)
-    Error(ERR_EXIT, "cannot read icon bitmap file '%s'", icon_filename);
+  if (XReadBitmapFile(display, new_window->drawable,
+		      getCustomImageFilename(program.x11_icon_filename),
+		      &icon_width, &icon_height, &icon_pixmap,
+		      &icon_hot_x, &icon_hot_y) != BitmapSuccess)
+    Error(ERR_EXIT, "cannot read icon bitmap file '%s'",
+	  program.x11_icon_filename);
 
 #if 0
-  sprintf(icon_filename, "%s/%s/%s",
-	  options.ro_base_directory, GRAPHICS_DIRECTORY,
+  sprintf(icon_filename, "%s/%s", options.graphics_directory,
 	  icon_pic.picturemask_filename);
 #endif
-  XReadBitmapFile(display, new_window->drawable, program.x11_iconmask_filename,
-		  &icon_width, &icon_height,
-		  &iconmask_pixmap, &icon_hot_x, &icon_hot_y);
-  if (!iconmask_pixmap)
-    Error(ERR_EXIT, "cannot read icon bitmap file '%s'", icon_filename);
+  if (XReadBitmapFile(display, new_window->drawable,
+		      getCustomImageFilename(program.x11_iconmask_filename),
+		      &icon_width, &icon_height, &iconmask_pixmap,
+		      &icon_hot_x, &icon_hot_y) != BitmapSuccess)
+    Error(ERR_EXIT, "cannot read icon bitmap file '%s'",
+	  program.x11_iconmask_filename);
 
   size_hints.width  = size_hints.min_width  = size_hints.max_width  = width;
   size_hints.height = size_hints.min_height = size_hints.max_height = height;
@@ -200,7 +199,10 @@ static DrawWindow X11InitWindow()
   window_event_mask =
     ExposureMask | StructureNotifyMask | FocusChangeMask |
     ButtonPressMask | ButtonReleaseMask | PointerMotionMask |
-    PointerMotionHintMask | KeyPressMask | KeyReleaseMask;
+    KeyPressMask | KeyReleaseMask;
+
+  /* unwanted mouse motion events now get filtered out by filter function */
+  /* window_event_mask |= PointerMotionHintMask; */
 
   XSelectInput(display, new_window->drawable, window_event_mask);
 #endif
@@ -213,7 +215,297 @@ static DrawWindow X11InitWindow()
   new_window->gc =
     XCreateGC(display, new_window->drawable, gc_valuemask, &gc_values);
 
+  /* create GCs for line drawing (black and white) */
+  for(i=0; i<2; i++)
+  {
+    gc_values.graphics_exposures = False;
+    gc_values.foreground = (i ? pen_fg : pen_bg);
+    gc_values.background = pen_bg;
+    gc_values.line_width = 4;
+    gc_values.line_style = LineSolid;
+    gc_values.cap_style = CapRound;
+    gc_values.join_style = JoinRound;
+
+    gc_valuemask = GCGraphicsExposures | GCForeground | GCBackground |
+                   GCLineWidth | GCLineStyle | GCCapStyle | GCJoinStyle;
+    new_window->line_gc[i] =
+      XCreateGC(display, new_window->drawable, gc_valuemask, &gc_values);
+  }
+
   return new_window;
 }
 
+void X11ZoomBitmap(Bitmap *src_bitmap, Bitmap *dst_bitmap)
+{
+#if defined(TARGET_ALLEGRO)
+  AllegroZoomBitmap(src_bitmap->drawable, dst_bitmap->drawable,
+		    src_bitmap->width, src_bitmap->height,
+		    dst_bitmap->width, dst_bitmap->height);
+#else
+  ZoomPixmap(display, src_bitmap->gc,
+	     src_bitmap->drawable, dst_bitmap->drawable,
+	     src_bitmap->width, src_bitmap->height,
+	     dst_bitmap->width, dst_bitmap->height);
+#endif
+}
+
+static void SetImageDimensions(Bitmap *bitmap)
+{
+#if defined(TARGET_ALLEGRO)
+  BITMAP *allegro_bitmap = (BITMAP *)(bitmap->drawable);
+
+  bitmap->width  = allegro_bitmap->w;
+  bitmap->height = allegro_bitmap->h;
+#else
+  Window root;
+  int x, y;
+  unsigned int border_width, depth;
+
+  XGetGeometry(display, bitmap->drawable, &root, &x, &y,
+	       &bitmap->width, &bitmap->height, &border_width, &depth);
+#endif
+}
+
+Bitmap *X11LoadImage(char *filename)
+{
+  Bitmap *new_bitmap = CreateBitmapStruct();
+  char *error = "Read_PCX_to_Pixmap(): %s '%s'";
+  int pcx_err;
+  XGCValues clip_gc_values;
+  unsigned long clip_gc_valuemask;
+
+  pcx_err = Read_PCX_to_Pixmap(display, window->drawable, window->gc, filename,
+			       &new_bitmap->drawable, &new_bitmap->clip_mask);
+  switch(pcx_err)
+  {
+    case PCX_Success:
+      break;
+    case PCX_OpenFailed:
+      SetError(error, "cannot open PCX file", filename);
+      return NULL;
+    case PCX_ReadFailed:
+      SetError(error, "cannot read PCX file", filename);
+      return NULL;
+    case PCX_FileInvalid:
+      SetError(error, "invalid PCX file", filename);
+      return NULL;
+    case PCX_NoMemory:
+      SetError(error, "not enough memory for PCX file", filename);
+      return NULL;
+    case PCX_ColorFailed:
+      SetError(error, "cannot get colors for PCX file", filename);
+      return NULL;
+    case PCX_OtherError:
+      /* this should already have called SetError() */
+      return NULL;
+    default:
+      SetError(error, "unknown error reading PCX file", filename);
+      return NULL;
+  }
+
+  if (!new_bitmap->drawable)
+  {
+    SetError("X11LoadImage(): cannot get graphics for '%s'", filename);
+    return NULL;
+  }
+
+  if (!new_bitmap->clip_mask)
+  {
+    SetError("X11LoadImage(): cannot get clipmask for '%s'", filename);
+    return NULL;
+  }
+
+  clip_gc_values.graphics_exposures = False;
+  clip_gc_values.clip_mask = new_bitmap->clip_mask;
+  clip_gc_valuemask = GCGraphicsExposures | GCClipMask;
+  new_bitmap->stored_clip_gc = XCreateGC(display, window->drawable,
+					 clip_gc_valuemask, &clip_gc_values);
+
+  /* set GraphicContext inheritated from Window */
+  new_bitmap->gc = window->gc;
+
+  /* set image width and height */
+  SetImageDimensions(new_bitmap);
+
+  return new_bitmap;
+}
+
+inline void X11CreateBitmapContent(Bitmap *new_bitmap,
+				   int width, int height, int depth)
+{
+  Pixmap pixmap;
+
+  if ((pixmap = XCreatePixmap(display, window->drawable, width, height, depth))
+      == None)
+    Error(ERR_EXIT, "cannot create pixmap");
+
+  new_bitmap->drawable = pixmap;
+
+  if (window == NULL)
+    Error(ERR_EXIT, "Window GC needed for Bitmap -- create Window first");
+
+  new_bitmap->gc = window->gc;
+
+  new_bitmap->line_gc[0] = window->line_gc[0];
+  new_bitmap->line_gc[1] = window->line_gc[1];
+}
+
+inline void X11FreeBitmapPointers(Bitmap *bitmap)
+{
+  /* The X11 version seems to have a memory leak here -- although
+     "XFreePixmap()" is called, the corresponding memory seems not
+     to be freed (according to "ps"). The SDL version apparently
+     does not have this problem. */
+
+  if (bitmap->drawable)
+    XFreePixmap(display, bitmap->drawable);
+  if (bitmap->clip_mask)
+    XFreePixmap(display, bitmap->clip_mask);
+  if (bitmap->stored_clip_gc)
+    XFreeGC(display, bitmap->stored_clip_gc);
+  /* the other GCs are only pointers to GCs used elsewhere */
+  bitmap->drawable = None;
+  bitmap->clip_mask = None;
+  bitmap->stored_clip_gc = None;
+}
+
+inline void X11CopyArea(Bitmap *src_bitmap, Bitmap *dst_bitmap,
+			int src_x, int src_y, int width, int height,
+			int dst_x, int dst_y, int mask_mode)
+{
+  XCopyArea(display, src_bitmap->drawable, dst_bitmap->drawable,
+	    (mask_mode == BLIT_MASKED ? src_bitmap->clip_gc : dst_bitmap->gc),
+	    src_x, src_y, width, height, dst_x, dst_y);
+}
+
+inline void X11FillRectangle(Bitmap *bitmap, int x, int y,
+			     int width, int height, Pixel color)
+{
+  XSetForeground(display, bitmap->gc, color);
+  XFillRectangle(display, bitmap->drawable, bitmap->gc, x, y, width, height);
+}
+
+inline void X11DrawSimpleLine(Bitmap *bitmap, int from_x, int from_y,
+			      int to_x, int to_y, Pixel color)
+{
+  XSetForeground(display, bitmap->gc, color);
+  XDrawLine(display, bitmap->drawable, bitmap->gc, from_x, from_y, to_x, to_y);
+}
+
+inline Pixel X11GetPixel(Bitmap *bitmap, int x, int y)
+{
+  XImage *pixel_image;
+  Pixel pixel_value;
+
+  pixel_image = XGetImage(display, bitmap->drawable, x, y, 1, 1,
+			  AllPlanes, ZPixmap);
+  pixel_value = XGetPixel(pixel_image, 0, 0);
+
+  XDestroyImage(pixel_image);
+
+  return pixel_value;
+}
+
+inline Pixel X11GetPixelFromRGB(unsigned int color_r, unsigned int color_g,
+				unsigned int color_b)
+{
+  XColor xcolor;
+  Pixel pixel;
+
+  xcolor.flags = DoRed | DoGreen | DoBlue;
+  xcolor.red = (color_r << 8);
+  xcolor.green = (color_g << 8);
+  xcolor.blue = (color_b << 8);
+
+  XAllocColor(display, cmap, &xcolor);
+  pixel = xcolor.pixel;
+
+  return pixel;
+}
+
+/* ------------------------------------------------------------------------- */
+/* mouse pointer functions                                                   */
+/* ------------------------------------------------------------------------- */
+
+#if defined(TARGET_X11_NATIVE)
+
+static Cursor create_cursor(const char **image)
+{
+  Pixmap pixmap_data, pixmap_mask;
+  XColor color_fg, color_bg;
+  Cursor cursor;
+
+  int i, row, col;
+  char data[4*32];
+  char mask[4*32];
+  int hot_x, hot_y;
+
+  int data_width = 32, data_height = 32;
+  int mask_width = 32, mask_height = 32;
+
+  i = -1;
+  for (row=0; row<32; ++row)
+  {
+    for (col=0; col<32; ++col)
+    {
+      if (col % 8)
+      {
+        data[i] <<= 1;
+        mask[i] <<= 1;
+      }
+      else
+      {
+        i++;
+        data[i] = mask[i] = 0;
+      }
+
+      switch (image[4+row][col])
+      {
+        case 'X':
+	  data[i] |= 0x01;
+	  mask[i] |= 0x01;
+	  break;
+        case '.':
+	  mask[i] |= 0x01;
+	  break;
+        case ' ':
+	  break;
+      }
+    }
+  }
+
+  sscanf(image[4+row], "%d,%d", &hot_x, &hot_y);
+
+  /* shape and mask are single plane pixmaps */
+  pixmap_data = XCreatePixmapFromBitmapData(display, window->drawable, data,
+					    data_width, data_height, 1, 0, 1);
+  pixmap_mask = XCreatePixmapFromBitmapData(display, window->drawable, mask,
+					    mask_width, mask_height, 1, 0, 1);
+
+  XParseColor(display, cmap, "black", &color_fg);
+  XParseColor(display, cmap, "white", &color_bg);
+
+  cursor = XCreatePixmapCursor(display, pixmap_data, pixmap_mask,
+			       &color_fg, &color_bg, hot_x, hot_y);
+
+  return cursor;
+}
+
+void X11SetMouseCursor(const char **cursor_image)
+{
+  static const char **last_cursor_image = NULL;
+  static Cursor cursor_default = None;
+  static Cursor cursor_current = None;
+
+  if (cursor_image != NULL && cursor_image != last_cursor_image)
+  {
+    cursor_current = create_cursor(cursor_image);
+    last_cursor_image = cursor_image;
+  }
+
+  XDefineCursor(display, window->drawable,
+		cursor_image ? cursor_current : cursor_default);
+}
+#endif	/* TARGET_X11_NATIVE */
+
 #endif /* TARGET_X11 */