rgui.c

十七种模拟器源代码 非常有用的作课程设计不可缺少的

/******************************************************************************/
/*                                                                            */
/*                              R-GUI: RAINE GUI                              */
/*                                                                            */
/******************************************************************************/

#include "raine.h"
#include "rgui.h"
#include "rguiproc.h"
#ifdef GFX_SVGALIB
#include <vga.h> // Thanks allegro !
#endif
#ifdef GFX_XDGA2
#include <xalleg.h> // _xwin struct
#endif
#ifdef RAINE_DEBUG
#include "debug.h"
#endif
#include "gui.h" // gui_pal

#define GFX_CANCEL         3
#define GFX_DRIVER_LIST    4
#define GFX_MODE_LIST      5
#define GFX_SCAN_LIST      7
#define GFX_FSKIP_LIST     11
#define GFX_VSYNC_LIST     13
#define GFX_SPEED_LIST     16
#define GFX_EAGLE_LIST     19
#define GFX_TRIPLE_LIST    21
#define GFX_BPP_LIST       25

extern DIALOG gfx_mode_dialog[];

typedef struct GFX_MODE_DATA
{
   int w;
   int h;
   char *s;
} GFX_MODE_DATA;

static GFX_MODE_DATA gfx_mode_data_autodetect[] =
{
#if defined(RAINE_DOS) || defined(RAINE_UNIX)
   { 256,   200,  " 256 x 200"  },
   { 256,   224,  " 256 x 224"  },
   { 256,   240,  " 256 x 240"  },
   { 256,   256,  " 256 x 256"  },
   { 320,   200,  " 320 x 200"  },
   { 320,   240,  " 320 x 240"  },
   { 320,   256,  " 320 x 256"  },
#ifndef RAINE_UNIX
   // This is the only mode I can't make to work !!! Don't know why...
   { 320,   350,  " 320 x 350"  },
#endif   
   { 320,   400,  " 320 x 400"  },
   { 320,   480,  " 320 x 480"  },
   { 320,   600,  " 320 x 600"  },
   { 360,   200,  " 360 x 200"  },
   { 360,   240,  " 360 x 240"  },
   { 360,   270,  " 360 x 270"  },
   { 360,   360,  " 360 x 360"  },
   { 360,   400,  " 360 x 400"  },
   { 360,   480,  " 360 x 480"  },
   { 360,   600,  " 360 x 600"  },
   { 376,   282,  " 376 x 282"  },
   { 376,   308,  " 376 x 308"  },
   { 376,   564,  " 376 x 564"  },
   { 400,   300,  " 400 x 300"  },
   { 400,   600,  " 400 x 600"  },
   { 512,   384,  " 512 x 384"  },
   { 640,   200,  " 640 x 200"  },
   { 640,   240,  " 640 x 240"  },
   { 640,   400,  " 640 x 400"  },
   { 640,   480,  " 640 x 480"  },
   { 800,   200,  " 800 x 200"  },
   { 800,   300,  " 800 x 300"  },
   { 800,   600,  " 800 x 600"  },
   { 1024,  256,  "1024 x 256"  },
   { 1024,  384,  "1024 x 384"  },
   { 1024,  768,  "1024 x 768"  },
   { 1280,  1024, "1280 x 1024" },
   { 1600,  1200, "1600 x 1200" },
#else
   { 320,   200,  " 320 x 200"  },
   { 320,   240,  " 320 x 240"  },
   { 400,   300,  " 400 x 300"  },
   { 512,   384,  " 512 x 384"  },
   { 640,   400,  " 640 x 400"  },
   { 640,   480,  " 640 x 480"  },
   { 800,   600,  " 800 x 600"  },
   { 1024,  768,  "1024 x 768"  },
   { 1280,  1024, "1280 x 1024" },
   { 1600,  1200, "1600 x 1200" },
#endif
   { 0,     0,    NULL          }
};

