[BACK]Return to gtk_screen.c CVS log [TXT] [DIR] Up to [RetroPC.NET] / np2 / x11 / gtk2

Diff for /np2/x11/gtk2/gtk_screen.c between versions 1.2 and 1.12

version 1.2, 2004/07/15 14:24:33 version 1.12, 2011/01/15 18:43:13
Line 1 Line 1
 /*      $Id$    */  
   
 /*  /*
  * Copyright (c) 2003 NONAKA Kimihiro   * Copyright (c) 2003 NONAKA Kimihiro
  * All rights reserved.   * All rights reserved.
Line 12 Line 10
  * 2. Redistributions in binary form must reproduce the above copyright   * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the   *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.   *    documentation and/or other materials provided with the distribution.
  * 3. The name of the author may not be used to endorse or promote products  
  *    derived from this software without specific prior written permission.  
  *   *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR   * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES   * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
Line 29 Line 25
   
 #include "compiler.h"  #include "compiler.h"
   
   #include <math.h>
   
 #include "np2.h"  #include "np2.h"
 #include "palettes.h"  #include "palettes.h"
 #include "scrndraw.h"  #include "scrndraw.h"
   
   #include "toolkit.h"
   
 #include "scrnmng.h"  #include "scrnmng.h"
   #include "mousemng.h"
   #include "soundmng.h"
   
 #include "gtk2/xnp2.h"  #include "gtk2/xnp2.h"
 #include "gtk2/gtk_drawmng.h"  #include "gtk2/gtk_drawmng.h"
   #include "gtk2/gtk_menu.h"
   
   
 typedef struct {  typedef struct {
         UINT8           scrnmode;          UINT8           scrnmode;
         UINT8           drawing;          volatile int    drawing;
         int             width;          int             width;          /* drawarea の width */
         int             height;          int             height;         /* drawarea の height */
         int             extend;          int             extend;
         int             clipping;          int             clipping;
   
         PAL16MASK       pal16mask;          PAL16MASK       pal16mask;
   
         RECT_T          scrn;          RECT_T          scrn;           /* drawarea 内の描画領域位置 */
         RECT_T          rect;          RECT_T          rect;           /* drawarea に描画するサイズ */
   
         int             lpitch;  
         int             scrw;  
         int             scrh;  
   
         /* toolkit depend */          /* toolkit depend */
         GdkImage        *surface;          GdkPixbuf       *drawsurf;
         GdkPixmap       *backsurf;          GdkPixbuf       *backsurf;
           GdkPixbuf       *surface;
           double          ratio_w, ratio_h;
           int             interp;
   
         unsigned long   pixel[24];      /* pallete */          GdkColor        pal[24];
 } DRAWMNG;  } DRAWMNG;
   
 typedef struct {  typedef struct {
         int     width;          int     width;
         int     height;          int     height;
         int     extend;          int     extend;
           int     multiple;
 } SCRNSTAT;  } SCRNSTAT;
   
 typedef struct {  
         SCRNSURF        ss;  
   
         UINT8           renewal[SURFACE_HEIGHT];  
 } X11SCRNSURF;  
   
 static SCRNMNG scrnmng;  static SCRNMNG scrnmng;
 static DRAWMNG drawmng;  static DRAWMNG drawmng;
 static SCRNSTAT scrnstat;  static SCRNSTAT scrnstat = { 640, 400, 1, SCREEN_DEFMUL };
 static X11SCRNSURF scrnsurf;  static SCRNSURF scrnsurf;
   static int real_fullscreen;
   
 SCRNMNG *scrnmngp = &scrnmng;  SCRNMNG *scrnmngp = &scrnmng;
   
 GtkWidget *main_window;  GtkWidget *main_window;
 GtkWidget *drawarea;  GtkWidget *drawarea;
   
   #define BITS_PER_PIXEL  24
   #define BYTES_PER_PIXEL 3
   
   /*
    * drawarea のアスペクト比を 4:3 (640x480) にする。
    */
 static void  static void
 set_window_size(int width, int height)  adapt_aspect(int width, int height, int scrnwidth, int scrnheight)
 {  {
           double ratio;
           int w, h;
   
         drawmng.scrw = width + np2oscfg.paddingx * 2;          ratio = (double)scrnwidth / width;
         drawmng.scrh = height + np2oscfg.paddingy * 2;          h = floor((height * ratio) + 0.5);
           if (h < scrnheight) {
                   drawmng.rect.right = scrnwidth;
                   drawmng.rect.bottom = h;
           } else {
                   ratio = (double)scrnheight / height;
                   w = floor((width * ratio) + 0.5);
                   if (w < scrnwidth) {
                           drawmng.rect.right = w;
                           drawmng.rect.bottom = scrnheight;
                   }
           }
   }
   
         gtk_widget_set_size_request(drawarea, drawmng.scrw, drawmng.scrh);  static void
   set_window_size(int width, int height)
   {
   
           gtk_widget_set_size_request(drawarea,
               width + np2oscfg.paddingx * 2, height + np2oscfg.paddingy * 2);
 }  }
   
 static void  static void
Line 104  renewal_client_size(void) Line 126  renewal_client_size(void)
         int extend;          int extend;
         int scrnwidth;          int scrnwidth;
         int scrnheight;          int scrnheight;
           int multiple;
   
         width = min(scrnstat.width, drawmng.width);          width = min(scrnstat.width, drawmng.width);
         height = min(scrnstat.height, drawmng.height);          height = min(scrnstat.height, drawmng.height);
         extend = 0;          extend = 0;
   
 #if notyet  
         if (drawmng.scrnmode & SCRNMODE_FULLSCREEN) {          if (drawmng.scrnmode & SCRNMODE_FULLSCREEN) {
         } else                  scrnwidth = drawmng.width;
 #endif                  scrnheight = drawmng.height;
         {  
                   drawmng.rect.right = width;
                   drawmng.rect.bottom = height;
                   if (!real_fullscreen) {
                           adapt_aspect(width, height, scrnwidth, scrnheight);
                   }
   
                   drawmng.ratio_w = (double)drawmng.rect.right / width;
                   drawmng.ratio_h = (double)drawmng.rect.bottom / height;
   
                   drawmng.scrn.left = (scrnwidth - drawmng.rect.right) / 2;
                   drawmng.scrn.top = (scrnheight - drawmng.rect.bottom) / 2;
                   drawmng.scrn.right = drawmng.scrn.left + drawmng.rect.right;
                   drawmng.scrn.bottom = drawmng.scrn.top + drawmng.rect.bottom;
   
                   gtk_widget_set_size_request(drawarea, scrnwidth, scrnheight);
           } else {
                   multiple = scrnstat.multiple;
                 if (!(drawmng.scrnmode & SCRNMODE_ROTATE)) {                  if (!(drawmng.scrnmode & SCRNMODE_ROTATE)) {
                         if (np2oscfg.paddingx > 0) {                          if ((np2oscfg.paddingx > 0) && (multiple == SCREEN_DEFMUL)) {
                                 extend = min(scrnstat.extend, drawmng.extend);                                  extend = min(scrnstat.extend, drawmng.extend);
                         }                          }
                         scrnwidth = width;                          scrnwidth = (width * multiple) / SCREEN_DEFMUL;
                         scrnheight = height;                          scrnheight = (height * multiple) / SCREEN_DEFMUL;
                         drawmng.rect.right = width + extend;  
                         drawmng.rect.bottom = height;                          drawmng.rect.right = scrnwidth + extend;
                           drawmng.rect.bottom = scrnheight;
   
                           drawmng.ratio_w = (double)drawmng.rect.right / width;
                           drawmng.ratio_h = (double)drawmng.rect.bottom / height;
   
                         drawmng.scrn.left = np2oscfg.paddingx - extend;                          drawmng.scrn.left = np2oscfg.paddingx - extend;
                         drawmng.scrn.top = np2oscfg.paddingy;                          drawmng.scrn.top = np2oscfg.paddingy;
                 } else {                  } else {
                         if (np2oscfg.paddingy > 0) {                          if ((np2oscfg.paddingy > 0) && (multiple == SCREEN_DEFMUL)) {
                                 extend = min(scrnstat.extend, drawmng.extend);                                  extend = min(scrnstat.extend, drawmng.extend);
                         }                          }
                         scrnwidth = height;                          scrnwidth = (height * multiple) / SCREEN_DEFMUL;
                         scrnheight = width;                          scrnheight = (width * multiple) / SCREEN_DEFMUL;
                         drawmng.rect.right = height;  
                         drawmng.rect.bottom = width + extend;                          drawmng.rect.right = scrnwidth;
                           drawmng.rect.bottom = scrnheight + extend;
   
                           drawmng.ratio_w = (double)drawmng.rect.right / height;
                           drawmng.ratio_h = (double)drawmng.rect.bottom / width;
   
                         drawmng.scrn.left = np2oscfg.paddingx;                          drawmng.scrn.left = np2oscfg.paddingx;
                         drawmng.scrn.top = np2oscfg.paddingy - extend;                          drawmng.scrn.top = np2oscfg.paddingy - extend;
                 }                  }
                 drawmng.scrn.right = np2oscfg.paddingx + scrnwidth;                  drawmng.scrn.right = np2oscfg.paddingx + scrnwidth;
                 drawmng.scrn.bottom = np2oscfg.paddingy + scrnheight;                  drawmng.scrn.bottom = np2oscfg.paddingy + scrnheight;
   
                 set_window_size(scrnwidth, scrnheight);                  set_window_size(scrnwidth, scrnheight);
         }          }
         scrnsurf.ss.width = width;  
         scrnsurf.ss.height = height;          scrnsurf.width = width;
         scrnsurf.ss.extend = extend;          scrnsurf.height = height;
           scrnsurf.extend = extend;
 }  }
   
 static void  static void