#ifdef GFX_MODEX
static GFX_MODE_DATA gfx_mode_data_modex[] =
{
   { 256,   200,  " 256 x 200"  },
   { 256,   224,  " 256 x 224"  },
   { 256,   240,  " 256 x 240"  },
   { 256,   256,  " 256 x 256"  },
   { 320,   200,  " 320 x 200"  },
   { 320,   240,  " 320 x 240"  },
   { 320,   256,  " 320 x 256"  },
#ifndef RAINE_UNIX
   { 320,   350,  " 320 x 350"  },
#endif   
   { 320,   400,  " 320 x 400"  },
   { 320,   480,  " 320 x 480"  },
   { 320,   600,  " 320 x 600"  },
   { 360,   200,  " 360 x 200"  },
   { 360,   240,  " 360 x 240"  },
   { 360,   270,  " 360 x 270"  },
   { 360,   360,  " 360 x 360"  },
   { 360,   400,  " 360 x 400"  },
   { 360,   480,  " 360 x 480"  },
   { 360,   600,  " 360 x 600"  },
   { 376,   282,  " 376 x 282"  },
   { 376,   308,  " 376 x 308"  },
   { 376,   564,  " 376 x 564"  },
   { 400,   300,  " 400 x 300"  },
   { 400,   600,  " 400 x 600"  },

   { 0,     0,    NULL          }
};

static GFX_MODE_DATA gfx_mode_data_arcade_monitor[] =
{
   { 320,   240,  " 320 x 240"  },
   { 0,     0,    NULL          }
};
#endif

#ifdef GFX_VGA
static GFX_MODE_DATA gfx_mode_data_vga[] =
{
   { 320,   200,  " 320 x 200"  },
   { 0,     0,    NULL          }
};
#endif

#ifdef GFX_DRIVER_XTENDED
static GFX_MODE_DATA gfx_mode_data_extended[] =
{
   { 640,   400,  " 640 x 400"  },
   { 0,     0,    NULL          }
};
#endif

#ifdef GFX_SVGALIB
static GFX_MODE_DATA *gfx_mode_data_svga = NULL; // Generated...
#endif

#ifdef GFX_XDGA2

#define MAX_DGAMODES 20
static GFX_MODE_DATA gfx_mode_data_dga[MAX_DGAMODES],
  gfx_mode_data_xfs[MAX_DGAMODES];
#endif

#ifdef GFX_FBCON
#define MAX_FBMODES 20
// 20 should be much enough !!!
static GFX_MODE_DATA gfx_mode_data_fb[MAX_FBMODES] =
{
  { 640,   480,  " 640 x 480"  },
  { 800,   600,  " 800 x 600"  },
  { 1024,  768,  "1024 x 768"  },
  { 0,     0,    NULL          }
};
#endif

#ifdef GFX_DRIVER_VESA1
static GFX_MODE_DATA gfx_mode_data_vesa[] =
{
   { 320,   200,  " 320 x 200"  },
   { 320,   240,  " 320 x 240"  },
   { 400,   300,  " 400 x 300"  },
   { 512,   384,  " 512 x 384"  },
   { 640,   400,  " 640 x 400"  },
   { 640,   480,  " 640 x 480"  },
   { 800,   600,  " 800 x 600"  },
   { 1024,  768,  "1024 x 768"  },
   { 1280,  1024, "1280 x 1024" },
   { 1600,  1200, "1600 x 1200" },

   { 320,   400,  " 320 x 400"  },
   { 320,   480,  " 320 x 480"  },
   { 400,   600,  " 400 x 600"  },
   { 640,   200,  " 640 x 200"  },
   { 640,   240,  " 640 x 240"  },
   { 800,   200,  " 800 x 200"  },
   { 800,   300,  " 800 x 300"  },
   { 1024,  256,  "1024 x 256"  },
   { 1024,  384,  "1024 x 384"  },

   { 0,     0,    NULL          }
};
#endif

#if !defined(RAINE_DOS) && !defined(RAINE_UNIX)
static GFX_MODE_DATA gfx_mode_data_directx[] =
{
   { 320,   200,  " 320 x 200"  },
   { 320,   240,  " 320 x 240"  },
   { 400,   300,  " 400 x 300"  },
   { 512,   384,  " 512 x 384"  },
   { 640,   400,  " 640 x 400"  },
   { 640,   480,  " 640 x 480"  },
   { 800,   600,  " 800 x 600"  },
   { 1024,  768,  "1024 x 768"  },
   { 1280,  1024, "1280 x 1024" },
   { 1600,  1200, "1600 x 1200" },

   { 0,     0,    NULL          }
};
#endif
// gfx_mode_getter():
// Listbox data getter routine for the graphics mode list.

GFX_MODE_DATA *res_data;
UINT32 res_data_length;

static char *gfx_mode_getter(int index, int *list_size)
{
   UINT32 ta;

   if(index == -1){
      if(list_size){
         if(!res_data_length){
            ta = 0;
            while(res_data[ta].s){
               ta++;
            }
            res_data_length = ta;
         }
	 *list_size = res_data_length;
      }
      return NULL;
   }

   if((index >= 0)&&((UINT32)index < res_data_length))
      return raine_translate_text(res_data[index].s);
   else
      return NULL;
}