Line 187  clear_out_of_rect(const RECT_T *target,  Line 238  clear_out_of_rect(const RECT_T *target, 
 static void  static void
 clear_outscreen(void)  clear_outscreen(void)
 {  {
         RECT_T target;  
         RECT_T base;          RECT_T base;
   
         base.left = base.top = 0;          base.left = base.top = 0;
         base.right = drawmng.scrw;          base.right = drawarea->allocation.width;
         base.bottom = drawmng.scrh;          base.bottom = drawarea->allocation.height;
         target = drawmng.scrn;          clear_out_of_rect(&drawmng.scrn, &base);
         clear_out_of_rect(&target, &base);  
 }  }
   
 static void  static void
 palette_init(void)  palette_init(void)
 {  {
         GdkColor color;  
         GdkColormap *cmap;          GdkColormap *cmap;
         int rv;          gboolean success;
         int i;          int i;
   
         cmap = gdk_colormap_get_system();          cmap = gdk_colormap_get_system();
         rv = gdk_colors_alloc(cmap, TRUE, NULL, 0, drawmng.pixel, 24);  
         if (rv == 0) {  
                 g_error("Can't allocate enough color.\n");  
                 return;  
         }  
   
         for (i = 0; i < 8; i++) {          for (i = 0; i < 8; i++) {
                 color.pixel = drawmng.pixel[NP2PAL_TEXT + i + 1];                  drawmng.pal[NP2PAL_TEXT + i + 1].pixel =
                 color.red = np2_pal32[NP2PAL_TEXT + i + 1].p.r << 8;                      (np2_pal32[NP2PAL_TEXT + i + 1].p.r << 0) |
                 color.green = np2_pal32[NP2PAL_TEXT + i + 1].p.g << 8;                      (np2_pal32[NP2PAL_TEXT + i + 1].p.g << 8) |
                 color.blue = np2_pal32[NP2PAL_TEXT + i + 1].p.b << 8;                      (np2_pal32[NP2PAL_TEXT + i + 1].p.b << 16);
                 gdk_colormap_alloc_color(cmap, &color, TRUE, FALSE);                  drawmng.pal[NP2PAL_TEXT + i + 1].red =
                       np2_pal32[NP2PAL_TEXT + i + 1].p.r << 8;
                   drawmng.pal[NP2PAL_TEXT + i + 1].green =
                       np2_pal32[NP2PAL_TEXT + i + 1].p.g << 8;
                   drawmng.pal[NP2PAL_TEXT + i + 1].blue =
                       np2_pal32[NP2PAL_TEXT + i + 1].p.b << 8;
         }          }
           gdk_colormap_alloc_colors(cmap, &drawmng.pal[NP2PAL_TEXT + 1], 8,
               TRUE, FALSE, &success);
 }  }
   
 static void  static void
 palette_set(void)  palette_set(void)
 {  {
         GdkColor color;          static int first = 1;
         GdkColormap *cmap;          GdkColormap *cmap;
           gboolean success;
         int i;          int i;
   
         cmap = gdk_colormap_get_system();          cmap = gdk_colormap_get_system();
   
           if (!first) {
                   gdk_colormap_free_colors(cmap, &drawmng.pal[NP2PAL_GRPH],
                       NP2PALS_GRPH);
           }
           first = 0;
   
         for (i = 0; i < NP2PALS_GRPH; i++) {          for (i = 0; i < NP2PALS_GRPH; i++) {
                 color.pixel = drawmng.pixel[NP2PAL_GRPH + i];                  drawmng.pal[NP2PAL_GRPH + i].pixel =
                 color.red = np2_pal32[NP2PAL_GRPH + i].p.r << 8;                      (np2_pal32[NP2PAL_GRPH + i].p.r << 0) |
                 color.green = np2_pal32[NP2PAL_GRPH + i].p.g << 8;                      (np2_pal32[NP2PAL_GRPH + i].p.g << 8) |
                 color.blue = np2_pal32[NP2PAL_GRPH + i].p.b << 8;                      (np2_pal32[NP2PAL_GRPH + i].p.b << 16);
                 gdk_colormap_alloc_color(cmap, &color, TRUE, FALSE);                  drawmng.pal[NP2PAL_GRPH + i].red =
                       np2_pal32[NP2PAL_GRPH + i].p.r << 8;
                   drawmng.pal[NP2PAL_GRPH + i].green =
                       np2_pal32[NP2PAL_GRPH + i].p.g << 8;
                   drawmng.pal[NP2PAL_GRPH + i].blue =
                       np2_pal32[NP2PAL_GRPH + i].p.b << 8;
         }          }
           gdk_colormap_alloc_colors(cmap, &drawmng.pal[NP2PAL_GRPH], NP2PALS_GRPH,
               TRUE, FALSE, &success);
 }  }
   
 void  void
Line 246  scrnmng_initialize(void) Line 310  scrnmng_initialize(void)
         scrnstat.width = 640;          scrnstat.width = 640;
         scrnstat.height = 400;          scrnstat.height = 400;
         scrnstat.extend = 1;          scrnstat.extend = 1;
           scrnstat.multiple = SCREEN_DEFMUL;
         set_window_size(scrnstat.width, scrnstat.height);          set_window_size(scrnstat.width, scrnstat.height);
   
           real_fullscreen = gtk_window_init_fullscreen(main_window);
   
           switch (np2oscfg.drawinterp) {
           case INTERP_NEAREST:
                   drawmng.interp = GDK_INTERP_NEAREST;
                   break;
   
           case INTERP_TILES:
                   drawmng.interp = GDK_INTERP_TILES;
                   break;
   
           case INTERP_HYPER:
                   drawmng.interp = GDK_INTERP_HYPER;
                   break;
   
           case INTERP_BILINEAR:
           default:
                   drawmng.interp = GDK_INTERP_BILINEAR;
                   break;
           }
 }  }
   
 BOOL  BOOL
 scrnmng_create(UINT8 mode)  scrnmng_create(UINT8 mode)
 {  {
           GdkScreen *screen;
         GdkVisual *visual;          GdkVisual *visual;
         RECT_T rect;          RECT_T rect;
         int height;          pixmap_format_t fmt;
         int bitcolor;  
         UINT lpitch;  
         UINT8 bytes_per_pixel;  
   
         while (drawmng.drawing)          while (drawmng.drawing)
                 gtk_main_iteration_do(FALSE);                  gtk_main_iteration_do(FALSE);
         drawmng.drawing = TRUE;          drawmng.drawing = TRUE;
   
 #if notyet          visual = gtk_widget_get_visual(drawarea);
         if (mode & SCRNMODE_FULLSCREEN) {          if (!gtkdrawmng_getformat(drawarea, main_window, &fmt))
                 mode &= ~SCRNMODE_ROTATEMASK;  
                 drawmng.extend = 0;  
                 return FAILURE;                  return FAILURE;
         } else  
 #endif  
         {  
                 scrnmng.flag = SCRNFLAG_HAVEEXTEND;  
   
                 visual = gtk_widget_get_visual(drawarea);          switch (fmt.bits_per_pixel) {
                 bitcolor = gtkdrawmng_getbpp(drawarea, main_window);          case 16:
                 if (bitcolor == 0) {                  drawmng_make16mask(&drawmng.pal16mask, visual->blue_mask,
                         return FAILURE;                      visual->red_mask, visual->green_mask);
                 } else if (bitcolor == 16) {                  break;
                         drawmng_make16mask(&drawmng.pal16mask, visual->blue_mask, visual->red_mask, visual->green_mask);  
                 } else if (bitcolor == 8) {          case 8:
                         palette_init();                  palette_init();
                 }                  break;
                 drawmng.extend = 1;          }
                 bytes_per_pixel = bitcolor >> 3;  
   
                 if (!(mode & SCRNMODE_ROTATE)) {          if (mode & SCRNMODE_FULLSCREEN) {
                         rect.right = 641;                  mode &= ~SCRNMODE_ROTATEMASK;
                         rect.bottom = 480;                  scrnmng.flag = 0;
                         lpitch = rect.right * bytes_per_pixel;                  drawmng.extend = 0;
                         if (lpitch % 4) {                  if (real_fullscreen) {
                                 rect.right += (lpitch % 4) / bytes_per_pixel;                          drawmng.width = FULLSCREEN_WIDTH;
                                 lpitch = rect.right * bytes_per_pixel;                          drawmng.height = FULLSCREEN_HEIGHT;
                         }  
                 } else {                  } else {
                         rect.right = 480;                          screen = gdk_screen_get_default();
                         rect.bottom = 641;                          drawmng.width = gdk_screen_get_width(screen);
                         lpitch = rect.right * bytes_per_pixel;                          drawmng.height = gdk_screen_get_height(screen);
                 }  
                 height = 480;  
   
                 drawmng.surface = gdk_image_new(GDK_IMAGE_FASTEST, visual,  
                     rect.right, rect.bottom);  
                 if (drawmng.surface == NULL) {  
                         g_message("can't create surface.");  
                         return FAILURE;  
                 }                  }
           } else {
                   scrnmng.flag = SCRNFLAG_HAVEEXTEND;
                   drawmng.extend = 1;
                   drawmng.width = 640;
                   drawmng.height = 480;
           }
   
                 drawmng.backsurf = gdk_pixmap_new(drawarea->window,          if (!(mode & SCRNMODE_ROTATE)) {
                     rect.right, rect.bottom, visual->depth);                  rect.right = 640 + drawmng.extend;
                 if (drawmng.backsurf == NULL) {                  rect.bottom = 480;
                         g_message("can't create pixmap.");          } else {
                         return FAILURE;                  rect.right = 480;
                 }                  rect.bottom = 640 + drawmng.extend;
                 gdk_draw_rectangle(drawmng.backsurf, drawarea->style->black_gc,  
                     TRUE, 0, 0, rect.right, rect.bottom);  
         }          }
         scrnmng.bpp = (UINT8)bitcolor;  
         drawmng.lpitch = lpitch;          scrnmng.bpp = BITS_PER_PIXEL;
         scrnsurf.ss.bpp = bitcolor;          scrnsurf.bpp = BITS_PER_PIXEL;
         drawmng.scrnmode = mode;          drawmng.scrnmode = mode;
         drawmng.width = 640;  
         drawmng.height = height;  
         drawmng.clipping = 0;          drawmng.clipping = 0;
         renewal_client_size();          renewal_client_size();
   
           drawmng.backsurf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, FALSE, 8,
               rect.right, rect.bottom);
           if (drawmng.backsurf == NULL) {
                   drawmng.drawing = FALSE;
                   g_message("can't create backsurf.");
                   return FAILURE;
           }
           gdk_pixbuf_fill(drawmng.backsurf, 0);
   
           drawmng.surface = gdk_pixbuf_new(GDK_COLORSPACE_RGB, FALSE, 8,
               drawmng.rect.right, drawmng.rect.bottom);
           if (drawmng.surface == NULL) {
                   drawmng.drawing = FALSE;
                   g_message("can't create surface.");
                   return FAILURE;
           }
           gdk_pixbuf_fill(drawmng.surface, 0);
   
           if (mode & SCRNMODE_FULLSCREEN) {
                   drawmng.drawsurf =
                       real_fullscreen ? drawmng.backsurf : drawmng.surface;
                   xmenu_hide();
                   gtk_window_fullscreen_mode(main_window);
           } else {
                   drawmng.drawsurf = (scrnstat.multiple == SCREEN_DEFMUL)
                       ? drawmng.backsurf : drawmng.surface;
                   gtk_window_restore_mode(main_window);
                   xmenu_show();
           }
   
         drawmng.drawing = FALSE;          drawmng.drawing = FALSE;
   
         return SUCCESS;          return SUCCESS;
Line 335  scrnmng_destroy(void) Line 435  scrnmng_destroy(void)
 {  {
   
         if (drawmng.backsurf) {          if (drawmng.backsurf) {
                 gdk_pixmap_unref(drawmng.backsurf);                  g_object_unref(drawmng.backsurf);
                 drawmng.backsurf = NULL;                  drawmng.backsurf = NULL;
         }          }
         if (drawmng.surface) {          if (drawmng.surface) {
                 gdk_image_destroy(drawmng.surface);                  g_object_unref(drawmng.surface);
                 drawmng.surface = NULL;                  drawmng.surface = NULL;
         }          }
 }  }
   
   void
   scrnmng_fullscreen(int onoff)
   {
   
           if (onoff) {
                   gtk_window_fullscreen_mode(main_window);
           } else {
                   gtk_window_restore_mode(main_window);
           }
   }
   
 RGB16  RGB16
 scrnmng_makepal16(RGB32 pal32)  scrnmng_makepal16(RGB32 pal32)
 {  {
Line 355  void Line 466  void
 scrnmng_setwidth(int posx, int width)  scrnmng_setwidth(int posx, int width)
 {  {
   
         UNUSED(posx);  
   
         scrnstat.width = width;          scrnstat.width = width;
         renewal_client_size();          renewal_client_size();
 }  }
Line 365  void Line 474  void
 scrnmng_setheight(int posy, int height)  scrnmng_setheight(int posy, int height)
 {  {
   
         UNUSED(posy);  
   
         scrnstat.height = height;          scrnstat.height = height;
         renewal_client_size();          renewal_client_size();
 }  }
Line 376  scrnmng_setextend(int extend) Line 483  scrnmng_setextend(int extend)
 {  {
   
         scrnstat.extend = extend;          scrnstat.extend = extend;
           scrnmng.allflash = TRUE;
         renewal_client_size();          renewal_client_size();
 }  }
   
   void
   scrnmng_setmultiple(int multiple)
   {
   
           if (scrnstat.multiple != multiple) {
                   scrnstat.multiple = multiple;
                   if (!(drawmng.scrnmode & SCRNMODE_FULLSCREEN)) {
                           soundmng_stop();
                           mouse_running(MOUSE_STOP);
                           scrnmng_destroy();
                           if (scrnmng_create(scrnmode) != SUCCESS) {
                                   toolkit_widget_quit();
                                   return;
                           }
                           renewal_client_size();
                           scrndraw_redraw();
                           mouse_running(MOUSE_CONT);
                           soundmng_play();
                   }
           }
   }
   
 const SCRNSURF *  const SCRNSURF *
 scrnmng_surflock(void)  scrnmng_surflock(void)
 {  {
         int lpitch = drawmng.lpitch;          const int lpitch = gdk_pixbuf_get_rowstride(drawmng.backsurf);
         int bytes_per_pixel = scrnsurf.ss.bpp >> 3;  
   
 #if !defined(USE_SCREEN_INVALIDATE)  
         memcpy(scrnsurf.renewal, renewal_line, sizeof(scrnsurf.renewal));  
 #endif  
   
         scrnsurf.ss.ptr = (UINT8 *)drawmng.surface->mem;          scrnsurf.ptr = (UINT8 *)gdk_pixbuf_get_pixels(drawmng.backsurf);
         if (!(drawmng.scrnmode & SCRNMODE_ROTATE)) {          if (!(drawmng.scrnmode & SCRNMODE_ROTATE)) {
                 scrnsurf.ss.xalign = bytes_per_pixel;                  scrnsurf.xalign = BYTES_PER_PIXEL;
                 scrnsurf.ss.yalign = lpitch;                  scrnsurf.yalign = lpitch;
         } else if (!(drawmng.scrnmode & SCRNMODE_ROTATEDIR)) {          } else if (!(drawmng.scrnmode & SCRNMODE_ROTATEDIR)) {
                 /* rotate left */                  /* rotate left */
                 scrnsurf.ss.ptr += (scrnsurf.ss.width + scrnsurf.ss.extend - 1) * lpitch;                  scrnsurf.ptr += (scrnsurf.width + scrnsurf.extend - 1) * lpitch;
                 scrnsurf.ss.xalign = -lpitch;                  scrnsurf.xalign = -lpitch;
                 scrnsurf.ss.yalign = bytes_per_pixel;                  scrnsurf.yalign = BYTES_PER_PIXEL;
         } else {          } else {
                 /* rotate right */                  /* rotate right */
                 scrnsurf.ss.ptr += (drawmng.rect.right - 1) * bytes_per_pixel;                  scrnsurf.ptr += (scrnsurf.height - 1) * BYTES_PER_PIXEL;
                 scrnsurf.ss.xalign = lpitch;                  scrnsurf.xalign = lpitch;
                 scrnsurf.ss.yalign = -bytes_per_pixel;                  scrnsurf.yalign = -BYTES_PER_PIXEL;
         }          }
         return &scrnsurf.ss;          return &scrnsurf;
 }  }
   
 void  void
 scrnmng_surfunlock(const SCRNSURF *surf)  scrnmng_surfunlock(const SCRNSURF *surf)
 {  {
         GdkDrawable *d = drawarea->window;  
         GdkGC *gc = drawarea->style->fg_gc[GTK_WIDGET_STATE(drawarea)];  
         X11SCRNSURF *ss = (X11SCRNSURF *)surf;  
         UINT8 *delta = ss->renewal;  
         RECT_T r;  
         gint h, s;  
   
         r.left = drawmng.scrn.left;  
         r.top = drawmng.scrn.top;  
         r.right = drawmng.rect.right;  
         r.bottom = drawmng.rect.bottom;  
   
 #if !defined(USE_SCREEN_INVALIDATE)          if (drawmng.drawsurf == drawmng.surface) {
         if (!(drawmng.scrnmode & SCRNMODE_ROTATE)) {                  gdk_pixbuf_scale(drawmng.backsurf, drawmng.surface,
                 /* normal */                      0, 0, drawmng.rect.right, drawmng.rect.bottom,
                 for (s = h = 0; h < r.bottom; h++) {                      0, 0, drawmng.ratio_w, drawmng.ratio_h,
                         if ((renewal_line[h] != delta[h]) || (s == h))                      drawmng.interp);
                                 continue;  
   
                         gdk_draw_image(drawmng.backsurf, gc, drawmng.surface,  
                             0, s, r.left, r.top + s, r.right, h - s);  
                         s = h + 1;  
                 }  
                 if (s != h) {  
                         gdk_draw_image(drawmng.backsurf, gc, drawmng.surface,  
                             0, s, r.left, r.top + s, r.right, h - s);  
                 }  
         } else if (!(drawmng.scrnmode & SCRNMODE_ROTATEDIR)) {  
                 /* rotate left */  
                 for (s = h = 0; h < r.right; h++) {  
                         if ((renewal_line[h] != delta[h]) || (s == h))  
                                 continue;  
   
                         gdk_draw_image(drawmng.backsurf, gc, drawmng.surface,  
                             s, 0, r.left + s, r.top, h - s, r.bottom);  
                         s = h + 1;  
                 }  
                 if (s != h) {  
                         gdk_draw_image(drawmng.backsurf, gc, drawmng.surface,  
                             s, 0, r.left + s, r.top, h - s, r.bottom);  
                 }  
         } else {  
                 /* rotate right */  
                 for (s = h = 0; h < r.right; h++) {  
                         if ((renewal_line[h] != delta[h]) || (s == h))  
                                 continue;  
   
                         gdk_draw_image(drawmng.backsurf, gc, drawmng.surface,  
                             r.right - h, 0,  
                             drawmng.scrn.right - h, r.top, h - s, r.bottom);  
                         s = h + 1;  
                 }  
                 if (s != h) {  
                         gdk_draw_image(drawmng.backsurf, gc, drawmng.surface,  
                             r.right - h, 0,  
                             drawmng.scrn.right - h, r.top, h - s, r.bottom);  
                 }  
         }          }
 #else  
         gtk_widget_queue_draw_area(drawarea, r.left, r.top, r.right, r.bottom);          scrnmng_update();
 #endif  }
   
   void
   scrnmng_update(void)
   {
           GdkDrawable *d = drawarea->window;
           GdkGC *gc = drawarea->style->fg_gc[gtk_widget_get_state(drawarea)];
   
         if (scrnmng.palchanged) {          if (scrnmng.palchanged) {
                 scrnmng.palchanged = FALSE;                  scrnmng.palchanged = FALSE;
                 palette_set();                  palette_set();
         }          }
   
 #if !defined(USE_SCREEN_INVALIDATE)  
         if (drawmng.drawing)          if (drawmng.drawing)
                 return;                  return;
   
         drawmng.drawing = TRUE;          drawmng.drawing = TRUE;
 #if notyet  
         if (drawmng.scrnmode & SCRNMODE_FULLSCREEN) {          if (drawmng.scrnmode & SCRNMODE_FULLSCREEN) {
         } else  
 #endif  
         {  
                 if (scrnmng.allflash) {                  if (scrnmng.allflash) {
                         scrnmng.allflash = 0;                          scrnmng.allflash = 0;
                         if (np2oscfg.paddingx || np2oscfg.paddingy) {                          clear_outscreen();
                                 clear_outscreen();  
                         }  
                 }                  }
                 gdk_draw_pixmap(d, gc, drawmng.backsurf,          } else {
                     0, 0,                                     /* src  */  
                     drawmng.scrn.left, drawmng.scrn.top,      /* dest */  
                     drawmng.rect.right, drawmng.rect.bottom); /* w/h  */  
         }  
         drawmng.drawing = FALSE;  
 #endif  
 }  
   
 void  
 scrnmng_draw(RECT_T *r)  
 {  
         GdkDrawable *d = drawarea->window;  
         GdkGC *gc = drawarea->style->fg_gc[GTK_WIDGET_STATE(drawarea)];  
   
         if (drawmng.drawing)  
                 return;  
   
         drawmng.drawing = TRUE;  
   
         if (r->right > drawmng.rect.right)  
                 r->right = drawmng.rect.right;  
         if (r->bottom > drawmng.rect.bottom)  
                 r->bottom = drawmng.rect.bottom;  
   
 #if notyet  
         if (drawmng.scrnmode & SCRNMODE_FULLSCREEN) {  
         } else  
 #endif  
         {  
                 if (scrnmng.allflash) {                  if (scrnmng.allflash) {
                         scrnmng.allflash = 0;                          scrnmng.allflash = 0;
                         if (np2oscfg.paddingx || np2oscfg.paddingy) {                          if (np2oscfg.paddingx || np2oscfg.paddingy) {
                                 clear_outscreen();                                  clear_outscreen();
                         }                          }
                 }                  }
 #if !defined(USE_SCREEN_INVALIDATE)  
                 gdk_draw_pixmap(d, gc, drawmng.backsurf,  
                     r->left, r->top,  
                     r->left, r->top, r->right, r->bottom);  
 #else  
                 gdk_draw_image(d, gc, drawmng.surface,  
                     r->left, r->top,  
                     r->left, r->top, r->right, r->bottom);  
 #endif  
         }          }
   
           gdk_draw_pixbuf(d, gc, drawmng.drawsurf,
               0, 0,
               drawmng.scrn.left, drawmng.scrn.top,
               drawmng.rect.right, drawmng.rect.bottom,
               GDK_RGB_DITHER_NORMAL, 0, 0);
   
         drawmng.drawing = FALSE;          drawmng.drawing = FALSE;
 }  }
Removed from v.1.2  
changed lines
  Added in v.1.12

RetroPC.NET-CVS <cvs@retropc.net>