typedef struct GFX_CARD_DATA
{
   UINT32 id;
   UINT8 *name;
   GFX_MODE_DATA *res_list;
} GFX_CARD_DATA;

struct GFX_CARD_DATA gfx_card_data[] =
{
	{ GFX_AUTODETECT,     "Autodetect",           gfx_mode_data_autodetect },
#ifdef GFX_VGA
	{ GFX_VGA,            "VGA",                  gfx_mode_data_vga },
#endif
#ifdef GFX_MODEX
	{ GFX_MODEX,          "Mode-X",               gfx_mode_data_modex },
	{ GFX_ARCMON,         "Arcade Monitor",       gfx_mode_data_arcade_monitor },
#endif
#ifdef GFX_DRIVER_VESA1
	{ GFX_VESA1,          "VESA 1.2",             gfx_mode_data_vesa },
#endif
#ifdef GFX_DRIVER_VESA2B
	{ GFX_VESA2B,         "VESA 2.0 (banked)",    gfx_mode_data_vesa },
#endif
#ifdef GFX_DRIVER_VESA2L
	{ GFX_VESA2L,         "VESA 2.0 (linear)",    gfx_mode_data_vesa },
#endif
#ifdef GFX_DRIVER_VESA3
	{ GFX_VESA3,          "VESA 3.0",             gfx_mode_data_vesa },
#endif
#ifdef GFX_DRIVER_VBEAF
	{ GFX_VBEAF,          "VBE/AF",               gfx_mode_data_vesa },
#endif
#ifdef GFX_DRIVER_XTENDED
	{ GFX_XTENDED,        "Extended Mode",        gfx_mode_data_extended },
#endif
#ifdef GFX_DRIVER_DIRECTX
	{ GFX_DIRECTX_ACCEL,  "Accelerated", gfx_mode_data_directx },
	{ GFX_DIRECTX_SAFE,   "Safe",        gfx_mode_data_directx },
	{ GFX_DIRECTX_SOFT,   "Soft",        gfx_mode_data_directx },
	{ GFX_DIRECTX_OVL,    "Overlay",     gfx_mode_data_directx },
	{ GFX_DIRECTX_WIN,    "Windowed",    gfx_mode_data_directx },
#endif
#ifdef GFX_SVGALIB
	{ GFX_SVGALIB,   "SVGA", NULL	 },
#endif
};

#ifdef RAINE_UNIX
struct GFX_CARD_DATA gfx_card_data_xfree[] =
{
  { GFX_XWINDOWS, "standard X Windows", gfx_mode_data_autodetect },
#ifdef GFX_XWINDOWS_FULLSCREEN
  { GFX_XWINDOWS_FULLSCREEN, "X11 Fullscreen", gfx_mode_data_xfs },
#endif
#ifdef GFX_XDGA2
  { GFX_XDGA2, "DGA 2.0 mode", gfx_mode_data_dga },
  { GFX_XDGA2_SOFT, "DGA 2.0 software only mode", gfx_mode_data_dga },
#endif
};
#endif

int fbcon_enabled = 0;

void switch_gfx_res_data(int screen_mode, int x, int y)
{
   int i;

#ifdef RAINE_UNIX
   if (x_display)
     res_data = gfx_card_data_xfree[screen_mode].res_list;
   else
#endif
     res_data = gfx_card_data[screen_mode].res_list;

   res_data_length = 0;

   gfx_mode_dialog[GFX_MODE_LIST].d1 = 0;

   for(i=0; res_data[i].s; i++){
      if((res_data[i].w >= x)&&(res_data[i].h >= y)){
	 gfx_mode_dialog[GFX_MODE_LIST].d1 = i;
	 return; 
      }
   }

}

/* gfx_card_getter:
 *  Listbox data getter routine for the graphics card list.
 */
static char *gfx_card_getter(int index, int *list_size)
{
  
  if(index == -1){
    if(list_size){
#ifdef RAINE_UNIX
      if (x_display)
	if (geteuid()>0) // Non root -> only xfree standard
	  *list_size = 2; // X11 & X11FS
	else
	  *list_size = (sizeof(gfx_card_data_xfree) / sizeof(GFX_CARD_DATA));
      else
#endif      
#ifdef GFX_FBCON
	if (fbcon_enabled)
	  *list_size = 1;
	else
#endif
	*list_size = (sizeof(gfx_card_data) / sizeof(GFX_CARD_DATA));
    }
      return NULL;
   }

   if(index == -4){

      SEND_MESSAGE(&gfx_mode_dialog[GFX_MODE_LIST], MSG_END, 0);

      switch_gfx_res_data(
         *list_size,
         res_data[gfx_mode_dialog[GFX_MODE_LIST].d1].w,
         res_data[gfx_mode_dialog[GFX_MODE_LIST].d1].h
      );

      SEND_MESSAGE(&gfx_mode_dialog[GFX_MODE_LIST], MSG_START, 0);
      SEND_MESSAGE(&gfx_mode_dialog[GFX_MODE_LIST], MSG_DRAW, 0);

      return NULL;
   }

   if(index >= 0)
#ifdef RAINE_UNIX
     if (x_display)
       return raine_translate_text(gfx_card_data_xfree[index].name);
     else
#endif   
       return raine_translate_text(gfx_card_data[index].name);
   else
      return NULL;
}

int qsort_modes(const void *a, const void *b) {
  char *s1 = ((GFX_MODE_DATA*)a)->s;
  char *s2 = ((GFX_MODE_DATA*)b)->s;
  int diff = strlen(s1)-strlen(s2);
  if (diff)
    return diff;
  return stricmp(s1,s2);
}

#ifdef GFX_XDGA2
void setup_dga_modes() {
  // This one is easy (at least it looks easy compared to fbcon !)
   XDGAMode *mode;
   int num_modes;
   int  i, trouve,nb=0,w,h,j;
   char name[10];

   if (x_display) {
     mode = XDGAQueryModes(_xwin.display, _xwin.screen, &num_modes);
     for (i=0; i<num_modes; i++) {
       w = mode[i].viewportWidth;
       h = mode[i].viewportHeight;
       // Check if current mode is already in (with a different refresh rate...)
       trouve = 0;
       for (j=0; j<nb; j++) {
	 if (gfx_mode_data_dga[j].w == w && gfx_mode_data_dga[j].h == h) {
	   trouve = 1;
	   break;
	 }
       }
       
       if (!trouve && nb < MAX_DGAMODES-1) {
	 gfx_mode_data_dga[nb].w = w;
	 gfx_mode_data_dga[nb].h = h;
	 sprintf(name,"%dx%d",w,h);
	 gfx_mode_data_dga[nb++].s = strdup(name);
       }
     }
     
     gfx_mode_data_dga[nb].w = 
       gfx_mode_data_dga[nb].h = 0;
     gfx_mode_data_dga[nb].s = NULL;
     // The array must be sorted for the auto-change res...
     qsort(gfx_mode_data_dga,nb,sizeof(GFX_MODE_DATA),qsort_modes);
   }
}    
#endif

#ifdef GFX_XWINDOWS_FULLSCREEN
void setup_xfs_modes() {
  // A copy of the dga version for x11 full screen
   int  i, trouve,nb=0,w,h,j;
   char name[10];
   XF86VidModeModeInfo *mode;

   if (x_display) {
     /* Get list of modelines.  */
     if (!XF86VidModeGetAllModeLines(_xwin.display, _xwin.screen,
				     &_xwin.num_modes, &_xwin.modesinfo)) {
       return;
     }

     for (i=0; i<_xwin.num_modes; i++) {
       mode = _xwin.modesinfo[i];
       w = mode->hdisplay;
       h = mode->vdisplay;
       
       // Check if current mode is already in (with a different refresh rate...)
       trouve = 0;
       for (j=0; j<nb; j++) {
	 if (gfx_mode_data_xfs[j].w == w && gfx_mode_data_xfs[j].h == h) {
	   trouve = 1;
	   break;
	 }
       }
       
       if (!trouve && nb < MAX_DGAMODES-1) {
	 gfx_mode_data_xfs[nb].w = w;
	 gfx_mode_data_xfs[nb].h = h;
	 sprintf(name,"%dx%d",w,h);
	 gfx_mode_data_xfs[nb++].s = strdup(name);
	 
       }
     }
     
     gfx_mode_data_xfs[nb].w = 
       gfx_mode_data_xfs[nb].h = 0;
     gfx_mode_data_xfs[nb].s = NULL;
     // The array must be sorted for the auto-change res...
     qsort(gfx_mode_data_xfs,nb,sizeof(GFX_MODE_DATA),qsort_modes);
   }
}    
#endif

#ifdef GFX_SVGALIB
void setup_svga_modes() {